"use strict";
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 __typeError = (msg) => {
  throw TypeError(msg);
};
var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
var __esm = (fn3, res) => function __init() {
  return fn3 && (res = (0, fn3[__getOwnPropNames(fn3)[0]])(fn3 = 0)), res;
};
var __commonJS = (cb, mod) => function __require() {
  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all) => {
  for (var name3 in all)
    __defProp(target, name3, { get: all[name3], enumerable: true });
};
var __copyProps = (to3, from, except5, desc2) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to3, key) && key !== except5)
        __defProp(to3, key, { get: () => from[key], enumerable: !(desc2 = __getOwnPropDesc(from, key)) || desc2.enumerable });
  }
  return to3;
};
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
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
var __privateWrapper = (obj, member, setter, getter) => ({
  set _(value) {
    __privateSet(obj, member, value, setter);
  },
  get _() {
    return __privateGet(obj, member, getter);
  }
});

// ../drizzle-orm/dist/entity.js
function is(value, type) {
  if (!value || typeof value !== "object") {
    return false;
  }
  if (value instanceof type) {
    return true;
  }
  if (!Object.prototype.hasOwnProperty.call(type, entityKind)) {
    throw new Error(
      `Class "${type.name ?? "<unknown>"}" doesn't look like a Drizzle entity. If this is incorrect and the class is provided by Drizzle, please report this as a bug.`
    );
  }
  let cls = Object.getPrototypeOf(value).constructor;
  if (cls) {
    while (cls) {
      if (entityKind in cls && cls[entityKind] === type[entityKind]) {
        return true;
      }
      cls = Object.getPrototypeOf(cls);
    }
  }
  return false;
}
var entityKind, hasOwnEntityKind;
var init_entity = __esm({
  "../drizzle-orm/dist/entity.js"() {
    "use strict";
    entityKind = Symbol.for("drizzle:entityKind");
    hasOwnEntityKind = Symbol.for("drizzle:hasOwnEntityKind");
  }
});

// ../drizzle-orm/dist/column.js
var _a, Column;
var init_column = __esm({
  "../drizzle-orm/dist/column.js"() {
    "use strict";
    init_entity();
    _a = entityKind;
    Column = class {
      constructor(table6, config) {
        __publicField(this, "name");
        __publicField(this, "keyAsName");
        __publicField(this, "primary");
        __publicField(this, "notNull");
        __publicField(this, "default");
        __publicField(this, "defaultFn");
        __publicField(this, "onUpdateFn");
        __publicField(this, "hasDefault");
        __publicField(this, "isUnique");
        __publicField(this, "uniqueName");
        __publicField(this, "uniqueType");
        __publicField(this, "dataType");
        __publicField(this, "columnType");
        __publicField(this, "enumValues");
        __publicField(this, "generated");
        __publicField(this, "generatedIdentity");
        __publicField(this, "config");
        this.table = table6;
        this.config = config;
        this.name = config.name;
        this.keyAsName = config.keyAsName;
        this.notNull = config.notNull;
        this.default = config.default;
        this.defaultFn = config.defaultFn;
        this.onUpdateFn = config.onUpdateFn;
        this.hasDefault = config.hasDefault;
        this.primary = config.primaryKey;
        this.isUnique = config.isUnique;
        this.uniqueName = config.uniqueName;
        this.uniqueType = config.uniqueType;
        this.dataType = config.dataType;
        this.columnType = config.columnType;
        this.generated = config.generated;
        this.generatedIdentity = config.generatedIdentity;
      }
      mapFromDriverValue(value) {
        return value;
      }
      mapToDriverValue(value) {
        return value;
      }
      // ** @internal */
      shouldDisableInsert() {
        return this.config.generated !== void 0 && this.config.generated.type !== "byDefault";
      }
    };
    __publicField(Column, _a, "Column");
  }
});

// ../drizzle-orm/dist/column-builder.js
var _a2, ColumnBuilder;
var init_column_builder = __esm({
  "../drizzle-orm/dist/column-builder.js"() {
    "use strict";
    init_entity();
    _a2 = entityKind;
    ColumnBuilder = class {
      constructor(name3, dataType, columnType) {
        __publicField(this, "config");
        /**
         * Alias for {@link $defaultFn}.
         */
        __publicField(this, "$default", this.$defaultFn);
        /**
         * Alias for {@link $onUpdateFn}.
         */
        __publicField(this, "$onUpdate", this.$onUpdateFn);
        this.config = {
          name: name3,
          keyAsName: name3 === "",
          notNull: false,
          default: void 0,
          hasDefault: false,
          primaryKey: false,
          isUnique: false,
          uniqueName: void 0,
          uniqueType: void 0,
          dataType,
          columnType,
          generated: void 0
        };
      }
      /**
       * Changes the data type of the column. Commonly used with `json` columns. Also, useful for branded types.
       *
       * @example
       * ```ts
       * const users = pgTable('users', {
       * 	id: integer('id').$type<UserId>().primaryKey(),
       * 	details: json('details').$type<UserDetails>().notNull(),
       * });
       * ```
       */
      $type() {
        return this;
      }
      /**
       * Adds a `not null` clause to the column definition.
       *
       * Affects the `select` model of the table - columns *without* `not null` will be nullable on select.
       */
      notNull() {
        this.config.notNull = true;
        return this;
      }
      /**
       * Adds a `default <value>` clause to the column definition.
       *
       * Affects the `insert` model of the table - columns *with* `default` are optional on insert.
       *
       * If you need to set a dynamic default value, use {@link $defaultFn} instead.
       */
      default(value) {
        this.config.default = value;
        this.config.hasDefault = true;
        return this;
      }
      /**
       * Adds a dynamic default value to the column.
       * The function will be called when the row is inserted, and the returned value will be used as the column value.
       *
       * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
       */
      $defaultFn(fn3) {
        this.config.defaultFn = fn3;
        this.config.hasDefault = true;
        return this;
      }
      /**
       * Adds a dynamic update value to the column.
       * The function will be called when the row is updated, and the returned value will be used as the column value if none is provided.
       * If no `default` (or `$defaultFn`) value is provided, the function will be called when the row is inserted as well, and the returned value will be used as the column value.
       *
       * **Note:** This value does not affect the `drizzle-kit` behavior, it is only used at runtime in `drizzle-orm`.
       */
      $onUpdateFn(fn3) {
        this.config.onUpdateFn = fn3;
        this.config.hasDefault = true;
        return this;
      }
      /**
       * Adds a `primary key` clause to the column definition. This implicitly makes the column `not null`.
       *
       * In SQLite, `integer primary key` implicitly makes the column auto-incrementing.
       */
      primaryKey() {
        this.config.primaryKey = true;
        this.config.notNull = true;
        return this;
      }
      /** @internal Sets the name of the column to the key within the table definition if a name was not given. */
      setName(name3) {
        if (this.config.name !== "") return;
        this.config.name = name3;
      }
    };
    __publicField(ColumnBuilder, _a2, "ColumnBuilder");
  }
});

// ../drizzle-orm/dist/table.utils.js
var TableName;
var init_table_utils = __esm({
  "../drizzle-orm/dist/table.utils.js"() {
    "use strict";
    TableName = Symbol.for("drizzle:Name");
  }
});

// ../drizzle-orm/dist/pg-core/foreign-keys.js
function foreignKey(config) {
  function mappedConfig() {
    const { name: name3, columns, foreignColumns } = config;
    return {
      name: name3,
      columns,
      foreignColumns
    };
  }
  return new ForeignKeyBuilder(mappedConfig);
}
var _a3, ForeignKeyBuilder, _a4, ForeignKey;
var init_foreign_keys = __esm({
  "../drizzle-orm/dist/pg-core/foreign-keys.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    _a3 = entityKind;
    ForeignKeyBuilder = class {
      constructor(config, actions) {
        /** @internal */
        __publicField(this, "reference");
        /** @internal */
        __publicField(this, "_onUpdate", "no action");
        /** @internal */
        __publicField(this, "_onDelete", "no action");
        this.reference = () => {
          const { name: name3, columns, foreignColumns } = config();
          return { name: name3, columns, foreignTable: foreignColumns[0].table, foreignColumns };
        };
        if (actions) {
          this._onUpdate = actions.onUpdate;
          this._onDelete = actions.onDelete;
        }
      }
      onUpdate(action) {
        this._onUpdate = action === void 0 ? "no action" : action;
        return this;
      }
      onDelete(action) {
        this._onDelete = action === void 0 ? "no action" : action;
        return this;
      }
      /** @internal */
      build(table6) {
        return new ForeignKey(table6, this);
      }
    };
    __publicField(ForeignKeyBuilder, _a3, "PgForeignKeyBuilder");
    _a4 = entityKind;
    ForeignKey = class {
      constructor(table6, builder) {
        __publicField(this, "reference");
        __publicField(this, "onUpdate");
        __publicField(this, "onDelete");
        this.table = table6;
        this.reference = builder.reference;
        this.onUpdate = builder._onUpdate;
        this.onDelete = builder._onDelete;
      }
      getName() {
        const { name: name3, columns, foreignColumns } = this.reference();
        const columnNames = columns.map((column6) => column6.name);
        const foreignColumnNames = foreignColumns.map((column6) => column6.name);
        const chunks = [
          this.table[TableName],
          ...columnNames,
          foreignColumns[0].table[TableName],
          ...foreignColumnNames
        ];
        return name3 ?? `${chunks.join("_")}_fk`;
      }
    };
    __publicField(ForeignKey, _a4, "PgForeignKey");
  }
});

// ../drizzle-orm/dist/tracing-utils.js
function iife(fn3, ...args2) {
  return fn3(...args2);
}
var init_tracing_utils = __esm({
  "../drizzle-orm/dist/tracing-utils.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/pg-core/unique-constraint.js
function unique(name3) {
  return new UniqueOnConstraintBuilder(name3);
}
function uniqueKeyName(table6, columns) {
  return `${table6[TableName]}_${columns.join("_")}_unique`;
}
var _a5, UniqueConstraintBuilder, _a6, UniqueOnConstraintBuilder, _a7, UniqueConstraint;
var init_unique_constraint = __esm({
  "../drizzle-orm/dist/pg-core/unique-constraint.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    _a5 = entityKind;
    UniqueConstraintBuilder = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        /** @internal */
        __publicField(this, "nullsNotDistinctConfig", false);
        this.name = name3;
        this.columns = columns;
      }
      nullsNotDistinct() {
        this.nullsNotDistinctConfig = true;
        return this;
      }
      /** @internal */
      build(table6) {
        return new UniqueConstraint(table6, this.columns, this.nullsNotDistinctConfig, this.name);
      }
    };
    __publicField(UniqueConstraintBuilder, _a5, "PgUniqueConstraintBuilder");
    _a6 = entityKind;
    UniqueOnConstraintBuilder = class {
      constructor(name3) {
        /** @internal */
        __publicField(this, "name");
        this.name = name3;
      }
      on(...columns) {
        return new UniqueConstraintBuilder(columns, this.name);
      }
    };
    __publicField(UniqueOnConstraintBuilder, _a6, "PgUniqueOnConstraintBuilder");
    _a7 = entityKind;
    UniqueConstraint = class {
      constructor(table6, columns, nullsNotDistinct, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        __publicField(this, "nullsNotDistinct", false);
        this.table = table6;
        this.columns = columns;
        this.name = name3 ?? uniqueKeyName(this.table, this.columns.map((column6) => column6.name));
        this.nullsNotDistinct = nullsNotDistinct;
      }
      getName() {
        return this.name;
      }
    };
    __publicField(UniqueConstraint, _a7, "PgUniqueConstraint");
  }
});

// ../drizzle-orm/dist/pg-core/utils/array.js
function parsePgArrayValue(arrayString, startFrom, inQuotes) {
  for (let i8 = startFrom; i8 < arrayString.length; i8++) {
    const char4 = arrayString[i8];
    if (char4 === "\\") {
      i8++;
      continue;
    }
    if (char4 === '"') {
      return [arrayString.slice(startFrom, i8).replace(/\\/g, ""), i8 + 1];
    }
    if (inQuotes) {
      continue;
    }
    if (char4 === "," || char4 === "}") {
      return [arrayString.slice(startFrom, i8).replace(/\\/g, ""), i8];
    }
  }
  return [arrayString.slice(startFrom).replace(/\\/g, ""), arrayString.length];
}
function parsePgNestedArray(arrayString, startFrom = 0) {
  const result = [];
  let i8 = startFrom;
  let lastCharIsComma = false;
  while (i8 < arrayString.length) {
    const char4 = arrayString[i8];
    if (char4 === ",") {
      if (lastCharIsComma || i8 === startFrom) {
        result.push("");
      }
      lastCharIsComma = true;
      i8++;
      continue;
    }
    lastCharIsComma = false;
    if (char4 === "\\") {
      i8 += 2;
      continue;
    }
    if (char4 === '"') {
      const [value2, startFrom2] = parsePgArrayValue(arrayString, i8 + 1, true);
      result.push(value2);
      i8 = startFrom2;
      continue;
    }
    if (char4 === "}") {
      return [result, i8 + 1];
    }
    if (char4 === "{") {
      const [value2, startFrom2] = parsePgNestedArray(arrayString, i8 + 1);
      result.push(value2);
      i8 = startFrom2;
      continue;
    }
    const [value, newStartFrom] = parsePgArrayValue(arrayString, i8, false);
    result.push(value);
    i8 = newStartFrom;
  }
  return [result, i8];
}
function parsePgArray(arrayString) {
  const [result] = parsePgNestedArray(arrayString, 1);
  return result;
}
function makePgArray(array3) {
  return `{${array3.map((item) => {
    if (Array.isArray(item)) {
      return makePgArray(item);
    }
    if (typeof item === "string") {
      return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
    }
    return `${item}`;
  }).join(",")}}`;
}
var init_array = __esm({
  "../drizzle-orm/dist/pg-core/utils/array.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/pg-core/columns/common.js
var _a8, _b, PgColumnBuilder, _a9, _b2, PgColumn, _a10, _b3, ExtraConfigColumn, _a11, IndexedColumn, _a12, _b4, PgArrayBuilder, _a13, _b5, _PgArray, PgArray;
var init_common = __esm({
  "../drizzle-orm/dist/pg-core/columns/common.js"() {
    "use strict";
    init_column_builder();
    init_column();
    init_entity();
    init_foreign_keys();
    init_tracing_utils();
    init_unique_constraint();
    init_array();
    PgColumnBuilder = class extends (_b = ColumnBuilder, _a8 = entityKind, _b) {
      constructor() {
        super(...arguments);
        __publicField(this, "foreignKeyConfigs", []);
      }
      array(size2) {
        return new PgArrayBuilder(this.config.name, this, size2);
      }
      references(ref, actions = {}) {
        this.foreignKeyConfigs.push({ ref, actions });
        return this;
      }
      unique(name3, config) {
        this.config.isUnique = true;
        this.config.uniqueName = name3;
        this.config.uniqueType = config?.nulls;
        return this;
      }
      generatedAlwaysAs(as) {
        this.config.generated = {
          as,
          type: "always",
          mode: "stored"
        };
        return this;
      }
      /** @internal */
      buildForeignKeys(column6, table6) {
        return this.foreignKeyConfigs.map(({ ref, actions }) => {
          return iife(
            (ref2, actions2) => {
              const builder = new ForeignKeyBuilder(() => {
                const foreignColumn = ref2();
                return { columns: [column6], foreignColumns: [foreignColumn] };
              });
              if (actions2.onUpdate) {
                builder.onUpdate(actions2.onUpdate);
              }
              if (actions2.onDelete) {
                builder.onDelete(actions2.onDelete);
              }
              return builder.build(table6);
            },
            ref,
            actions
          );
        });
      }
      /** @internal */
      buildExtraConfigColumn(table6) {
        return new ExtraConfigColumn(table6, this.config);
      }
    };
    __publicField(PgColumnBuilder, _a8, "PgColumnBuilder");
    PgColumn = class extends (_b2 = Column, _a9 = entityKind, _b2) {
      constructor(table6, config) {
        if (!config.uniqueName) {
          config.uniqueName = uniqueKeyName(table6, [config.name]);
        }
        super(table6, config);
        this.table = table6;
      }
    };
    __publicField(PgColumn, _a9, "PgColumn");
    ExtraConfigColumn = class extends (_b3 = PgColumn, _a10 = entityKind, _b3) {
      constructor() {
        super(...arguments);
        __publicField(this, "indexConfig", {
          order: this.config.order ?? "asc",
          nulls: this.config.nulls ?? "last",
          opClass: this.config.opClass
        });
        __publicField(this, "defaultConfig", {
          order: "asc",
          nulls: "last",
          opClass: void 0
        });
      }
      getSQLType() {
        return this.getSQLType();
      }
      asc() {
        this.indexConfig.order = "asc";
        return this;
      }
      desc() {
        this.indexConfig.order = "desc";
        return this;
      }
      nullsFirst() {
        this.indexConfig.nulls = "first";
        return this;
      }
      nullsLast() {
        this.indexConfig.nulls = "last";
        return this;
      }
      /**
       * ### PostgreSQL documentation quote
       *
       * > An operator class with optional parameters can be specified for each column of an index.
       * The operator class identifies the operators to be used by the index for that column.
       * For example, a B-tree index on four-byte integers would use the int4_ops class;
       * this operator class includes comparison functions for four-byte integers.
       * In practice the default operator class for the column's data type is usually sufficient.
       * The main point of having operator classes is that for some data types, there could be more than one meaningful ordering.
       * For example, we might want to sort a complex-number data type either by absolute value or by real part.
       * We could do this by defining two operator classes for the data type and then selecting the proper class when creating an index.
       * More information about operator classes check:
       *
       * ### Useful links
       * https://www.postgresql.org/docs/current/sql-createindex.html
       *
       * https://www.postgresql.org/docs/current/indexes-opclass.html
       *
       * https://www.postgresql.org/docs/current/xindex.html
       *
       * ### Additional types
       * If you have the `pg_vector` extension installed in your database, you can use the
       * `vector_l2_ops`, `vector_ip_ops`, `vector_cosine_ops`, `vector_l1_ops`, `bit_hamming_ops`, `bit_jaccard_ops`, `halfvec_l2_ops`, `sparsevec_l2_ops` options, which are predefined types.
       *
       * **You can always specify any string you want in the operator class, in case Drizzle doesn't have it natively in its types**
       *
       * @param opClass
       * @returns
       */
      op(opClass) {
        this.indexConfig.opClass = opClass;
        return this;
      }
    };
    __publicField(ExtraConfigColumn, _a10, "ExtraConfigColumn");
    _a11 = entityKind;
    IndexedColumn = class {
      constructor(name3, keyAsName, type, indexConfig) {
        __publicField(this, "name");
        __publicField(this, "keyAsName");
        __publicField(this, "type");
        __publicField(this, "indexConfig");
        this.name = name3;
        this.keyAsName = keyAsName;
        this.type = type;
        this.indexConfig = indexConfig;
      }
    };
    __publicField(IndexedColumn, _a11, "IndexedColumn");
    PgArrayBuilder = class extends (_b4 = PgColumnBuilder, _a12 = entityKind, _b4) {
      constructor(name3, baseBuilder, size2) {
        super(name3, "array", "PgArray");
        this.config.baseBuilder = baseBuilder;
        this.config.size = size2;
      }
      /** @internal */
      build(table6) {
        const baseColumn = this.config.baseBuilder.build(table6);
        return new PgArray(
          table6,
          this.config,
          baseColumn
        );
      }
    };
    __publicField(PgArrayBuilder, _a12, "PgArrayBuilder");
    _PgArray = class _PgArray extends (_b5 = PgColumn, _a13 = entityKind, _b5) {
      constructor(table6, config, baseColumn, range) {
        super(table6, config);
        __publicField(this, "size");
        this.baseColumn = baseColumn;
        this.range = range;
        this.size = config.size;
      }
      getSQLType() {
        return `${this.baseColumn.getSQLType()}[${typeof this.size === "number" ? this.size : ""}]`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          value = parsePgArray(value);
        }
        return value.map((v11) => this.baseColumn.mapFromDriverValue(v11));
      }
      mapToDriverValue(value, isNestedArray = false) {
        const a9 = value.map(
          (v11) => v11 === null ? null : is(this.baseColumn, _PgArray) ? this.baseColumn.mapToDriverValue(v11, true) : this.baseColumn.mapToDriverValue(v11)
        );
        if (isNestedArray) return a9;
        return makePgArray(a9);
      }
    };
    __publicField(_PgArray, _a13, "PgArray");
    PgArray = _PgArray;
  }
});

// ../drizzle-orm/dist/pg-core/columns/enum.js
function isPgEnum(obj) {
  return !!obj && typeof obj === "function" && isPgEnumSym in obj && obj[isPgEnumSym] === true;
}
function pgEnum(enumName, input) {
  return Array.isArray(input) ? pgEnumWithSchema(enumName, [...input], void 0) : pgEnumObjectWithSchema(enumName, input, void 0);
}
function pgEnumWithSchema(enumName, values2, schema6) {
  const enumInstance = Object.assign(
    (name3) => new PgEnumColumnBuilder(name3 ?? "", enumInstance),
    {
      enumName,
      enumValues: values2,
      schema: schema6,
      [isPgEnumSym]: true
    }
  );
  return enumInstance;
}
function pgEnumObjectWithSchema(enumName, values2, schema6) {
  const enumInstance = Object.assign(
    (name3) => new PgEnumObjectColumnBuilder(name3 ?? "", enumInstance),
    {
      enumName,
      enumValues: Object.values(values2),
      schema: schema6,
      [isPgEnumSym]: true
    }
  );
  return enumInstance;
}
var _a14, _b6, PgEnumObjectColumnBuilder, _a15, _b7, PgEnumObjectColumn, isPgEnumSym, _a16, _b8, PgEnumColumnBuilder, _a17, _b9, PgEnumColumn;
var init_enum = __esm({
  "../drizzle-orm/dist/pg-core/columns/enum.js"() {
    "use strict";
    init_entity();
    init_common();
    PgEnumObjectColumnBuilder = class extends (_b6 = PgColumnBuilder, _a14 = entityKind, _b6) {
      constructor(name3, enumInstance) {
        super(name3, "string", "PgEnumObjectColumn");
        this.config.enum = enumInstance;
      }
      /** @internal */
      build(table6) {
        return new PgEnumObjectColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(PgEnumObjectColumnBuilder, _a14, "PgEnumObjectColumnBuilder");
    PgEnumObjectColumn = class extends (_b7 = PgColumn, _a15 = entityKind, _b7) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "enum");
        __publicField(this, "enumValues", this.config.enum.enumValues);
        this.enum = config.enum;
      }
      getSQLType() {
        return this.enum.enumName;
      }
    };
    __publicField(PgEnumObjectColumn, _a15, "PgEnumObjectColumn");
    isPgEnumSym = Symbol.for("drizzle:isPgEnum");
    PgEnumColumnBuilder = class extends (_b8 = PgColumnBuilder, _a16 = entityKind, _b8) {
      constructor(name3, enumInstance) {
        super(name3, "string", "PgEnumColumn");
        this.config.enum = enumInstance;
      }
      /** @internal */
      build(table6) {
        return new PgEnumColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(PgEnumColumnBuilder, _a16, "PgEnumColumnBuilder");
    PgEnumColumn = class extends (_b9 = PgColumn, _a17 = entityKind, _b9) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "enum", this.config.enum);
        __publicField(this, "enumValues", this.config.enum.enumValues);
        this.enum = config.enum;
      }
      getSQLType() {
        return this.enum.enumName;
      }
    };
    __publicField(PgEnumColumn, _a17, "PgEnumColumn");
  }
});

// ../drizzle-orm/dist/subquery.js
var _a18, Subquery, _a19, _b10, WithSubquery;
var init_subquery = __esm({
  "../drizzle-orm/dist/subquery.js"() {
    "use strict";
    init_entity();
    _a18 = entityKind;
    Subquery = class {
      constructor(sql3, fields, alias2, isWith = false, usedTables = []) {
        this._ = {
          brand: "Subquery",
          sql: sql3,
          selectedFields: fields,
          alias: alias2,
          isWith,
          usedTables
        };
      }
      // getSQL(): SQL<unknown> {
      // 	return new SQL([this]);
      // }
    };
    __publicField(Subquery, _a18, "Subquery");
    WithSubquery = class extends (_b10 = Subquery, _a19 = entityKind, _b10) {
    };
    __publicField(WithSubquery, _a19, "WithSubquery");
  }
});

// ../drizzle-orm/dist/version.js
var version;
var init_version = __esm({
  "../drizzle-orm/dist/version.js"() {
    "use strict";
    version = "0.44.7";
  }
});

// ../drizzle-orm/dist/tracing.js
var otel, rawTracer, tracer;
var init_tracing = __esm({
  "../drizzle-orm/dist/tracing.js"() {
    "use strict";
    init_tracing_utils();
    init_version();
    tracer = {
      startActiveSpan(name3, fn3) {
        if (!otel) {
          return fn3();
        }
        if (!rawTracer) {
          rawTracer = otel.trace.getTracer("drizzle-orm", version);
        }
        return iife(
          (otel2, rawTracer2) => rawTracer2.startActiveSpan(
            name3,
            (span) => {
              try {
                return fn3(span);
              } catch (e6) {
                span.setStatus({
                  code: otel2.SpanStatusCode.ERROR,
                  message: e6 instanceof Error ? e6.message : "Unknown error"
                  // eslint-disable-line no-instanceof/no-instanceof
                });
                throw e6;
              } finally {
                span.end();
              }
            }
          ),
          otel,
          rawTracer
        );
      }
    };
  }
});

// ../drizzle-orm/dist/view-common.js
var ViewBaseConfig;
var init_view_common = __esm({
  "../drizzle-orm/dist/view-common.js"() {
    "use strict";
    ViewBaseConfig = Symbol.for("drizzle:ViewBaseConfig");
  }
});

// ../drizzle-orm/dist/table.js
function isTable(table6) {
  return typeof table6 === "object" && table6 !== null && IsDrizzleTable in table6;
}
function getTableName(table6) {
  return table6[TableName];
}
function getTableUniqueName(table6) {
  return `${table6[Schema] ?? "public"}.${table6[TableName]}`;
}
var Schema, Columns, ExtraConfigColumns, OriginalName, BaseName, IsAlias, ExtraConfigBuilder, IsDrizzleTable, _a20, _b11, _c, _d, _e, _f, _g, _h, _i, _j, Table;
var init_table = __esm({
  "../drizzle-orm/dist/table.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    Schema = Symbol.for("drizzle:Schema");
    Columns = Symbol.for("drizzle:Columns");
    ExtraConfigColumns = Symbol.for("drizzle:ExtraConfigColumns");
    OriginalName = Symbol.for("drizzle:OriginalName");
    BaseName = Symbol.for("drizzle:BaseName");
    IsAlias = Symbol.for("drizzle:IsAlias");
    ExtraConfigBuilder = Symbol.for("drizzle:ExtraConfigBuilder");
    IsDrizzleTable = Symbol.for("drizzle:IsDrizzleTable");
    _j = entityKind, _i = TableName, _h = OriginalName, _g = Schema, _f = Columns, _e = ExtraConfigColumns, _d = BaseName, _c = IsAlias, _b11 = IsDrizzleTable, _a20 = ExtraConfigBuilder;
    Table = class {
      constructor(name3, schema6, baseName) {
        /**
         * @internal
         * Can be changed if the table is aliased.
         */
        __publicField(this, _i);
        /**
         * @internal
         * Used to store the original name of the table, before any aliasing.
         */
        __publicField(this, _h);
        /** @internal */
        __publicField(this, _g);
        /** @internal */
        __publicField(this, _f);
        /** @internal */
        __publicField(this, _e);
        /**
         *  @internal
         * Used to store the table name before the transformation via the `tableCreator` functions.
         */
        __publicField(this, _d);
        /** @internal */
        __publicField(this, _c, false);
        /** @internal */
        __publicField(this, _b11, true);
        /** @internal */
        __publicField(this, _a20);
        this[TableName] = this[OriginalName] = name3;
        this[Schema] = schema6;
        this[BaseName] = baseName;
      }
    };
    __publicField(Table, _j, "Table");
    /** @internal */
    __publicField(Table, "Symbol", {
      Name: TableName,
      Schema,
      OriginalName,
      Columns,
      ExtraConfigColumns,
      BaseName,
      IsAlias,
      ExtraConfigBuilder
    });
  }
});

// ../drizzle-orm/dist/sql/sql.js
function isSQLWrapper(value) {
  return value !== null && value !== void 0 && typeof value.getSQL === "function";
}
function mergeQueries(queries) {
  const result = { sql: "", params: [] };
  for (const query of queries) {
    result.sql += query.sql;
    result.params.push(...query.params);
    if (query.typings?.length) {
      if (!result.typings) {
        result.typings = [];
      }
      result.typings.push(...query.typings);
    }
  }
  return result;
}
function name2(value) {
  return new Name(value);
}
function isDriverValueEncoder(value) {
  return typeof value === "object" && value !== null && "mapToDriverValue" in value && typeof value.mapToDriverValue === "function";
}
function param(value, encoder) {
  return new Param(value, encoder);
}
function sql(strings, ...params) {
  const queryChunks = [];
  if (params.length > 0 || strings.length > 0 && strings[0] !== "") {
    queryChunks.push(new StringChunk(strings[0]));
  }
  for (const [paramIndex, param2] of params.entries()) {
    queryChunks.push(param2, new StringChunk(strings[paramIndex + 1]));
  }
  return new SQL(queryChunks);
}
function placeholder(name22) {
  return new Placeholder(name22);
}
function fillPlaceholders(params, values2) {
  return params.map((p11) => {
    if (is(p11, Placeholder)) {
      if (!(p11.name in values2)) {
        throw new Error(`No value for placeholder "${p11.name}" was provided`);
      }
      return values2[p11.name];
    }
    if (is(p11, Param) && is(p11.value, Placeholder)) {
      if (!(p11.value.name in values2)) {
        throw new Error(`No value for placeholder "${p11.value.name}" was provided`);
      }
      return p11.encoder.mapToDriverValue(values2[p11.value.name]);
    }
    return p11;
  });
}
function isView(view5) {
  return typeof view5 === "object" && view5 !== null && IsDrizzleView in view5;
}
function getViewName(view5) {
  return view5[ViewBaseConfig].name;
}
var _a21, FakePrimitiveParam, _a22, StringChunk, _a23, _SQL, SQL, _a24, Name, noopDecoder, noopEncoder, noopMapper, _a25, Param, _a26, Placeholder, IsDrizzleView, _a27, _b12, _c2, View;
var init_sql = __esm({
  "../drizzle-orm/dist/sql/sql.js"() {
    "use strict";
    init_entity();
    init_enum();
    init_subquery();
    init_tracing();
    init_view_common();
    init_column();
    init_table();
    _a21 = entityKind;
    FakePrimitiveParam = class {
    };
    __publicField(FakePrimitiveParam, _a21, "FakePrimitiveParam");
    _a22 = entityKind;
    StringChunk = class {
      constructor(value) {
        __publicField(this, "value");
        this.value = Array.isArray(value) ? value : [value];
      }
      getSQL() {
        return new SQL([this]);
      }
    };
    __publicField(StringChunk, _a22, "StringChunk");
    _a23 = entityKind;
    _SQL = class _SQL {
      constructor(queryChunks) {
        /** @internal */
        __publicField(this, "decoder", noopDecoder);
        __publicField(this, "shouldInlineParams", false);
        /** @internal */
        __publicField(this, "usedTables", []);
        this.queryChunks = queryChunks;
        for (const chunk of queryChunks) {
          if (is(chunk, Table)) {
            const schemaName = chunk[Table.Symbol.Schema];
            this.usedTables.push(
              schemaName === void 0 ? chunk[Table.Symbol.Name] : schemaName + "." + chunk[Table.Symbol.Name]
            );
          }
        }
      }
      append(query) {
        this.queryChunks.push(...query.queryChunks);
        return this;
      }
      toQuery(config) {
        return tracer.startActiveSpan("drizzle.buildSQL", (span) => {
          const query = this.buildQueryFromSourceParams(this.queryChunks, config);
          span?.setAttributes({
            "drizzle.query.text": query.sql,
            "drizzle.query.params": JSON.stringify(query.params)
          });
          return query;
        });
      }
      buildQueryFromSourceParams(chunks, _config) {
        const config = Object.assign({}, _config, {
          inlineParams: _config.inlineParams || this.shouldInlineParams,
          paramStartIndex: _config.paramStartIndex || { value: 0 }
        });
        const {
          casing: casing2,
          escapeName,
          escapeParam,
          prepareTyping,
          inlineParams,
          paramStartIndex
        } = config;
        return mergeQueries(chunks.map((chunk) => {
          if (is(chunk, StringChunk)) {
            return { sql: chunk.value.join(""), params: [] };
          }
          if (is(chunk, Name)) {
            return { sql: escapeName(chunk.value), params: [] };
          }
          if (chunk === void 0) {
            return { sql: "", params: [] };
          }
          if (Array.isArray(chunk)) {
            const result = [new StringChunk("(")];
            for (const [i8, p11] of chunk.entries()) {
              result.push(p11);
              if (i8 < chunk.length - 1) {
                result.push(new StringChunk(", "));
              }
            }
            result.push(new StringChunk(")"));
            return this.buildQueryFromSourceParams(result, config);
          }
          if (is(chunk, _SQL)) {
            return this.buildQueryFromSourceParams(chunk.queryChunks, {
              ...config,
              inlineParams: inlineParams || chunk.shouldInlineParams
            });
          }
          if (is(chunk, Table)) {
            const schemaName = chunk[Table.Symbol.Schema];
            const tableName = chunk[Table.Symbol.Name];
            return {
              sql: schemaName === void 0 || chunk[IsAlias] ? escapeName(tableName) : escapeName(schemaName) + "." + escapeName(tableName),
              params: []
            };
          }
          if (is(chunk, Column)) {
            const columnName = casing2.getColumnCasing(chunk);
            if (_config.invokeSource === "indexes") {
              return { sql: escapeName(columnName), params: [] };
            }
            const schemaName = chunk.table[Table.Symbol.Schema];
            return {
              sql: chunk.table[IsAlias] || schemaName === void 0 ? escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName) : escapeName(schemaName) + "." + escapeName(chunk.table[Table.Symbol.Name]) + "." + escapeName(columnName),
              params: []
            };
          }
          if (is(chunk, View)) {
            const schemaName = chunk[ViewBaseConfig].schema;
            const viewName = chunk[ViewBaseConfig].name;
            return {
              sql: schemaName === void 0 || chunk[ViewBaseConfig].isAlias ? escapeName(viewName) : escapeName(schemaName) + "." + escapeName(viewName),
              params: []
            };
          }
          if (is(chunk, Param)) {
            if (is(chunk.value, Placeholder)) {
              return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
            }
            const mappedValue = chunk.value === null ? null : chunk.encoder.mapToDriverValue(chunk.value);
            if (is(mappedValue, _SQL)) {
              return this.buildQueryFromSourceParams([mappedValue], config);
            }
            if (inlineParams) {
              return { sql: this.mapInlineParam(mappedValue, config), params: [] };
            }
            let typings = ["none"];
            if (prepareTyping) {
              typings = [prepareTyping(chunk.encoder)];
            }
            return { sql: escapeParam(paramStartIndex.value++, mappedValue), params: [mappedValue], typings };
          }
          if (is(chunk, Placeholder)) {
            return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
          }
          if (is(chunk, _SQL.Aliased) && chunk.fieldAlias !== void 0) {
            return { sql: escapeName(chunk.fieldAlias), params: [] };
          }
          if (is(chunk, Subquery)) {
            if (chunk._.isWith) {
              return { sql: escapeName(chunk._.alias), params: [] };
            }
            return this.buildQueryFromSourceParams([
              new StringChunk("("),
              chunk._.sql,
              new StringChunk(") "),
              new Name(chunk._.alias)
            ], config);
          }
          if (isPgEnum(chunk)) {
            if (chunk.schema) {
              return { sql: escapeName(chunk.schema) + "." + escapeName(chunk.enumName), params: [] };
            }
            return { sql: escapeName(chunk.enumName), params: [] };
          }
          if (isSQLWrapper(chunk)) {
            if (chunk.shouldOmitSQLParens?.()) {
              return this.buildQueryFromSourceParams([chunk.getSQL()], config);
            }
            return this.buildQueryFromSourceParams([
              new StringChunk("("),
              chunk.getSQL(),
              new StringChunk(")")
            ], config);
          }
          if (inlineParams) {
            return { sql: this.mapInlineParam(chunk, config), params: [] };
          }
          return { sql: escapeParam(paramStartIndex.value++, chunk), params: [chunk], typings: ["none"] };
        }));
      }
      mapInlineParam(chunk, { escapeString }) {
        if (chunk === null) {
          return "null";
        }
        if (typeof chunk === "number" || typeof chunk === "boolean") {
          return chunk.toString();
        }
        if (typeof chunk === "string") {
          return escapeString(chunk);
        }
        if (typeof chunk === "object") {
          const mappedValueAsString = chunk.toString();
          if (mappedValueAsString === "[object Object]") {
            return escapeString(JSON.stringify(chunk));
          }
          return escapeString(mappedValueAsString);
        }
        throw new Error("Unexpected param value: " + chunk);
      }
      getSQL() {
        return this;
      }
      as(alias2) {
        if (alias2 === void 0) {
          return this;
        }
        return new _SQL.Aliased(this, alias2);
      }
      mapWith(decoder2) {
        this.decoder = typeof decoder2 === "function" ? { mapFromDriverValue: decoder2 } : decoder2;
        return this;
      }
      inlineParams() {
        this.shouldInlineParams = true;
        return this;
      }
      /**
       * This method is used to conditionally include a part of the query.
       *
       * @param condition - Condition to check
       * @returns itself if the condition is `true`, otherwise `undefined`
       */
      if(condition) {
        return condition ? this : void 0;
      }
    };
    __publicField(_SQL, _a23, "SQL");
    SQL = _SQL;
    _a24 = entityKind;
    Name = class {
      constructor(value) {
        __publicField(this, "brand");
        this.value = value;
      }
      getSQL() {
        return new SQL([this]);
      }
    };
    __publicField(Name, _a24, "Name");
    noopDecoder = {
      mapFromDriverValue: (value) => value
    };
    noopEncoder = {
      mapToDriverValue: (value) => value
    };
    noopMapper = {
      ...noopDecoder,
      ...noopEncoder
    };
    _a25 = entityKind;
    Param = class {
      /**
       * @param value - Parameter value
       * @param encoder - Encoder to convert the value to a driver parameter
       */
      constructor(value, encoder = noopEncoder) {
        __publicField(this, "brand");
        this.value = value;
        this.encoder = encoder;
      }
      getSQL() {
        return new SQL([this]);
      }
    };
    __publicField(Param, _a25, "Param");
    ((sql22) => {
      function empty() {
        return new SQL([]);
      }
      sql22.empty = empty;
      function fromList(list) {
        return new SQL(list);
      }
      sql22.fromList = fromList;
      function raw2(str) {
        return new SQL([new StringChunk(str)]);
      }
      sql22.raw = raw2;
      function join7(chunks, separator) {
        const result = [];
        for (const [i8, chunk] of chunks.entries()) {
          if (i8 > 0 && separator !== void 0) {
            result.push(separator);
          }
          result.push(chunk);
        }
        return new SQL(result);
      }
      sql22.join = join7;
      function identifier(value) {
        return new Name(value);
      }
      sql22.identifier = identifier;
      function placeholder2(name22) {
        return new Placeholder(name22);
      }
      sql22.placeholder = placeholder2;
      function param2(value, encoder) {
        return new Param(value, encoder);
      }
      sql22.param = param2;
    })(sql || (sql = {}));
    ((SQL2) => {
      var _a506;
      _a506 = entityKind;
      const _Aliased = class _Aliased {
        constructor(sql22, fieldAlias) {
          /** @internal */
          __publicField(this, "isSelectionField", false);
          this.sql = sql22;
          this.fieldAlias = fieldAlias;
        }
        getSQL() {
          return this.sql;
        }
        /** @internal */
        clone() {
          return new _Aliased(this.sql, this.fieldAlias);
        }
      };
      __publicField(_Aliased, _a506, "SQL.Aliased");
      let Aliased = _Aliased;
      SQL2.Aliased = Aliased;
    })(SQL || (SQL = {}));
    _a26 = entityKind;
    Placeholder = class {
      constructor(name22) {
        this.name = name22;
      }
      getSQL() {
        return new SQL([this]);
      }
    };
    __publicField(Placeholder, _a26, "Placeholder");
    IsDrizzleView = Symbol.for("drizzle:IsDrizzleView");
    _c2 = entityKind, _b12 = ViewBaseConfig, _a27 = IsDrizzleView;
    View = class {
      constructor({ name: name22, schema: schema6, selectedFields, query }) {
        /** @internal */
        __publicField(this, _b12);
        /** @internal */
        __publicField(this, _a27, true);
        this[ViewBaseConfig] = {
          name: name22,
          originalName: name22,
          schema: schema6,
          selectedFields,
          query,
          isExisting: !query,
          isAlias: false
        };
      }
      getSQL() {
        return new SQL([this]);
      }
    };
    __publicField(View, _c2, "View");
    Column.prototype.getSQL = function() {
      return new SQL([this]);
    };
    Table.prototype.getSQL = function() {
      return new SQL([this]);
    };
    Subquery.prototype.getSQL = function() {
      return new SQL([this]);
    };
  }
});

// ../drizzle-orm/dist/alias.js
function aliasedTable(table6, tableAlias) {
  return new Proxy(table6, new TableAliasProxyHandler(tableAlias, false));
}
function aliasedRelation(relation, tableAlias) {
  return new Proxy(relation, new RelationTableAliasProxyHandler(tableAlias));
}
function aliasedTableColumn(column6, tableAlias) {
  return new Proxy(
    column6,
    new ColumnAliasProxyHandler(new Proxy(column6.table, new TableAliasProxyHandler(tableAlias, false)))
  );
}
function mapColumnsInAliasedSQLToAlias(query, alias2) {
  return new SQL.Aliased(mapColumnsInSQLToAlias(query.sql, alias2), query.fieldAlias);
}
function mapColumnsInSQLToAlias(query, alias2) {
  return sql.join(query.queryChunks.map((c6) => {
    if (is(c6, Column)) {
      return aliasedTableColumn(c6, alias2);
    }
    if (is(c6, SQL)) {
      return mapColumnsInSQLToAlias(c6, alias2);
    }
    if (is(c6, SQL.Aliased)) {
      return mapColumnsInAliasedSQLToAlias(c6, alias2);
    }
    return c6;
  }));
}
var _a28, ColumnAliasProxyHandler, _a29, TableAliasProxyHandler, _a30, RelationTableAliasProxyHandler;
var init_alias = __esm({
  "../drizzle-orm/dist/alias.js"() {
    "use strict";
    init_column();
    init_entity();
    init_sql();
    init_table();
    init_view_common();
    _a28 = entityKind;
    ColumnAliasProxyHandler = class {
      constructor(table6) {
        this.table = table6;
      }
      get(columnObj, prop) {
        if (prop === "table") {
          return this.table;
        }
        return columnObj[prop];
      }
    };
    __publicField(ColumnAliasProxyHandler, _a28, "ColumnAliasProxyHandler");
    _a29 = entityKind;
    TableAliasProxyHandler = class {
      constructor(alias2, replaceOriginalName) {
        this.alias = alias2;
        this.replaceOriginalName = replaceOriginalName;
      }
      get(target, prop) {
        if (prop === Table.Symbol.IsAlias) {
          return true;
        }
        if (prop === Table.Symbol.Name) {
          return this.alias;
        }
        if (this.replaceOriginalName && prop === Table.Symbol.OriginalName) {
          return this.alias;
        }
        if (prop === ViewBaseConfig) {
          return {
            ...target[ViewBaseConfig],
            name: this.alias,
            isAlias: true
          };
        }
        if (prop === Table.Symbol.Columns) {
          const columns = target[Table.Symbol.Columns];
          if (!columns) {
            return columns;
          }
          const proxiedColumns = {};
          Object.keys(columns).map((key) => {
            proxiedColumns[key] = new Proxy(
              columns[key],
              new ColumnAliasProxyHandler(new Proxy(target, this))
            );
          });
          return proxiedColumns;
        }
        const value = target[prop];
        if (is(value, Column)) {
          return new Proxy(value, new ColumnAliasProxyHandler(new Proxy(target, this)));
        }
        return value;
      }
    };
    __publicField(TableAliasProxyHandler, _a29, "TableAliasProxyHandler");
    _a30 = entityKind;
    RelationTableAliasProxyHandler = class {
      constructor(alias2) {
        this.alias = alias2;
      }
      get(target, prop) {
        if (prop === "sourceTable") {
          return aliasedTable(target.sourceTable, this.alias);
        }
        return target[prop];
      }
    };
    __publicField(RelationTableAliasProxyHandler, _a30, "RelationTableAliasProxyHandler");
  }
});

// ../drizzle-orm/dist/errors.js
var _a31, _b13, DrizzleError, DrizzleQueryError, _a32, _b14, TransactionRollbackError;
var init_errors = __esm({
  "../drizzle-orm/dist/errors.js"() {
    "use strict";
    init_entity();
    DrizzleError = class extends (_b13 = Error, _a31 = entityKind, _b13) {
      constructor({ message, cause }) {
        super(message);
        this.name = "DrizzleError";
        this.cause = cause;
      }
    };
    __publicField(DrizzleError, _a31, "DrizzleError");
    DrizzleQueryError = class _DrizzleQueryError extends Error {
      constructor(query, params, cause) {
        super(`Failed query: ${query}
params: ${params}`);
        this.query = query;
        this.params = params;
        this.cause = cause;
        Error.captureStackTrace(this, _DrizzleQueryError);
        if (cause) this.cause = cause;
      }
    };
    TransactionRollbackError = class extends (_b14 = DrizzleError, _a32 = entityKind, _b14) {
      constructor() {
        super({ message: "Rollback" });
      }
    };
    __publicField(TransactionRollbackError, _a32, "TransactionRollbackError");
  }
});

// ../drizzle-orm/dist/logger.js
var _a33, ConsoleLogWriter, _a34, DefaultLogger, _a35, NoopLogger;
var init_logger = __esm({
  "../drizzle-orm/dist/logger.js"() {
    "use strict";
    init_entity();
    _a33 = entityKind;
    ConsoleLogWriter = class {
      write(message) {
        console.log(message);
      }
    };
    __publicField(ConsoleLogWriter, _a33, "ConsoleLogWriter");
    _a34 = entityKind;
    DefaultLogger = class {
      constructor(config) {
        __publicField(this, "writer");
        this.writer = config?.writer ?? new ConsoleLogWriter();
      }
      logQuery(query, params) {
        const stringifiedParams = params.map((p11) => {
          try {
            return JSON.stringify(p11);
          } catch {
            return String(p11);
          }
        });
        const paramsStr = stringifiedParams.length ? ` -- params: [${stringifiedParams.join(", ")}]` : "";
        this.writer.write(`Query: ${query}${paramsStr}`);
      }
    };
    __publicField(DefaultLogger, _a34, "DefaultLogger");
    _a35 = entityKind;
    NoopLogger = class {
      logQuery() {
      }
    };
    __publicField(NoopLogger, _a35, "NoopLogger");
  }
});

// ../drizzle-orm/dist/operations.js
var init_operations = __esm({
  "../drizzle-orm/dist/operations.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/query-promise.js
var _a36, _b15, QueryPromise;
var init_query_promise = __esm({
  "../drizzle-orm/dist/query-promise.js"() {
    "use strict";
    init_entity();
    _b15 = entityKind, _a36 = Symbol.toStringTag;
    QueryPromise = class {
      constructor() {
        __publicField(this, _a36, "QueryPromise");
      }
      catch(onRejected) {
        return this.then(void 0, onRejected);
      }
      finally(onFinally) {
        return this.then(
          (value) => {
            onFinally?.();
            return value;
          },
          (reason) => {
            onFinally?.();
            throw reason;
          }
        );
      }
      then(onFulfilled, onRejected) {
        return this.execute().then(onFulfilled, onRejected);
      }
    };
    __publicField(QueryPromise, _b15, "QueryPromise");
  }
});

// ../drizzle-orm/dist/utils.js
function mapResultRow(columns, row, joinsNotNullableMap) {
  const nullifyMap = {};
  const result = columns.reduce(
    (result2, { path: path3, field }, columnIndex) => {
      let decoder2;
      if (is(field, Column)) {
        decoder2 = field;
      } else if (is(field, SQL)) {
        decoder2 = field.decoder;
      } else {
        decoder2 = field.sql.decoder;
      }
      let node = result2;
      for (const [pathChunkIndex, pathChunk] of path3.entries()) {
        if (pathChunkIndex < path3.length - 1) {
          if (!(pathChunk in node)) {
            node[pathChunk] = {};
          }
          node = node[pathChunk];
        } else {
          const rawValue = row[columnIndex];
          const value = node[pathChunk] = rawValue === null ? null : decoder2.mapFromDriverValue(rawValue);
          if (joinsNotNullableMap && is(field, Column) && path3.length === 2) {
            const objectName = path3[0];
            if (!(objectName in nullifyMap)) {
              nullifyMap[objectName] = value === null ? getTableName(field.table) : false;
            } else if (typeof nullifyMap[objectName] === "string" && nullifyMap[objectName] !== getTableName(field.table)) {
              nullifyMap[objectName] = false;
            }
          }
        }
      }
      return result2;
    },
    {}
  );
  if (joinsNotNullableMap && Object.keys(nullifyMap).length > 0) {
    for (const [objectName, tableName] of Object.entries(nullifyMap)) {
      if (typeof tableName === "string" && !joinsNotNullableMap[tableName]) {
        result[objectName] = null;
      }
    }
  }
  return result;
}
function orderSelectedFields(fields, pathPrefix) {
  return Object.entries(fields).reduce((result, [name3, field]) => {
    if (typeof name3 !== "string") {
      return result;
    }
    const newPath = pathPrefix ? [...pathPrefix, name3] : [name3];
    if (is(field, Column) || is(field, SQL) || is(field, SQL.Aliased)) {
      result.push({ path: newPath, field });
    } else if (is(field, Table)) {
      result.push(...orderSelectedFields(field[Table.Symbol.Columns], newPath));
    } else {
      result.push(...orderSelectedFields(field, newPath));
    }
    return result;
  }, []);
}
function haveSameKeys(left, right) {
  const leftKeys = Object.keys(left);
  const rightKeys = Object.keys(right);
  if (leftKeys.length !== rightKeys.length) {
    return false;
  }
  for (const [index7, key] of leftKeys.entries()) {
    if (key !== rightKeys[index7]) {
      return false;
    }
  }
  return true;
}
function mapUpdateSet(table6, values2) {
  const entries = Object.entries(values2).filter(([, value]) => value !== void 0).map(([key, value]) => {
    if (is(value, SQL) || is(value, Column)) {
      return [key, value];
    } else {
      return [key, new Param(value, table6[Table.Symbol.Columns][key])];
    }
  });
  if (entries.length === 0) {
    throw new Error("No values to set");
  }
  return Object.fromEntries(entries);
}
function applyMixins(baseClass, extendedClasses) {
  for (const extendedClass of extendedClasses) {
    for (const name3 of Object.getOwnPropertyNames(extendedClass.prototype)) {
      if (name3 === "constructor") continue;
      Object.defineProperty(
        baseClass.prototype,
        name3,
        Object.getOwnPropertyDescriptor(extendedClass.prototype, name3) || /* @__PURE__ */ Object.create(null)
      );
    }
  }
}
function getTableColumns(table6) {
  return table6[Table.Symbol.Columns];
}
function getViewSelectedFields(view5) {
  return view5[ViewBaseConfig].selectedFields;
}
function getTableLikeName(table6) {
  return is(table6, Subquery) ? table6._.alias : is(table6, View) ? table6[ViewBaseConfig].name : is(table6, SQL) ? void 0 : table6[Table.Symbol.IsAlias] ? table6[Table.Symbol.Name] : table6[Table.Symbol.BaseName];
}
function getColumnNameAndConfig(a9, b9) {
  return {
    name: typeof a9 === "string" && a9.length > 0 ? a9 : "",
    config: typeof a9 === "object" ? a9 : b9
  };
}
function isConfig(data) {
  if (typeof data !== "object" || data === null) return false;
  if (data.constructor.name !== "Object") return false;
  if ("logger" in data) {
    const type = typeof data["logger"];
    if (type !== "boolean" && (type !== "object" || typeof data["logger"]["logQuery"] !== "function") && type !== "undefined") return false;
    return true;
  }
  if ("schema" in data) {
    const type = typeof data["schema"];
    if (type !== "object" && type !== "undefined") return false;
    return true;
  }
  if ("casing" in data) {
    const type = typeof data["casing"];
    if (type !== "string" && type !== "undefined") return false;
    return true;
  }
  if ("mode" in data) {
    if (data["mode"] !== "default" || data["mode"] !== "planetscale" || data["mode"] !== void 0) return false;
    return true;
  }
  if ("connection" in data) {
    const type = typeof data["connection"];
    if (type !== "string" && type !== "object" && type !== "undefined") return false;
    return true;
  }
  if ("client" in data) {
    const type = typeof data["client"];
    if (type !== "object" && type !== "function" && type !== "undefined") return false;
    return true;
  }
  if (Object.keys(data).length === 0) return true;
  return false;
}
var textDecoder;
var init_utils = __esm({
  "../drizzle-orm/dist/utils.js"() {
    "use strict";
    init_column();
    init_entity();
    init_sql();
    init_subquery();
    init_table();
    init_view_common();
    textDecoder = typeof TextDecoder === "undefined" ? null : new TextDecoder();
  }
});

// ../drizzle-orm/dist/pg-core/columns/int.common.js
var _a37, _b16, PgIntColumnBaseBuilder;
var init_int_common = __esm({
  "../drizzle-orm/dist/pg-core/columns/int.common.js"() {
    "use strict";
    init_entity();
    init_common();
    PgIntColumnBaseBuilder = class extends (_b16 = PgColumnBuilder, _a37 = entityKind, _b16) {
      generatedAlwaysAsIdentity(sequence) {
        if (sequence) {
          const { name: name3, ...options } = sequence;
          this.config.generatedIdentity = {
            type: "always",
            sequenceName: name3,
            sequenceOptions: options
          };
        } else {
          this.config.generatedIdentity = {
            type: "always"
          };
        }
        this.config.hasDefault = true;
        this.config.notNull = true;
        return this;
      }
      generatedByDefaultAsIdentity(sequence) {
        if (sequence) {
          const { name: name3, ...options } = sequence;
          this.config.generatedIdentity = {
            type: "byDefault",
            sequenceName: name3,
            sequenceOptions: options
          };
        } else {
          this.config.generatedIdentity = {
            type: "byDefault"
          };
        }
        this.config.hasDefault = true;
        this.config.notNull = true;
        return this;
      }
    };
    __publicField(PgIntColumnBaseBuilder, _a37, "PgIntColumnBaseBuilder");
  }
});

// ../drizzle-orm/dist/pg-core/columns/bigint.js
function bigint(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config.mode === "number") {
    return new PgBigInt53Builder(name3);
  }
  return new PgBigInt64Builder(name3);
}
var _a38, _b17, PgBigInt53Builder, _a39, _b18, PgBigInt53, _a40, _b19, PgBigInt64Builder, _a41, _b20, PgBigInt64;
var init_bigint = __esm({
  "../drizzle-orm/dist/pg-core/columns/bigint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    init_int_common();
    PgBigInt53Builder = class extends (_b17 = PgIntColumnBaseBuilder, _a38 = entityKind, _b17) {
      constructor(name3) {
        super(name3, "number", "PgBigInt53");
      }
      /** @internal */
      build(table6) {
        return new PgBigInt53(table6, this.config);
      }
    };
    __publicField(PgBigInt53Builder, _a38, "PgBigInt53Builder");
    PgBigInt53 = class extends (_b18 = PgColumn, _a39 = entityKind, _b18) {
      getSQLType() {
        return "bigint";
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") {
          return value;
        }
        return Number(value);
      }
    };
    __publicField(PgBigInt53, _a39, "PgBigInt53");
    PgBigInt64Builder = class extends (_b19 = PgIntColumnBaseBuilder, _a40 = entityKind, _b19) {
      constructor(name3) {
        super(name3, "bigint", "PgBigInt64");
      }
      /** @internal */
      build(table6) {
        return new PgBigInt64(
          table6,
          this.config
        );
      }
    };
    __publicField(PgBigInt64Builder, _a40, "PgBigInt64Builder");
    PgBigInt64 = class extends (_b20 = PgColumn, _a41 = entityKind, _b20) {
      getSQLType() {
        return "bigint";
      }
      // eslint-disable-next-line unicorn/prefer-native-coercion-functions
      mapFromDriverValue(value) {
        return BigInt(value);
      }
    };
    __publicField(PgBigInt64, _a41, "PgBigInt64");
  }
});

// ../drizzle-orm/dist/pg-core/columns/bigserial.js
function bigserial(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config.mode === "number") {
    return new PgBigSerial53Builder(name3);
  }
  return new PgBigSerial64Builder(name3);
}
var _a42, _b21, PgBigSerial53Builder, _a43, _b22, PgBigSerial53, _a44, _b23, PgBigSerial64Builder, _a45, _b24, PgBigSerial64;
var init_bigserial = __esm({
  "../drizzle-orm/dist/pg-core/columns/bigserial.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgBigSerial53Builder = class extends (_b21 = PgColumnBuilder, _a42 = entityKind, _b21) {
      constructor(name3) {
        super(name3, "number", "PgBigSerial53");
        this.config.hasDefault = true;
        this.config.notNull = true;
      }
      /** @internal */
      build(table6) {
        return new PgBigSerial53(
          table6,
          this.config
        );
      }
    };
    __publicField(PgBigSerial53Builder, _a42, "PgBigSerial53Builder");
    PgBigSerial53 = class extends (_b22 = PgColumn, _a43 = entityKind, _b22) {
      getSQLType() {
        return "bigserial";
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") {
          return value;
        }
        return Number(value);
      }
    };
    __publicField(PgBigSerial53, _a43, "PgBigSerial53");
    PgBigSerial64Builder = class extends (_b23 = PgColumnBuilder, _a44 = entityKind, _b23) {
      constructor(name3) {
        super(name3, "bigint", "PgBigSerial64");
        this.config.hasDefault = true;
      }
      /** @internal */
      build(table6) {
        return new PgBigSerial64(
          table6,
          this.config
        );
      }
    };
    __publicField(PgBigSerial64Builder, _a44, "PgBigSerial64Builder");
    PgBigSerial64 = class extends (_b24 = PgColumn, _a45 = entityKind, _b24) {
      getSQLType() {
        return "bigserial";
      }
      // eslint-disable-next-line unicorn/prefer-native-coercion-functions
      mapFromDriverValue(value) {
        return BigInt(value);
      }
    };
    __publicField(PgBigSerial64, _a45, "PgBigSerial64");
  }
});

// ../drizzle-orm/dist/pg-core/columns/boolean.js
function boolean(name3) {
  return new PgBooleanBuilder(name3 ?? "");
}
var _a46, _b25, PgBooleanBuilder, _a47, _b26, PgBoolean;
var init_boolean = __esm({
  "../drizzle-orm/dist/pg-core/columns/boolean.js"() {
    "use strict";
    init_entity();
    init_common();
    PgBooleanBuilder = class extends (_b25 = PgColumnBuilder, _a46 = entityKind, _b25) {
      constructor(name3) {
        super(name3, "boolean", "PgBoolean");
      }
      /** @internal */
      build(table6) {
        return new PgBoolean(table6, this.config);
      }
    };
    __publicField(PgBooleanBuilder, _a46, "PgBooleanBuilder");
    PgBoolean = class extends (_b26 = PgColumn, _a47 = entityKind, _b26) {
      getSQLType() {
        return "boolean";
      }
    };
    __publicField(PgBoolean, _a47, "PgBoolean");
  }
});

// ../drizzle-orm/dist/pg-core/columns/char.js
function char(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgCharBuilder(name3, config);
}
var _a48, _b27, PgCharBuilder, _a49, _b28, PgChar;
var init_char = __esm({
  "../drizzle-orm/dist/pg-core/columns/char.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgCharBuilder = class extends (_b27 = PgColumnBuilder, _a48 = entityKind, _b27) {
      constructor(name3, config) {
        super(name3, "string", "PgChar");
        this.config.length = config.length;
        this.config.enumValues = config.enum;
      }
      /** @internal */
      build(table6) {
        return new PgChar(
          table6,
          this.config
        );
      }
    };
    __publicField(PgCharBuilder, _a48, "PgCharBuilder");
    PgChar = class extends (_b28 = PgColumn, _a49 = entityKind, _b28) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return this.length === void 0 ? `char` : `char(${this.length})`;
      }
    };
    __publicField(PgChar, _a49, "PgChar");
  }
});

// ../drizzle-orm/dist/pg-core/columns/cidr.js
function cidr(name3) {
  return new PgCidrBuilder(name3 ?? "");
}
var _a50, _b29, PgCidrBuilder, _a51, _b30, PgCidr;
var init_cidr = __esm({
  "../drizzle-orm/dist/pg-core/columns/cidr.js"() {
    "use strict";
    init_entity();
    init_common();
    PgCidrBuilder = class extends (_b29 = PgColumnBuilder, _a50 = entityKind, _b29) {
      constructor(name3) {
        super(name3, "string", "PgCidr");
      }
      /** @internal */
      build(table6) {
        return new PgCidr(table6, this.config);
      }
    };
    __publicField(PgCidrBuilder, _a50, "PgCidrBuilder");
    PgCidr = class extends (_b30 = PgColumn, _a51 = entityKind, _b30) {
      getSQLType() {
        return "cidr";
      }
    };
    __publicField(PgCidr, _a51, "PgCidr");
  }
});

// ../drizzle-orm/dist/pg-core/columns/custom.js
function customType(customTypeParams) {
  return (a9, b9) => {
    const { name: name3, config } = getColumnNameAndConfig(a9, b9);
    return new PgCustomColumnBuilder(name3, config, customTypeParams);
  };
}
var _a52, _b31, PgCustomColumnBuilder, _a53, _b32, PgCustomColumn;
var init_custom = __esm({
  "../drizzle-orm/dist/pg-core/columns/custom.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgCustomColumnBuilder = class extends (_b31 = PgColumnBuilder, _a52 = entityKind, _b31) {
      constructor(name3, fieldConfig, customTypeParams) {
        super(name3, "custom", "PgCustomColumn");
        this.config.fieldConfig = fieldConfig;
        this.config.customTypeParams = customTypeParams;
      }
      /** @internal */
      build(table6) {
        return new PgCustomColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(PgCustomColumnBuilder, _a52, "PgCustomColumnBuilder");
    PgCustomColumn = class extends (_b32 = PgColumn, _a53 = entityKind, _b32) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "sqlName");
        __publicField(this, "mapTo");
        __publicField(this, "mapFrom");
        this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
        this.mapTo = config.customTypeParams.toDriver;
        this.mapFrom = config.customTypeParams.fromDriver;
      }
      getSQLType() {
        return this.sqlName;
      }
      mapFromDriverValue(value) {
        return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
      }
      mapToDriverValue(value) {
        return typeof this.mapTo === "function" ? this.mapTo(value) : value;
      }
    };
    __publicField(PgCustomColumn, _a53, "PgCustomColumn");
  }
});

// ../drizzle-orm/dist/pg-core/columns/date.common.js
var _a54, _b33, PgDateColumnBaseBuilder;
var init_date_common = __esm({
  "../drizzle-orm/dist/pg-core/columns/date.common.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_common();
    PgDateColumnBaseBuilder = class extends (_b33 = PgColumnBuilder, _a54 = entityKind, _b33) {
      defaultNow() {
        return this.default(sql`now()`);
      }
    };
    __publicField(PgDateColumnBaseBuilder, _a54, "PgDateColumnBaseBuilder");
  }
});

// ../drizzle-orm/dist/pg-core/columns/date.js
function date(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "date") {
    return new PgDateBuilder(name3);
  }
  return new PgDateStringBuilder(name3);
}
var _a55, _b34, PgDateBuilder, _a56, _b35, PgDate, _a57, _b36, PgDateStringBuilder, _a58, _b37, PgDateString;
var init_date = __esm({
  "../drizzle-orm/dist/pg-core/columns/date.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    init_date_common();
    PgDateBuilder = class extends (_b34 = PgDateColumnBaseBuilder, _a55 = entityKind, _b34) {
      constructor(name3) {
        super(name3, "date", "PgDate");
      }
      /** @internal */
      build(table6) {
        return new PgDate(table6, this.config);
      }
    };
    __publicField(PgDateBuilder, _a55, "PgDateBuilder");
    PgDate = class extends (_b35 = PgColumn, _a56 = entityKind, _b35) {
      getSQLType() {
        return "date";
      }
      mapFromDriverValue(value) {
        return new Date(value);
      }
      mapToDriverValue(value) {
        return value.toISOString();
      }
    };
    __publicField(PgDate, _a56, "PgDate");
    PgDateStringBuilder = class extends (_b36 = PgDateColumnBaseBuilder, _a57 = entityKind, _b36) {
      constructor(name3) {
        super(name3, "string", "PgDateString");
      }
      /** @internal */
      build(table6) {
        return new PgDateString(
          table6,
          this.config
        );
      }
    };
    __publicField(PgDateStringBuilder, _a57, "PgDateStringBuilder");
    PgDateString = class extends (_b37 = PgColumn, _a58 = entityKind, _b37) {
      getSQLType() {
        return "date";
      }
    };
    __publicField(PgDateString, _a58, "PgDateString");
  }
});

// ../drizzle-orm/dist/pg-core/columns/double-precision.js
function doublePrecision(name3) {
  return new PgDoublePrecisionBuilder(name3 ?? "");
}
var _a59, _b38, PgDoublePrecisionBuilder, _a60, _b39, PgDoublePrecision;
var init_double_precision = __esm({
  "../drizzle-orm/dist/pg-core/columns/double-precision.js"() {
    "use strict";
    init_entity();
    init_common();
    PgDoublePrecisionBuilder = class extends (_b38 = PgColumnBuilder, _a59 = entityKind, _b38) {
      constructor(name3) {
        super(name3, "number", "PgDoublePrecision");
      }
      /** @internal */
      build(table6) {
        return new PgDoublePrecision(
          table6,
          this.config
        );
      }
    };
    __publicField(PgDoublePrecisionBuilder, _a59, "PgDoublePrecisionBuilder");
    PgDoublePrecision = class extends (_b39 = PgColumn, _a60 = entityKind, _b39) {
      getSQLType() {
        return "double precision";
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number.parseFloat(value);
        }
        return value;
      }
    };
    __publicField(PgDoublePrecision, _a60, "PgDoublePrecision");
  }
});

// ../drizzle-orm/dist/pg-core/columns/inet.js
function inet(name3) {
  return new PgInetBuilder(name3 ?? "");
}
var _a61, _b40, PgInetBuilder, _a62, _b41, PgInet;
var init_inet = __esm({
  "../drizzle-orm/dist/pg-core/columns/inet.js"() {
    "use strict";
    init_entity();
    init_common();
    PgInetBuilder = class extends (_b40 = PgColumnBuilder, _a61 = entityKind, _b40) {
      constructor(name3) {
        super(name3, "string", "PgInet");
      }
      /** @internal */
      build(table6) {
        return new PgInet(table6, this.config);
      }
    };
    __publicField(PgInetBuilder, _a61, "PgInetBuilder");
    PgInet = class extends (_b41 = PgColumn, _a62 = entityKind, _b41) {
      getSQLType() {
        return "inet";
      }
    };
    __publicField(PgInet, _a62, "PgInet");
  }
});

// ../drizzle-orm/dist/pg-core/columns/integer.js
function integer(name3) {
  return new PgIntegerBuilder(name3 ?? "");
}
var _a63, _b42, PgIntegerBuilder, _a64, _b43, PgInteger;
var init_integer = __esm({
  "../drizzle-orm/dist/pg-core/columns/integer.js"() {
    "use strict";
    init_entity();
    init_common();
    init_int_common();
    PgIntegerBuilder = class extends (_b42 = PgIntColumnBaseBuilder, _a63 = entityKind, _b42) {
      constructor(name3) {
        super(name3, "number", "PgInteger");
      }
      /** @internal */
      build(table6) {
        return new PgInteger(table6, this.config);
      }
    };
    __publicField(PgIntegerBuilder, _a63, "PgIntegerBuilder");
    PgInteger = class extends (_b43 = PgColumn, _a64 = entityKind, _b43) {
      getSQLType() {
        return "integer";
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number.parseInt(value);
        }
        return value;
      }
    };
    __publicField(PgInteger, _a64, "PgInteger");
  }
});

// ../drizzle-orm/dist/pg-core/columns/interval.js
function interval(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgIntervalBuilder(name3, config);
}
var _a65, _b44, PgIntervalBuilder, _a66, _b45, PgInterval;
var init_interval = __esm({
  "../drizzle-orm/dist/pg-core/columns/interval.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgIntervalBuilder = class extends (_b44 = PgColumnBuilder, _a65 = entityKind, _b44) {
      constructor(name3, intervalConfig) {
        super(name3, "string", "PgInterval");
        this.config.intervalConfig = intervalConfig;
      }
      /** @internal */
      build(table6) {
        return new PgInterval(table6, this.config);
      }
    };
    __publicField(PgIntervalBuilder, _a65, "PgIntervalBuilder");
    PgInterval = class extends (_b45 = PgColumn, _a66 = entityKind, _b45) {
      constructor() {
        super(...arguments);
        __publicField(this, "fields", this.config.intervalConfig.fields);
        __publicField(this, "precision", this.config.intervalConfig.precision);
      }
      getSQLType() {
        const fields = this.fields ? ` ${this.fields}` : "";
        const precision = this.precision ? `(${this.precision})` : "";
        return `interval${fields}${precision}`;
      }
    };
    __publicField(PgInterval, _a66, "PgInterval");
  }
});

// ../drizzle-orm/dist/pg-core/columns/json.js
function json(name3) {
  return new PgJsonBuilder(name3 ?? "");
}
var _a67, _b46, PgJsonBuilder, _a68, _b47, PgJson;
var init_json = __esm({
  "../drizzle-orm/dist/pg-core/columns/json.js"() {
    "use strict";
    init_entity();
    init_common();
    PgJsonBuilder = class extends (_b46 = PgColumnBuilder, _a67 = entityKind, _b46) {
      constructor(name3) {
        super(name3, "json", "PgJson");
      }
      /** @internal */
      build(table6) {
        return new PgJson(table6, this.config);
      }
    };
    __publicField(PgJsonBuilder, _a67, "PgJsonBuilder");
    PgJson = class extends (_b47 = PgColumn, _a68 = entityKind, _b47) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return "json";
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          try {
            return JSON.parse(value);
          } catch {
            return value;
          }
        }
        return value;
      }
    };
    __publicField(PgJson, _a68, "PgJson");
  }
});

// ../drizzle-orm/dist/pg-core/columns/jsonb.js
function jsonb(name3) {
  return new PgJsonbBuilder(name3 ?? "");
}
var _a69, _b48, PgJsonbBuilder, _a70, _b49, PgJsonb;
var init_jsonb = __esm({
  "../drizzle-orm/dist/pg-core/columns/jsonb.js"() {
    "use strict";
    init_entity();
    init_common();
    PgJsonbBuilder = class extends (_b48 = PgColumnBuilder, _a69 = entityKind, _b48) {
      constructor(name3) {
        super(name3, "json", "PgJsonb");
      }
      /** @internal */
      build(table6) {
        return new PgJsonb(table6, this.config);
      }
    };
    __publicField(PgJsonbBuilder, _a69, "PgJsonbBuilder");
    PgJsonb = class extends (_b49 = PgColumn, _a70 = entityKind, _b49) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return "jsonb";
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          try {
            return JSON.parse(value);
          } catch {
            return value;
          }
        }
        return value;
      }
    };
    __publicField(PgJsonb, _a70, "PgJsonb");
  }
});

// ../drizzle-orm/dist/pg-core/columns/line.js
function line(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (!config?.mode || config.mode === "tuple") {
    return new PgLineBuilder(name3);
  }
  return new PgLineABCBuilder(name3);
}
var _a71, _b50, PgLineBuilder, _a72, _b51, PgLineTuple, _a73, _b52, PgLineABCBuilder, _a74, _b53, PgLineABC;
var init_line = __esm({
  "../drizzle-orm/dist/pg-core/columns/line.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgLineBuilder = class extends (_b50 = PgColumnBuilder, _a71 = entityKind, _b50) {
      constructor(name3) {
        super(name3, "array", "PgLine");
      }
      /** @internal */
      build(table6) {
        return new PgLineTuple(
          table6,
          this.config
        );
      }
    };
    __publicField(PgLineBuilder, _a71, "PgLineBuilder");
    PgLineTuple = class extends (_b51 = PgColumn, _a72 = entityKind, _b51) {
      getSQLType() {
        return "line";
      }
      mapFromDriverValue(value) {
        const [a9, b9, c6] = value.slice(1, -1).split(",");
        return [Number.parseFloat(a9), Number.parseFloat(b9), Number.parseFloat(c6)];
      }
      mapToDriverValue(value) {
        return `{${value[0]},${value[1]},${value[2]}}`;
      }
    };
    __publicField(PgLineTuple, _a72, "PgLine");
    PgLineABCBuilder = class extends (_b52 = PgColumnBuilder, _a73 = entityKind, _b52) {
      constructor(name3) {
        super(name3, "json", "PgLineABC");
      }
      /** @internal */
      build(table6) {
        return new PgLineABC(
          table6,
          this.config
        );
      }
    };
    __publicField(PgLineABCBuilder, _a73, "PgLineABCBuilder");
    PgLineABC = class extends (_b53 = PgColumn, _a74 = entityKind, _b53) {
      getSQLType() {
        return "line";
      }
      mapFromDriverValue(value) {
        const [a9, b9, c6] = value.slice(1, -1).split(",");
        return { a: Number.parseFloat(a9), b: Number.parseFloat(b9), c: Number.parseFloat(c6) };
      }
      mapToDriverValue(value) {
        return `{${value.a},${value.b},${value.c}}`;
      }
    };
    __publicField(PgLineABC, _a74, "PgLineABC");
  }
});

// ../drizzle-orm/dist/pg-core/columns/macaddr.js
function macaddr(name3) {
  return new PgMacaddrBuilder(name3 ?? "");
}
var _a75, _b54, PgMacaddrBuilder, _a76, _b55, PgMacaddr;
var init_macaddr = __esm({
  "../drizzle-orm/dist/pg-core/columns/macaddr.js"() {
    "use strict";
    init_entity();
    init_common();
    PgMacaddrBuilder = class extends (_b54 = PgColumnBuilder, _a75 = entityKind, _b54) {
      constructor(name3) {
        super(name3, "string", "PgMacaddr");
      }
      /** @internal */
      build(table6) {
        return new PgMacaddr(table6, this.config);
      }
    };
    __publicField(PgMacaddrBuilder, _a75, "PgMacaddrBuilder");
    PgMacaddr = class extends (_b55 = PgColumn, _a76 = entityKind, _b55) {
      getSQLType() {
        return "macaddr";
      }
    };
    __publicField(PgMacaddr, _a76, "PgMacaddr");
  }
});

// ../drizzle-orm/dist/pg-core/columns/macaddr8.js
function macaddr8(name3) {
  return new PgMacaddr8Builder(name3 ?? "");
}
var _a77, _b56, PgMacaddr8Builder, _a78, _b57, PgMacaddr8;
var init_macaddr8 = __esm({
  "../drizzle-orm/dist/pg-core/columns/macaddr8.js"() {
    "use strict";
    init_entity();
    init_common();
    PgMacaddr8Builder = class extends (_b56 = PgColumnBuilder, _a77 = entityKind, _b56) {
      constructor(name3) {
        super(name3, "string", "PgMacaddr8");
      }
      /** @internal */
      build(table6) {
        return new PgMacaddr8(table6, this.config);
      }
    };
    __publicField(PgMacaddr8Builder, _a77, "PgMacaddr8Builder");
    PgMacaddr8 = class extends (_b57 = PgColumn, _a78 = entityKind, _b57) {
      getSQLType() {
        return "macaddr8";
      }
    };
    __publicField(PgMacaddr8, _a78, "PgMacaddr8");
  }
});

// ../drizzle-orm/dist/pg-core/columns/numeric.js
function numeric(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  const mode = config?.mode;
  return mode === "number" ? new PgNumericNumberBuilder(name3, config?.precision, config?.scale) : mode === "bigint" ? new PgNumericBigIntBuilder(name3, config?.precision, config?.scale) : new PgNumericBuilder(name3, config?.precision, config?.scale);
}
var _a79, _b58, PgNumericBuilder, _a80, _b59, PgNumeric, _a81, _b60, PgNumericNumberBuilder, _a82, _b61, PgNumericNumber, _a83, _b62, PgNumericBigIntBuilder, _a84, _b63, PgNumericBigInt, decimal;
var init_numeric = __esm({
  "../drizzle-orm/dist/pg-core/columns/numeric.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgNumericBuilder = class extends (_b58 = PgColumnBuilder, _a79 = entityKind, _b58) {
      constructor(name3, precision, scale) {
        super(name3, "string", "PgNumeric");
        this.config.precision = precision;
        this.config.scale = scale;
      }
      /** @internal */
      build(table6) {
        return new PgNumeric(table6, this.config);
      }
    };
    __publicField(PgNumericBuilder, _a79, "PgNumericBuilder");
    PgNumeric = class extends (_b59 = PgColumn, _a80 = entityKind, _b59) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "precision");
        __publicField(this, "scale");
        this.precision = config.precision;
        this.scale = config.scale;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        return String(value);
      }
      getSQLType() {
        if (this.precision !== void 0 && this.scale !== void 0) {
          return `numeric(${this.precision}, ${this.scale})`;
        } else if (this.precision === void 0) {
          return "numeric";
        } else {
          return `numeric(${this.precision})`;
        }
      }
    };
    __publicField(PgNumeric, _a80, "PgNumeric");
    PgNumericNumberBuilder = class extends (_b60 = PgColumnBuilder, _a81 = entityKind, _b60) {
      constructor(name3, precision, scale) {
        super(name3, "number", "PgNumericNumber");
        this.config.precision = precision;
        this.config.scale = scale;
      }
      /** @internal */
      build(table6) {
        return new PgNumericNumber(
          table6,
          this.config
        );
      }
    };
    __publicField(PgNumericNumberBuilder, _a81, "PgNumericNumberBuilder");
    PgNumericNumber = class extends (_b61 = PgColumn, _a82 = entityKind, _b61) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "precision");
        __publicField(this, "scale");
        __publicField(this, "mapToDriverValue", String);
        this.precision = config.precision;
        this.scale = config.scale;
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") return value;
        return Number(value);
      }
      getSQLType() {
        if (this.precision !== void 0 && this.scale !== void 0) {
          return `numeric(${this.precision}, ${this.scale})`;
        } else if (this.precision === void 0) {
          return "numeric";
        } else {
          return `numeric(${this.precision})`;
        }
      }
    };
    __publicField(PgNumericNumber, _a82, "PgNumericNumber");
    PgNumericBigIntBuilder = class extends (_b62 = PgColumnBuilder, _a83 = entityKind, _b62) {
      constructor(name3, precision, scale) {
        super(name3, "bigint", "PgNumericBigInt");
        this.config.precision = precision;
        this.config.scale = scale;
      }
      /** @internal */
      build(table6) {
        return new PgNumericBigInt(
          table6,
          this.config
        );
      }
    };
    __publicField(PgNumericBigIntBuilder, _a83, "PgNumericBigIntBuilder");
    PgNumericBigInt = class extends (_b63 = PgColumn, _a84 = entityKind, _b63) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "precision");
        __publicField(this, "scale");
        __publicField(this, "mapFromDriverValue", BigInt);
        __publicField(this, "mapToDriverValue", String);
        this.precision = config.precision;
        this.scale = config.scale;
      }
      getSQLType() {
        if (this.precision !== void 0 && this.scale !== void 0) {
          return `numeric(${this.precision}, ${this.scale})`;
        } else if (this.precision === void 0) {
          return "numeric";
        } else {
          return `numeric(${this.precision})`;
        }
      }
    };
    __publicField(PgNumericBigInt, _a84, "PgNumericBigInt");
    decimal = numeric;
  }
});

// ../drizzle-orm/dist/pg-core/columns/point.js
function point(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (!config?.mode || config.mode === "tuple") {
    return new PgPointTupleBuilder(name3);
  }
  return new PgPointObjectBuilder(name3);
}
var _a85, _b64, PgPointTupleBuilder, _a86, _b65, PgPointTuple, _a87, _b66, PgPointObjectBuilder, _a88, _b67, PgPointObject;
var init_point = __esm({
  "../drizzle-orm/dist/pg-core/columns/point.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgPointTupleBuilder = class extends (_b64 = PgColumnBuilder, _a85 = entityKind, _b64) {
      constructor(name3) {
        super(name3, "array", "PgPointTuple");
      }
      /** @internal */
      build(table6) {
        return new PgPointTuple(
          table6,
          this.config
        );
      }
    };
    __publicField(PgPointTupleBuilder, _a85, "PgPointTupleBuilder");
    PgPointTuple = class extends (_b65 = PgColumn, _a86 = entityKind, _b65) {
      getSQLType() {
        return "point";
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          const [x11, y7] = value.slice(1, -1).split(",");
          return [Number.parseFloat(x11), Number.parseFloat(y7)];
        }
        return [value.x, value.y];
      }
      mapToDriverValue(value) {
        return `(${value[0]},${value[1]})`;
      }
    };
    __publicField(PgPointTuple, _a86, "PgPointTuple");
    PgPointObjectBuilder = class extends (_b66 = PgColumnBuilder, _a87 = entityKind, _b66) {
      constructor(name3) {
        super(name3, "json", "PgPointObject");
      }
      /** @internal */
      build(table6) {
        return new PgPointObject(
          table6,
          this.config
        );
      }
    };
    __publicField(PgPointObjectBuilder, _a87, "PgPointObjectBuilder");
    PgPointObject = class extends (_b67 = PgColumn, _a88 = entityKind, _b67) {
      getSQLType() {
        return "point";
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          const [x11, y7] = value.slice(1, -1).split(",");
          return { x: Number.parseFloat(x11), y: Number.parseFloat(y7) };
        }
        return value;
      }
      mapToDriverValue(value) {
        return `(${value.x},${value.y})`;
      }
    };
    __publicField(PgPointObject, _a88, "PgPointObject");
  }
});

// ../drizzle-orm/dist/pg-core/columns/postgis_extension/utils.js
function hexToBytes(hex2) {
  const bytes2 = [];
  for (let c6 = 0; c6 < hex2.length; c6 += 2) {
    bytes2.push(Number.parseInt(hex2.slice(c6, c6 + 2), 16));
  }
  return new Uint8Array(bytes2);
}
function bytesToFloat64(bytes2, offset) {
  const buffer2 = new ArrayBuffer(8);
  const view5 = new DataView(buffer2);
  for (let i8 = 0; i8 < 8; i8++) {
    view5.setUint8(i8, bytes2[offset + i8]);
  }
  return view5.getFloat64(0, true);
}
function parseEWKB(hex2) {
  const bytes2 = hexToBytes(hex2);
  let offset = 0;
  const byteOrder = bytes2[offset];
  offset += 1;
  const view5 = new DataView(bytes2.buffer);
  const geomType = view5.getUint32(offset, byteOrder === 1);
  offset += 4;
  let _srid;
  if (geomType & 536870912) {
    _srid = view5.getUint32(offset, byteOrder === 1);
    offset += 4;
  }
  if ((geomType & 65535) === 1) {
    const x11 = bytesToFloat64(bytes2, offset);
    offset += 8;
    const y7 = bytesToFloat64(bytes2, offset);
    offset += 8;
    return [x11, y7];
  }
  throw new Error("Unsupported geometry type");
}
var init_utils2 = __esm({
  "../drizzle-orm/dist/pg-core/columns/postgis_extension/utils.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/pg-core/columns/postgis_extension/geometry.js
function geometry(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (!config?.mode || config.mode === "tuple") {
    return new PgGeometryBuilder(name3);
  }
  return new PgGeometryObjectBuilder(name3);
}
var _a89, _b68, PgGeometryBuilder, _a90, _b69, PgGeometry, _a91, _b70, PgGeometryObjectBuilder, _a92, _b71, PgGeometryObject;
var init_geometry = __esm({
  "../drizzle-orm/dist/pg-core/columns/postgis_extension/geometry.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    init_utils2();
    PgGeometryBuilder = class extends (_b68 = PgColumnBuilder, _a89 = entityKind, _b68) {
      constructor(name3) {
        super(name3, "array", "PgGeometry");
      }
      /** @internal */
      build(table6) {
        return new PgGeometry(
          table6,
          this.config
        );
      }
    };
    __publicField(PgGeometryBuilder, _a89, "PgGeometryBuilder");
    PgGeometry = class extends (_b69 = PgColumn, _a90 = entityKind, _b69) {
      getSQLType() {
        return "geometry(point)";
      }
      mapFromDriverValue(value) {
        return parseEWKB(value);
      }
      mapToDriverValue(value) {
        return `point(${value[0]} ${value[1]})`;
      }
    };
    __publicField(PgGeometry, _a90, "PgGeometry");
    PgGeometryObjectBuilder = class extends (_b70 = PgColumnBuilder, _a91 = entityKind, _b70) {
      constructor(name3) {
        super(name3, "json", "PgGeometryObject");
      }
      /** @internal */
      build(table6) {
        return new PgGeometryObject(
          table6,
          this.config
        );
      }
    };
    __publicField(PgGeometryObjectBuilder, _a91, "PgGeometryObjectBuilder");
    PgGeometryObject = class extends (_b71 = PgColumn, _a92 = entityKind, _b71) {
      getSQLType() {
        return "geometry(point)";
      }
      mapFromDriverValue(value) {
        const parsed = parseEWKB(value);
        return { x: parsed[0], y: parsed[1] };
      }
      mapToDriverValue(value) {
        return `point(${value.x} ${value.y})`;
      }
    };
    __publicField(PgGeometryObject, _a92, "PgGeometryObject");
  }
});

// ../drizzle-orm/dist/pg-core/columns/real.js
function real(name3) {
  return new PgRealBuilder(name3 ?? "");
}
var _a93, _b72, PgRealBuilder, _a94, _b73, PgReal;
var init_real = __esm({
  "../drizzle-orm/dist/pg-core/columns/real.js"() {
    "use strict";
    init_entity();
    init_common();
    PgRealBuilder = class extends (_b72 = PgColumnBuilder, _a93 = entityKind, _b72) {
      constructor(name3, length) {
        super(name3, "number", "PgReal");
        this.config.length = length;
      }
      /** @internal */
      build(table6) {
        return new PgReal(table6, this.config);
      }
    };
    __publicField(PgRealBuilder, _a93, "PgRealBuilder");
    PgReal = class extends (_b73 = PgColumn, _a94 = entityKind, _b73) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "mapFromDriverValue", (value) => {
          if (typeof value === "string") {
            return Number.parseFloat(value);
          }
          return value;
        });
      }
      getSQLType() {
        return "real";
      }
    };
    __publicField(PgReal, _a94, "PgReal");
  }
});

// ../drizzle-orm/dist/pg-core/columns/serial.js
function serial(name3) {
  return new PgSerialBuilder(name3 ?? "");
}
var _a95, _b74, PgSerialBuilder, _a96, _b75, PgSerial;
var init_serial = __esm({
  "../drizzle-orm/dist/pg-core/columns/serial.js"() {
    "use strict";
    init_entity();
    init_common();
    PgSerialBuilder = class extends (_b74 = PgColumnBuilder, _a95 = entityKind, _b74) {
      constructor(name3) {
        super(name3, "number", "PgSerial");
        this.config.hasDefault = true;
        this.config.notNull = true;
      }
      /** @internal */
      build(table6) {
        return new PgSerial(table6, this.config);
      }
    };
    __publicField(PgSerialBuilder, _a95, "PgSerialBuilder");
    PgSerial = class extends (_b75 = PgColumn, _a96 = entityKind, _b75) {
      getSQLType() {
        return "serial";
      }
    };
    __publicField(PgSerial, _a96, "PgSerial");
  }
});

// ../drizzle-orm/dist/pg-core/columns/smallint.js
function smallint(name3) {
  return new PgSmallIntBuilder(name3 ?? "");
}
var _a97, _b76, PgSmallIntBuilder, _a98, _b77, PgSmallInt;
var init_smallint = __esm({
  "../drizzle-orm/dist/pg-core/columns/smallint.js"() {
    "use strict";
    init_entity();
    init_common();
    init_int_common();
    PgSmallIntBuilder = class extends (_b76 = PgIntColumnBaseBuilder, _a97 = entityKind, _b76) {
      constructor(name3) {
        super(name3, "number", "PgSmallInt");
      }
      /** @internal */
      build(table6) {
        return new PgSmallInt(table6, this.config);
      }
    };
    __publicField(PgSmallIntBuilder, _a97, "PgSmallIntBuilder");
    PgSmallInt = class extends (_b77 = PgColumn, _a98 = entityKind, _b77) {
      constructor() {
        super(...arguments);
        __publicField(this, "mapFromDriverValue", (value) => {
          if (typeof value === "string") {
            return Number(value);
          }
          return value;
        });
      }
      getSQLType() {
        return "smallint";
      }
    };
    __publicField(PgSmallInt, _a98, "PgSmallInt");
  }
});

// ../drizzle-orm/dist/pg-core/columns/smallserial.js
function smallserial(name3) {
  return new PgSmallSerialBuilder(name3 ?? "");
}
var _a99, _b78, PgSmallSerialBuilder, _a100, _b79, PgSmallSerial;
var init_smallserial = __esm({
  "../drizzle-orm/dist/pg-core/columns/smallserial.js"() {
    "use strict";
    init_entity();
    init_common();
    PgSmallSerialBuilder = class extends (_b78 = PgColumnBuilder, _a99 = entityKind, _b78) {
      constructor(name3) {
        super(name3, "number", "PgSmallSerial");
        this.config.hasDefault = true;
        this.config.notNull = true;
      }
      /** @internal */
      build(table6) {
        return new PgSmallSerial(
          table6,
          this.config
        );
      }
    };
    __publicField(PgSmallSerialBuilder, _a99, "PgSmallSerialBuilder");
    PgSmallSerial = class extends (_b79 = PgColumn, _a100 = entityKind, _b79) {
      getSQLType() {
        return "smallserial";
      }
    };
    __publicField(PgSmallSerial, _a100, "PgSmallSerial");
  }
});

// ../drizzle-orm/dist/pg-core/columns/text.js
function text(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgTextBuilder(name3, config);
}
var _a101, _b80, PgTextBuilder, _a102, _b81, PgText;
var init_text = __esm({
  "../drizzle-orm/dist/pg-core/columns/text.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgTextBuilder = class extends (_b80 = PgColumnBuilder, _a101 = entityKind, _b80) {
      constructor(name3, config) {
        super(name3, "string", "PgText");
        this.config.enumValues = config.enum;
      }
      /** @internal */
      build(table6) {
        return new PgText(table6, this.config);
      }
    };
    __publicField(PgTextBuilder, _a101, "PgTextBuilder");
    PgText = class extends (_b81 = PgColumn, _a102 = entityKind, _b81) {
      constructor() {
        super(...arguments);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return "text";
      }
    };
    __publicField(PgText, _a102, "PgText");
  }
});

// ../drizzle-orm/dist/pg-core/columns/time.js
function time(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgTimeBuilder(name3, config.withTimezone ?? false, config.precision);
}
var _a103, _b82, PgTimeBuilder, _a104, _b83, PgTime;
var init_time = __esm({
  "../drizzle-orm/dist/pg-core/columns/time.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    init_date_common();
    PgTimeBuilder = class extends (_b82 = PgDateColumnBaseBuilder, _a103 = entityKind, _b82) {
      constructor(name3, withTimezone, precision) {
        super(name3, "string", "PgTime");
        this.withTimezone = withTimezone;
        this.precision = precision;
        this.config.withTimezone = withTimezone;
        this.config.precision = precision;
      }
      /** @internal */
      build(table6) {
        return new PgTime(table6, this.config);
      }
    };
    __publicField(PgTimeBuilder, _a103, "PgTimeBuilder");
    PgTime = class extends (_b83 = PgColumn, _a104 = entityKind, _b83) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "withTimezone");
        __publicField(this, "precision");
        this.withTimezone = config.withTimezone;
        this.precision = config.precision;
      }
      getSQLType() {
        const precision = this.precision === void 0 ? "" : `(${this.precision})`;
        return `time${precision}${this.withTimezone ? " with time zone" : ""}`;
      }
    };
    __publicField(PgTime, _a104, "PgTime");
  }
});

// ../drizzle-orm/dist/pg-core/columns/timestamp.js
function timestamp(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "string") {
    return new PgTimestampStringBuilder(name3, config.withTimezone ?? false, config.precision);
  }
  return new PgTimestampBuilder(name3, config?.withTimezone ?? false, config?.precision);
}
var _a105, _b84, PgTimestampBuilder, _a106, _b85, PgTimestamp, _a107, _b86, PgTimestampStringBuilder, _a108, _b87, PgTimestampString;
var init_timestamp = __esm({
  "../drizzle-orm/dist/pg-core/columns/timestamp.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    init_date_common();
    PgTimestampBuilder = class extends (_b84 = PgDateColumnBaseBuilder, _a105 = entityKind, _b84) {
      constructor(name3, withTimezone, precision) {
        super(name3, "date", "PgTimestamp");
        this.config.withTimezone = withTimezone;
        this.config.precision = precision;
      }
      /** @internal */
      build(table6) {
        return new PgTimestamp(table6, this.config);
      }
    };
    __publicField(PgTimestampBuilder, _a105, "PgTimestampBuilder");
    PgTimestamp = class extends (_b85 = PgColumn, _a106 = entityKind, _b85) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "withTimezone");
        __publicField(this, "precision");
        __publicField(this, "mapFromDriverValue", (value) => {
          return new Date(this.withTimezone ? value : value + "+0000");
        });
        __publicField(this, "mapToDriverValue", (value) => {
          return value.toISOString();
        });
        this.withTimezone = config.withTimezone;
        this.precision = config.precision;
      }
      getSQLType() {
        const precision = this.precision === void 0 ? "" : ` (${this.precision})`;
        return `timestamp${precision}${this.withTimezone ? " with time zone" : ""}`;
      }
    };
    __publicField(PgTimestamp, _a106, "PgTimestamp");
    PgTimestampStringBuilder = class extends (_b86 = PgDateColumnBaseBuilder, _a107 = entityKind, _b86) {
      constructor(name3, withTimezone, precision) {
        super(name3, "string", "PgTimestampString");
        this.config.withTimezone = withTimezone;
        this.config.precision = precision;
      }
      /** @internal */
      build(table6) {
        return new PgTimestampString(
          table6,
          this.config
        );
      }
    };
    __publicField(PgTimestampStringBuilder, _a107, "PgTimestampStringBuilder");
    PgTimestampString = class extends (_b87 = PgColumn, _a108 = entityKind, _b87) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "withTimezone");
        __publicField(this, "precision");
        this.withTimezone = config.withTimezone;
        this.precision = config.precision;
      }
      getSQLType() {
        const precision = this.precision === void 0 ? "" : `(${this.precision})`;
        return `timestamp${precision}${this.withTimezone ? " with time zone" : ""}`;
      }
    };
    __publicField(PgTimestampString, _a108, "PgTimestampString");
  }
});

// ../drizzle-orm/dist/pg-core/columns/uuid.js
function uuid(name3) {
  return new PgUUIDBuilder(name3 ?? "");
}
var _a109, _b88, PgUUIDBuilder, _a110, _b89, PgUUID;
var init_uuid = __esm({
  "../drizzle-orm/dist/pg-core/columns/uuid.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_common();
    PgUUIDBuilder = class extends (_b88 = PgColumnBuilder, _a109 = entityKind, _b88) {
      constructor(name3) {
        super(name3, "string", "PgUUID");
      }
      /**
       * Adds `default gen_random_uuid()` to the column definition.
       */
      defaultRandom() {
        return this.default(sql`gen_random_uuid()`);
      }
      /** @internal */
      build(table6) {
        return new PgUUID(table6, this.config);
      }
    };
    __publicField(PgUUIDBuilder, _a109, "PgUUIDBuilder");
    PgUUID = class extends (_b89 = PgColumn, _a110 = entityKind, _b89) {
      getSQLType() {
        return "uuid";
      }
    };
    __publicField(PgUUID, _a110, "PgUUID");
  }
});

// ../drizzle-orm/dist/pg-core/columns/varchar.js
function varchar(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgVarcharBuilder(name3, config);
}
var _a111, _b90, PgVarcharBuilder, _a112, _b91, PgVarchar;
var init_varchar = __esm({
  "../drizzle-orm/dist/pg-core/columns/varchar.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgVarcharBuilder = class extends (_b90 = PgColumnBuilder, _a111 = entityKind, _b90) {
      constructor(name3, config) {
        super(name3, "string", "PgVarchar");
        this.config.length = config.length;
        this.config.enumValues = config.enum;
      }
      /** @internal */
      build(table6) {
        return new PgVarchar(
          table6,
          this.config
        );
      }
    };
    __publicField(PgVarcharBuilder, _a111, "PgVarcharBuilder");
    PgVarchar = class extends (_b91 = PgColumn, _a112 = entityKind, _b91) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return this.length === void 0 ? `varchar` : `varchar(${this.length})`;
      }
    };
    __publicField(PgVarchar, _a112, "PgVarchar");
  }
});

// ../drizzle-orm/dist/pg-core/columns/vector_extension/bit.js
function bit(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgBinaryVectorBuilder(name3, config);
}
var _a113, _b92, PgBinaryVectorBuilder, _a114, _b93, PgBinaryVector;
var init_bit = __esm({
  "../drizzle-orm/dist/pg-core/columns/vector_extension/bit.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgBinaryVectorBuilder = class extends (_b92 = PgColumnBuilder, _a113 = entityKind, _b92) {
      constructor(name3, config) {
        super(name3, "string", "PgBinaryVector");
        this.config.dimensions = config.dimensions;
      }
      /** @internal */
      build(table6) {
        return new PgBinaryVector(
          table6,
          this.config
        );
      }
    };
    __publicField(PgBinaryVectorBuilder, _a113, "PgBinaryVectorBuilder");
    PgBinaryVector = class extends (_b93 = PgColumn, _a114 = entityKind, _b93) {
      constructor() {
        super(...arguments);
        __publicField(this, "dimensions", this.config.dimensions);
      }
      getSQLType() {
        return `bit(${this.dimensions})`;
      }
    };
    __publicField(PgBinaryVector, _a114, "PgBinaryVector");
  }
});

// ../drizzle-orm/dist/pg-core/columns/vector_extension/halfvec.js
function halfvec(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgHalfVectorBuilder(name3, config);
}
var _a115, _b94, PgHalfVectorBuilder, _a116, _b95, PgHalfVector;
var init_halfvec = __esm({
  "../drizzle-orm/dist/pg-core/columns/vector_extension/halfvec.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgHalfVectorBuilder = class extends (_b94 = PgColumnBuilder, _a115 = entityKind, _b94) {
      constructor(name3, config) {
        super(name3, "array", "PgHalfVector");
        this.config.dimensions = config.dimensions;
      }
      /** @internal */
      build(table6) {
        return new PgHalfVector(
          table6,
          this.config
        );
      }
    };
    __publicField(PgHalfVectorBuilder, _a115, "PgHalfVectorBuilder");
    PgHalfVector = class extends (_b95 = PgColumn, _a116 = entityKind, _b95) {
      constructor() {
        super(...arguments);
        __publicField(this, "dimensions", this.config.dimensions);
      }
      getSQLType() {
        return `halfvec(${this.dimensions})`;
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
      mapFromDriverValue(value) {
        return value.slice(1, -1).split(",").map((v11) => Number.parseFloat(v11));
      }
    };
    __publicField(PgHalfVector, _a116, "PgHalfVector");
  }
});

// ../drizzle-orm/dist/pg-core/columns/vector_extension/sparsevec.js
function sparsevec(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgSparseVectorBuilder(name3, config);
}
var _a117, _b96, PgSparseVectorBuilder, _a118, _b97, PgSparseVector;
var init_sparsevec = __esm({
  "../drizzle-orm/dist/pg-core/columns/vector_extension/sparsevec.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgSparseVectorBuilder = class extends (_b96 = PgColumnBuilder, _a117 = entityKind, _b96) {
      constructor(name3, config) {
        super(name3, "string", "PgSparseVector");
        this.config.dimensions = config.dimensions;
      }
      /** @internal */
      build(table6) {
        return new PgSparseVector(
          table6,
          this.config
        );
      }
    };
    __publicField(PgSparseVectorBuilder, _a117, "PgSparseVectorBuilder");
    PgSparseVector = class extends (_b97 = PgColumn, _a118 = entityKind, _b97) {
      constructor() {
        super(...arguments);
        __publicField(this, "dimensions", this.config.dimensions);
      }
      getSQLType() {
        return `sparsevec(${this.dimensions})`;
      }
    };
    __publicField(PgSparseVector, _a118, "PgSparseVector");
  }
});

// ../drizzle-orm/dist/pg-core/columns/vector_extension/vector.js
function vector(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new PgVectorBuilder(name3, config);
}
var _a119, _b98, PgVectorBuilder, _a120, _b99, PgVector;
var init_vector = __esm({
  "../drizzle-orm/dist/pg-core/columns/vector_extension/vector.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common();
    PgVectorBuilder = class extends (_b98 = PgColumnBuilder, _a119 = entityKind, _b98) {
      constructor(name3, config) {
        super(name3, "array", "PgVector");
        this.config.dimensions = config.dimensions;
      }
      /** @internal */
      build(table6) {
        return new PgVector(
          table6,
          this.config
        );
      }
    };
    __publicField(PgVectorBuilder, _a119, "PgVectorBuilder");
    PgVector = class extends (_b99 = PgColumn, _a120 = entityKind, _b99) {
      constructor() {
        super(...arguments);
        __publicField(this, "dimensions", this.config.dimensions);
      }
      getSQLType() {
        return `vector(${this.dimensions})`;
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
      mapFromDriverValue(value) {
        return value.slice(1, -1).split(",").map((v11) => Number.parseFloat(v11));
      }
    };
    __publicField(PgVector, _a120, "PgVector");
  }
});

// ../drizzle-orm/dist/pg-core/columns/all.js
function getPgColumnBuilders() {
  return {
    bigint,
    bigserial,
    boolean,
    char,
    cidr,
    customType,
    date,
    doublePrecision,
    inet,
    integer,
    interval,
    json,
    jsonb,
    line,
    macaddr,
    macaddr8,
    numeric,
    point,
    geometry,
    real,
    serial,
    smallint,
    smallserial,
    text,
    time,
    timestamp,
    uuid,
    varchar,
    bit,
    halfvec,
    sparsevec,
    vector
  };
}
var init_all = __esm({
  "../drizzle-orm/dist/pg-core/columns/all.js"() {
    "use strict";
    init_bigint();
    init_bigserial();
    init_boolean();
    init_char();
    init_cidr();
    init_custom();
    init_date();
    init_double_precision();
    init_inet();
    init_integer();
    init_interval();
    init_json();
    init_jsonb();
    init_line();
    init_macaddr();
    init_macaddr8();
    init_numeric();
    init_point();
    init_geometry();
    init_real();
    init_serial();
    init_smallint();
    init_smallserial();
    init_text();
    init_time();
    init_timestamp();
    init_uuid();
    init_varchar();
    init_bit();
    init_halfvec();
    init_sparsevec();
    init_vector();
  }
});

// ../drizzle-orm/dist/pg-core/table.js
function pgTableWithSchema(name3, columns, extraConfig, schema6, baseName = name3) {
  const rawTable = new PgTable(name3, schema6, baseName);
  const parsedColumns = typeof columns === "function" ? columns(getPgColumnBuilders()) : columns;
  const builtColumns = Object.fromEntries(
    Object.entries(parsedColumns).map(([name22, colBuilderBase]) => {
      const colBuilder = colBuilderBase;
      colBuilder.setName(name22);
      const column6 = colBuilder.build(rawTable);
      rawTable[InlineForeignKeys].push(...colBuilder.buildForeignKeys(column6, rawTable));
      return [name22, column6];
    })
  );
  const builtColumnsForExtraConfig = Object.fromEntries(
    Object.entries(parsedColumns).map(([name22, colBuilderBase]) => {
      const colBuilder = colBuilderBase;
      colBuilder.setName(name22);
      const column6 = colBuilder.buildExtraConfigColumn(rawTable);
      return [name22, column6];
    })
  );
  const table6 = Object.assign(rawTable, builtColumns);
  table6[Table.Symbol.Columns] = builtColumns;
  table6[Table.Symbol.ExtraConfigColumns] = builtColumnsForExtraConfig;
  if (extraConfig) {
    table6[PgTable.Symbol.ExtraConfigBuilder] = extraConfig;
  }
  return Object.assign(table6, {
    enableRLS: () => {
      table6[PgTable.Symbol.EnableRLS] = true;
      return table6;
    }
  });
}
function pgTableCreator(customizeTableName) {
  return (name3, columns, extraConfig) => {
    return pgTableWithSchema(customizeTableName(name3), columns, extraConfig, void 0, name3);
  };
}
var InlineForeignKeys, EnableRLS, _a121, _b100, _c3, _d2, _e2, _f2, PgTable, pgTable;
var init_table2 = __esm({
  "../drizzle-orm/dist/pg-core/table.js"() {
    "use strict";
    init_entity();
    init_table();
    init_all();
    InlineForeignKeys = Symbol.for("drizzle:PgInlineForeignKeys");
    EnableRLS = Symbol.for("drizzle:EnableRLS");
    PgTable = class extends (_f2 = Table, _e2 = entityKind, _d2 = InlineForeignKeys, _c3 = EnableRLS, _b100 = Table.Symbol.ExtraConfigBuilder, _a121 = Table.Symbol.ExtraConfigColumns, _f2) {
      constructor() {
        super(...arguments);
        /**@internal */
        __publicField(this, _d2, []);
        /** @internal */
        __publicField(this, _c3, false);
        /** @internal */
        __publicField(this, _b100);
        /** @internal */
        __publicField(this, _a121, {});
      }
    };
    __publicField(PgTable, _e2, "PgTable");
    /** @internal */
    __publicField(PgTable, "Symbol", Object.assign({}, Table.Symbol, {
      InlineForeignKeys,
      EnableRLS
    }));
    pgTable = (name3, columns, extraConfig) => {
      return pgTableWithSchema(name3, columns, extraConfig, void 0);
    };
  }
});

// ../drizzle-orm/dist/pg-core/primary-keys.js
function primaryKey(...config) {
  if (config[0].columns) {
    return new PrimaryKeyBuilder(config[0].columns, config[0].name);
  }
  return new PrimaryKeyBuilder(config);
}
var _a122, PrimaryKeyBuilder, _a123, PrimaryKey;
var init_primary_keys = __esm({
  "../drizzle-orm/dist/pg-core/primary-keys.js"() {
    "use strict";
    init_entity();
    init_table2();
    _a122 = entityKind;
    PrimaryKeyBuilder = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        /** @internal */
        __publicField(this, "name");
        this.columns = columns;
        this.name = name3;
      }
      /** @internal */
      build(table6) {
        return new PrimaryKey(table6, this.columns, this.name);
      }
    };
    __publicField(PrimaryKeyBuilder, _a122, "PgPrimaryKeyBuilder");
    _a123 = entityKind;
    PrimaryKey = class {
      constructor(table6, columns, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        this.table = table6;
        this.columns = columns;
        this.name = name3;
      }
      getName() {
        return this.name ?? `${this.table[PgTable.Symbol.Name]}_${this.columns.map((column6) => column6.name).join("_")}_pk`;
      }
    };
    __publicField(PrimaryKey, _a123, "PgPrimaryKey");
  }
});

// ../drizzle-orm/dist/sql/expressions/conditions.js
function bindIfParam(value, column6) {
  if (isDriverValueEncoder(column6) && !isSQLWrapper(value) && !is(value, Param) && !is(value, Placeholder) && !is(value, Column) && !is(value, Table) && !is(value, View)) {
    return new Param(value, column6);
  }
  return value;
}
function and(...unfilteredConditions) {
  const conditions = unfilteredConditions.filter(
    (c6) => c6 !== void 0
  );
  if (conditions.length === 0) {
    return void 0;
  }
  if (conditions.length === 1) {
    return new SQL(conditions);
  }
  return new SQL([
    new StringChunk("("),
    sql.join(conditions, new StringChunk(" and ")),
    new StringChunk(")")
  ]);
}
function or(...unfilteredConditions) {
  const conditions = unfilteredConditions.filter(
    (c6) => c6 !== void 0
  );
  if (conditions.length === 0) {
    return void 0;
  }
  if (conditions.length === 1) {
    return new SQL(conditions);
  }
  return new SQL([
    new StringChunk("("),
    sql.join(conditions, new StringChunk(" or ")),
    new StringChunk(")")
  ]);
}
function not(condition) {
  return sql`not ${condition}`;
}
function inArray(column6, values2) {
  if (Array.isArray(values2)) {
    if (values2.length === 0) {
      return sql`false`;
    }
    return sql`${column6} in ${values2.map((v11) => bindIfParam(v11, column6))}`;
  }
  return sql`${column6} in ${bindIfParam(values2, column6)}`;
}
function notInArray(column6, values2) {
  if (Array.isArray(values2)) {
    if (values2.length === 0) {
      return sql`true`;
    }
    return sql`${column6} not in ${values2.map((v11) => bindIfParam(v11, column6))}`;
  }
  return sql`${column6} not in ${bindIfParam(values2, column6)}`;
}
function isNull(value) {
  return sql`${value} is null`;
}
function isNotNull(value) {
  return sql`${value} is not null`;
}
function exists(subquery) {
  return sql`exists ${subquery}`;
}
function notExists(subquery) {
  return sql`not exists ${subquery}`;
}
function between(column6, min2, max2) {
  return sql`${column6} between ${bindIfParam(min2, column6)} and ${bindIfParam(
    max2,
    column6
  )}`;
}
function notBetween(column6, min2, max2) {
  return sql`${column6} not between ${bindIfParam(
    min2,
    column6
  )} and ${bindIfParam(max2, column6)}`;
}
function like(column6, value) {
  return sql`${column6} like ${value}`;
}
function notLike(column6, value) {
  return sql`${column6} not like ${value}`;
}
function ilike(column6, value) {
  return sql`${column6} ilike ${value}`;
}
function notIlike(column6, value) {
  return sql`${column6} not ilike ${value}`;
}
function arrayContains(column6, values2) {
  if (Array.isArray(values2)) {
    if (values2.length === 0) {
      throw new Error("arrayContains requires at least one value");
    }
    const array3 = sql`${bindIfParam(values2, column6)}`;
    return sql`${column6} @> ${array3}`;
  }
  return sql`${column6} @> ${bindIfParam(values2, column6)}`;
}
function arrayContained(column6, values2) {
  if (Array.isArray(values2)) {
    if (values2.length === 0) {
      throw new Error("arrayContained requires at least one value");
    }
    const array3 = sql`${bindIfParam(values2, column6)}`;
    return sql`${column6} <@ ${array3}`;
  }
  return sql`${column6} <@ ${bindIfParam(values2, column6)}`;
}
function arrayOverlaps(column6, values2) {
  if (Array.isArray(values2)) {
    if (values2.length === 0) {
      throw new Error("arrayOverlaps requires at least one value");
    }
    const array3 = sql`${bindIfParam(values2, column6)}`;
    return sql`${column6} && ${array3}`;
  }
  return sql`${column6} && ${bindIfParam(values2, column6)}`;
}
var eq, ne, gt, gte, lt, lte;
var init_conditions = __esm({
  "../drizzle-orm/dist/sql/expressions/conditions.js"() {
    "use strict";
    init_column();
    init_entity();
    init_table();
    init_sql();
    eq = (left, right) => {
      return sql`${left} = ${bindIfParam(right, left)}`;
    };
    ne = (left, right) => {
      return sql`${left} <> ${bindIfParam(right, left)}`;
    };
    gt = (left, right) => {
      return sql`${left} > ${bindIfParam(right, left)}`;
    };
    gte = (left, right) => {
      return sql`${left} >= ${bindIfParam(right, left)}`;
    };
    lt = (left, right) => {
      return sql`${left} < ${bindIfParam(right, left)}`;
    };
    lte = (left, right) => {
      return sql`${left} <= ${bindIfParam(right, left)}`;
    };
  }
});

// ../drizzle-orm/dist/sql/expressions/select.js
function asc(column6) {
  return sql`${column6} asc`;
}
function desc(column6) {
  return sql`${column6} desc`;
}
var init_select = __esm({
  "../drizzle-orm/dist/sql/expressions/select.js"() {
    "use strict";
    init_sql();
  }
});

// ../drizzle-orm/dist/sql/expressions/index.js
var init_expressions = __esm({
  "../drizzle-orm/dist/sql/expressions/index.js"() {
    "use strict";
    init_conditions();
    init_select();
  }
});

// ../drizzle-orm/dist/relations.js
function getOperators() {
  return {
    and,
    between,
    eq,
    exists,
    gt,
    gte,
    ilike,
    inArray,
    isNull,
    isNotNull,
    like,
    lt,
    lte,
    ne,
    not,
    notBetween,
    notExists,
    notLike,
    notIlike,
    notInArray,
    or,
    sql
  };
}
function getOrderByOperators() {
  return {
    sql,
    asc,
    desc
  };
}
function extractTablesRelationalConfig(schema6, configHelpers) {
  if (Object.keys(schema6).length === 1 && "default" in schema6 && !is(schema6["default"], Table)) {
    schema6 = schema6["default"];
  }
  const tableNamesMap = {};
  const relationsBuffer = {};
  const tablesConfig = {};
  for (const [key, value] of Object.entries(schema6)) {
    if (is(value, Table)) {
      const dbName = getTableUniqueName(value);
      const bufferedRelations = relationsBuffer[dbName];
      tableNamesMap[dbName] = key;
      tablesConfig[key] = {
        tsName: key,
        dbName: value[Table.Symbol.Name],
        schema: value[Table.Symbol.Schema],
        columns: value[Table.Symbol.Columns],
        relations: bufferedRelations?.relations ?? {},
        primaryKey: bufferedRelations?.primaryKey ?? []
      };
      for (const column6 of Object.values(
        value[Table.Symbol.Columns]
      )) {
        if (column6.primary) {
          tablesConfig[key].primaryKey.push(column6);
        }
      }
      const extraConfig = value[Table.Symbol.ExtraConfigBuilder]?.(value[Table.Symbol.ExtraConfigColumns]);
      if (extraConfig) {
        for (const configEntry of Object.values(extraConfig)) {
          if (is(configEntry, PrimaryKeyBuilder)) {
            tablesConfig[key].primaryKey.push(...configEntry.columns);
          }
        }
      }
    } else if (is(value, Relations)) {
      const dbName = getTableUniqueName(value.table);
      const tableName = tableNamesMap[dbName];
      const relations2 = value.config(
        configHelpers(value.table)
      );
      let primaryKey2;
      for (const [relationName, relation] of Object.entries(relations2)) {
        if (tableName) {
          const tableConfig = tablesConfig[tableName];
          tableConfig.relations[relationName] = relation;
          if (primaryKey2) {
            tableConfig.primaryKey.push(...primaryKey2);
          }
        } else {
          if (!(dbName in relationsBuffer)) {
            relationsBuffer[dbName] = {
              relations: {},
              primaryKey: primaryKey2
            };
          }
          relationsBuffer[dbName].relations[relationName] = relation;
        }
      }
    }
  }
  return { tables: tablesConfig, tableNamesMap };
}
function relations(table6, relations2) {
  return new Relations(
    table6,
    (helpers) => Object.fromEntries(
      Object.entries(relations2(helpers)).map(([key, value]) => [
        key,
        value.withFieldName(key)
      ])
    )
  );
}
function createOne(sourceTable) {
  return function one(table6, config) {
    return new One(
      sourceTable,
      table6,
      config,
      config?.fields.reduce((res, f9) => res && f9.notNull, true) ?? false
    );
  };
}
function createMany(sourceTable) {
  return function many(referencedTable, config) {
    return new Many(sourceTable, referencedTable, config);
  };
}
function normalizeRelation(schema6, tableNamesMap, relation) {
  if (is(relation, One) && relation.config) {
    return {
      fields: relation.config.fields,
      references: relation.config.references
    };
  }
  const referencedTableTsName = tableNamesMap[getTableUniqueName(relation.referencedTable)];
  if (!referencedTableTsName) {
    throw new Error(
      `Table "${relation.referencedTable[Table.Symbol.Name]}" not found in schema`
    );
  }
  const referencedTableConfig = schema6[referencedTableTsName];
  if (!referencedTableConfig) {
    throw new Error(`Table "${referencedTableTsName}" not found in schema`);
  }
  const sourceTable = relation.sourceTable;
  const sourceTableTsName = tableNamesMap[getTableUniqueName(sourceTable)];
  if (!sourceTableTsName) {
    throw new Error(
      `Table "${sourceTable[Table.Symbol.Name]}" not found in schema`
    );
  }
  const reverseRelations = [];
  for (const referencedTableRelation of Object.values(
    referencedTableConfig.relations
  )) {
    if (relation.relationName && relation !== referencedTableRelation && referencedTableRelation.relationName === relation.relationName || !relation.relationName && referencedTableRelation.referencedTable === relation.sourceTable) {
      reverseRelations.push(referencedTableRelation);
    }
  }
  if (reverseRelations.length > 1) {
    throw relation.relationName ? new Error(
      `There are multiple relations with name "${relation.relationName}" in table "${referencedTableTsName}"`
    ) : new Error(
      `There are multiple relations between "${referencedTableTsName}" and "${relation.sourceTable[Table.Symbol.Name]}". Please specify relation name`
    );
  }
  if (reverseRelations[0] && is(reverseRelations[0], One) && reverseRelations[0].config) {
    return {
      fields: reverseRelations[0].config.references,
      references: reverseRelations[0].config.fields
    };
  }
  throw new Error(
    `There is not enough information to infer relation "${sourceTableTsName}.${relation.fieldName}"`
  );
}
function createTableRelationsHelpers(sourceTable) {
  return {
    one: createOne(sourceTable),
    many: createMany(sourceTable)
  };
}
function mapRelationalRow(tablesConfig, tableConfig, row, buildQueryResultSelection, mapColumnValue = (value) => value) {
  const result = {};
  for (const [
    selectionItemIndex,
    selectionItem
  ] of buildQueryResultSelection.entries()) {
    if (selectionItem.isJson) {
      const relation = tableConfig.relations[selectionItem.tsKey];
      const rawSubRows = row[selectionItemIndex];
      const subRows = typeof rawSubRows === "string" ? JSON.parse(rawSubRows) : rawSubRows;
      result[selectionItem.tsKey] = is(relation, One) ? subRows && mapRelationalRow(
        tablesConfig,
        tablesConfig[selectionItem.relationTableTsKey],
        subRows,
        selectionItem.selection,
        mapColumnValue
      ) : subRows.map(
        (subRow) => mapRelationalRow(
          tablesConfig,
          tablesConfig[selectionItem.relationTableTsKey],
          subRow,
          selectionItem.selection,
          mapColumnValue
        )
      );
    } else {
      const value = mapColumnValue(row[selectionItemIndex]);
      const field = selectionItem.field;
      let decoder2;
      if (is(field, Column)) {
        decoder2 = field;
      } else if (is(field, SQL)) {
        decoder2 = field.decoder;
      } else {
        decoder2 = field.sql.decoder;
      }
      result[selectionItem.tsKey] = value === null ? null : decoder2.mapFromDriverValue(value);
    }
  }
  return result;
}
var _a124, Relation, _a125, Relations, _a126, _b101, _One, One, _a127, _b102, _Many, Many;
var init_relations = __esm({
  "../drizzle-orm/dist/relations.js"() {
    "use strict";
    init_table();
    init_column();
    init_entity();
    init_primary_keys();
    init_expressions();
    init_sql();
    _a124 = entityKind;
    Relation = class {
      constructor(sourceTable, referencedTable, relationName) {
        __publicField(this, "referencedTableName");
        __publicField(this, "fieldName");
        this.sourceTable = sourceTable;
        this.referencedTable = referencedTable;
        this.relationName = relationName;
        this.referencedTableName = referencedTable[Table.Symbol.Name];
      }
    };
    __publicField(Relation, _a124, "Relation");
    _a125 = entityKind;
    Relations = class {
      constructor(table6, config) {
        this.table = table6;
        this.config = config;
      }
    };
    __publicField(Relations, _a125, "Relations");
    _One = class _One extends (_b101 = Relation, _a126 = entityKind, _b101) {
      constructor(sourceTable, referencedTable, config, isNullable) {
        super(sourceTable, referencedTable, config?.relationName);
        this.config = config;
        this.isNullable = isNullable;
      }
      withFieldName(fieldName) {
        const relation = new _One(
          this.sourceTable,
          this.referencedTable,
          this.config,
          this.isNullable
        );
        relation.fieldName = fieldName;
        return relation;
      }
    };
    __publicField(_One, _a126, "One");
    One = _One;
    _Many = class _Many extends (_b102 = Relation, _a127 = entityKind, _b102) {
      constructor(sourceTable, referencedTable, config) {
        super(sourceTable, referencedTable, config?.relationName);
        this.config = config;
      }
      withFieldName(fieldName) {
        const relation = new _Many(
          this.sourceTable,
          this.referencedTable,
          this.config
        );
        relation.fieldName = fieldName;
        return relation;
      }
    };
    __publicField(_Many, _a127, "Many");
    Many = _Many;
  }
});

// ../drizzle-orm/dist/sql/functions/aggregate.js
function count(expression) {
  return sql`count(${expression || sql.raw("*")})`.mapWith(Number);
}
function countDistinct(expression) {
  return sql`count(distinct ${expression})`.mapWith(Number);
}
function avg(expression) {
  return sql`avg(${expression})`.mapWith(String);
}
function avgDistinct(expression) {
  return sql`avg(distinct ${expression})`.mapWith(String);
}
function sum(expression) {
  return sql`sum(${expression})`.mapWith(String);
}
function sumDistinct(expression) {
  return sql`sum(distinct ${expression})`.mapWith(String);
}
function max(expression) {
  return sql`max(${expression})`.mapWith(is(expression, Column) ? expression : String);
}
function min(expression) {
  return sql`min(${expression})`.mapWith(is(expression, Column) ? expression : String);
}
var init_aggregate = __esm({
  "../drizzle-orm/dist/sql/functions/aggregate.js"() {
    "use strict";
    init_column();
    init_entity();
    init_sql();
  }
});

// ../drizzle-orm/dist/sql/functions/vector.js
function toSql(value) {
  return JSON.stringify(value);
}
function l2Distance(column6, value) {
  if (Array.isArray(value)) {
    return sql`${column6} <-> ${toSql(value)}`;
  }
  return sql`${column6} <-> ${value}`;
}
function l1Distance(column6, value) {
  if (Array.isArray(value)) {
    return sql`${column6} <+> ${toSql(value)}`;
  }
  return sql`${column6} <+> ${value}`;
}
function innerProduct(column6, value) {
  if (Array.isArray(value)) {
    return sql`${column6} <#> ${toSql(value)}`;
  }
  return sql`${column6} <#> ${value}`;
}
function cosineDistance(column6, value) {
  if (Array.isArray(value)) {
    return sql`${column6} <=> ${toSql(value)}`;
  }
  return sql`${column6} <=> ${value}`;
}
function hammingDistance(column6, value) {
  if (Array.isArray(value)) {
    return sql`${column6} <~> ${toSql(value)}`;
  }
  return sql`${column6} <~> ${value}`;
}
function jaccardDistance(column6, value) {
  if (Array.isArray(value)) {
    return sql`${column6} <%> ${toSql(value)}`;
  }
  return sql`${column6} <%> ${value}`;
}
var init_vector2 = __esm({
  "../drizzle-orm/dist/sql/functions/vector.js"() {
    "use strict";
    init_sql();
  }
});

// ../drizzle-orm/dist/sql/functions/index.js
var init_functions = __esm({
  "../drizzle-orm/dist/sql/functions/index.js"() {
    "use strict";
    init_aggregate();
    init_vector2();
  }
});

// ../drizzle-orm/dist/sql/index.js
var init_sql2 = __esm({
  "../drizzle-orm/dist/sql/index.js"() {
    "use strict";
    init_expressions();
    init_functions();
    init_sql();
  }
});

// ../drizzle-orm/dist/index.js
var dist_exports = {};
__export(dist_exports, {
  BaseName: () => BaseName,
  Column: () => Column,
  ColumnAliasProxyHandler: () => ColumnAliasProxyHandler,
  ColumnBuilder: () => ColumnBuilder,
  Columns: () => Columns,
  ConsoleLogWriter: () => ConsoleLogWriter,
  DefaultLogger: () => DefaultLogger,
  DrizzleError: () => DrizzleError,
  DrizzleQueryError: () => DrizzleQueryError,
  ExtraConfigBuilder: () => ExtraConfigBuilder,
  ExtraConfigColumns: () => ExtraConfigColumns,
  FakePrimitiveParam: () => FakePrimitiveParam,
  IsAlias: () => IsAlias,
  Many: () => Many,
  Name: () => Name,
  NoopLogger: () => NoopLogger,
  One: () => One,
  OriginalName: () => OriginalName,
  Param: () => Param,
  Placeholder: () => Placeholder,
  QueryPromise: () => QueryPromise,
  Relation: () => Relation,
  RelationTableAliasProxyHandler: () => RelationTableAliasProxyHandler,
  Relations: () => Relations,
  SQL: () => SQL,
  Schema: () => Schema,
  StringChunk: () => StringChunk,
  Subquery: () => Subquery,
  Table: () => Table,
  TableAliasProxyHandler: () => TableAliasProxyHandler,
  TransactionRollbackError: () => TransactionRollbackError,
  View: () => View,
  ViewBaseConfig: () => ViewBaseConfig,
  WithSubquery: () => WithSubquery,
  aliasedRelation: () => aliasedRelation,
  aliasedTable: () => aliasedTable,
  aliasedTableColumn: () => aliasedTableColumn,
  and: () => and,
  applyMixins: () => applyMixins,
  arrayContained: () => arrayContained,
  arrayContains: () => arrayContains,
  arrayOverlaps: () => arrayOverlaps,
  asc: () => asc,
  avg: () => avg,
  avgDistinct: () => avgDistinct,
  between: () => between,
  bindIfParam: () => bindIfParam,
  cosineDistance: () => cosineDistance,
  count: () => count,
  countDistinct: () => countDistinct,
  createMany: () => createMany,
  createOne: () => createOne,
  createTableRelationsHelpers: () => createTableRelationsHelpers,
  desc: () => desc,
  entityKind: () => entityKind,
  eq: () => eq,
  exists: () => exists,
  extractTablesRelationalConfig: () => extractTablesRelationalConfig,
  fillPlaceholders: () => fillPlaceholders,
  getColumnNameAndConfig: () => getColumnNameAndConfig,
  getOperators: () => getOperators,
  getOrderByOperators: () => getOrderByOperators,
  getTableColumns: () => getTableColumns,
  getTableLikeName: () => getTableLikeName,
  getTableName: () => getTableName,
  getTableUniqueName: () => getTableUniqueName,
  getViewName: () => getViewName,
  getViewSelectedFields: () => getViewSelectedFields,
  gt: () => gt,
  gte: () => gte,
  hammingDistance: () => hammingDistance,
  hasOwnEntityKind: () => hasOwnEntityKind,
  haveSameKeys: () => haveSameKeys,
  ilike: () => ilike,
  inArray: () => inArray,
  innerProduct: () => innerProduct,
  is: () => is,
  isConfig: () => isConfig,
  isDriverValueEncoder: () => isDriverValueEncoder,
  isNotNull: () => isNotNull,
  isNull: () => isNull,
  isSQLWrapper: () => isSQLWrapper,
  isTable: () => isTable,
  isView: () => isView,
  jaccardDistance: () => jaccardDistance,
  l1Distance: () => l1Distance,
  l2Distance: () => l2Distance,
  like: () => like,
  lt: () => lt,
  lte: () => lte,
  mapColumnsInAliasedSQLToAlias: () => mapColumnsInAliasedSQLToAlias,
  mapColumnsInSQLToAlias: () => mapColumnsInSQLToAlias,
  mapRelationalRow: () => mapRelationalRow,
  mapResultRow: () => mapResultRow,
  mapUpdateSet: () => mapUpdateSet,
  max: () => max,
  min: () => min,
  name: () => name2,
  ne: () => ne,
  noopDecoder: () => noopDecoder,
  noopEncoder: () => noopEncoder,
  noopMapper: () => noopMapper,
  normalizeRelation: () => normalizeRelation,
  not: () => not,
  notBetween: () => notBetween,
  notExists: () => notExists,
  notIlike: () => notIlike,
  notInArray: () => notInArray,
  notLike: () => notLike,
  or: () => or,
  orderSelectedFields: () => orderSelectedFields,
  param: () => param,
  placeholder: () => placeholder,
  relations: () => relations,
  sql: () => sql,
  sum: () => sum,
  sumDistinct: () => sumDistinct,
  textDecoder: () => textDecoder
});
var init_dist = __esm({
  "../drizzle-orm/dist/index.js"() {
    "use strict";
    init_alias();
    init_column_builder();
    init_column();
    init_entity();
    init_errors();
    init_logger();
    init_operations();
    init_query_promise();
    init_relations();
    init_sql2();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
  }
});

// ../drizzle-orm/dist/mysql-core/alias.js
var init_alias2 = __esm({
  "../drizzle-orm/dist/mysql-core/alias.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/mysql-core/checks.js
var _a128, CheckBuilder, _a129, Check;
var init_checks = __esm({
  "../drizzle-orm/dist/mysql-core/checks.js"() {
    "use strict";
    init_entity();
    _a128 = entityKind;
    CheckBuilder = class {
      constructor(name3, value) {
        __publicField(this, "brand");
        this.name = name3;
        this.value = value;
      }
      /** @internal */
      build(table6) {
        return new Check(table6, this);
      }
    };
    __publicField(CheckBuilder, _a128, "MySqlCheckBuilder");
    _a129 = entityKind;
    Check = class {
      constructor(table6, builder) {
        __publicField(this, "name");
        __publicField(this, "value");
        this.table = table6;
        this.name = builder.name;
        this.value = builder.value;
      }
    };
    __publicField(Check, _a129, "MySqlCheck");
  }
});

// ../drizzle-orm/dist/mysql-core/foreign-keys.js
var _a130, ForeignKeyBuilder2, _a131, ForeignKey2;
var init_foreign_keys2 = __esm({
  "../drizzle-orm/dist/mysql-core/foreign-keys.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    _a130 = entityKind;
    ForeignKeyBuilder2 = class {
      constructor(config, actions) {
        /** @internal */
        __publicField(this, "reference");
        /** @internal */
        __publicField(this, "_onUpdate");
        /** @internal */
        __publicField(this, "_onDelete");
        this.reference = () => {
          const { name: name3, columns, foreignColumns } = config();
          return { name: name3, columns, foreignTable: foreignColumns[0].table, foreignColumns };
        };
        if (actions) {
          this._onUpdate = actions.onUpdate;
          this._onDelete = actions.onDelete;
        }
      }
      onUpdate(action) {
        this._onUpdate = action;
        return this;
      }
      onDelete(action) {
        this._onDelete = action;
        return this;
      }
      /** @internal */
      build(table6) {
        return new ForeignKey2(table6, this);
      }
    };
    __publicField(ForeignKeyBuilder2, _a130, "MySqlForeignKeyBuilder");
    _a131 = entityKind;
    ForeignKey2 = class {
      constructor(table6, builder) {
        __publicField(this, "reference");
        __publicField(this, "onUpdate");
        __publicField(this, "onDelete");
        this.table = table6;
        this.reference = builder.reference;
        this.onUpdate = builder._onUpdate;
        this.onDelete = builder._onDelete;
      }
      getName() {
        const { name: name3, columns, foreignColumns } = this.reference();
        const columnNames = columns.map((column6) => column6.name);
        const foreignColumnNames = foreignColumns.map((column6) => column6.name);
        const chunks = [
          this.table[TableName],
          ...columnNames,
          foreignColumns[0].table[TableName],
          ...foreignColumnNames
        ];
        return name3 ?? `${chunks.join("_")}_fk`;
      }
    };
    __publicField(ForeignKey2, _a131, "MySqlForeignKey");
  }
});

// ../drizzle-orm/dist/mysql-core/unique-constraint.js
function uniqueKeyName2(table6, columns) {
  return `${table6[TableName]}_${columns.join("_")}_unique`;
}
var _a132, UniqueConstraintBuilder2, _a133, UniqueOnConstraintBuilder2, _a134, UniqueConstraint2;
var init_unique_constraint2 = __esm({
  "../drizzle-orm/dist/mysql-core/unique-constraint.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    _a132 = entityKind;
    UniqueConstraintBuilder2 = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        this.name = name3;
        this.columns = columns;
      }
      /** @internal */
      build(table6) {
        return new UniqueConstraint2(table6, this.columns, this.name);
      }
    };
    __publicField(UniqueConstraintBuilder2, _a132, "MySqlUniqueConstraintBuilder");
    _a133 = entityKind;
    UniqueOnConstraintBuilder2 = class {
      constructor(name3) {
        /** @internal */
        __publicField(this, "name");
        this.name = name3;
      }
      on(...columns) {
        return new UniqueConstraintBuilder2(columns, this.name);
      }
    };
    __publicField(UniqueOnConstraintBuilder2, _a133, "MySqlUniqueOnConstraintBuilder");
    _a134 = entityKind;
    UniqueConstraint2 = class {
      constructor(table6, columns, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        __publicField(this, "nullsNotDistinct", false);
        this.table = table6;
        this.columns = columns;
        this.name = name3 ?? uniqueKeyName2(this.table, this.columns.map((column6) => column6.name));
      }
      getName() {
        return this.name;
      }
    };
    __publicField(UniqueConstraint2, _a134, "MySqlUniqueConstraint");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/common.js
var _a135, _b103, MySqlColumnBuilder, _a136, _b104, MySqlColumn, _a137, _b105, MySqlColumnBuilderWithAutoIncrement, _a138, _b106, MySqlColumnWithAutoIncrement;
var init_common2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/common.js"() {
    "use strict";
    init_column_builder();
    init_column();
    init_entity();
    init_foreign_keys2();
    init_unique_constraint2();
    MySqlColumnBuilder = class extends (_b103 = ColumnBuilder, _a135 = entityKind, _b103) {
      constructor() {
        super(...arguments);
        __publicField(this, "foreignKeyConfigs", []);
      }
      references(ref, actions = {}) {
        this.foreignKeyConfigs.push({ ref, actions });
        return this;
      }
      unique(name3) {
        this.config.isUnique = true;
        this.config.uniqueName = name3;
        return this;
      }
      generatedAlwaysAs(as, config) {
        this.config.generated = {
          as,
          type: "always",
          mode: config?.mode ?? "virtual"
        };
        return this;
      }
      /** @internal */
      buildForeignKeys(column6, table6) {
        return this.foreignKeyConfigs.map(({ ref, actions }) => {
          return ((ref2, actions2) => {
            const builder = new ForeignKeyBuilder2(() => {
              const foreignColumn = ref2();
              return { columns: [column6], foreignColumns: [foreignColumn] };
            });
            if (actions2.onUpdate) {
              builder.onUpdate(actions2.onUpdate);
            }
            if (actions2.onDelete) {
              builder.onDelete(actions2.onDelete);
            }
            return builder.build(table6);
          })(ref, actions);
        });
      }
    };
    __publicField(MySqlColumnBuilder, _a135, "MySqlColumnBuilder");
    MySqlColumn = class extends (_b104 = Column, _a136 = entityKind, _b104) {
      constructor(table6, config) {
        if (!config.uniqueName) {
          config.uniqueName = uniqueKeyName2(table6, [config.name]);
        }
        super(table6, config);
        this.table = table6;
      }
    };
    __publicField(MySqlColumn, _a136, "MySqlColumn");
    MySqlColumnBuilderWithAutoIncrement = class extends (_b105 = MySqlColumnBuilder, _a137 = entityKind, _b105) {
      constructor(name3, dataType, columnType) {
        super(name3, dataType, columnType);
        this.config.autoIncrement = false;
      }
      autoincrement() {
        this.config.autoIncrement = true;
        this.config.hasDefault = true;
        return this;
      }
    };
    __publicField(MySqlColumnBuilderWithAutoIncrement, _a137, "MySqlColumnBuilderWithAutoIncrement");
    MySqlColumnWithAutoIncrement = class extends (_b106 = MySqlColumn, _a138 = entityKind, _b106) {
      constructor() {
        super(...arguments);
        __publicField(this, "autoIncrement", this.config.autoIncrement);
      }
    };
    __publicField(MySqlColumnWithAutoIncrement, _a138, "MySqlColumnWithAutoIncrement");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/bigint.js
function bigint2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config.mode === "number") {
    return new MySqlBigInt53Builder(name3, config.unsigned);
  }
  return new MySqlBigInt64Builder(name3, config.unsigned);
}
var _a139, _b107, MySqlBigInt53Builder, _a140, _b108, MySqlBigInt53, _a141, _b109, MySqlBigInt64Builder, _a142, _b110, MySqlBigInt64;
var init_bigint2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/bigint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlBigInt53Builder = class extends (_b107 = MySqlColumnBuilderWithAutoIncrement, _a139 = entityKind, _b107) {
      constructor(name3, unsigned = false) {
        super(name3, "number", "MySqlBigInt53");
        this.config.unsigned = unsigned;
      }
      /** @internal */
      build(table6) {
        return new MySqlBigInt53(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlBigInt53Builder, _a139, "MySqlBigInt53Builder");
    MySqlBigInt53 = class extends (_b108 = MySqlColumnWithAutoIncrement, _a140 = entityKind, _b108) {
      getSQLType() {
        return `bigint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") {
          return value;
        }
        return Number(value);
      }
    };
    __publicField(MySqlBigInt53, _a140, "MySqlBigInt53");
    MySqlBigInt64Builder = class extends (_b109 = MySqlColumnBuilderWithAutoIncrement, _a141 = entityKind, _b109) {
      constructor(name3, unsigned = false) {
        super(name3, "bigint", "MySqlBigInt64");
        this.config.unsigned = unsigned;
      }
      /** @internal */
      build(table6) {
        return new MySqlBigInt64(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlBigInt64Builder, _a141, "MySqlBigInt64Builder");
    MySqlBigInt64 = class extends (_b110 = MySqlColumnWithAutoIncrement, _a142 = entityKind, _b110) {
      getSQLType() {
        return `bigint${this.config.unsigned ? " unsigned" : ""}`;
      }
      // eslint-disable-next-line unicorn/prefer-native-coercion-functions
      mapFromDriverValue(value) {
        return BigInt(value);
      }
    };
    __publicField(MySqlBigInt64, _a142, "MySqlBigInt64");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/binary.js
function binary2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlBinaryBuilder(name3, config.length);
}
var _a143, _b111, MySqlBinaryBuilder, _a144, _b112, MySqlBinary;
var init_binary = __esm({
  "../drizzle-orm/dist/mysql-core/columns/binary.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlBinaryBuilder = class extends (_b111 = MySqlColumnBuilder, _a143 = entityKind, _b111) {
      constructor(name3, length) {
        super(name3, "string", "MySqlBinary");
        this.config.length = length;
      }
      /** @internal */
      build(table6) {
        return new MySqlBinary(table6, this.config);
      }
    };
    __publicField(MySqlBinaryBuilder, _a143, "MySqlBinaryBuilder");
    MySqlBinary = class extends (_b112 = MySqlColumn, _a144 = entityKind, _b112) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        if (Buffer.isBuffer(value)) return value.toString();
        const str = [];
        for (const v11 of value) {
          str.push(v11 === 49 ? "1" : "0");
        }
        return str.join("");
      }
      getSQLType() {
        return this.length === void 0 ? `binary` : `binary(${this.length})`;
      }
    };
    __publicField(MySqlBinary, _a144, "MySqlBinary");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/boolean.js
function boolean2(name3) {
  return new MySqlBooleanBuilder(name3 ?? "");
}
var _a145, _b113, MySqlBooleanBuilder, _a146, _b114, MySqlBoolean;
var init_boolean2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/boolean.js"() {
    "use strict";
    init_entity();
    init_common2();
    MySqlBooleanBuilder = class extends (_b113 = MySqlColumnBuilder, _a145 = entityKind, _b113) {
      constructor(name3) {
        super(name3, "boolean", "MySqlBoolean");
      }
      /** @internal */
      build(table6) {
        return new MySqlBoolean(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlBooleanBuilder, _a145, "MySqlBooleanBuilder");
    MySqlBoolean = class extends (_b114 = MySqlColumn, _a146 = entityKind, _b114) {
      getSQLType() {
        return "boolean";
      }
      mapFromDriverValue(value) {
        if (typeof value === "boolean") {
          return value;
        }
        return value === 1;
      }
    };
    __publicField(MySqlBoolean, _a146, "MySqlBoolean");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/char.js
function char2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlCharBuilder(name3, config);
}
var _a147, _b115, MySqlCharBuilder, _a148, _b116, MySqlChar;
var init_char2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/char.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlCharBuilder = class extends (_b115 = MySqlColumnBuilder, _a147 = entityKind, _b115) {
      constructor(name3, config) {
        super(name3, "string", "MySqlChar");
        this.config.length = config.length;
        this.config.enum = config.enum;
      }
      /** @internal */
      build(table6) {
        return new MySqlChar(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlCharBuilder, _a147, "MySqlCharBuilder");
    MySqlChar = class extends (_b116 = MySqlColumn, _a148 = entityKind, _b116) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
        __publicField(this, "enumValues", this.config.enum);
      }
      getSQLType() {
        return this.length === void 0 ? `char` : `char(${this.length})`;
      }
    };
    __publicField(MySqlChar, _a148, "MySqlChar");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/custom.js
function customType2(customTypeParams) {
  return (a9, b9) => {
    const { name: name3, config } = getColumnNameAndConfig(a9, b9);
    return new MySqlCustomColumnBuilder(name3, config, customTypeParams);
  };
}
var _a149, _b117, MySqlCustomColumnBuilder, _a150, _b118, MySqlCustomColumn;
var init_custom2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/custom.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlCustomColumnBuilder = class extends (_b117 = MySqlColumnBuilder, _a149 = entityKind, _b117) {
      constructor(name3, fieldConfig, customTypeParams) {
        super(name3, "custom", "MySqlCustomColumn");
        this.config.fieldConfig = fieldConfig;
        this.config.customTypeParams = customTypeParams;
      }
      /** @internal */
      build(table6) {
        return new MySqlCustomColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlCustomColumnBuilder, _a149, "MySqlCustomColumnBuilder");
    MySqlCustomColumn = class extends (_b118 = MySqlColumn, _a150 = entityKind, _b118) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "sqlName");
        __publicField(this, "mapTo");
        __publicField(this, "mapFrom");
        this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
        this.mapTo = config.customTypeParams.toDriver;
        this.mapFrom = config.customTypeParams.fromDriver;
      }
      getSQLType() {
        return this.sqlName;
      }
      mapFromDriverValue(value) {
        return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
      }
      mapToDriverValue(value) {
        return typeof this.mapTo === "function" ? this.mapTo(value) : value;
      }
    };
    __publicField(MySqlCustomColumn, _a150, "MySqlCustomColumn");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/date.js
function date2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "string") {
    return new MySqlDateStringBuilder(name3);
  }
  return new MySqlDateBuilder(name3);
}
var _a151, _b119, MySqlDateBuilder, _a152, _b120, MySqlDate, _a153, _b121, MySqlDateStringBuilder, _a154, _b122, MySqlDateString;
var init_date2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/date.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlDateBuilder = class extends (_b119 = MySqlColumnBuilder, _a151 = entityKind, _b119) {
      constructor(name3) {
        super(name3, "date", "MySqlDate");
      }
      /** @internal */
      build(table6) {
        return new MySqlDate(table6, this.config);
      }
    };
    __publicField(MySqlDateBuilder, _a151, "MySqlDateBuilder");
    MySqlDate = class extends (_b120 = MySqlColumn, _a152 = entityKind, _b120) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return `date`;
      }
      mapFromDriverValue(value) {
        return new Date(value);
      }
    };
    __publicField(MySqlDate, _a152, "MySqlDate");
    MySqlDateStringBuilder = class extends (_b121 = MySqlColumnBuilder, _a153 = entityKind, _b121) {
      constructor(name3) {
        super(name3, "string", "MySqlDateString");
      }
      /** @internal */
      build(table6) {
        return new MySqlDateString(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlDateStringBuilder, _a153, "MySqlDateStringBuilder");
    MySqlDateString = class extends (_b122 = MySqlColumn, _a154 = entityKind, _b122) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return `date`;
      }
    };
    __publicField(MySqlDateString, _a154, "MySqlDateString");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/datetime.js
function datetime(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "string") {
    return new MySqlDateTimeStringBuilder(name3, config);
  }
  return new MySqlDateTimeBuilder(name3, config);
}
var _a155, _b123, MySqlDateTimeBuilder, _a156, _b124, MySqlDateTime, _a157, _b125, MySqlDateTimeStringBuilder, _a158, _b126, MySqlDateTimeString;
var init_datetime = __esm({
  "../drizzle-orm/dist/mysql-core/columns/datetime.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlDateTimeBuilder = class extends (_b123 = MySqlColumnBuilder, _a155 = entityKind, _b123) {
      constructor(name3, config) {
        super(name3, "date", "MySqlDateTime");
        this.config.fsp = config?.fsp;
      }
      /** @internal */
      build(table6) {
        return new MySqlDateTime(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlDateTimeBuilder, _a155, "MySqlDateTimeBuilder");
    MySqlDateTime = class extends (_b124 = MySqlColumn, _a156 = entityKind, _b124) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "fsp");
        this.fsp = config.fsp;
      }
      getSQLType() {
        const precision = this.fsp === void 0 ? "" : `(${this.fsp})`;
        return `datetime${precision}`;
      }
      mapToDriverValue(value) {
        return value.toISOString().replace("T", " ").replace("Z", "");
      }
      mapFromDriverValue(value) {
        return /* @__PURE__ */ new Date(value.replace(" ", "T") + "Z");
      }
    };
    __publicField(MySqlDateTime, _a156, "MySqlDateTime");
    MySqlDateTimeStringBuilder = class extends (_b125 = MySqlColumnBuilder, _a157 = entityKind, _b125) {
      constructor(name3, config) {
        super(name3, "string", "MySqlDateTimeString");
        this.config.fsp = config?.fsp;
      }
      /** @internal */
      build(table6) {
        return new MySqlDateTimeString(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlDateTimeStringBuilder, _a157, "MySqlDateTimeStringBuilder");
    MySqlDateTimeString = class extends (_b126 = MySqlColumn, _a158 = entityKind, _b126) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "fsp");
        this.fsp = config.fsp;
      }
      getSQLType() {
        const precision = this.fsp === void 0 ? "" : `(${this.fsp})`;
        return `datetime${precision}`;
      }
    };
    __publicField(MySqlDateTimeString, _a158, "MySqlDateTimeString");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/decimal.js
function decimal2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  const mode = config?.mode;
  return mode === "number" ? new MySqlDecimalNumberBuilder(name3, config) : mode === "bigint" ? new MySqlDecimalBigIntBuilder(name3, config) : new MySqlDecimalBuilder(name3, config);
}
var _a159, _b127, MySqlDecimalBuilder, _a160, _b128, MySqlDecimal, _a161, _b129, MySqlDecimalNumberBuilder, _a162, _b130, MySqlDecimalNumber, _a163, _b131, MySqlDecimalBigIntBuilder, _a164, _b132, MySqlDecimalBigInt;
var init_decimal = __esm({
  "../drizzle-orm/dist/mysql-core/columns/decimal.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlDecimalBuilder = class extends (_b127 = MySqlColumnBuilderWithAutoIncrement, _a159 = entityKind, _b127) {
      constructor(name3, config) {
        super(name3, "string", "MySqlDecimal");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new MySqlDecimal(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlDecimalBuilder, _a159, "MySqlDecimalBuilder");
    MySqlDecimal = class extends (_b128 = MySqlColumnWithAutoIncrement, _a160 = entityKind, _b128) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        return String(value);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `decimal(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "decimal";
        } else {
          type += `decimal(${this.precision})`;
        }
        type = type === "decimal(10,0)" || type === "decimal(10)" ? "decimal" : type;
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(MySqlDecimal, _a160, "MySqlDecimal");
    MySqlDecimalNumberBuilder = class extends (_b129 = MySqlColumnBuilderWithAutoIncrement, _a161 = entityKind, _b129) {
      constructor(name3, config) {
        super(name3, "number", "MySqlDecimalNumber");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new MySqlDecimalNumber(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlDecimalNumberBuilder, _a161, "MySqlDecimalNumberBuilder");
    MySqlDecimalNumber = class extends (_b130 = MySqlColumnWithAutoIncrement, _a162 = entityKind, _b130) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
        __publicField(this, "mapToDriverValue", String);
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") return value;
        return Number(value);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `decimal(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "decimal";
        } else {
          type += `decimal(${this.precision})`;
        }
        type = type === "decimal(10,0)" || type === "decimal(10)" ? "decimal" : type;
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(MySqlDecimalNumber, _a162, "MySqlDecimalNumber");
    MySqlDecimalBigIntBuilder = class extends (_b131 = MySqlColumnBuilderWithAutoIncrement, _a163 = entityKind, _b131) {
      constructor(name3, config) {
        super(name3, "bigint", "MySqlDecimalBigInt");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new MySqlDecimalBigInt(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlDecimalBigIntBuilder, _a163, "MySqlDecimalBigIntBuilder");
    MySqlDecimalBigInt = class extends (_b132 = MySqlColumnWithAutoIncrement, _a164 = entityKind, _b132) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
        __publicField(this, "mapFromDriverValue", BigInt);
        __publicField(this, "mapToDriverValue", String);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `decimal(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "decimal";
        } else {
          type += `decimal(${this.precision})`;
        }
        type = type === "decimal(10,0)" || type === "decimal(10)" ? "decimal" : type;
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(MySqlDecimalBigInt, _a164, "MySqlDecimalBigInt");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/double.js
function double(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlDoubleBuilder(name3, config);
}
var _a165, _b133, MySqlDoubleBuilder, _a166, _b134, MySqlDouble;
var init_double = __esm({
  "../drizzle-orm/dist/mysql-core/columns/double.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlDoubleBuilder = class extends (_b133 = MySqlColumnBuilderWithAutoIncrement, _a165 = entityKind, _b133) {
      constructor(name3, config) {
        super(name3, "number", "MySqlDouble");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new MySqlDouble(table6, this.config);
      }
    };
    __publicField(MySqlDoubleBuilder, _a165, "MySqlDoubleBuilder");
    MySqlDouble = class extends (_b134 = MySqlColumnWithAutoIncrement, _a166 = entityKind, _b134) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `double(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "double";
        } else {
          type += `double(${this.precision})`;
        }
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(MySqlDouble, _a166, "MySqlDouble");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/enum.js
function mysqlEnum(a9, b9) {
  if (typeof a9 === "string" && Array.isArray(b9) || Array.isArray(a9)) {
    const name3 = typeof a9 === "string" && a9.length > 0 ? a9 : "";
    const values2 = (typeof a9 === "string" ? b9 : a9) ?? [];
    if (values2.length === 0) {
      throw new Error(`You have an empty array for "${name3}" enum values`);
    }
    return new MySqlEnumColumnBuilder(name3, values2);
  }
  if (typeof a9 === "string" && typeof b9 === "object" || typeof a9 === "object") {
    const name3 = typeof a9 === "object" ? "" : a9;
    const values2 = typeof a9 === "object" ? Object.values(a9) : typeof b9 === "object" ? Object.values(b9) : [];
    if (values2.length === 0) {
      throw new Error(`You have an empty array for "${name3}" enum values`);
    }
    return new MySqlEnumObjectColumnBuilder(name3, values2);
  }
}
var _a167, _b135, MySqlEnumColumnBuilder, _a168, _b136, MySqlEnumColumn, _a169, _b137, MySqlEnumObjectColumnBuilder, _a170, _b138, MySqlEnumObjectColumn;
var init_enum2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/enum.js"() {
    "use strict";
    init_entity();
    init_common2();
    MySqlEnumColumnBuilder = class extends (_b135 = MySqlColumnBuilder, _a167 = entityKind, _b135) {
      constructor(name3, values2) {
        super(name3, "string", "MySqlEnumColumn");
        this.config.enumValues = values2;
      }
      /** @internal */
      build(table6) {
        return new MySqlEnumColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlEnumColumnBuilder, _a167, "MySqlEnumColumnBuilder");
    MySqlEnumColumn = class extends (_b136 = MySqlColumn, _a168 = entityKind, _b136) {
      constructor() {
        super(...arguments);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return `enum(${this.enumValues.map((value) => `'${value}'`).join(",")})`;
      }
    };
    __publicField(MySqlEnumColumn, _a168, "MySqlEnumColumn");
    MySqlEnumObjectColumnBuilder = class extends (_b137 = MySqlColumnBuilder, _a169 = entityKind, _b137) {
      constructor(name3, values2) {
        super(name3, "string", "MySqlEnumObjectColumn");
        this.config.enumValues = values2;
      }
      /** @internal */
      build(table6) {
        return new MySqlEnumObjectColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlEnumObjectColumnBuilder, _a169, "MySqlEnumObjectColumnBuilder");
    MySqlEnumObjectColumn = class extends (_b138 = MySqlColumn, _a170 = entityKind, _b138) {
      constructor() {
        super(...arguments);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return `enum(${this.enumValues.map((value) => `'${value}'`).join(",")})`;
      }
    };
    __publicField(MySqlEnumObjectColumn, _a170, "MySqlEnumObjectColumn");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/float.js
function float(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlFloatBuilder(name3, config);
}
var _a171, _b139, MySqlFloatBuilder, _a172, _b140, MySqlFloat;
var init_float = __esm({
  "../drizzle-orm/dist/mysql-core/columns/float.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlFloatBuilder = class extends (_b139 = MySqlColumnBuilderWithAutoIncrement, _a171 = entityKind, _b139) {
      constructor(name3, config) {
        super(name3, "number", "MySqlFloat");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new MySqlFloat(table6, this.config);
      }
    };
    __publicField(MySqlFloatBuilder, _a171, "MySqlFloatBuilder");
    MySqlFloat = class extends (_b140 = MySqlColumnWithAutoIncrement, _a172 = entityKind, _b140) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `float(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "float";
        } else {
          type += `float(${this.precision})`;
        }
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(MySqlFloat, _a172, "MySqlFloat");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/int.js
function int(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlIntBuilder(name3, config);
}
var _a173, _b141, MySqlIntBuilder, _a174, _b142, MySqlInt;
var init_int = __esm({
  "../drizzle-orm/dist/mysql-core/columns/int.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlIntBuilder = class extends (_b141 = MySqlColumnBuilderWithAutoIncrement, _a173 = entityKind, _b141) {
      constructor(name3, config) {
        super(name3, "number", "MySqlInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new MySqlInt(table6, this.config);
      }
    };
    __publicField(MySqlIntBuilder, _a173, "MySqlIntBuilder");
    MySqlInt = class extends (_b142 = MySqlColumnWithAutoIncrement, _a174 = entityKind, _b142) {
      getSQLType() {
        return `int${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(MySqlInt, _a174, "MySqlInt");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/json.js
function json2(name3) {
  return new MySqlJsonBuilder(name3 ?? "");
}
var _a175, _b143, MySqlJsonBuilder, _a176, _b144, MySqlJson;
var init_json2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/json.js"() {
    "use strict";
    init_entity();
    init_common2();
    MySqlJsonBuilder = class extends (_b143 = MySqlColumnBuilder, _a175 = entityKind, _b143) {
      constructor(name3) {
        super(name3, "json", "MySqlJson");
      }
      /** @internal */
      build(table6) {
        return new MySqlJson(table6, this.config);
      }
    };
    __publicField(MySqlJsonBuilder, _a175, "MySqlJsonBuilder");
    MySqlJson = class extends (_b144 = MySqlColumn, _a176 = entityKind, _b144) {
      getSQLType() {
        return "json";
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
    };
    __publicField(MySqlJson, _a176, "MySqlJson");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/mediumint.js
function mediumint(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlMediumIntBuilder(name3, config);
}
var _a177, _b145, MySqlMediumIntBuilder, _a178, _b146, MySqlMediumInt;
var init_mediumint = __esm({
  "../drizzle-orm/dist/mysql-core/columns/mediumint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlMediumIntBuilder = class extends (_b145 = MySqlColumnBuilderWithAutoIncrement, _a177 = entityKind, _b145) {
      constructor(name3, config) {
        super(name3, "number", "MySqlMediumInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new MySqlMediumInt(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlMediumIntBuilder, _a177, "MySqlMediumIntBuilder");
    MySqlMediumInt = class extends (_b146 = MySqlColumnWithAutoIncrement, _a178 = entityKind, _b146) {
      getSQLType() {
        return `mediumint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(MySqlMediumInt, _a178, "MySqlMediumInt");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/real.js
function real2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlRealBuilder(name3, config);
}
var _a179, _b147, MySqlRealBuilder, _a180, _b148, MySqlReal;
var init_real2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/real.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlRealBuilder = class extends (_b147 = MySqlColumnBuilderWithAutoIncrement, _a179 = entityKind, _b147) {
      constructor(name3, config) {
        super(name3, "number", "MySqlReal");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
      }
      /** @internal */
      build(table6) {
        return new MySqlReal(table6, this.config);
      }
    };
    __publicField(MySqlRealBuilder, _a179, "MySqlRealBuilder");
    MySqlReal = class extends (_b148 = MySqlColumnWithAutoIncrement, _a180 = entityKind, _b148) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
      }
      getSQLType() {
        if (this.precision !== void 0 && this.scale !== void 0) {
          return `real(${this.precision}, ${this.scale})`;
        } else if (this.precision === void 0) {
          return "real";
        } else {
          return `real(${this.precision})`;
        }
      }
    };
    __publicField(MySqlReal, _a180, "MySqlReal");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/serial.js
function serial2(name3) {
  return new MySqlSerialBuilder(name3 ?? "");
}
var _a181, _b149, MySqlSerialBuilder, _a182, _b150, MySqlSerial;
var init_serial2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/serial.js"() {
    "use strict";
    init_entity();
    init_common2();
    MySqlSerialBuilder = class extends (_b149 = MySqlColumnBuilderWithAutoIncrement, _a181 = entityKind, _b149) {
      constructor(name3) {
        super(name3, "number", "MySqlSerial");
        this.config.hasDefault = true;
        this.config.autoIncrement = true;
      }
      /** @internal */
      build(table6) {
        return new MySqlSerial(table6, this.config);
      }
    };
    __publicField(MySqlSerialBuilder, _a181, "MySqlSerialBuilder");
    MySqlSerial = class extends (_b150 = MySqlColumnWithAutoIncrement, _a182 = entityKind, _b150) {
      getSQLType() {
        return "serial";
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(MySqlSerial, _a182, "MySqlSerial");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/smallint.js
function smallint2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlSmallIntBuilder(name3, config);
}
var _a183, _b151, MySqlSmallIntBuilder, _a184, _b152, MySqlSmallInt;
var init_smallint2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/smallint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlSmallIntBuilder = class extends (_b151 = MySqlColumnBuilderWithAutoIncrement, _a183 = entityKind, _b151) {
      constructor(name3, config) {
        super(name3, "number", "MySqlSmallInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new MySqlSmallInt(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlSmallIntBuilder, _a183, "MySqlSmallIntBuilder");
    MySqlSmallInt = class extends (_b152 = MySqlColumnWithAutoIncrement, _a184 = entityKind, _b152) {
      getSQLType() {
        return `smallint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(MySqlSmallInt, _a184, "MySqlSmallInt");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/text.js
function text2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlTextBuilder(name3, "text", config);
}
function tinytext(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlTextBuilder(name3, "tinytext", config);
}
function mediumtext(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlTextBuilder(name3, "mediumtext", config);
}
function longtext(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlTextBuilder(name3, "longtext", config);
}
var _a185, _b153, MySqlTextBuilder, _a186, _b154, MySqlText;
var init_text2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/text.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlTextBuilder = class extends (_b153 = MySqlColumnBuilder, _a185 = entityKind, _b153) {
      constructor(name3, textType, config) {
        super(name3, "string", "MySqlText");
        this.config.textType = textType;
        this.config.enumValues = config.enum;
      }
      /** @internal */
      build(table6) {
        return new MySqlText(table6, this.config);
      }
    };
    __publicField(MySqlTextBuilder, _a185, "MySqlTextBuilder");
    MySqlText = class extends (_b154 = MySqlColumn, _a186 = entityKind, _b154) {
      constructor() {
        super(...arguments);
        __publicField(this, "textType", this.config.textType);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return this.textType;
      }
    };
    __publicField(MySqlText, _a186, "MySqlText");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/time.js
function time2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlTimeBuilder(name3, config);
}
var _a187, _b155, MySqlTimeBuilder, _a188, _b156, MySqlTime;
var init_time2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/time.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlTimeBuilder = class extends (_b155 = MySqlColumnBuilder, _a187 = entityKind, _b155) {
      constructor(name3, config) {
        super(name3, "string", "MySqlTime");
        this.config.fsp = config?.fsp;
      }
      /** @internal */
      build(table6) {
        return new MySqlTime(table6, this.config);
      }
    };
    __publicField(MySqlTimeBuilder, _a187, "MySqlTimeBuilder");
    MySqlTime = class extends (_b156 = MySqlColumn, _a188 = entityKind, _b156) {
      constructor() {
        super(...arguments);
        __publicField(this, "fsp", this.config.fsp);
      }
      getSQLType() {
        const precision = this.fsp === void 0 ? "" : `(${this.fsp})`;
        return `time${precision}`;
      }
    };
    __publicField(MySqlTime, _a188, "MySqlTime");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/date.common.js
var _a189, _b157, MySqlDateColumnBaseBuilder, _a190, _b158, MySqlDateBaseColumn;
var init_date_common2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/date.common.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_common2();
    MySqlDateColumnBaseBuilder = class extends (_b157 = MySqlColumnBuilder, _a189 = entityKind, _b157) {
      defaultNow() {
        return this.default(sql`(now())`);
      }
      // "on update now" also adds an implicit default value to the column - https://dev.mysql.com/doc/refman/8.0/en/timestamp-initialization.html
      onUpdateNow() {
        this.config.hasOnUpdateNow = true;
        this.config.hasDefault = true;
        return this;
      }
    };
    __publicField(MySqlDateColumnBaseBuilder, _a189, "MySqlDateColumnBuilder");
    MySqlDateBaseColumn = class extends (_b158 = MySqlColumn, _a190 = entityKind, _b158) {
      constructor() {
        super(...arguments);
        __publicField(this, "hasOnUpdateNow", this.config.hasOnUpdateNow);
      }
    };
    __publicField(MySqlDateBaseColumn, _a190, "MySqlDateColumn");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/timestamp.js
function timestamp2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "string") {
    return new MySqlTimestampStringBuilder(name3, config);
  }
  return new MySqlTimestampBuilder(name3, config);
}
var _a191, _b159, MySqlTimestampBuilder, _a192, _b160, MySqlTimestamp, _a193, _b161, MySqlTimestampStringBuilder, _a194, _b162, MySqlTimestampString;
var init_timestamp2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/timestamp.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_date_common2();
    MySqlTimestampBuilder = class extends (_b159 = MySqlDateColumnBaseBuilder, _a191 = entityKind, _b159) {
      constructor(name3, config) {
        super(name3, "date", "MySqlTimestamp");
        this.config.fsp = config?.fsp;
      }
      /** @internal */
      build(table6) {
        return new MySqlTimestamp(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlTimestampBuilder, _a191, "MySqlTimestampBuilder");
    MySqlTimestamp = class extends (_b160 = MySqlDateBaseColumn, _a192 = entityKind, _b160) {
      constructor() {
        super(...arguments);
        __publicField(this, "fsp", this.config.fsp);
      }
      getSQLType() {
        const precision = this.fsp === void 0 ? "" : `(${this.fsp})`;
        return `timestamp${precision}`;
      }
      mapFromDriverValue(value) {
        return /* @__PURE__ */ new Date(value + "+0000");
      }
      mapToDriverValue(value) {
        return value.toISOString().slice(0, -1).replace("T", " ");
      }
    };
    __publicField(MySqlTimestamp, _a192, "MySqlTimestamp");
    MySqlTimestampStringBuilder = class extends (_b161 = MySqlDateColumnBaseBuilder, _a193 = entityKind, _b161) {
      constructor(name3, config) {
        super(name3, "string", "MySqlTimestampString");
        this.config.fsp = config?.fsp;
      }
      /** @internal */
      build(table6) {
        return new MySqlTimestampString(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlTimestampStringBuilder, _a193, "MySqlTimestampStringBuilder");
    MySqlTimestampString = class extends (_b162 = MySqlDateBaseColumn, _a194 = entityKind, _b162) {
      constructor() {
        super(...arguments);
        __publicField(this, "fsp", this.config.fsp);
      }
      getSQLType() {
        const precision = this.fsp === void 0 ? "" : `(${this.fsp})`;
        return `timestamp${precision}`;
      }
    };
    __publicField(MySqlTimestampString, _a194, "MySqlTimestampString");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/tinyint.js
function tinyint(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlTinyIntBuilder(name3, config);
}
var _a195, _b163, MySqlTinyIntBuilder, _a196, _b164, MySqlTinyInt;
var init_tinyint = __esm({
  "../drizzle-orm/dist/mysql-core/columns/tinyint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlTinyIntBuilder = class extends (_b163 = MySqlColumnBuilderWithAutoIncrement, _a195 = entityKind, _b163) {
      constructor(name3, config) {
        super(name3, "number", "MySqlTinyInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new MySqlTinyInt(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlTinyIntBuilder, _a195, "MySqlTinyIntBuilder");
    MySqlTinyInt = class extends (_b164 = MySqlColumnWithAutoIncrement, _a196 = entityKind, _b164) {
      getSQLType() {
        return `tinyint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(MySqlTinyInt, _a196, "MySqlTinyInt");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/varbinary.js
function varbinary(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlVarBinaryBuilder(name3, config);
}
var _a197, _b165, MySqlVarBinaryBuilder, _a198, _b166, MySqlVarBinary;
var init_varbinary = __esm({
  "../drizzle-orm/dist/mysql-core/columns/varbinary.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlVarBinaryBuilder = class extends (_b165 = MySqlColumnBuilder, _a197 = entityKind, _b165) {
      /** @internal */
      constructor(name3, config) {
        super(name3, "string", "MySqlVarBinary");
        this.config.length = config?.length;
      }
      /** @internal */
      build(table6) {
        return new MySqlVarBinary(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlVarBinaryBuilder, _a197, "MySqlVarBinaryBuilder");
    MySqlVarBinary = class extends (_b166 = MySqlColumn, _a198 = entityKind, _b166) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        if (Buffer.isBuffer(value)) return value.toString();
        const str = [];
        for (const v11 of value) {
          str.push(v11 === 49 ? "1" : "0");
        }
        return str.join("");
      }
      getSQLType() {
        return this.length === void 0 ? `varbinary` : `varbinary(${this.length})`;
      }
    };
    __publicField(MySqlVarBinary, _a198, "MySqlVarBinary");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/varchar.js
function varchar2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new MySqlVarCharBuilder(name3, config);
}
var _a199, _b167, MySqlVarCharBuilder, _a200, _b168, MySqlVarChar;
var init_varchar2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/varchar.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common2();
    MySqlVarCharBuilder = class extends (_b167 = MySqlColumnBuilder, _a199 = entityKind, _b167) {
      /** @internal */
      constructor(name3, config) {
        super(name3, "string", "MySqlVarChar");
        this.config.length = config.length;
        this.config.enum = config.enum;
      }
      /** @internal */
      build(table6) {
        return new MySqlVarChar(
          table6,
          this.config
        );
      }
    };
    __publicField(MySqlVarCharBuilder, _a199, "MySqlVarCharBuilder");
    MySqlVarChar = class extends (_b168 = MySqlColumn, _a200 = entityKind, _b168) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
        __publicField(this, "enumValues", this.config.enum);
      }
      getSQLType() {
        return this.length === void 0 ? `varchar` : `varchar(${this.length})`;
      }
    };
    __publicField(MySqlVarChar, _a200, "MySqlVarChar");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/year.js
function year(name3) {
  return new MySqlYearBuilder(name3 ?? "");
}
var _a201, _b169, MySqlYearBuilder, _a202, _b170, MySqlYear;
var init_year = __esm({
  "../drizzle-orm/dist/mysql-core/columns/year.js"() {
    "use strict";
    init_entity();
    init_common2();
    MySqlYearBuilder = class extends (_b169 = MySqlColumnBuilder, _a201 = entityKind, _b169) {
      constructor(name3) {
        super(name3, "number", "MySqlYear");
      }
      /** @internal */
      build(table6) {
        return new MySqlYear(table6, this.config);
      }
    };
    __publicField(MySqlYearBuilder, _a201, "MySqlYearBuilder");
    MySqlYear = class extends (_b170 = MySqlColumn, _a202 = entityKind, _b170) {
      getSQLType() {
        return `year`;
      }
    };
    __publicField(MySqlYear, _a202, "MySqlYear");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/index.js
var init_columns = __esm({
  "../drizzle-orm/dist/mysql-core/columns/index.js"() {
    "use strict";
    init_bigint2();
    init_binary();
    init_boolean2();
    init_char2();
    init_common2();
    init_custom2();
    init_date2();
    init_datetime();
    init_decimal();
    init_double();
    init_enum2();
    init_float();
    init_int();
    init_json2();
    init_mediumint();
    init_real2();
    init_serial2();
    init_smallint2();
    init_text2();
    init_time2();
    init_timestamp2();
    init_tinyint();
    init_varbinary();
    init_varchar2();
    init_year();
  }
});

// ../drizzle-orm/dist/selection-proxy.js
var _a203, _SelectionProxyHandler, SelectionProxyHandler;
var init_selection_proxy = __esm({
  "../drizzle-orm/dist/selection-proxy.js"() {
    "use strict";
    init_alias();
    init_column();
    init_entity();
    init_sql();
    init_subquery();
    init_view_common();
    _a203 = entityKind;
    _SelectionProxyHandler = class _SelectionProxyHandler {
      constructor(config) {
        __publicField(this, "config");
        this.config = { ...config };
      }
      get(subquery, prop) {
        if (prop === "_") {
          return {
            ...subquery["_"],
            selectedFields: new Proxy(
              subquery._.selectedFields,
              this
            )
          };
        }
        if (prop === ViewBaseConfig) {
          return {
            ...subquery[ViewBaseConfig],
            selectedFields: new Proxy(
              subquery[ViewBaseConfig].selectedFields,
              this
            )
          };
        }
        if (typeof prop === "symbol") {
          return subquery[prop];
        }
        const columns = is(subquery, Subquery) ? subquery._.selectedFields : is(subquery, View) ? subquery[ViewBaseConfig].selectedFields : subquery;
        const value = columns[prop];
        if (is(value, SQL.Aliased)) {
          if (this.config.sqlAliasedBehavior === "sql" && !value.isSelectionField) {
            return value.sql;
          }
          const newValue = value.clone();
          newValue.isSelectionField = true;
          return newValue;
        }
        if (is(value, SQL)) {
          if (this.config.sqlBehavior === "sql") {
            return value;
          }
          throw new Error(
            `You tried to reference "${prop}" field from a subquery, which is a raw SQL field, but it doesn't have an alias declared. Please add an alias to the field using ".as('alias')" method.`
          );
        }
        if (is(value, Column)) {
          if (this.config.alias) {
            return new Proxy(
              value,
              new ColumnAliasProxyHandler(
                new Proxy(
                  value.table,
                  new TableAliasProxyHandler(this.config.alias, this.config.replaceOriginalName ?? false)
                )
              )
            );
          }
          return value;
        }
        if (typeof value !== "object" || value === null) {
          return value;
        }
        return new Proxy(value, new _SelectionProxyHandler(this.config));
      }
    };
    __publicField(_SelectionProxyHandler, _a203, "SelectionProxyHandler");
    SelectionProxyHandler = _SelectionProxyHandler;
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/count.js
var _a204, _b171, _c4, _MySqlCountBuilder, MySqlCountBuilder;
var init_count = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/count.js"() {
    "use strict";
    init_entity();
    init_sql();
    _MySqlCountBuilder = class _MySqlCountBuilder extends (_c4 = SQL, _b171 = entityKind, _a204 = Symbol.toStringTag, _c4) {
      constructor(params) {
        super(_MySqlCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
        __publicField(this, "sql");
        __publicField(this, _a204, "MySqlCountBuilder");
        __publicField(this, "session");
        this.params = params;
        this.mapWith(Number);
        this.session = params.session;
        this.sql = _MySqlCountBuilder.buildCount(
          params.source,
          params.filters
        );
      }
      static buildEmbeddedCount(source, filters) {
        return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
      }
      static buildCount(source, filters) {
        return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters}`;
      }
      then(onfulfilled, onrejected) {
        return Promise.resolve(this.session.count(this.sql)).then(
          onfulfilled,
          onrejected
        );
      }
      catch(onRejected) {
        return this.then(void 0, onRejected);
      }
      finally(onFinally) {
        return this.then(
          (value) => {
            onFinally?.();
            return value;
          },
          (reason) => {
            onFinally?.();
            throw reason;
          }
        );
      }
    };
    __publicField(_MySqlCountBuilder, _b171, "MySqlCountBuilder");
    MySqlCountBuilder = _MySqlCountBuilder;
  }
});

// ../drizzle-orm/dist/mysql-core/indexes.js
var _a205, IndexBuilderOn, _a206, IndexBuilder, _a207, Index;
var init_indexes = __esm({
  "../drizzle-orm/dist/mysql-core/indexes.js"() {
    "use strict";
    init_entity();
    _a205 = entityKind;
    IndexBuilderOn = class {
      constructor(name3, unique2) {
        this.name = name3;
        this.unique = unique2;
      }
      on(...columns) {
        return new IndexBuilder(this.name, columns, this.unique);
      }
    };
    __publicField(IndexBuilderOn, _a205, "MySqlIndexBuilderOn");
    _a206 = entityKind;
    IndexBuilder = class {
      constructor(name3, columns, unique2) {
        /** @internal */
        __publicField(this, "config");
        this.config = {
          name: name3,
          columns,
          unique: unique2
        };
      }
      using(using) {
        this.config.using = using;
        return this;
      }
      algorythm(algorythm) {
        this.config.algorythm = algorythm;
        return this;
      }
      lock(lock) {
        this.config.lock = lock;
        return this;
      }
      /** @internal */
      build(table6) {
        return new Index(this.config, table6);
      }
    };
    __publicField(IndexBuilder, _a206, "MySqlIndexBuilder");
    _a207 = entityKind;
    Index = class {
      constructor(config, table6) {
        __publicField(this, "config");
        this.config = { ...config, table: table6 };
      }
    };
    __publicField(Index, _a207, "MySqlIndex");
  }
});

// ../drizzle-orm/dist/mysql-core/columns/all.js
function getMySqlColumnBuilders() {
  return {
    bigint: bigint2,
    binary: binary2,
    boolean: boolean2,
    char: char2,
    customType: customType2,
    date: date2,
    datetime,
    decimal: decimal2,
    double,
    mysqlEnum,
    float,
    int,
    json: json2,
    mediumint,
    real: real2,
    serial: serial2,
    smallint: smallint2,
    text: text2,
    time: time2,
    timestamp: timestamp2,
    tinyint,
    varbinary,
    varchar: varchar2,
    year,
    longtext,
    mediumtext,
    tinytext
  };
}
var init_all2 = __esm({
  "../drizzle-orm/dist/mysql-core/columns/all.js"() {
    "use strict";
    init_bigint2();
    init_binary();
    init_boolean2();
    init_char2();
    init_custom2();
    init_date2();
    init_datetime();
    init_decimal();
    init_double();
    init_enum2();
    init_float();
    init_int();
    init_json2();
    init_mediumint();
    init_real2();
    init_serial2();
    init_smallint2();
    init_text2();
    init_time2();
    init_timestamp2();
    init_tinyint();
    init_varbinary();
    init_varchar2();
    init_year();
  }
});

// ../drizzle-orm/dist/mysql-core/table.js
function mysqlTableWithSchema(name3, columns, extraConfig, schema6, baseName = name3) {
  const rawTable = new MySqlTable(name3, schema6, baseName);
  const parsedColumns = typeof columns === "function" ? columns(getMySqlColumnBuilders()) : columns;
  const builtColumns = Object.fromEntries(
    Object.entries(parsedColumns).map(([name22, colBuilderBase]) => {
      const colBuilder = colBuilderBase;
      colBuilder.setName(name22);
      const column6 = colBuilder.build(rawTable);
      rawTable[InlineForeignKeys2].push(...colBuilder.buildForeignKeys(column6, rawTable));
      return [name22, column6];
    })
  );
  const table6 = Object.assign(rawTable, builtColumns);
  table6[Table.Symbol.Columns] = builtColumns;
  table6[Table.Symbol.ExtraConfigColumns] = builtColumns;
  if (extraConfig) {
    table6[MySqlTable.Symbol.ExtraConfigBuilder] = extraConfig;
  }
  return table6;
}
var InlineForeignKeys2, _a208, _b172, _c5, _d3, _e3, MySqlTable, mysqlTable;
var init_table3 = __esm({
  "../drizzle-orm/dist/mysql-core/table.js"() {
    "use strict";
    init_entity();
    init_table();
    init_all2();
    InlineForeignKeys2 = Symbol.for("drizzle:MySqlInlineForeignKeys");
    MySqlTable = class extends (_e3 = Table, _d3 = entityKind, _c5 = Table.Symbol.Columns, _b172 = InlineForeignKeys2, _a208 = Table.Symbol.ExtraConfigBuilder, _e3) {
      constructor() {
        super(...arguments);
        /** @internal */
        __publicField(this, _c5);
        /** @internal */
        __publicField(this, _b172, []);
        /** @internal */
        __publicField(this, _a208);
      }
    };
    __publicField(MySqlTable, _d3, "MySqlTable");
    /** @internal */
    __publicField(MySqlTable, "Symbol", Object.assign({}, Table.Symbol, {
      InlineForeignKeys: InlineForeignKeys2
    }));
    mysqlTable = (name3, columns, extraConfig) => {
      return mysqlTableWithSchema(name3, columns, extraConfig, void 0, name3);
    };
  }
});

// ../drizzle-orm/dist/mysql-core/primary-keys.js
var _a209, PrimaryKeyBuilder2, _a210, PrimaryKey2;
var init_primary_keys2 = __esm({
  "../drizzle-orm/dist/mysql-core/primary-keys.js"() {
    "use strict";
    init_entity();
    init_table3();
    _a209 = entityKind;
    PrimaryKeyBuilder2 = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        /** @internal */
        __publicField(this, "name");
        this.columns = columns;
        this.name = name3;
      }
      /** @internal */
      build(table6) {
        return new PrimaryKey2(table6, this.columns, this.name);
      }
    };
    __publicField(PrimaryKeyBuilder2, _a209, "MySqlPrimaryKeyBuilder");
    _a210 = entityKind;
    PrimaryKey2 = class {
      constructor(table6, columns, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        this.table = table6;
        this.columns = columns;
        this.name = name3;
      }
      getName() {
        return this.name ?? `${this.table[MySqlTable.Symbol.Name]}_${this.columns.map((column6) => column6.name).join("_")}_pk`;
      }
    };
    __publicField(PrimaryKey2, _a210, "MySqlPrimaryKey");
  }
});

// ../drizzle-orm/dist/mysql-core/view-common.js
var MySqlViewConfig;
var init_view_common2 = __esm({
  "../drizzle-orm/dist/mysql-core/view-common.js"() {
    "use strict";
    MySqlViewConfig = Symbol.for("drizzle:MySqlViewConfig");
  }
});

// ../drizzle-orm/dist/mysql-core/utils.js
function extractUsedTable(table6) {
  if (is(table6, MySqlTable)) {
    return [`${table6[Table.Symbol.BaseName]}`];
  }
  if (is(table6, Subquery)) {
    return table6._.usedTables ?? [];
  }
  if (is(table6, SQL)) {
    return table6.usedTables ?? [];
  }
  return [];
}
function getTableConfig(table6) {
  const columns = Object.values(table6[MySqlTable.Symbol.Columns]);
  const indexes = [];
  const checks = [];
  const primaryKeys = [];
  const uniqueConstraints = [];
  const foreignKeys = Object.values(table6[MySqlTable.Symbol.InlineForeignKeys]);
  const name3 = table6[Table.Symbol.Name];
  const schema6 = table6[Table.Symbol.Schema];
  const baseName = table6[Table.Symbol.BaseName];
  const extraConfigBuilder = table6[MySqlTable.Symbol.ExtraConfigBuilder];
  if (extraConfigBuilder !== void 0) {
    const extraConfig = extraConfigBuilder(table6[MySqlTable.Symbol.Columns]);
    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);
    for (const builder of Object.values(extraValues)) {
      if (is(builder, IndexBuilder)) {
        indexes.push(builder.build(table6));
      } else if (is(builder, CheckBuilder)) {
        checks.push(builder.build(table6));
      } else if (is(builder, UniqueConstraintBuilder2)) {
        uniqueConstraints.push(builder.build(table6));
      } else if (is(builder, PrimaryKeyBuilder2)) {
        primaryKeys.push(builder.build(table6));
      } else if (is(builder, ForeignKeyBuilder2)) {
        foreignKeys.push(builder.build(table6));
      }
    }
  }
  return {
    columns,
    indexes,
    foreignKeys,
    checks,
    primaryKeys,
    uniqueConstraints,
    name: name3,
    schema: schema6,
    baseName
  };
}
function getViewConfig(view5) {
  return {
    ...view5[ViewBaseConfig],
    ...view5[MySqlViewConfig]
  };
}
function convertIndexToString(indexes) {
  return indexes.map((idx) => {
    return typeof idx === "object" ? idx.config.name : idx;
  });
}
function toArray(value) {
  return Array.isArray(value) ? value : [value];
}
var init_utils3 = __esm({
  "../drizzle-orm/dist/mysql-core/utils.js"() {
    "use strict";
    init_entity();
    init_dist();
    init_subquery();
    init_table();
    init_view_common();
    init_checks();
    init_foreign_keys2();
    init_indexes();
    init_primary_keys2();
    init_table3();
    init_unique_constraint2();
    init_view_common2();
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/delete.js
var _a211, _b173, MySqlDeleteBase;
var init_delete = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/delete.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_table();
    init_utils3();
    MySqlDeleteBase = class extends (_b173 = QueryPromise, _a211 = entityKind, _b173) {
      constructor(table6, session, dialect6, withList) {
        super();
        __publicField(this, "config");
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, withList };
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will delete only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be deleted.
       *
       * ```ts
       * // Delete all cars with green color
       * db.delete(cars).where(eq(cars.color, 'green'));
       * // or
       * db.delete(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Delete all BMW cars with a green color
       * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Delete all cars with the green or blue color
       * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.table[Table.Symbol.Columns],
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          this.config.orderBy = orderByArray;
        } else {
          const orderByArray = columns;
          this.config.orderBy = orderByArray;
        }
        return this;
      }
      limit(limit) {
        this.config.limit = limit;
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildDeleteQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      prepare() {
        return this.session.prepareQuery(
          this.dialect.sqlToQuery(this.getSQL()),
          this.config.returning,
          void 0,
          void 0,
          void 0,
          {
            type: "delete",
            tables: extractUsedTable(this.config.table)
          }
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(MySqlDeleteBase, _a211, "MySqlDelete");
  }
});

// ../drizzle-orm/dist/casing.js
function toSnakeCase(input) {
  const words = input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
  return words.map((word) => word.toLowerCase()).join("_");
}
function toCamelCase(input) {
  const words = input.replace(/['\u2019]/g, "").match(/[\da-z]+|[A-Z]+(?![a-z])|[A-Z][\da-z]+/g) ?? [];
  return words.reduce((acc, word, i8) => {
    const formattedWord = i8 === 0 ? word.toLowerCase() : `${word[0].toUpperCase()}${word.slice(1)}`;
    return acc + formattedWord;
  }, "");
}
function noopCase(input) {
  return input;
}
var _a212, CasingCache;
var init_casing = __esm({
  "../drizzle-orm/dist/casing.js"() {
    "use strict";
    init_entity();
    init_table();
    _a212 = entityKind;
    CasingCache = class {
      constructor(casing2) {
        /** @internal */
        __publicField(this, "cache", {});
        __publicField(this, "cachedTables", {});
        __publicField(this, "convert");
        this.convert = casing2 === "snake_case" ? toSnakeCase : casing2 === "camelCase" ? toCamelCase : noopCase;
      }
      getColumnCasing(column6) {
        if (!column6.keyAsName) return column6.name;
        const schema6 = column6.table[Table.Symbol.Schema] ?? "public";
        const tableName = column6.table[Table.Symbol.OriginalName];
        const key = `${schema6}.${tableName}.${column6.name}`;
        if (!this.cache[key]) {
          this.cacheTable(column6.table);
        }
        return this.cache[key];
      }
      cacheTable(table6) {
        const schema6 = table6[Table.Symbol.Schema] ?? "public";
        const tableName = table6[Table.Symbol.OriginalName];
        const tableKey2 = `${schema6}.${tableName}`;
        if (!this.cachedTables[tableKey2]) {
          for (const column6 of Object.values(table6[Table.Symbol.Columns])) {
            const columnKey = `${tableKey2}.${column6.name}`;
            this.cache[columnKey] = this.convert(column6.name);
          }
          this.cachedTables[tableKey2] = true;
        }
      }
      clearCache() {
        this.cache = {};
        this.cachedTables = {};
      }
    };
    __publicField(CasingCache, _a212, "CasingCache");
  }
});

// ../drizzle-orm/dist/mysql-core/view-base.js
var _a213, _b174, MySqlViewBase;
var init_view_base = __esm({
  "../drizzle-orm/dist/mysql-core/view-base.js"() {
    "use strict";
    init_entity();
    init_sql();
    MySqlViewBase = class extends (_b174 = View, _a213 = entityKind, _b174) {
    };
    __publicField(MySqlViewBase, _a213, "MySqlViewBase");
  }
});

// ../drizzle-orm/dist/mysql-core/dialect.js
var _a214, MySqlDialect;
var init_dialect = __esm({
  "../drizzle-orm/dist/mysql-core/dialect.js"() {
    "use strict";
    init_alias();
    init_casing();
    init_column();
    init_entity();
    init_errors();
    init_relations();
    init_expressions();
    init_sql();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_common2();
    init_table3();
    init_view_base();
    _a214 = entityKind;
    MySqlDialect = class {
      constructor(config) {
        /** @internal */
        __publicField(this, "casing");
        this.casing = new CasingCache(config?.casing);
      }
      async migrate(migrations, session, config) {
        const migrationsTable = config.migrationsTable ?? "__drizzle_migrations";
        const migrationTableCreate = sql`
			create table if not exists ${sql.identifier(migrationsTable)} (
				id serial primary key,
				hash text not null,
				created_at bigint
			)
		`;
        await session.execute(migrationTableCreate);
        const dbMigrations = await session.all(
          sql`select id, hash, created_at from ${sql.identifier(migrationsTable)} order by created_at desc limit 1`
        );
        const lastDbMigration = dbMigrations[0];
        await session.transaction(async (tx) => {
          for (const migration of migrations) {
            if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
              for (const stmt of migration.sql) {
                await tx.execute(sql.raw(stmt));
              }
              await tx.execute(
                sql`insert into ${sql.identifier(migrationsTable)} (\`hash\`, \`created_at\`) values(${migration.hash}, ${migration.folderMillis})`
              );
            }
          }
        });
      }
      escapeName(name3) {
        return `\`${name3}\``;
      }
      escapeParam(_num) {
        return `?`;
      }
      escapeString(str) {
        return `'${str.replace(/'/g, "''")}'`;
      }
      buildWithCTE(queries) {
        if (!queries?.length) return void 0;
        const withSqlChunks = [sql`with `];
        for (const [i8, w10] of queries.entries()) {
          withSqlChunks.push(sql`${sql.identifier(w10._.alias)} as (${w10._.sql})`);
          if (i8 < queries.length - 1) {
            withSqlChunks.push(sql`, `);
          }
        }
        withSqlChunks.push(sql` `);
        return sql.join(withSqlChunks);
      }
      buildDeleteQuery({ table: table6, where, returning, withList, limit, orderBy }) {
        const withSql = this.buildWithCTE(withList);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const limitSql = this.buildLimit(limit);
        return sql`${withSql}delete from ${table6}${whereSql}${orderBySql}${limitSql}${returningSql}`;
      }
      buildUpdateSet(table6, set) {
        const tableColumns = table6[Table.Symbol.Columns];
        const columnNames = Object.keys(tableColumns).filter(
          (colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0
        );
        const setSize = columnNames.length;
        return sql.join(columnNames.flatMap((colName, i8) => {
          const col = tableColumns[colName];
          const value = set[colName] ?? sql.param(col.onUpdateFn(), col);
          const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
          if (i8 < setSize - 1) {
            return [res, sql.raw(", ")];
          }
          return [res];
        }));
      }
      buildUpdateQuery({ table: table6, set, where, returning, withList, limit, orderBy }) {
        const withSql = this.buildWithCTE(withList);
        const setSql = this.buildUpdateSet(table6, set);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const limitSql = this.buildLimit(limit);
        return sql`${withSql}update ${table6} set ${setSql}${whereSql}${orderBySql}${limitSql}${returningSql}`;
      }
      /**
       * Builds selection SQL with provided fields/expressions
       *
       * Examples:
       *
       * `select <selection> from`
       *
       * `insert ... returning <selection>`
       *
       * If `isSingleTable` is true, then columns won't be prefixed with table name
       */
      buildSelection(fields, { isSingleTable = false } = {}) {
        const columnsLen = fields.length;
        const chunks = fields.flatMap(({ field }, i8) => {
          const chunk = [];
          if (is(field, SQL.Aliased) && field.isSelectionField) {
            chunk.push(sql.identifier(field.fieldAlias));
          } else if (is(field, SQL.Aliased) || is(field, SQL)) {
            const query = is(field, SQL.Aliased) ? field.sql : field;
            if (isSingleTable) {
              chunk.push(
                new SQL(
                  query.queryChunks.map((c6) => {
                    if (is(c6, MySqlColumn)) {
                      return sql.identifier(this.casing.getColumnCasing(c6));
                    }
                    return c6;
                  })
                )
              );
            } else {
              chunk.push(query);
            }
            if (is(field, SQL.Aliased)) {
              chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
            }
          } else if (is(field, Column)) {
            if (isSingleTable) {
              chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
            } else {
              chunk.push(field);
            }
          }
          if (i8 < columnsLen - 1) {
            chunk.push(sql`, `);
          }
          return chunk;
        });
        return sql.join(chunks);
      }
      buildLimit(limit) {
        return typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
      }
      buildOrderBy(orderBy) {
        return orderBy && orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : void 0;
      }
      buildIndex({
        indexes,
        indexFor
      }) {
        return indexes && indexes.length > 0 ? sql` ${sql.raw(indexFor)} INDEX (${sql.raw(indexes.join(`, `))})` : void 0;
      }
      buildSelectQuery({
        withList,
        fields,
        fieldsFlat,
        where,
        having,
        table: table6,
        joins,
        orderBy,
        groupBy,
        limit,
        offset,
        lockingClause,
        distinct,
        setOperators,
        useIndex,
        forceIndex,
        ignoreIndex
      }) {
        const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
        for (const f9 of fieldsList) {
          if (is(f9.field, Column) && getTableName(f9.field.table) !== (is(table6, Subquery) ? table6._.alias : is(table6, MySqlViewBase) ? table6[ViewBaseConfig].name : is(table6, SQL) ? void 0 : getTableName(table6)) && !((table22) => joins?.some(
            ({ alias: alias2 }) => alias2 === (table22[Table.Symbol.IsAlias] ? getTableName(table22) : table22[Table.Symbol.BaseName])
          ))(f9.field.table)) {
            const tableName = getTableName(f9.field.table);
            throw new Error(
              `Your "${f9.path.join("->")}" field references a column "${tableName}"."${f9.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`
            );
          }
        }
        const isSingleTable = !joins || joins.length === 0;
        const withSql = this.buildWithCTE(withList);
        const distinctSql = distinct ? sql` distinct` : void 0;
        const selection = this.buildSelection(fieldsList, { isSingleTable });
        const tableSql = (() => {
          if (is(table6, Table) && table6[Table.Symbol.IsAlias]) {
            return sql`${sql`${sql.identifier(table6[Table.Symbol.Schema] ?? "")}.`.if(table6[Table.Symbol.Schema])}${sql.identifier(table6[Table.Symbol.OriginalName])} ${sql.identifier(table6[Table.Symbol.Name])}`;
          }
          return table6;
        })();
        const joinsArray = [];
        if (joins) {
          for (const [index7, joinMeta] of joins.entries()) {
            if (index7 === 0) {
              joinsArray.push(sql` `);
            }
            const table22 = joinMeta.table;
            const lateralSql = joinMeta.lateral ? sql` lateral` : void 0;
            const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : void 0;
            if (is(table22, MySqlTable)) {
              const tableName = table22[MySqlTable.Symbol.Name];
              const tableSchema = table22[MySqlTable.Symbol.Schema];
              const origTableName = table22[MySqlTable.Symbol.OriginalName];
              const alias2 = tableName === origTableName ? void 0 : joinMeta.alias;
              const useIndexSql2 = this.buildIndex({ indexes: joinMeta.useIndex, indexFor: "USE" });
              const forceIndexSql2 = this.buildIndex({ indexes: joinMeta.forceIndex, indexFor: "FORCE" });
              const ignoreIndexSql2 = this.buildIndex({ indexes: joinMeta.ignoreIndex, indexFor: "IGNORE" });
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${useIndexSql2}${forceIndexSql2}${ignoreIndexSql2}${alias2 && sql` ${sql.identifier(alias2)}`}${onSql}`
              );
            } else if (is(table22, View)) {
              const viewName = table22[ViewBaseConfig].name;
              const viewSchema = table22[ViewBaseConfig].schema;
              const origViewName = table22[ViewBaseConfig].originalName;
              const alias2 = viewName === origViewName ? void 0 : joinMeta.alias;
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql`${sql.identifier(viewSchema)}.` : void 0}${sql.identifier(origViewName)}${alias2 && sql` ${sql.identifier(alias2)}`}${onSql}`
              );
            } else {
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table22}${onSql}`
              );
            }
            if (index7 < joins.length - 1) {
              joinsArray.push(sql` `);
            }
          }
        }
        const joinsSql = sql.join(joinsArray);
        const whereSql = where ? sql` where ${where}` : void 0;
        const havingSql = having ? sql` having ${having}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const groupBySql = groupBy && groupBy.length > 0 ? sql` group by ${sql.join(groupBy, sql`, `)}` : void 0;
        const limitSql = this.buildLimit(limit);
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        const useIndexSql = this.buildIndex({ indexes: useIndex, indexFor: "USE" });
        const forceIndexSql = this.buildIndex({ indexes: forceIndex, indexFor: "FORCE" });
        const ignoreIndexSql = this.buildIndex({ indexes: ignoreIndex, indexFor: "IGNORE" });
        let lockingClausesSql;
        if (lockingClause) {
          const { config, strength } = lockingClause;
          lockingClausesSql = sql` for ${sql.raw(strength)}`;
          if (config.noWait) {
            lockingClausesSql.append(sql` nowait`);
          } else if (config.skipLocked) {
            lockingClausesSql.append(sql` skip locked`);
          }
        }
        const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${useIndexSql}${forceIndexSql}${ignoreIndexSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
        if (setOperators.length > 0) {
          return this.buildSetOperations(finalQuery, setOperators);
        }
        return finalQuery;
      }
      buildSetOperations(leftSelect, setOperators) {
        const [setOperator, ...rest] = setOperators;
        if (!setOperator) {
          throw new Error("Cannot pass undefined values to any set operator");
        }
        if (rest.length === 0) {
          return this.buildSetOperationQuery({ leftSelect, setOperator });
        }
        return this.buildSetOperations(
          this.buildSetOperationQuery({ leftSelect, setOperator }),
          rest
        );
      }
      buildSetOperationQuery({
        leftSelect,
        setOperator: { type, isAll, rightSelect, limit, orderBy, offset }
      }) {
        const leftChunk = sql`(${leftSelect.getSQL()}) `;
        const rightChunk = sql`(${rightSelect.getSQL()})`;
        let orderBySql;
        if (orderBy && orderBy.length > 0) {
          const orderByValues = [];
          for (const orderByUnit of orderBy) {
            if (is(orderByUnit, MySqlColumn)) {
              orderByValues.push(sql.identifier(this.casing.getColumnCasing(orderByUnit)));
            } else if (is(orderByUnit, SQL)) {
              for (let i8 = 0; i8 < orderByUnit.queryChunks.length; i8++) {
                const chunk = orderByUnit.queryChunks[i8];
                if (is(chunk, MySqlColumn)) {
                  orderByUnit.queryChunks[i8] = sql.identifier(this.casing.getColumnCasing(chunk));
                }
              }
              orderByValues.push(sql`${orderByUnit}`);
            } else {
              orderByValues.push(sql`${orderByUnit}`);
            }
          }
          orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
        }
        const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
        const operatorChunk = sql.raw(`${type} ${isAll ? "all " : ""}`);
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
      }
      buildInsertQuery({ table: table6, values: valuesOrSelect, ignore, onConflict, select: select2 }) {
        const valuesSqlList = [];
        const columns = table6[Table.Symbol.Columns];
        const colEntries = Object.entries(columns).filter(
          ([_7, col]) => !col.shouldDisableInsert()
        );
        const insertOrder = colEntries.map(([, column6]) => sql.identifier(this.casing.getColumnCasing(column6)));
        const generatedIdsResponse = [];
        if (select2) {
          const select22 = valuesOrSelect;
          if (is(select22, SQL)) {
            valuesSqlList.push(select22);
          } else {
            valuesSqlList.push(select22.getSQL());
          }
        } else {
          const values2 = valuesOrSelect;
          valuesSqlList.push(sql.raw("values "));
          for (const [valueIndex, value] of values2.entries()) {
            const generatedIds = {};
            const valueList = [];
            for (const [fieldName, col] of colEntries) {
              const colValue = value[fieldName];
              if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
                if (col.defaultFn !== void 0) {
                  const defaultFnResult = col.defaultFn();
                  generatedIds[fieldName] = defaultFnResult;
                  const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
                  valueList.push(defaultValue);
                } else if (!col.default && col.onUpdateFn !== void 0) {
                  const onUpdateFnResult = col.onUpdateFn();
                  const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
                  valueList.push(newValue);
                } else {
                  valueList.push(sql`default`);
                }
              } else {
                if (col.defaultFn && is(colValue, Param)) {
                  generatedIds[fieldName] = colValue.value;
                }
                valueList.push(colValue);
              }
            }
            generatedIdsResponse.push(generatedIds);
            valuesSqlList.push(valueList);
            if (valueIndex < values2.length - 1) {
              valuesSqlList.push(sql`, `);
            }
          }
        }
        const valuesSql = sql.join(valuesSqlList);
        const ignoreSql = ignore ? sql` ignore` : void 0;
        const onConflictSql = onConflict ? sql` on duplicate key ${onConflict}` : void 0;
        return {
          sql: sql`insert${ignoreSql} into ${table6} ${insertOrder} ${valuesSql}${onConflictSql}`,
          generatedIds: generatedIdsResponse
        };
      }
      sqlToQuery(sql22, invokeSource) {
        return sql22.toQuery({
          casing: this.casing,
          escapeName: this.escapeName,
          escapeParam: this.escapeParam,
          escapeString: this.escapeString,
          invokeSource
        });
      }
      buildRelationalQuery({
        fullSchema,
        schema: schema6,
        tableNamesMap,
        table: table6,
        tableConfig,
        queryConfig: config,
        tableAlias,
        nestedQueryRelation,
        joinOn
      }) {
        let selection = [];
        let limit, offset, orderBy, where;
        const joins = [];
        if (config === true) {
          const selectionEntries = Object.entries(tableConfig.columns);
          selection = selectionEntries.map(([key, value]) => ({
            dbKey: value.name,
            tsKey: key,
            field: aliasedTableColumn(value, tableAlias),
            relationTableTsKey: void 0,
            isJson: false,
            selection: []
          }));
        } else {
          const aliasedColumns = Object.fromEntries(
            Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)])
          );
          if (config.where) {
            const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
          }
          const fieldsSelection = [];
          let selectedColumns = [];
          if (config.columns) {
            let isIncludeMode = false;
            for (const [field, value] of Object.entries(config.columns)) {
              if (value === void 0) {
                continue;
              }
              if (field in tableConfig.columns) {
                if (!isIncludeMode && value === true) {
                  isIncludeMode = true;
                }
                selectedColumns.push(field);
              }
            }
            if (selectedColumns.length > 0) {
              selectedColumns = isIncludeMode ? selectedColumns.filter((c6) => config.columns?.[c6] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
            }
          } else {
            selectedColumns = Object.keys(tableConfig.columns);
          }
          for (const field of selectedColumns) {
            const column6 = tableConfig.columns[field];
            fieldsSelection.push({ tsKey: field, value: column6 });
          }
          let selectedRelations = [];
          if (config.with) {
            selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
          }
          let extras;
          if (config.extras) {
            extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
            for (const [tsKey, value] of Object.entries(extras)) {
              fieldsSelection.push({
                tsKey,
                value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
              });
            }
          }
          for (const { tsKey, value } of fieldsSelection) {
            selection.push({
              dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
              tsKey,
              field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
              relationTableTsKey: void 0,
              isJson: false,
              selection: []
            });
          }
          let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
          if (!Array.isArray(orderByOrig)) {
            orderByOrig = [orderByOrig];
          }
          orderBy = orderByOrig.map((orderByValue) => {
            if (is(orderByValue, Column)) {
              return aliasedTableColumn(orderByValue, tableAlias);
            }
            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
          });
          limit = config.limit;
          offset = config.offset;
          for (const {
            tsKey: selectedRelationTsKey,
            queryConfig: selectedRelationConfigValue,
            relation
          } of selectedRelations) {
            const normalizedRelation = normalizeRelation(schema6, tableNamesMap, relation);
            const relationTableName = getTableUniqueName(relation.referencedTable);
            const relationTableTsName = tableNamesMap[relationTableName];
            const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
            const joinOn2 = and(
              ...normalizedRelation.fields.map(
                (field2, i8) => eq(
                  aliasedTableColumn(normalizedRelation.references[i8], relationTableAlias),
                  aliasedTableColumn(field2, tableAlias)
                )
              )
            );
            const builtRelation = this.buildRelationalQuery({
              fullSchema,
              schema: schema6,
              tableNamesMap,
              table: fullSchema[relationTableTsName],
              tableConfig: schema6[relationTableTsName],
              queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
              tableAlias: relationTableAlias,
              joinOn: joinOn2,
              nestedQueryRelation: relation
            });
            const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier("data")}`.as(selectedRelationTsKey);
            joins.push({
              on: sql`true`,
              table: new Subquery(builtRelation.sql, {}, relationTableAlias),
              alias: relationTableAlias,
              joinType: "left",
              lateral: true
            });
            selection.push({
              dbKey: selectedRelationTsKey,
              tsKey: selectedRelationTsKey,
              field,
              relationTableTsKey: relationTableTsName,
              isJson: true,
              selection: builtRelation.selection
            });
          }
        }
        if (selection.length === 0) {
          throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
        }
        let result;
        where = and(joinOn, where);
        if (nestedQueryRelation) {
          let field = sql`json_array(${sql.join(
            selection.map(
              ({ field: field2, tsKey, isJson: isJson2 }) => isJson2 ? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier("data")}` : is(field2, SQL.Aliased) ? field2.sql : field2
            ),
            sql`, `
          )})`;
          if (is(nestedQueryRelation, Many)) {
            field = sql`coalesce(json_arrayagg(${field}), json_array())`;
          }
          const nestedSelection = [{
            dbKey: "data",
            tsKey: "data",
            field: field.as("data"),
            isJson: true,
            relationTableTsKey: tableConfig.tsName,
            selection
          }];
          const needsSubquery = limit !== void 0 || offset !== void 0 || (orderBy?.length ?? 0) > 0;
          if (needsSubquery) {
            result = this.buildSelectQuery({
              table: aliasedTable(table6, tableAlias),
              fields: {},
              fieldsFlat: [
                {
                  path: [],
                  field: sql.raw("*")
                },
                ...(orderBy?.length ?? 0) > 0 ? [{
                  path: [],
                  field: sql`row_number() over (order by ${sql.join(orderBy, sql`, `)})`
                }] : []
              ],
              where,
              limit,
              offset,
              setOperators: []
            });
            where = void 0;
            limit = void 0;
            offset = void 0;
            orderBy = void 0;
          } else {
            result = aliasedTable(table6, tableAlias);
          }
          result = this.buildSelectQuery({
            table: is(result, MySqlTable) ? result : new Subquery(result, {}, tableAlias),
            fields: {},
            fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
              path: [],
              field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        } else {
          result = this.buildSelectQuery({
            table: aliasedTable(table6, tableAlias),
            fields: {},
            fieldsFlat: selection.map(({ field }) => ({
              path: [],
              field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        }
        return {
          tableTsKey: tableConfig.tsName,
          sql: result,
          selection
        };
      }
      buildRelationalQueryWithoutLateralSubqueries({
        fullSchema,
        schema: schema6,
        tableNamesMap,
        table: table6,
        tableConfig,
        queryConfig: config,
        tableAlias,
        nestedQueryRelation,
        joinOn
      }) {
        let selection = [];
        let limit, offset, orderBy = [], where;
        if (config === true) {
          const selectionEntries = Object.entries(tableConfig.columns);
          selection = selectionEntries.map(([key, value]) => ({
            dbKey: value.name,
            tsKey: key,
            field: aliasedTableColumn(value, tableAlias),
            relationTableTsKey: void 0,
            isJson: false,
            selection: []
          }));
        } else {
          const aliasedColumns = Object.fromEntries(
            Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)])
          );
          if (config.where) {
            const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
          }
          const fieldsSelection = [];
          let selectedColumns = [];
          if (config.columns) {
            let isIncludeMode = false;
            for (const [field, value] of Object.entries(config.columns)) {
              if (value === void 0) {
                continue;
              }
              if (field in tableConfig.columns) {
                if (!isIncludeMode && value === true) {
                  isIncludeMode = true;
                }
                selectedColumns.push(field);
              }
            }
            if (selectedColumns.length > 0) {
              selectedColumns = isIncludeMode ? selectedColumns.filter((c6) => config.columns?.[c6] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
            }
          } else {
            selectedColumns = Object.keys(tableConfig.columns);
          }
          for (const field of selectedColumns) {
            const column6 = tableConfig.columns[field];
            fieldsSelection.push({ tsKey: field, value: column6 });
          }
          let selectedRelations = [];
          if (config.with) {
            selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
          }
          let extras;
          if (config.extras) {
            extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
            for (const [tsKey, value] of Object.entries(extras)) {
              fieldsSelection.push({
                tsKey,
                value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
              });
            }
          }
          for (const { tsKey, value } of fieldsSelection) {
            selection.push({
              dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
              tsKey,
              field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
              relationTableTsKey: void 0,
              isJson: false,
              selection: []
            });
          }
          let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
          if (!Array.isArray(orderByOrig)) {
            orderByOrig = [orderByOrig];
          }
          orderBy = orderByOrig.map((orderByValue) => {
            if (is(orderByValue, Column)) {
              return aliasedTableColumn(orderByValue, tableAlias);
            }
            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
          });
          limit = config.limit;
          offset = config.offset;
          for (const {
            tsKey: selectedRelationTsKey,
            queryConfig: selectedRelationConfigValue,
            relation
          } of selectedRelations) {
            const normalizedRelation = normalizeRelation(schema6, tableNamesMap, relation);
            const relationTableName = getTableUniqueName(relation.referencedTable);
            const relationTableTsName = tableNamesMap[relationTableName];
            const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
            const joinOn2 = and(
              ...normalizedRelation.fields.map(
                (field2, i8) => eq(
                  aliasedTableColumn(normalizedRelation.references[i8], relationTableAlias),
                  aliasedTableColumn(field2, tableAlias)
                )
              )
            );
            const builtRelation = this.buildRelationalQueryWithoutLateralSubqueries({
              fullSchema,
              schema: schema6,
              tableNamesMap,
              table: fullSchema[relationTableTsName],
              tableConfig: schema6[relationTableTsName],
              queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
              tableAlias: relationTableAlias,
              joinOn: joinOn2,
              nestedQueryRelation: relation
            });
            let fieldSql = sql`(${builtRelation.sql})`;
            if (is(relation, Many)) {
              fieldSql = sql`coalesce(${fieldSql}, json_array())`;
            }
            const field = fieldSql.as(selectedRelationTsKey);
            selection.push({
              dbKey: selectedRelationTsKey,
              tsKey: selectedRelationTsKey,
              field,
              relationTableTsKey: relationTableTsName,
              isJson: true,
              selection: builtRelation.selection
            });
          }
        }
        if (selection.length === 0) {
          throw new DrizzleError({
            message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`
          });
        }
        let result;
        where = and(joinOn, where);
        if (nestedQueryRelation) {
          let field = sql`json_array(${sql.join(
            selection.map(
              ({ field: field2 }) => is(field2, MySqlColumn) ? sql.identifier(this.casing.getColumnCasing(field2)) : is(field2, SQL.Aliased) ? field2.sql : field2
            ),
            sql`, `
          )})`;
          if (is(nestedQueryRelation, Many)) {
            field = sql`json_arrayagg(${field})`;
          }
          const nestedSelection = [{
            dbKey: "data",
            tsKey: "data",
            field,
            isJson: true,
            relationTableTsKey: tableConfig.tsName,
            selection
          }];
          const needsSubquery = limit !== void 0 || offset !== void 0 || orderBy.length > 0;
          if (needsSubquery) {
            result = this.buildSelectQuery({
              table: aliasedTable(table6, tableAlias),
              fields: {},
              fieldsFlat: [
                {
                  path: [],
                  field: sql.raw("*")
                },
                ...orderBy.length > 0 ? [{
                  path: [],
                  field: sql`row_number() over (order by ${sql.join(orderBy, sql`, `)})`
                }] : []
              ],
              where,
              limit,
              offset,
              setOperators: []
            });
            where = void 0;
            limit = void 0;
            offset = void 0;
            orderBy = void 0;
          } else {
            result = aliasedTable(table6, tableAlias);
          }
          result = this.buildSelectQuery({
            table: is(result, MySqlTable) ? result : new Subquery(result, {}, tableAlias),
            fields: {},
            fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
              path: [],
              field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2
            })),
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        } else {
          result = this.buildSelectQuery({
            table: aliasedTable(table6, tableAlias),
            fields: {},
            fieldsFlat: selection.map(({ field }) => ({
              path: [],
              field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
            })),
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        }
        return {
          tableTsKey: tableConfig.tsName,
          sql: result,
          selection
        };
      }
    };
    __publicField(MySqlDialect, _a214, "MySqlDialect");
  }
});

// ../drizzle-orm/dist/query-builders/query-builder.js
var _a215, TypedQueryBuilder;
var init_query_builder = __esm({
  "../drizzle-orm/dist/query-builders/query-builder.js"() {
    "use strict";
    init_entity();
    _a215 = entityKind;
    TypedQueryBuilder = class {
      /** @internal */
      getSelectedFields() {
        return this._.selectedFields;
      }
    };
    __publicField(TypedQueryBuilder, _a215, "TypedQueryBuilder");
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/select.js
function createSetOperator(type, isAll) {
  return (leftSelect, rightSelect, ...restSelects) => {
    const setOperators = [rightSelect, ...restSelects].map((select2) => ({
      type,
      isAll,
      rightSelect: select2
    }));
    for (const setOperator of setOperators) {
      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
        throw new Error(
          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
        );
      }
    }
    return leftSelect.addSetOperators(setOperators);
  };
}
var _a216, MySqlSelectBuilder, _a217, _b175, MySqlSelectQueryBuilderBase, _a218, _b176, MySqlSelectBase, getMySqlSetOperators, union, unionAll, intersect, intersectAll, except, exceptAll;
var init_select2 = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/select.js"() {
    "use strict";
    init_entity();
    init_table3();
    init_query_builder();
    init_query_promise();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_utils3();
    init_view_base();
    _a216 = entityKind;
    MySqlSelectBuilder = class {
      constructor(config) {
        __publicField(this, "fields");
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "withList", []);
        __publicField(this, "distinct");
        this.fields = config.fields;
        this.session = config.session;
        this.dialect = config.dialect;
        if (config.withList) {
          this.withList = config.withList;
        }
        this.distinct = config.distinct;
      }
      from(source, onIndex) {
        const isPartialSelect = !!this.fields;
        let fields;
        if (this.fields) {
          fields = this.fields;
        } else if (is(source, Subquery)) {
          fields = Object.fromEntries(
            Object.keys(source._.selectedFields).map((key) => [key, source[key]])
          );
        } else if (is(source, MySqlViewBase)) {
          fields = source[ViewBaseConfig].selectedFields;
        } else if (is(source, SQL)) {
          fields = {};
        } else {
          fields = getTableColumns(source);
        }
        let useIndex = [];
        let forceIndex = [];
        let ignoreIndex = [];
        if (is(source, MySqlTable) && onIndex && typeof onIndex !== "string") {
          if (onIndex.useIndex) {
            useIndex = convertIndexToString(toArray(onIndex.useIndex));
          }
          if (onIndex.forceIndex) {
            forceIndex = convertIndexToString(toArray(onIndex.forceIndex));
          }
          if (onIndex.ignoreIndex) {
            ignoreIndex = convertIndexToString(toArray(onIndex.ignoreIndex));
          }
        }
        return new MySqlSelectBase(
          {
            table: source,
            fields,
            isPartialSelect,
            session: this.session,
            dialect: this.dialect,
            withList: this.withList,
            distinct: this.distinct,
            useIndex,
            forceIndex,
            ignoreIndex
          }
        );
      }
    };
    __publicField(MySqlSelectBuilder, _a216, "MySqlSelectBuilder");
    MySqlSelectQueryBuilderBase = class extends (_b175 = TypedQueryBuilder, _a217 = entityKind, _b175) {
      constructor({ table: table6, fields, isPartialSelect, session, dialect: dialect6, withList, distinct, useIndex, forceIndex, ignoreIndex }) {
        super();
        __publicField(this, "_");
        __publicField(this, "config");
        __publicField(this, "joinsNotNullableMap");
        __publicField(this, "tableName");
        __publicField(this, "isPartialSelect");
        /** @internal */
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "cacheConfig");
        __publicField(this, "usedTables", /* @__PURE__ */ new Set());
        /**
         * Executes a `left join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         * @param onIndex index hint.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId with use index hint
         * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId), {
         *     useIndex: ['pets_owner_id_index']
         * })
         * ```
         */
        __publicField(this, "leftJoin", this.createJoin("left", false));
        /**
         * Executes a `left join lateral` operation by adding subquery to the current query.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#left-join-lateral}
         *
         * @param table the subquery to join.
         * @param on the `on` clause.
         */
        __publicField(this, "leftJoinLateral", this.createJoin("left", true));
        /**
         * Executes a `right join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         * @param onIndex index hint.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId with use index hint
         * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId), {
         *     useIndex: ['pets_owner_id_index']
         * })
         * ```
         */
        __publicField(this, "rightJoin", this.createJoin("right", false));
        /**
         * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
         *
         * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         * @param onIndex index hint.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId with use index hint
         * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId), {
         *     useIndex: ['pets_owner_id_index']
         * })
         * ```
         */
        __publicField(this, "innerJoin", this.createJoin("inner", false));
        /**
         * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join-lateral}
         *
         * @param table the subquery to join.
         * @param on the `on` clause.
         */
        __publicField(this, "innerJoinLateral", this.createJoin("inner", true));
        /**
         * Executes a `cross join` operation by combining rows from two tables into a new table.
         *
         * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
         *
         * @param table the table to join.
         * @param onIndex index hint.
         *
         * @example
         *
         * ```ts
         * // Select all users, each user with every pet
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .crossJoin(pets)
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .crossJoin(pets)
         *
         * // Select userId and petId with use index hint
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .crossJoin(pets, {
         *     useIndex: ['pets_owner_id_index']
         * })
         * ```
         */
        __publicField(this, "crossJoin", this.createJoin("cross", false));
        /**
         * Executes a `cross join lateral` operation by combining rows from two queries into a new table.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}
         *
         * @param table the query to join.
         */
        __publicField(this, "crossJoinLateral", this.createJoin("cross", true));
        /**
         * Adds `union` set operator to the query.
         *
         * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
         *
         * @example
         *
         * ```ts
         * // Select all unique names from customers and users tables
         * await db.select({ name: users.name })
         *   .from(users)
         *   .union(
         *     db.select({ name: customers.name }).from(customers)
         *   );
         * // or
         * import { union } from 'drizzle-orm/mysql-core'
         *
         * await union(
         *   db.select({ name: users.name }).from(users),
         *   db.select({ name: customers.name }).from(customers)
         * );
         * ```
         */
        __publicField(this, "union", this.createSetOperator("union", false));
        /**
         * Adds `union all` set operator to the query.
         *
         * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
         *
         * @example
         *
         * ```ts
         * // Select all transaction ids from both online and in-store sales
         * await db.select({ transaction: onlineSales.transactionId })
         *   .from(onlineSales)
         *   .unionAll(
         *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         *   );
         * // or
         * import { unionAll } from 'drizzle-orm/mysql-core'
         *
         * await unionAll(
         *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
         *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         * );
         * ```
         */
        __publicField(this, "unionAll", this.createSetOperator("union", true));
        /**
         * Adds `intersect` set operator to the query.
         *
         * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
         *
         * @example
         *
         * ```ts
         * // Select course names that are offered in both departments A and B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .intersect(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { intersect } from 'drizzle-orm/mysql-core'
         *
         * await intersect(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "intersect", this.createSetOperator("intersect", false));
        /**
         * Adds `intersect all` set operator to the query.
         *
         * Calling this method will retain only the rows that are present in both result sets including all duplicates.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
         *
         * @example
         *
         * ```ts
         * // Select all products and quantities that are ordered by both regular and VIP customers
         * await db.select({
         *   productId: regularCustomerOrders.productId,
         *   quantityOrdered: regularCustomerOrders.quantityOrdered
         * })
         * .from(regularCustomerOrders)
         * .intersectAll(
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered
         *   })
         *   .from(vipCustomerOrders)
         * );
         * // or
         * import { intersectAll } from 'drizzle-orm/mysql-core'
         *
         * await intersectAll(
         *   db.select({
         *     productId: regularCustomerOrders.productId,
         *     quantityOrdered: regularCustomerOrders.quantityOrdered
         *   })
         *   .from(regularCustomerOrders),
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered
         *   })
         *   .from(vipCustomerOrders)
         * );
         * ```
         */
        __publicField(this, "intersectAll", this.createSetOperator("intersect", true));
        /**
         * Adds `except` set operator to the query.
         *
         * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
         *
         * @example
         *
         * ```ts
         * // Select all courses offered in department A but not in department B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .except(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { except } from 'drizzle-orm/mysql-core'
         *
         * await except(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "except", this.createSetOperator("except", false));
        /**
         * Adds `except all` set operator to the query.
         *
         * Calling this method will retrieve all rows from the left query, except for the rows that are present in the result set of the right query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#except-all}
         *
         * @example
         *
         * ```ts
         * // Select all products that are ordered by regular customers but not by VIP customers
         * await db.select({
         *   productId: regularCustomerOrders.productId,
         *   quantityOrdered: regularCustomerOrders.quantityOrdered,
         * })
         * .from(regularCustomerOrders)
         * .exceptAll(
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered,
         *   })
         *   .from(vipCustomerOrders)
         * );
         * // or
         * import { exceptAll } from 'drizzle-orm/mysql-core'
         *
         * await exceptAll(
         *   db.select({
         *     productId: regularCustomerOrders.productId,
         *     quantityOrdered: regularCustomerOrders.quantityOrdered
         *   })
         *   .from(regularCustomerOrders),
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered
         *   })
         *   .from(vipCustomerOrders)
         * );
         * ```
         */
        __publicField(this, "exceptAll", this.createSetOperator("except", true));
        this.config = {
          withList,
          table: table6,
          fields: { ...fields },
          distinct,
          setOperators: [],
          useIndex,
          forceIndex,
          ignoreIndex
        };
        this.isPartialSelect = isPartialSelect;
        this.session = session;
        this.dialect = dialect6;
        this._ = {
          selectedFields: fields,
          config: this.config
        };
        this.tableName = getTableLikeName(table6);
        this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
        for (const item of extractUsedTable(table6)) this.usedTables.add(item);
      }
      /** @internal */
      getUsedTables() {
        return [...this.usedTables];
      }
      createJoin(joinType, lateral) {
        return (table6, a9, b9) => {
          const isCrossJoin = joinType === "cross";
          let on3 = isCrossJoin ? void 0 : a9;
          const onIndex = isCrossJoin ? a9 : b9;
          const baseTableName = this.tableName;
          const tableName = getTableLikeName(table6);
          for (const item of extractUsedTable(table6)) this.usedTables.add(item);
          if (typeof tableName === "string" && this.config.joins?.some((join7) => join7.alias === tableName)) {
            throw new Error(`Alias "${tableName}" is already used in this query`);
          }
          if (!this.isPartialSelect) {
            if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") {
              this.config.fields = {
                [baseTableName]: this.config.fields
              };
            }
            if (typeof tableName === "string" && !is(table6, SQL)) {
              const selection = is(table6, Subquery) ? table6._.selectedFields : is(table6, View) ? table6[ViewBaseConfig].selectedFields : table6[Table.Symbol.Columns];
              this.config.fields[tableName] = selection;
            }
          }
          if (typeof on3 === "function") {
            on3 = on3(
              new Proxy(
                this.config.fields,
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              )
            );
          }
          if (!this.config.joins) {
            this.config.joins = [];
          }
          let useIndex = [];
          let forceIndex = [];
          let ignoreIndex = [];
          if (is(table6, MySqlTable) && onIndex && typeof onIndex !== "string") {
            if (onIndex.useIndex) {
              useIndex = convertIndexToString(toArray(onIndex.useIndex));
            }
            if (onIndex.forceIndex) {
              forceIndex = convertIndexToString(toArray(onIndex.forceIndex));
            }
            if (onIndex.ignoreIndex) {
              ignoreIndex = convertIndexToString(toArray(onIndex.ignoreIndex));
            }
          }
          this.config.joins.push({ on: on3, table: table6, joinType, alias: tableName, useIndex, forceIndex, ignoreIndex, lateral });
          if (typeof tableName === "string") {
            switch (joinType) {
              case "left": {
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
              case "right": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "cross":
              case "inner": {
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
            }
          }
          return this;
        };
      }
      createSetOperator(type, isAll) {
        return (rightSelection) => {
          const rightSelect = typeof rightSelection === "function" ? rightSelection(getMySqlSetOperators()) : rightSelection;
          if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
            throw new Error(
              "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
            );
          }
          this.config.setOperators.push({ type, isAll, rightSelect });
          return this;
        };
      }
      /** @internal */
      addSetOperators(setOperators) {
        this.config.setOperators.push(...setOperators);
        return this;
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be selected.
       *
       * ```ts
       * // Select all cars with green color
       * await db.select().from(cars).where(eq(cars.color, 'green'));
       * // or
       * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Select all BMW cars with a green color
       * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Select all cars with the green or blue color
       * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        if (typeof where === "function") {
          where = where(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.where = where;
        return this;
      }
      /**
       * Adds a `having` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
       *
       * @param having the `having` clause.
       *
       * @example
       *
       * ```ts
       * // Select all brands with more than one car
       * await db.select({
       * 	brand: cars.brand,
       * 	count: sql<number>`cast(count(${cars.id}) as int)`,
       * })
       *   .from(cars)
       *   .groupBy(cars.brand)
       *   .having(({ count }) => gt(count, 1));
       * ```
       */
      having(having) {
        if (typeof having === "function") {
          having = having(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.having = having;
        return this;
      }
      groupBy(...columns) {
        if (typeof columns[0] === "function") {
          const groupBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
        } else {
          this.config.groupBy = columns;
        }
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        } else {
          const orderByArray = columns;
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        }
        return this;
      }
      /**
       * Adds a `limit` clause to the query.
       *
       * Calling this method will set the maximum number of rows that will be returned by this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param limit the `limit` clause.
       *
       * @example
       *
       * ```ts
       * // Get the first 10 people from this query.
       * await db.select().from(people).limit(10);
       * ```
       */
      limit(limit) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).limit = limit;
        } else {
          this.config.limit = limit;
        }
        return this;
      }
      /**
       * Adds an `offset` clause to the query.
       *
       * Calling this method will skip a number of rows when returning results from this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param offset the `offset` clause.
       *
       * @example
       *
       * ```ts
       * // Get the 10th-20th people from this query.
       * await db.select().from(people).offset(10).limit(10);
       * ```
       */
      offset(offset) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).offset = offset;
        } else {
          this.config.offset = offset;
        }
        return this;
      }
      /**
       * Adds a `for` clause to the query.
       *
       * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
       *
       * See docs: {@link https://dev.mysql.com/doc/refman/8.0/en/innodb-locking-reads.html}
       *
       * @param strength the lock strength.
       * @param config the lock configuration.
       */
      for(strength, config = {}) {
        this.config.lockingClause = { strength, config };
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildSelectQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      as(alias2) {
        const usedTables = [];
        usedTables.push(...extractUsedTable(this.config.table));
        if (this.config.joins) {
          for (const it2 of this.config.joins) usedTables.push(...extractUsedTable(it2.table));
        }
        return new Proxy(
          new Subquery(this.getSQL(), this.config.fields, alias2, false, [...new Set(usedTables)]),
          new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      /** @internal */
      getSelectedFields() {
        return new Proxy(
          this.config.fields,
          new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      $dynamic() {
        return this;
      }
      $withCache(config) {
        this.cacheConfig = config === void 0 ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };
        return this;
      }
    };
    __publicField(MySqlSelectQueryBuilderBase, _a217, "MySqlSelectQueryBuilder");
    MySqlSelectBase = class extends (_b176 = MySqlSelectQueryBuilderBase, _a218 = entityKind, _b176) {
      constructor() {
        super(...arguments);
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
      }
      prepare() {
        if (!this.session) {
          throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
        }
        const fieldsList = orderSelectedFields(this.config.fields);
        const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), fieldsList, void 0, void 0, void 0, {
          type: "select",
          tables: [...this.usedTables]
        }, this.cacheConfig);
        query.joinsNotNullableMap = this.joinsNotNullableMap;
        return query;
      }
    };
    __publicField(MySqlSelectBase, _a218, "MySqlSelect");
    applyMixins(MySqlSelectBase, [QueryPromise]);
    getMySqlSetOperators = () => ({
      union,
      unionAll,
      intersect,
      intersectAll,
      except,
      exceptAll
    });
    union = createSetOperator("union", false);
    unionAll = createSetOperator("union", true);
    intersect = createSetOperator("intersect", false);
    intersectAll = createSetOperator("intersect", true);
    except = createSetOperator("except", false);
    exceptAll = createSetOperator("except", true);
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/query-builder.js
var _a219, QueryBuilder;
var init_query_builder2 = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/query-builder.js"() {
    "use strict";
    init_entity();
    init_dialect();
    init_selection_proxy();
    init_subquery();
    init_select2();
    _a219 = entityKind;
    QueryBuilder = class {
      constructor(dialect6) {
        __publicField(this, "dialect");
        __publicField(this, "dialectConfig");
        __publicField(this, "$with", (alias2, selection) => {
          const queryBuilder = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(queryBuilder);
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        this.dialect = is(dialect6, MySqlDialect) ? dialect6 : void 0;
        this.dialectConfig = is(dialect6, MySqlDialect) ? void 0 : dialect6;
      }
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new MySqlSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new MySqlSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            withList: queries,
            distinct: true
          });
        }
        return { select: select2, selectDistinct };
      }
      select(fields) {
        return new MySqlSelectBuilder({ fields: fields ?? void 0, session: void 0, dialect: this.getDialect() });
      }
      selectDistinct(fields) {
        return new MySqlSelectBuilder({
          fields: fields ?? void 0,
          session: void 0,
          dialect: this.getDialect(),
          distinct: true
        });
      }
      // Lazy load dialect to avoid circular dependency
      getDialect() {
        if (!this.dialect) {
          this.dialect = new MySqlDialect(this.dialectConfig);
        }
        return this.dialect;
      }
    };
    __publicField(QueryBuilder, _a219, "MySqlQueryBuilder");
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/insert.js
var _a220, MySqlInsertBuilder, _a221, _b177, MySqlInsertBase;
var init_insert = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/insert.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_sql();
    init_table();
    init_utils();
    init_utils3();
    init_query_builder2();
    _a220 = entityKind;
    MySqlInsertBuilder = class {
      constructor(table6, session, dialect6) {
        __publicField(this, "shouldIgnore", false);
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
      }
      ignore() {
        this.shouldIgnore = true;
        return this;
      }
      values(values2) {
        values2 = Array.isArray(values2) ? values2 : [values2];
        if (values2.length === 0) {
          throw new Error("values() must be called with at least one value");
        }
        const mappedValues = values2.map((entry) => {
          const result = {};
          const cols = this.table[Table.Symbol.Columns];
          for (const colKey of Object.keys(entry)) {
            const colValue = entry[colKey];
            result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
          }
          return result;
        });
        return new MySqlInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
      }
      select(selectQuery) {
        const select2 = typeof selectQuery === "function" ? selectQuery(new QueryBuilder()) : selectQuery;
        if (!is(select2, SQL) && !haveSameKeys(this.table[Columns], select2._.selectedFields)) {
          throw new Error(
            "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
          );
        }
        return new MySqlInsertBase(this.table, select2, this.shouldIgnore, this.session, this.dialect, true);
      }
    };
    __publicField(MySqlInsertBuilder, _a220, "MySqlInsertBuilder");
    MySqlInsertBase = class extends (_b177 = QueryPromise, _a221 = entityKind, _b177) {
      constructor(table6, values2, ignore, session, dialect6, select2) {
        super();
        __publicField(this, "config");
        __publicField(this, "cacheConfig");
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, values: values2, select: select2, ignore };
      }
      /**
       * Adds an `on duplicate key update` clause to the query.
       *
       * Calling this method will update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
       *
       * @param config The `set` clause
       *
       * @example
       * ```ts
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW'})
       *   .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
       * ```
       *
       * While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
       *
       * ```ts
       * import { sql } from 'drizzle-orm';
       *
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onDuplicateKeyUpdate({ set: { id: sql`id` } });
       * ```
       */
      onDuplicateKeyUpdate(config) {
        const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
        this.config.onConflict = sql`update ${setSql}`;
        return this;
      }
      $returningId() {
        const returning = [];
        for (const [key, value] of Object.entries(this.config.table[Table.Symbol.Columns])) {
          if (value.primary) {
            returning.push({ field: value, path: [key] });
          }
        }
        this.config.returning = returning;
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildInsertQuery(this.config).sql;
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      prepare() {
        const { sql: sql22, generatedIds } = this.dialect.buildInsertQuery(this.config);
        return this.session.prepareQuery(
          this.dialect.sqlToQuery(sql22),
          void 0,
          void 0,
          generatedIds,
          this.config.returning,
          {
            type: "insert",
            tables: extractUsedTable(this.config.table)
          },
          this.cacheConfig
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(MySqlInsertBase, _a221, "MySqlInsert");
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/select.types.js
var init_select_types = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/select.types.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/update.js
var _a222, MySqlUpdateBuilder, _a223, _b178, MySqlUpdateBase;
var init_update = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/update.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_table();
    init_utils();
    init_utils3();
    _a222 = entityKind;
    MySqlUpdateBuilder = class {
      constructor(table6, session, dialect6, withList) {
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.withList = withList;
      }
      set(values2) {
        return new MySqlUpdateBase(this.table, mapUpdateSet(this.table, values2), this.session, this.dialect, this.withList);
      }
    };
    __publicField(MySqlUpdateBuilder, _a222, "MySqlUpdateBuilder");
    MySqlUpdateBase = class extends (_b178 = QueryPromise, _a223 = entityKind, _b178) {
      constructor(table6, set, session, dialect6, withList) {
        super();
        __publicField(this, "config");
        __publicField(this, "cacheConfig");
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
        this.session = session;
        this.dialect = dialect6;
        this.config = { set, table: table6, withList };
      }
      /**
       * Adds a 'where' clause to the query.
       *
       * Calling this method will update only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param where the 'where' clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be updated.
       *
       * ```ts
       * // Update all cars with green color
       * db.update(cars).set({ color: 'red' })
       *   .where(eq(cars.color, 'green'));
       * // or
       * db.update(cars).set({ color: 'red' })
       *   .where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Update all BMW cars with a green color
       * db.update(cars).set({ color: 'red' })
       *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Update all cars with the green or blue color
       * db.update(cars).set({ color: 'red' })
       *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.table[Table.Symbol.Columns],
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          this.config.orderBy = orderByArray;
        } else {
          const orderByArray = columns;
          this.config.orderBy = orderByArray;
        }
        return this;
      }
      limit(limit) {
        this.config.limit = limit;
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildUpdateQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      prepare() {
        return this.session.prepareQuery(
          this.dialect.sqlToQuery(this.getSQL()),
          void 0,
          void 0,
          void 0,
          this.config.returning,
          {
            type: "insert",
            tables: extractUsedTable(this.config.table)
          },
          this.cacheConfig
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(MySqlUpdateBase, _a223, "MySqlUpdate");
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/index.js
var init_query_builders = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/index.js"() {
    "use strict";
    init_delete();
    init_insert();
    init_query_builder2();
    init_select2();
    init_select_types();
    init_update();
  }
});

// ../drizzle-orm/dist/mysql-core/query-builders/query.js
var _a224, RelationalQueryBuilder, _a225, _b179, MySqlRelationalQuery;
var init_query = __esm({
  "../drizzle-orm/dist/mysql-core/query-builders/query.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_relations();
    _a224 = entityKind;
    RelationalQueryBuilder = class {
      constructor(fullSchema, schema6, tableNamesMap, table6, tableConfig, dialect6, session, mode) {
        this.fullSchema = fullSchema;
        this.schema = schema6;
        this.tableNamesMap = tableNamesMap;
        this.table = table6;
        this.tableConfig = tableConfig;
        this.dialect = dialect6;
        this.session = session;
        this.mode = mode;
      }
      findMany(config) {
        return new MySqlRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? config : {},
          "many",
          this.mode
        );
      }
      findFirst(config) {
        return new MySqlRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? { ...config, limit: 1 } : { limit: 1 },
          "first",
          this.mode
        );
      }
    };
    __publicField(RelationalQueryBuilder, _a224, "MySqlRelationalQueryBuilder");
    MySqlRelationalQuery = class extends (_b179 = QueryPromise, _a225 = entityKind, _b179) {
      constructor(fullSchema, schema6, tableNamesMap, table6, tableConfig, dialect6, session, config, queryMode, mode) {
        super();
        this.fullSchema = fullSchema;
        this.schema = schema6;
        this.tableNamesMap = tableNamesMap;
        this.table = table6;
        this.tableConfig = tableConfig;
        this.dialect = dialect6;
        this.session = session;
        this.config = config;
        this.queryMode = queryMode;
        this.mode = mode;
      }
      prepare() {
        const { query, builtQuery } = this._toSQL();
        return this.session.prepareQuery(
          builtQuery,
          void 0,
          (rawRows) => {
            const rows = rawRows.map((row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection));
            if (this.queryMode === "first") {
              return rows[0];
            }
            return rows;
          }
        );
      }
      _getQuery() {
        const query = this.mode === "planetscale" ? this.dialect.buildRelationalQueryWithoutLateralSubqueries({
          fullSchema: this.fullSchema,
          schema: this.schema,
          tableNamesMap: this.tableNamesMap,
          table: this.table,
          tableConfig: this.tableConfig,
          queryConfig: this.config,
          tableAlias: this.tableConfig.tsName
        }) : this.dialect.buildRelationalQuery({
          fullSchema: this.fullSchema,
          schema: this.schema,
          tableNamesMap: this.tableNamesMap,
          table: this.table,
          tableConfig: this.tableConfig,
          queryConfig: this.config,
          tableAlias: this.tableConfig.tsName
        });
        return query;
      }
      _toSQL() {
        const query = this._getQuery();
        const builtQuery = this.dialect.sqlToQuery(query.sql);
        return { builtQuery, query };
      }
      /** @internal */
      getSQL() {
        return this._getQuery().sql;
      }
      toSQL() {
        return this._toSQL().builtQuery;
      }
      execute() {
        return this.prepare().execute();
      }
    };
    __publicField(MySqlRelationalQuery, _a225, "MySqlRelationalQuery");
  }
});

// ../drizzle-orm/dist/mysql-core/db.js
var _a226, MySqlDatabase;
var init_db = __esm({
  "../drizzle-orm/dist/mysql-core/db.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_count();
    init_query_builders();
    init_query();
    _a226 = entityKind;
    MySqlDatabase = class {
      constructor(dialect6, session, schema6, mode) {
        __publicField(this, "query");
        /**
         * Creates a subquery that defines a temporary named result set as a CTE.
         *
         * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
         *
         * @param alias The alias for the subquery.
         *
         * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
         *
         * @example
         *
         * ```ts
         * // Create a subquery with alias 'sq' and use it in the select query
         * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
         *
         * const result = await db.with(sq).select().from(sq);
         * ```
         *
         * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
         *
         * ```ts
         * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
         * const sq = db.$with('sq').as(db.select({
         *   name: sql<string>`upper(${users.name})`.as('name'),
         * })
         * .from(users));
         *
         * const result = await db.with(sq).select({ name: sq.name }).from(sq);
         * ```
         */
        __publicField(this, "$with", (alias2, selection) => {
          const self2 = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(new QueryBuilder(self2.dialect));
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        __publicField(this, "$cache");
        this.dialect = dialect6;
        this.session = session;
        this.mode = mode;
        this._ = schema6 ? {
          schema: schema6.schema,
          fullSchema: schema6.fullSchema,
          tableNamesMap: schema6.tableNamesMap
        } : {
          schema: void 0,
          fullSchema: {},
          tableNamesMap: {}
        };
        this.query = {};
        if (this._.schema) {
          for (const [tableName, columns] of Object.entries(this._.schema)) {
            this.query[tableName] = new RelationalQueryBuilder(
              schema6.fullSchema,
              this._.schema,
              this._.tableNamesMap,
              schema6.fullSchema[tableName],
              columns,
              dialect6,
              session,
              this.mode
            );
          }
        }
        this.$cache = { invalidate: async (_params2) => {
        } };
      }
      $count(source, filters) {
        return new MySqlCountBuilder({ source, filters, session: this.session });
      }
      /**
       * Incorporates a previously defined CTE (using `$with`) into the main query.
       *
       * This method allows the main query to reference a temporary named result set.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
       *
       * @param queries The CTEs to incorporate into the main query.
       *
       * @example
       *
       * ```ts
       * // Define a subquery 'sq' as a CTE using $with
       * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
       *
       * // Incorporate the CTE 'sq' into the main query and select from it
       * const result = await db.with(sq).select().from(sq);
       * ```
       */
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new MySqlSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new MySqlSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries,
            distinct: true
          });
        }
        function update(table6) {
          return new MySqlUpdateBuilder(table6, self2.session, self2.dialect, queries);
        }
        function delete_(table6) {
          return new MySqlDeleteBase(table6, self2.session, self2.dialect, queries);
        }
        return { select: select2, selectDistinct, update, delete: delete_ };
      }
      select(fields) {
        return new MySqlSelectBuilder({ fields: fields ?? void 0, session: this.session, dialect: this.dialect });
      }
      selectDistinct(fields) {
        return new MySqlSelectBuilder({
          fields: fields ?? void 0,
          session: this.session,
          dialect: this.dialect,
          distinct: true
        });
      }
      /**
       * Creates an update query.
       *
       * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
       *
       * Use `.set()` method to specify which values to update.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param table The table to update.
       *
       * @example
       *
       * ```ts
       * // Update all rows in the 'cars' table
       * await db.update(cars).set({ color: 'red' });
       *
       * // Update rows with filters and conditions
       * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
       * ```
       */
      update(table6) {
        return new MySqlUpdateBuilder(table6, this.session, this.dialect);
      }
      /**
       * Creates an insert query.
       *
       * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert}
       *
       * @param table The table to insert into.
       *
       * @example
       *
       * ```ts
       * // Insert one row
       * await db.insert(cars).values({ brand: 'BMW' });
       *
       * // Insert multiple rows
       * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
       * ```
       */
      insert(table6) {
        return new MySqlInsertBuilder(table6, this.session, this.dialect);
      }
      /**
       * Creates a delete query.
       *
       * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param table The table to delete from.
       *
       * @example
       *
       * ```ts
       * // Delete all rows in the 'cars' table
       * await db.delete(cars);
       *
       * // Delete rows with filters and conditions
       * await db.delete(cars).where(eq(cars.color, 'green'));
       * ```
       */
      delete(table6) {
        return new MySqlDeleteBase(table6, this.session, this.dialect);
      }
      execute(query) {
        return this.session.execute(typeof query === "string" ? sql.raw(query) : query.getSQL());
      }
      transaction(transaction, config) {
        return this.session.transaction(transaction, config);
      }
    };
    __publicField(MySqlDatabase, _a226, "MySqlDatabase");
  }
});

// ../drizzle-orm/dist/mysql-core/view.js
function mysqlViewWithSchema(name3, selection, schema6) {
  if (selection) {
    return new ManualViewBuilder(name3, selection, schema6);
  }
  return new ViewBuilder(name3, schema6);
}
var _a227, ViewBuilderCore, _a228, _b180, ViewBuilder, _a229, _b181, ManualViewBuilder, _a230, _b182, _c6, MySqlView;
var init_view = __esm({
  "../drizzle-orm/dist/mysql-core/view.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_utils();
    init_query_builder2();
    init_table3();
    init_view_base();
    init_view_common2();
    _a227 = entityKind;
    ViewBuilderCore = class {
      constructor(name3, schema6) {
        __publicField(this, "config", {});
        this.name = name3;
        this.schema = schema6;
      }
      algorithm(algorithm) {
        this.config.algorithm = algorithm;
        return this;
      }
      sqlSecurity(sqlSecurity) {
        this.config.sqlSecurity = sqlSecurity;
        return this;
      }
      withCheckOption(withCheckOption) {
        this.config.withCheckOption = withCheckOption ?? "cascaded";
        return this;
      }
    };
    __publicField(ViewBuilderCore, _a227, "MySqlViewBuilder");
    ViewBuilder = class extends (_b180 = ViewBuilderCore, _a228 = entityKind, _b180) {
      as(qb) {
        if (typeof qb === "function") {
          qb = qb(new QueryBuilder());
        }
        const selectionProxy = new SelectionProxyHandler({
          alias: this.name,
          sqlBehavior: "error",
          sqlAliasedBehavior: "alias",
          replaceOriginalName: true
        });
        const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
        return new Proxy(
          new MySqlView({
            mysqlConfig: this.config,
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: aliasedSelection,
              query: qb.getSQL().inlineParams()
            }
          }),
          selectionProxy
        );
      }
    };
    __publicField(ViewBuilder, _a228, "MySqlViewBuilder");
    ManualViewBuilder = class extends (_b181 = ViewBuilderCore, _a229 = entityKind, _b181) {
      constructor(name3, columns, schema6) {
        super(name3, schema6);
        __publicField(this, "columns");
        this.columns = getTableColumns(mysqlTable(name3, columns));
      }
      existing() {
        return new Proxy(
          new MySqlView({
            mysqlConfig: void 0,
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: this.columns,
              query: void 0
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
      as(query) {
        return new Proxy(
          new MySqlView({
            mysqlConfig: this.config,
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: this.columns,
              query: query.inlineParams()
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
    };
    __publicField(ManualViewBuilder, _a229, "MySqlManualViewBuilder");
    MySqlView = class extends (_c6 = MySqlViewBase, _b182 = entityKind, _a230 = MySqlViewConfig, _c6) {
      constructor({ mysqlConfig, config }) {
        super(config);
        __publicField(this, _a230);
        this[MySqlViewConfig] = mysqlConfig;
      }
    };
    __publicField(MySqlView, _b182, "MySqlView");
  }
});

// ../drizzle-orm/dist/mysql-core/schema.js
var _a231, MySqlSchema;
var init_schema = __esm({
  "../drizzle-orm/dist/mysql-core/schema.js"() {
    "use strict";
    init_entity();
    init_table3();
    init_view();
    _a231 = entityKind;
    MySqlSchema = class {
      constructor(schemaName) {
        __publicField(this, "table", (name3, columns, extraConfig) => {
          return mysqlTableWithSchema(name3, columns, extraConfig, this.schemaName);
        });
        __publicField(this, "view", (name3, columns) => {
          return mysqlViewWithSchema(name3, columns, this.schemaName);
        });
        this.schemaName = schemaName;
      }
    };
    __publicField(MySqlSchema, _a231, "MySqlSchema");
  }
});

// ../drizzle-orm/dist/cache/core/cache.js
async function hashQuery(sql3, params) {
  const dataToHash = `${sql3}-${JSON.stringify(params)}`;
  const encoder = new TextEncoder();
  const data = encoder.encode(dataToHash);
  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
  const hashArray = [...new Uint8Array(hashBuffer)];
  const hashHex = hashArray.map((b9) => b9.toString(16).padStart(2, "0")).join("");
  return hashHex;
}
var _a232, Cache, _a233, _b183, NoopCache;
var init_cache = __esm({
  "../drizzle-orm/dist/cache/core/cache.js"() {
    "use strict";
    init_entity();
    _a232 = entityKind;
    Cache = class {
    };
    __publicField(Cache, _a232, "Cache");
    NoopCache = class extends (_b183 = Cache, _a233 = entityKind, _b183) {
      strategy() {
        return "all";
      }
      async get(_key) {
        return void 0;
      }
      async put(_hashedQuery, _response, _tables, _config) {
      }
      async onMutate(_params2) {
      }
    };
    __publicField(NoopCache, _a233, "NoopCache");
  }
});

// ../drizzle-orm/dist/mysql-core/session.js
var _a234, MySqlPreparedQuery, _a235, MySqlSession, _a236, _b184, MySqlTransaction;
var init_session = __esm({
  "../drizzle-orm/dist/mysql-core/session.js"() {
    "use strict";
    init_cache();
    init_entity();
    init_errors();
    init_sql();
    init_db();
    _a234 = entityKind;
    MySqlPreparedQuery = class {
      constructor(cache5, queryMetadata, cacheConfig) {
        /** @internal */
        __publicField(this, "joinsNotNullableMap");
        this.cache = cache5;
        this.queryMetadata = queryMetadata;
        this.cacheConfig = cacheConfig;
        if (cache5 && cache5.strategy() === "all" && cacheConfig === void 0) {
          this.cacheConfig = { enable: true, autoInvalidate: true };
        }
        if (!this.cacheConfig?.enable) {
          this.cacheConfig = void 0;
        }
      }
      /** @internal */
      async queryWithCache(queryString, params, query) {
        if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.cacheConfig && !this.cacheConfig.enable) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) {
          try {
            const [res] = await Promise.all([
              query(),
              this.cache.onMutate({ tables: this.queryMetadata.tables })
            ]);
            return res;
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (!this.cacheConfig) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.queryMetadata.type === "select") {
          const fromCache = await this.cache.get(
            this.cacheConfig.tag ?? await hashQuery(queryString, params),
            this.queryMetadata.tables,
            this.cacheConfig.tag !== void 0,
            this.cacheConfig.autoInvalidate
          );
          if (fromCache === void 0) {
            let result;
            try {
              result = await query();
            } catch (e6) {
              throw new DrizzleQueryError(queryString, params, e6);
            }
            await this.cache.put(
              this.cacheConfig.tag ?? await hashQuery(queryString, params),
              result,
              // make sure we send tables that were used in a query only if user wants to invalidate it on each write
              this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
              this.cacheConfig.tag !== void 0,
              this.cacheConfig.config
            );
            return result;
          }
          return fromCache;
        }
        try {
          return await query();
        } catch (e6) {
          throw new DrizzleQueryError(queryString, params, e6);
        }
      }
    };
    __publicField(MySqlPreparedQuery, _a234, "MySqlPreparedQuery");
    _a235 = entityKind;
    MySqlSession = class {
      constructor(dialect6) {
        this.dialect = dialect6;
      }
      execute(query) {
        return this.prepareQuery(
          this.dialect.sqlToQuery(query),
          void 0
        ).execute();
      }
      async count(sql22) {
        const res = await this.execute(sql22);
        return Number(
          res[0][0]["count"]
        );
      }
      getSetTransactionSQL(config) {
        const parts2 = [];
        if (config.isolationLevel) {
          parts2.push(`isolation level ${config.isolationLevel}`);
        }
        return parts2.length ? sql`set transaction ${sql.raw(parts2.join(" "))}` : void 0;
      }
      getStartTransactionSQL(config) {
        const parts2 = [];
        if (config.withConsistentSnapshot) {
          parts2.push("with consistent snapshot");
        }
        if (config.accessMode) {
          parts2.push(config.accessMode);
        }
        return parts2.length ? sql`start transaction ${sql.raw(parts2.join(" "))}` : void 0;
      }
    };
    __publicField(MySqlSession, _a235, "MySqlSession");
    MySqlTransaction = class extends (_b184 = MySqlDatabase, _a236 = entityKind, _b184) {
      constructor(dialect6, session, schema6, nestedIndex, mode) {
        super(dialect6, session, schema6, mode);
        this.schema = schema6;
        this.nestedIndex = nestedIndex;
      }
      rollback() {
        throw new TransactionRollbackError();
      }
    };
    __publicField(MySqlTransaction, _a236, "MySqlTransaction");
  }
});

// ../drizzle-orm/dist/mysql-core/subquery.js
var init_subquery2 = __esm({
  "../drizzle-orm/dist/mysql-core/subquery.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/mysql-core/index.js
var init_mysql_core = __esm({
  "../drizzle-orm/dist/mysql-core/index.js"() {
    "use strict";
    init_alias2();
    init_checks();
    init_columns();
    init_db();
    init_dialect();
    init_foreign_keys2();
    init_indexes();
    init_primary_keys2();
    init_query_builders();
    init_schema();
    init_session();
    init_subquery2();
    init_table3();
    init_unique_constraint2();
    init_utils3();
    init_view_common2();
    init_view();
  }
});

// ../drizzle-orm/dist/pg-core/alias.js
function alias(table6, alias2) {
  return new Proxy(table6, new TableAliasProxyHandler(alias2, false));
}
var init_alias3 = __esm({
  "../drizzle-orm/dist/pg-core/alias.js"() {
    "use strict";
    init_alias();
  }
});

// ../drizzle-orm/dist/pg-core/checks.js
function check(name3, value) {
  return new CheckBuilder2(name3, value);
}
var _a237, CheckBuilder2, _a238, Check2;
var init_checks2 = __esm({
  "../drizzle-orm/dist/pg-core/checks.js"() {
    "use strict";
    init_entity();
    _a237 = entityKind;
    CheckBuilder2 = class {
      constructor(name3, value) {
        __publicField(this, "brand");
        this.name = name3;
        this.value = value;
      }
      /** @internal */
      build(table6) {
        return new Check2(table6, this);
      }
    };
    __publicField(CheckBuilder2, _a237, "PgCheckBuilder");
    _a238 = entityKind;
    Check2 = class {
      constructor(table6, builder) {
        __publicField(this, "name");
        __publicField(this, "value");
        this.table = table6;
        this.name = builder.name;
        this.value = builder.value;
      }
    };
    __publicField(Check2, _a238, "PgCheck");
  }
});

// ../drizzle-orm/dist/pg-core/columns/index.js
var init_columns2 = __esm({
  "../drizzle-orm/dist/pg-core/columns/index.js"() {
    "use strict";
    init_bigint();
    init_bigserial();
    init_boolean();
    init_char();
    init_cidr();
    init_common();
    init_custom();
    init_date();
    init_double_precision();
    init_enum();
    init_inet();
    init_int_common();
    init_integer();
    init_interval();
    init_json();
    init_jsonb();
    init_line();
    init_macaddr();
    init_macaddr8();
    init_numeric();
    init_point();
    init_geometry();
    init_real();
    init_serial();
    init_smallint();
    init_smallserial();
    init_text();
    init_time();
    init_timestamp();
    init_uuid();
    init_varchar();
    init_bit();
    init_halfvec();
    init_sparsevec();
    init_vector();
  }
});

// ../drizzle-orm/dist/pg-core/indexes.js
function index(name3) {
  return new IndexBuilderOn2(false, name3);
}
function uniqueIndex(name3) {
  return new IndexBuilderOn2(true, name3);
}
var _a239, IndexBuilderOn2, _a240, IndexBuilder2, _a241, Index2;
var init_indexes2 = __esm({
  "../drizzle-orm/dist/pg-core/indexes.js"() {
    "use strict";
    init_sql();
    init_entity();
    init_columns2();
    _a239 = entityKind;
    IndexBuilderOn2 = class {
      constructor(unique2, name3) {
        this.unique = unique2;
        this.name = name3;
      }
      on(...columns) {
        return new IndexBuilder2(
          columns.map((it2) => {
            if (is(it2, SQL)) {
              return it2;
            }
            it2 = it2;
            const clonedIndexedColumn = new IndexedColumn(it2.name, !!it2.keyAsName, it2.columnType, it2.indexConfig);
            it2.indexConfig = JSON.parse(JSON.stringify(it2.defaultConfig));
            return clonedIndexedColumn;
          }),
          this.unique,
          false,
          this.name
        );
      }
      onOnly(...columns) {
        return new IndexBuilder2(
          columns.map((it2) => {
            if (is(it2, SQL)) {
              return it2;
            }
            it2 = it2;
            const clonedIndexedColumn = new IndexedColumn(it2.name, !!it2.keyAsName, it2.columnType, it2.indexConfig);
            it2.indexConfig = it2.defaultConfig;
            return clonedIndexedColumn;
          }),
          this.unique,
          true,
          this.name
        );
      }
      /**
       * Specify what index method to use. Choices are `btree`, `hash`, `gist`, `spgist`, `gin`, `brin`, or user-installed access methods like `bloom`. The default method is `btree.
       *
       * If you have the `pg_vector` extension installed in your database, you can use the `hnsw` and `ivfflat` options, which are predefined types.
       *
       * **You can always specify any string you want in the method, in case Drizzle doesn't have it natively in its types**
       *
       * @param method The name of the index method to be used
       * @param columns
       * @returns
       */
      using(method, ...columns) {
        return new IndexBuilder2(
          columns.map((it2) => {
            if (is(it2, SQL)) {
              return it2;
            }
            it2 = it2;
            const clonedIndexedColumn = new IndexedColumn(it2.name, !!it2.keyAsName, it2.columnType, it2.indexConfig);
            it2.indexConfig = JSON.parse(JSON.stringify(it2.defaultConfig));
            return clonedIndexedColumn;
          }),
          this.unique,
          true,
          this.name,
          method
        );
      }
    };
    __publicField(IndexBuilderOn2, _a239, "PgIndexBuilderOn");
    _a240 = entityKind;
    IndexBuilder2 = class {
      constructor(columns, unique2, only, name3, method = "btree") {
        /** @internal */
        __publicField(this, "config");
        this.config = {
          name: name3,
          columns,
          unique: unique2,
          only,
          method
        };
      }
      concurrently() {
        this.config.concurrently = true;
        return this;
      }
      with(obj) {
        this.config.with = obj;
        return this;
      }
      where(condition) {
        this.config.where = condition;
        return this;
      }
      /** @internal */
      build(table6) {
        return new Index2(this.config, table6);
      }
    };
    __publicField(IndexBuilder2, _a240, "PgIndexBuilder");
    _a241 = entityKind;
    Index2 = class {
      constructor(config, table6) {
        __publicField(this, "config");
        this.config = { ...config, table: table6 };
      }
    };
    __publicField(Index2, _a241, "PgIndex");
  }
});

// ../drizzle-orm/dist/pg-core/policies.js
function pgPolicy(name3, config) {
  return new PgPolicy(name3, config);
}
var _a242, PgPolicy;
var init_policies = __esm({
  "../drizzle-orm/dist/pg-core/policies.js"() {
    "use strict";
    init_entity();
    _a242 = entityKind;
    PgPolicy = class {
      constructor(name3, config) {
        __publicField(this, "as");
        __publicField(this, "for");
        __publicField(this, "to");
        __publicField(this, "using");
        __publicField(this, "withCheck");
        /** @internal */
        __publicField(this, "_linkedTable");
        this.name = name3;
        if (config) {
          this.as = config.as;
          this.for = config.for;
          this.to = config.to;
          this.using = config.using;
          this.withCheck = config.withCheck;
        }
      }
      link(table6) {
        this._linkedTable = table6;
        return this;
      }
    };
    __publicField(PgPolicy, _a242, "PgPolicy");
  }
});

// ../drizzle-orm/dist/pg-core/view-common.js
var PgViewConfig;
var init_view_common3 = __esm({
  "../drizzle-orm/dist/pg-core/view-common.js"() {
    "use strict";
    PgViewConfig = Symbol.for("drizzle:PgViewConfig");
  }
});

// ../drizzle-orm/dist/pg-core/view-base.js
var _a243, _b185, PgViewBase;
var init_view_base2 = __esm({
  "../drizzle-orm/dist/pg-core/view-base.js"() {
    "use strict";
    init_entity();
    init_sql();
    PgViewBase = class extends (_b185 = View, _a243 = entityKind, _b185) {
    };
    __publicField(PgViewBase, _a243, "PgViewBase");
  }
});

// ../drizzle-orm/dist/pg-core/dialect.js
var _a244, PgDialect;
var init_dialect2 = __esm({
  "../drizzle-orm/dist/pg-core/dialect.js"() {
    "use strict";
    init_alias();
    init_casing();
    init_column();
    init_entity();
    init_errors();
    init_columns2();
    init_table2();
    init_relations();
    init_sql2();
    init_sql();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_view_base2();
    _a244 = entityKind;
    PgDialect = class {
      constructor(config) {
        /** @internal */
        __publicField(this, "casing");
        this.casing = new CasingCache(config?.casing);
      }
      async migrate(migrations, session, config) {
        const migrationsTable = typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
        const migrationsSchema = typeof config === "string" ? "drizzle" : config.migrationsSchema ?? "drizzle";
        const migrationTableCreate = sql`
			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} (
				id SERIAL PRIMARY KEY,
				hash text NOT NULL,
				created_at bigint
			)
		`;
        await session.execute(sql`CREATE SCHEMA IF NOT EXISTS ${sql.identifier(migrationsSchema)}`);
        await session.execute(migrationTableCreate);
        const dbMigrations = await session.all(
          sql`select id, hash, created_at from ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} order by created_at desc limit 1`
        );
        const lastDbMigration = dbMigrations[0];
        await session.transaction(async (tx) => {
          for await (const migration of migrations) {
            if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
              for (const stmt of migration.sql) {
                await tx.execute(sql.raw(stmt));
              }
              await tx.execute(
                sql`insert into ${sql.identifier(migrationsSchema)}.${sql.identifier(migrationsTable)} ("hash", "created_at") values(${migration.hash}, ${migration.folderMillis})`
              );
            }
          }
        });
      }
      escapeName(name3) {
        return `"${name3}"`;
      }
      escapeParam(num) {
        return `$${num + 1}`;
      }
      escapeString(str) {
        return `'${str.replace(/'/g, "''")}'`;
      }
      buildWithCTE(queries) {
        if (!queries?.length) return void 0;
        const withSqlChunks = [sql`with `];
        for (const [i8, w10] of queries.entries()) {
          withSqlChunks.push(sql`${sql.identifier(w10._.alias)} as (${w10._.sql})`);
          if (i8 < queries.length - 1) {
            withSqlChunks.push(sql`, `);
          }
        }
        withSqlChunks.push(sql` `);
        return sql.join(withSqlChunks);
      }
      buildDeleteQuery({ table: table6, where, returning, withList }) {
        const withSql = this.buildWithCTE(withList);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        return sql`${withSql}delete from ${table6}${whereSql}${returningSql}`;
      }
      buildUpdateSet(table6, set) {
        const tableColumns = table6[Table.Symbol.Columns];
        const columnNames = Object.keys(tableColumns).filter(
          (colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0
        );
        const setSize = columnNames.length;
        return sql.join(columnNames.flatMap((colName, i8) => {
          const col = tableColumns[colName];
          const value = set[colName] ?? sql.param(col.onUpdateFn(), col);
          const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
          if (i8 < setSize - 1) {
            return [res, sql.raw(", ")];
          }
          return [res];
        }));
      }
      buildUpdateQuery({ table: table6, set, where, returning, withList, from, joins }) {
        const withSql = this.buildWithCTE(withList);
        const tableName = table6[PgTable.Symbol.Name];
        const tableSchema = table6[PgTable.Symbol.Schema];
        const origTableName = table6[PgTable.Symbol.OriginalName];
        const alias2 = tableName === origTableName ? void 0 : tableName;
        const tableSql = sql`${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias2 && sql` ${sql.identifier(alias2)}`}`;
        const setSql = this.buildUpdateSet(table6, set);
        const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
        const joinsSql = this.buildJoins(joins);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: !from })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        return sql`${withSql}update ${tableSql} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}`;
      }
      /**
       * Builds selection SQL with provided fields/expressions
       *
       * Examples:
       *
       * `select <selection> from`
       *
       * `insert ... returning <selection>`
       *
       * If `isSingleTable` is true, then columns won't be prefixed with table name
       */
      buildSelection(fields, { isSingleTable = false } = {}) {
        const columnsLen = fields.length;
        const chunks = fields.flatMap(({ field }, i8) => {
          const chunk = [];
          if (is(field, SQL.Aliased) && field.isSelectionField) {
            chunk.push(sql.identifier(field.fieldAlias));
          } else if (is(field, SQL.Aliased) || is(field, SQL)) {
            const query = is(field, SQL.Aliased) ? field.sql : field;
            if (isSingleTable) {
              chunk.push(
                new SQL(
                  query.queryChunks.map((c6) => {
                    if (is(c6, PgColumn)) {
                      return sql.identifier(this.casing.getColumnCasing(c6));
                    }
                    return c6;
                  })
                )
              );
            } else {
              chunk.push(query);
            }
            if (is(field, SQL.Aliased)) {
              chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
            }
          } else if (is(field, Column)) {
            if (isSingleTable) {
              chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
            } else {
              chunk.push(field);
            }
          }
          if (i8 < columnsLen - 1) {
            chunk.push(sql`, `);
          }
          return chunk;
        });
        return sql.join(chunks);
      }
      buildJoins(joins) {
        if (!joins || joins.length === 0) {
          return void 0;
        }
        const joinsArray = [];
        for (const [index7, joinMeta] of joins.entries()) {
          if (index7 === 0) {
            joinsArray.push(sql` `);
          }
          const table6 = joinMeta.table;
          const lateralSql = joinMeta.lateral ? sql` lateral` : void 0;
          const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : void 0;
          if (is(table6, PgTable)) {
            const tableName = table6[PgTable.Symbol.Name];
            const tableSchema = table6[PgTable.Symbol.Schema];
            const origTableName = table6[PgTable.Symbol.OriginalName];
            const alias2 = tableName === origTableName ? void 0 : joinMeta.alias;
            joinsArray.push(
              sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias2 && sql` ${sql.identifier(alias2)}`}${onSql}`
            );
          } else if (is(table6, View)) {
            const viewName = table6[ViewBaseConfig].name;
            const viewSchema = table6[ViewBaseConfig].schema;
            const origViewName = table6[ViewBaseConfig].originalName;
            const alias2 = viewName === origViewName ? void 0 : joinMeta.alias;
            joinsArray.push(
              sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql`${sql.identifier(viewSchema)}.` : void 0}${sql.identifier(origViewName)}${alias2 && sql` ${sql.identifier(alias2)}`}${onSql}`
            );
          } else {
            joinsArray.push(
              sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table6}${onSql}`
            );
          }
          if (index7 < joins.length - 1) {
            joinsArray.push(sql` `);
          }
        }
        return sql.join(joinsArray);
      }
      buildFromTable(table6) {
        if (is(table6, Table) && table6[Table.Symbol.IsAlias]) {
          let fullName = sql`${sql.identifier(table6[Table.Symbol.OriginalName])}`;
          if (table6[Table.Symbol.Schema]) {
            fullName = sql`${sql.identifier(table6[Table.Symbol.Schema])}.${fullName}`;
          }
          return sql`${fullName} ${sql.identifier(table6[Table.Symbol.Name])}`;
        }
        return table6;
      }
      buildSelectQuery({
        withList,
        fields,
        fieldsFlat,
        where,
        having,
        table: table6,
        joins,
        orderBy,
        groupBy,
        limit,
        offset,
        lockingClause,
        distinct,
        setOperators
      }) {
        const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
        for (const f9 of fieldsList) {
          if (is(f9.field, Column) && getTableName(f9.field.table) !== (is(table6, Subquery) ? table6._.alias : is(table6, PgViewBase) ? table6[ViewBaseConfig].name : is(table6, SQL) ? void 0 : getTableName(table6)) && !((table22) => joins?.some(
            ({ alias: alias2 }) => alias2 === (table22[Table.Symbol.IsAlias] ? getTableName(table22) : table22[Table.Symbol.BaseName])
          ))(f9.field.table)) {
            const tableName = getTableName(f9.field.table);
            throw new Error(
              `Your "${f9.path.join("->")}" field references a column "${tableName}"."${f9.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`
            );
          }
        }
        const isSingleTable = !joins || joins.length === 0;
        const withSql = this.buildWithCTE(withList);
        let distinctSql;
        if (distinct) {
          distinctSql = distinct === true ? sql` distinct` : sql` distinct on (${sql.join(distinct.on, sql`, `)})`;
        }
        const selection = this.buildSelection(fieldsList, { isSingleTable });
        const tableSql = this.buildFromTable(table6);
        const joinsSql = this.buildJoins(joins);
        const whereSql = where ? sql` where ${where}` : void 0;
        const havingSql = having ? sql` having ${having}` : void 0;
        let orderBySql;
        if (orderBy && orderBy.length > 0) {
          orderBySql = sql` order by ${sql.join(orderBy, sql`, `)}`;
        }
        let groupBySql;
        if (groupBy && groupBy.length > 0) {
          groupBySql = sql` group by ${sql.join(groupBy, sql`, `)}`;
        }
        const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        const lockingClauseSql = sql.empty();
        if (lockingClause) {
          const clauseSql = sql` for ${sql.raw(lockingClause.strength)}`;
          if (lockingClause.config.of) {
            clauseSql.append(
              sql` of ${sql.join(
                Array.isArray(lockingClause.config.of) ? lockingClause.config.of : [lockingClause.config.of],
                sql`, `
              )}`
            );
          }
          if (lockingClause.config.noWait) {
            clauseSql.append(sql` nowait`);
          } else if (lockingClause.config.skipLocked) {
            clauseSql.append(sql` skip locked`);
          }
          lockingClauseSql.append(clauseSql);
        }
        const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClauseSql}`;
        if (setOperators.length > 0) {
          return this.buildSetOperations(finalQuery, setOperators);
        }
        return finalQuery;
      }
      buildSetOperations(leftSelect, setOperators) {
        const [setOperator, ...rest] = setOperators;
        if (!setOperator) {
          throw new Error("Cannot pass undefined values to any set operator");
        }
        if (rest.length === 0) {
          return this.buildSetOperationQuery({ leftSelect, setOperator });
        }
        return this.buildSetOperations(
          this.buildSetOperationQuery({ leftSelect, setOperator }),
          rest
        );
      }
      buildSetOperationQuery({
        leftSelect,
        setOperator: { type, isAll, rightSelect, limit, orderBy, offset }
      }) {
        const leftChunk = sql`(${leftSelect.getSQL()}) `;
        const rightChunk = sql`(${rightSelect.getSQL()})`;
        let orderBySql;
        if (orderBy && orderBy.length > 0) {
          const orderByValues = [];
          for (const singleOrderBy of orderBy) {
            if (is(singleOrderBy, PgColumn)) {
              orderByValues.push(sql.identifier(singleOrderBy.name));
            } else if (is(singleOrderBy, SQL)) {
              for (let i8 = 0; i8 < singleOrderBy.queryChunks.length; i8++) {
                const chunk = singleOrderBy.queryChunks[i8];
                if (is(chunk, PgColumn)) {
                  singleOrderBy.queryChunks[i8] = sql.identifier(chunk.name);
                }
              }
              orderByValues.push(sql`${singleOrderBy}`);
            } else {
              orderByValues.push(sql`${singleOrderBy}`);
            }
          }
          orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
        }
        const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
        const operatorChunk = sql.raw(`${type} ${isAll ? "all " : ""}`);
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
      }
      buildInsertQuery({ table: table6, values: valuesOrSelect, onConflict, returning, withList, select: select2, overridingSystemValue_ }) {
        const valuesSqlList = [];
        const columns = table6[Table.Symbol.Columns];
        const colEntries = Object.entries(columns).filter(([_7, col]) => !col.shouldDisableInsert());
        const insertOrder = colEntries.map(
          ([, column6]) => sql.identifier(this.casing.getColumnCasing(column6))
        );
        if (select2) {
          const select22 = valuesOrSelect;
          if (is(select22, SQL)) {
            valuesSqlList.push(select22);
          } else {
            valuesSqlList.push(select22.getSQL());
          }
        } else {
          const values2 = valuesOrSelect;
          valuesSqlList.push(sql.raw("values "));
          for (const [valueIndex, value] of values2.entries()) {
            const valueList = [];
            for (const [fieldName, col] of colEntries) {
              const colValue = value[fieldName];
              if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
                if (col.defaultFn !== void 0) {
                  const defaultFnResult = col.defaultFn();
                  const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
                  valueList.push(defaultValue);
                } else if (!col.default && col.onUpdateFn !== void 0) {
                  const onUpdateFnResult = col.onUpdateFn();
                  const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
                  valueList.push(newValue);
                } else {
                  valueList.push(sql`default`);
                }
              } else {
                valueList.push(colValue);
              }
            }
            valuesSqlList.push(valueList);
            if (valueIndex < values2.length - 1) {
              valuesSqlList.push(sql`, `);
            }
          }
        }
        const withSql = this.buildWithCTE(withList);
        const valuesSql = sql.join(valuesSqlList);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const onConflictSql = onConflict ? sql` on conflict ${onConflict}` : void 0;
        const overridingSql = overridingSystemValue_ === true ? sql`overriding system value ` : void 0;
        return sql`${withSql}insert into ${table6} ${insertOrder} ${overridingSql}${valuesSql}${onConflictSql}${returningSql}`;
      }
      buildRefreshMaterializedViewQuery({ view: view5, concurrently, withNoData }) {
        const concurrentlySql = concurrently ? sql` concurrently` : void 0;
        const withNoDataSql = withNoData ? sql` with no data` : void 0;
        return sql`refresh materialized view${concurrentlySql} ${view5}${withNoDataSql}`;
      }
      prepareTyping(encoder) {
        if (is(encoder, PgJsonb) || is(encoder, PgJson)) {
          return "json";
        } else if (is(encoder, PgNumeric)) {
          return "decimal";
        } else if (is(encoder, PgTime)) {
          return "time";
        } else if (is(encoder, PgTimestamp) || is(encoder, PgTimestampString)) {
          return "timestamp";
        } else if (is(encoder, PgDate) || is(encoder, PgDateString)) {
          return "date";
        } else if (is(encoder, PgUUID)) {
          return "uuid";
        } else {
          return "none";
        }
      }
      sqlToQuery(sql22, invokeSource) {
        return sql22.toQuery({
          casing: this.casing,
          escapeName: this.escapeName,
          escapeParam: this.escapeParam,
          escapeString: this.escapeString,
          prepareTyping: this.prepareTyping,
          invokeSource
        });
      }
      // buildRelationalQueryWithPK({
      // 	fullSchema,
      // 	schema,
      // 	tableNamesMap,
      // 	table,
      // 	tableConfig,
      // 	queryConfig: config,
      // 	tableAlias,
      // 	isRoot = false,
      // 	joinOn,
      // }: {
      // 	fullSchema: Record<string, unknown>;
      // 	schema: TablesRelationalConfig;
      // 	tableNamesMap: Record<string, string>;
      // 	table: PgTable;
      // 	tableConfig: TableRelationalConfig;
      // 	queryConfig: true | DBQueryConfig<'many', true>;
      // 	tableAlias: string;
      // 	isRoot?: boolean;
      // 	joinOn?: SQL;
      // }): BuildRelationalQueryResult<PgTable, PgColumn> {
      // 	// For { "<relation>": true }, return a table with selection of all columns
      // 	if (config === true) {
      // 		const selectionEntries = Object.entries(tableConfig.columns);
      // 		const selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = selectionEntries.map((
      // 			[key, value],
      // 		) => ({
      // 			dbKey: value.name,
      // 			tsKey: key,
      // 			field: value as PgColumn,
      // 			relationTableTsKey: undefined,
      // 			isJson: false,
      // 			selection: [],
      // 		}));
      // 		return {
      // 			tableTsKey: tableConfig.tsName,
      // 			sql: table,
      // 			selection,
      // 		};
      // 	}
      // 	// let selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = [];
      // 	// let selectionForBuild = selection;
      // 	const aliasedColumns = Object.fromEntries(
      // 		Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)]),
      // 	);
      // 	const aliasedRelations = Object.fromEntries(
      // 		Object.entries(tableConfig.relations).map(([key, value]) => [key, aliasedRelation(value, tableAlias)]),
      // 	);
      // 	const aliasedFields = Object.assign({}, aliasedColumns, aliasedRelations);
      // 	let where, hasUserDefinedWhere;
      // 	if (config.where) {
      // 		const whereSql = typeof config.where === 'function' ? config.where(aliasedFields, operators) : config.where;
      // 		where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
      // 		hasUserDefinedWhere = !!where;
      // 	}
      // 	where = and(joinOn, where);
      // 	// const fieldsSelection: { tsKey: string; value: PgColumn | SQL.Aliased; isExtra?: boolean }[] = [];
      // 	let joins: Join[] = [];
      // 	let selectedColumns: string[] = [];
      // 	// Figure out which columns to select
      // 	if (config.columns) {
      // 		let isIncludeMode = false;
      // 		for (const [field, value] of Object.entries(config.columns)) {
      // 			if (value === undefined) {
      // 				continue;
      // 			}
      // 			if (field in tableConfig.columns) {
      // 				if (!isIncludeMode && value === true) {
      // 					isIncludeMode = true;
      // 				}
      // 				selectedColumns.push(field);
      // 			}
      // 		}
      // 		if (selectedColumns.length > 0) {
      // 			selectedColumns = isIncludeMode
      // 				? selectedColumns.filter((c) => config.columns?.[c] === true)
      // 				: Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
      // 		}
      // 	} else {
      // 		// Select all columns if selection is not specified
      // 		selectedColumns = Object.keys(tableConfig.columns);
      // 	}
      // 	// for (const field of selectedColumns) {
      // 	// 	const column = tableConfig.columns[field]! as PgColumn;
      // 	// 	fieldsSelection.push({ tsKey: field, value: column });
      // 	// }
      // 	let initiallySelectedRelations: {
      // 		tsKey: string;
      // 		queryConfig: true | DBQueryConfig<'many', false>;
      // 		relation: Relation;
      // 	}[] = [];
      // 	// let selectedRelations: BuildRelationalQueryResult<PgTable, PgColumn>['selection'] = [];
      // 	// Figure out which relations to select
      // 	if (config.with) {
      // 		initiallySelectedRelations = Object.entries(config.with)
      // 			.filter((entry): entry is [typeof entry[0], NonNullable<typeof entry[1]>] => !!entry[1])
      // 			.map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey]! }));
      // 	}
      // 	const manyRelations = initiallySelectedRelations.filter((r) =>
      // 		is(r.relation, Many)
      // 		&& (schema[tableNamesMap[r.relation.referencedTable[Table.Symbol.Name]]!]?.primaryKey.length ?? 0) > 0
      // 	);
      // 	// If this is the last Many relation (or there are no Many relations), we are on the innermost subquery level
      // 	const isInnermostQuery = manyRelations.length < 2;
      // 	const selectedExtras: {
      // 		tsKey: string;
      // 		value: SQL.Aliased;
      // 	}[] = [];
      // 	// Figure out which extras to select
      // 	if (isInnermostQuery && config.extras) {
      // 		const extras = typeof config.extras === 'function'
      // 			? config.extras(aliasedFields, { sql })
      // 			: config.extras;
      // 		for (const [tsKey, value] of Object.entries(extras)) {
      // 			selectedExtras.push({
      // 				tsKey,
      // 				value: mapColumnsInAliasedSQLToAlias(value, tableAlias),
      // 			});
      // 		}
      // 	}
      // 	// Transform `fieldsSelection` into `selection`
      // 	// `fieldsSelection` shouldn't be used after this point
      // 	// for (const { tsKey, value, isExtra } of fieldsSelection) {
      // 	// 	selection.push({
      // 	// 		dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey]!.name,
      // 	// 		tsKey,
      // 	// 		field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
      // 	// 		relationTableTsKey: undefined,
      // 	// 		isJson: false,
      // 	// 		isExtra,
      // 	// 		selection: [],
      // 	// 	});
      // 	// }
      // 	let orderByOrig = typeof config.orderBy === 'function'
      // 		? config.orderBy(aliasedFields, orderByOperators)
      // 		: config.orderBy ?? [];
      // 	if (!Array.isArray(orderByOrig)) {
      // 		orderByOrig = [orderByOrig];
      // 	}
      // 	const orderBy = orderByOrig.map((orderByValue) => {
      // 		if (is(orderByValue, Column)) {
      // 			return aliasedTableColumn(orderByValue, tableAlias) as PgColumn;
      // 		}
      // 		return mapColumnsInSQLToAlias(orderByValue, tableAlias);
      // 	});
      // 	const limit = isInnermostQuery ? config.limit : undefined;
      // 	const offset = isInnermostQuery ? config.offset : undefined;
      // 	// For non-root queries without additional config except columns, return a table with selection
      // 	if (
      // 		!isRoot
      // 		&& initiallySelectedRelations.length === 0
      // 		&& selectedExtras.length === 0
      // 		&& !where
      // 		&& orderBy.length === 0
      // 		&& limit === undefined
      // 		&& offset === undefined
      // 	) {
      // 		return {
      // 			tableTsKey: tableConfig.tsName,
      // 			sql: table,
      // 			selection: selectedColumns.map((key) => ({
      // 				dbKey: tableConfig.columns[key]!.name,
      // 				tsKey: key,
      // 				field: tableConfig.columns[key] as PgColumn,
      // 				relationTableTsKey: undefined,
      // 				isJson: false,
      // 				selection: [],
      // 			})),
      // 		};
      // 	}
      // 	const selectedRelationsWithoutPK:
      // 	// Process all relations without primary keys, because they need to be joined differently and will all be on the same query level
      // 	for (
      // 		const {
      // 			tsKey: selectedRelationTsKey,
      // 			queryConfig: selectedRelationConfigValue,
      // 			relation,
      // 		} of initiallySelectedRelations
      // 	) {
      // 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
      // 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
      // 		const relationTableTsName = tableNamesMap[relationTableName]!;
      // 		const relationTable = schema[relationTableTsName]!;
      // 		if (relationTable.primaryKey.length > 0) {
      // 			continue;
      // 		}
      // 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
      // 		const joinOn = and(
      // 			...normalizedRelation.fields.map((field, i) =>
      // 				eq(
      // 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
      // 					aliasedTableColumn(field, tableAlias),
      // 				)
      // 			),
      // 		);
      // 		const builtRelation = this.buildRelationalQueryWithoutPK({
      // 			fullSchema,
      // 			schema,
      // 			tableNamesMap,
      // 			table: fullSchema[relationTableTsName] as PgTable,
      // 			tableConfig: schema[relationTableTsName]!,
      // 			queryConfig: selectedRelationConfigValue,
      // 			tableAlias: relationTableAlias,
      // 			joinOn,
      // 			nestedQueryRelation: relation,
      // 		});
      // 		const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier('data')}`.as(selectedRelationTsKey);
      // 		joins.push({
      // 			on: sql`true`,
      // 			table: new Subquery(builtRelation.sql as SQL, {}, relationTableAlias),
      // 			alias: relationTableAlias,
      // 			joinType: 'left',
      // 			lateral: true,
      // 		});
      // 		selectedRelations.push({
      // 			dbKey: selectedRelationTsKey,
      // 			tsKey: selectedRelationTsKey,
      // 			field,
      // 			relationTableTsKey: relationTableTsName,
      // 			isJson: true,
      // 			selection: builtRelation.selection,
      // 		});
      // 	}
      // 	const oneRelations = initiallySelectedRelations.filter((r): r is typeof r & { relation: One } =>
      // 		is(r.relation, One)
      // 	);
      // 	// Process all One relations with PKs, because they can all be joined on the same level
      // 	for (
      // 		const {
      // 			tsKey: selectedRelationTsKey,
      // 			queryConfig: selectedRelationConfigValue,
      // 			relation,
      // 		} of oneRelations
      // 	) {
      // 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
      // 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
      // 		const relationTableTsName = tableNamesMap[relationTableName]!;
      // 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
      // 		const relationTable = schema[relationTableTsName]!;
      // 		if (relationTable.primaryKey.length === 0) {
      // 			continue;
      // 		}
      // 		const joinOn = and(
      // 			...normalizedRelation.fields.map((field, i) =>
      // 				eq(
      // 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
      // 					aliasedTableColumn(field, tableAlias),
      // 				)
      // 			),
      // 		);
      // 		const builtRelation = this.buildRelationalQueryWithPK({
      // 			fullSchema,
      // 			schema,
      // 			tableNamesMap,
      // 			table: fullSchema[relationTableTsName] as PgTable,
      // 			tableConfig: schema[relationTableTsName]!,
      // 			queryConfig: selectedRelationConfigValue,
      // 			tableAlias: relationTableAlias,
      // 			joinOn,
      // 		});
      // 		const field = sql`case when ${sql.identifier(relationTableAlias)} is null then null else json_build_array(${
      // 			sql.join(
      // 				builtRelation.selection.map(({ field }) =>
      // 					is(field, SQL.Aliased)
      // 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
      // 						: is(field, Column)
      // 						? aliasedTableColumn(field, relationTableAlias)
      // 						: field
      // 				),
      // 				sql`, `,
      // 			)
      // 		}) end`.as(selectedRelationTsKey);
      // 		const isLateralJoin = is(builtRelation.sql, SQL);
      // 		joins.push({
      // 			on: isLateralJoin ? sql`true` : joinOn,
      // 			table: is(builtRelation.sql, SQL)
      // 				? new Subquery(builtRelation.sql, {}, relationTableAlias)
      // 				: aliasedTable(builtRelation.sql, relationTableAlias),
      // 			alias: relationTableAlias,
      // 			joinType: 'left',
      // 			lateral: is(builtRelation.sql, SQL),
      // 		});
      // 		selectedRelations.push({
      // 			dbKey: selectedRelationTsKey,
      // 			tsKey: selectedRelationTsKey,
      // 			field,
      // 			relationTableTsKey: relationTableTsName,
      // 			isJson: true,
      // 			selection: builtRelation.selection,
      // 		});
      // 	}
      // 	let distinct: PgSelectConfig['distinct'];
      // 	let tableFrom: PgTable | Subquery = table;
      // 	// Process first Many relation - each one requires a nested subquery
      // 	const manyRelation = manyRelations[0];
      // 	if (manyRelation) {
      // 		const {
      // 			tsKey: selectedRelationTsKey,
      // 			queryConfig: selectedRelationQueryConfig,
      // 			relation,
      // 		} = manyRelation;
      // 		distinct = {
      // 			on: tableConfig.primaryKey.map((c) => aliasedTableColumn(c as PgColumn, tableAlias)),
      // 		};
      // 		const normalizedRelation = normalizeRelation(schema, tableNamesMap, relation);
      // 		const relationTableName = relation.referencedTable[Table.Symbol.Name];
      // 		const relationTableTsName = tableNamesMap[relationTableName]!;
      // 		const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
      // 		const joinOn = and(
      // 			...normalizedRelation.fields.map((field, i) =>
      // 				eq(
      // 					aliasedTableColumn(normalizedRelation.references[i]!, relationTableAlias),
      // 					aliasedTableColumn(field, tableAlias),
      // 				)
      // 			),
      // 		);
      // 		const builtRelationJoin = this.buildRelationalQueryWithPK({
      // 			fullSchema,
      // 			schema,
      // 			tableNamesMap,
      // 			table: fullSchema[relationTableTsName] as PgTable,
      // 			tableConfig: schema[relationTableTsName]!,
      // 			queryConfig: selectedRelationQueryConfig,
      // 			tableAlias: relationTableAlias,
      // 			joinOn,
      // 		});
      // 		const builtRelationSelectionField = sql`case when ${
      // 			sql.identifier(relationTableAlias)
      // 		} is null then '[]' else json_agg(json_build_array(${
      // 			sql.join(
      // 				builtRelationJoin.selection.map(({ field }) =>
      // 					is(field, SQL.Aliased)
      // 						? sql`${sql.identifier(relationTableAlias)}.${sql.identifier(field.fieldAlias)}`
      // 						: is(field, Column)
      // 						? aliasedTableColumn(field, relationTableAlias)
      // 						: field
      // 				),
      // 				sql`, `,
      // 			)
      // 		})) over (partition by ${sql.join(distinct.on, sql`, `)}) end`.as(selectedRelationTsKey);
      // 		const isLateralJoin = is(builtRelationJoin.sql, SQL);
      // 		joins.push({
      // 			on: isLateralJoin ? sql`true` : joinOn,
      // 			table: isLateralJoin
      // 				? new Subquery(builtRelationJoin.sql as SQL, {}, relationTableAlias)
      // 				: aliasedTable(builtRelationJoin.sql as PgTable, relationTableAlias),
      // 			alias: relationTableAlias,
      // 			joinType: 'left',
      // 			lateral: isLateralJoin,
      // 		});
      // 		// Build the "from" subquery with the remaining Many relations
      // 		const builtTableFrom = this.buildRelationalQueryWithPK({
      // 			fullSchema,
      // 			schema,
      // 			tableNamesMap,
      // 			table,
      // 			tableConfig,
      // 			queryConfig: {
      // 				...config,
      // 				where: undefined,
      // 				orderBy: undefined,
      // 				limit: undefined,
      // 				offset: undefined,
      // 				with: manyRelations.slice(1).reduce<NonNullable<typeof config['with']>>(
      // 					(result, { tsKey, queryConfig: configValue }) => {
      // 						result[tsKey] = configValue;
      // 						return result;
      // 					},
      // 					{},
      // 				),
      // 			},
      // 			tableAlias,
      // 		});
      // 		selectedRelations.push({
      // 			dbKey: selectedRelationTsKey,
      // 			tsKey: selectedRelationTsKey,
      // 			field: builtRelationSelectionField,
      // 			relationTableTsKey: relationTableTsName,
      // 			isJson: true,
      // 			selection: builtRelationJoin.selection,
      // 		});
      // 		// selection = builtTableFrom.selection.map((item) =>
      // 		// 	is(item.field, SQL.Aliased)
      // 		// 		? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
      // 		// 		: item
      // 		// );
      // 		// selectionForBuild = [{
      // 		// 	dbKey: '*',
      // 		// 	tsKey: '*',
      // 		// 	field: sql`${sql.identifier(tableAlias)}.*`,
      // 		// 	selection: [],
      // 		// 	isJson: false,
      // 		// 	relationTableTsKey: undefined,
      // 		// }];
      // 		// const newSelectionItem: (typeof selection)[number] = {
      // 		// 	dbKey: selectedRelationTsKey,
      // 		// 	tsKey: selectedRelationTsKey,
      // 		// 	field,
      // 		// 	relationTableTsKey: relationTableTsName,
      // 		// 	isJson: true,
      // 		// 	selection: builtRelationJoin.selection,
      // 		// };
      // 		// selection.push(newSelectionItem);
      // 		// selectionForBuild.push(newSelectionItem);
      // 		tableFrom = is(builtTableFrom.sql, PgTable)
      // 			? builtTableFrom.sql
      // 			: new Subquery(builtTableFrom.sql, {}, tableAlias);
      // 	}
      // 	if (selectedColumns.length === 0 && selectedRelations.length === 0 && selectedExtras.length === 0) {
      // 		throw new DrizzleError(`No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")`);
      // 	}
      // 	let selection: BuildRelationalQueryResult<PgTable, PgColumn>['selection'];
      // 	function prepareSelectedColumns() {
      // 		return selectedColumns.map((key) => ({
      // 			dbKey: tableConfig.columns[key]!.name,
      // 			tsKey: key,
      // 			field: tableConfig.columns[key] as PgColumn,
      // 			relationTableTsKey: undefined,
      // 			isJson: false,
      // 			selection: [],
      // 		}));
      // 	}
      // 	function prepareSelectedExtras() {
      // 		return selectedExtras.map((item) => ({
      // 			dbKey: item.value.fieldAlias,
      // 			tsKey: item.tsKey,
      // 			field: item.value,
      // 			relationTableTsKey: undefined,
      // 			isJson: false,
      // 			selection: [],
      // 		}));
      // 	}
      // 	if (isRoot) {
      // 		selection = [
      // 			...prepareSelectedColumns(),
      // 			...prepareSelectedExtras(),
      // 		];
      // 	}
      // 	if (hasUserDefinedWhere || orderBy.length > 0) {
      // 		tableFrom = new Subquery(
      // 			this.buildSelectQuery({
      // 				table: is(tableFrom, PgTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
      // 				fields: {},
      // 				fieldsFlat: selectionForBuild.map(({ field }) => ({
      // 					path: [],
      // 					field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
      // 				})),
      // 				joins,
      // 				distinct,
      // 			}),
      // 			{},
      // 			tableAlias,
      // 		);
      // 		selectionForBuild = selection.map((item) =>
      // 			is(item.field, SQL.Aliased)
      // 				? { ...item, field: sql`${sql.identifier(tableAlias)}.${sql.identifier(item.field.fieldAlias)}` }
      // 				: item
      // 		);
      // 		joins = [];
      // 		distinct = undefined;
      // 	}
      // 	const result = this.buildSelectQuery({
      // 		table: is(tableFrom, PgTable) ? aliasedTable(tableFrom, tableAlias) : tableFrom,
      // 		fields: {},
      // 		fieldsFlat: selectionForBuild.map(({ field }) => ({
      // 			path: [],
      // 			field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field,
      // 		})),
      // 		where,
      // 		limit,
      // 		offset,
      // 		joins,
      // 		orderBy,
      // 		distinct,
      // 	});
      // 	return {
      // 		tableTsKey: tableConfig.tsName,
      // 		sql: result,
      // 		selection,
      // 	};
      // }
      buildRelationalQueryWithoutPK({
        fullSchema,
        schema: schema6,
        tableNamesMap,
        table: table6,
        tableConfig,
        queryConfig: config,
        tableAlias,
        nestedQueryRelation,
        joinOn
      }) {
        let selection = [];
        let limit, offset, orderBy = [], where;
        const joins = [];
        if (config === true) {
          const selectionEntries = Object.entries(tableConfig.columns);
          selection = selectionEntries.map(([key, value]) => ({
            dbKey: value.name,
            tsKey: key,
            field: aliasedTableColumn(value, tableAlias),
            relationTableTsKey: void 0,
            isJson: false,
            selection: []
          }));
        } else {
          const aliasedColumns = Object.fromEntries(
            Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)])
          );
          if (config.where) {
            const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
          }
          const fieldsSelection = [];
          let selectedColumns = [];
          if (config.columns) {
            let isIncludeMode = false;
            for (const [field, value] of Object.entries(config.columns)) {
              if (value === void 0) {
                continue;
              }
              if (field in tableConfig.columns) {
                if (!isIncludeMode && value === true) {
                  isIncludeMode = true;
                }
                selectedColumns.push(field);
              }
            }
            if (selectedColumns.length > 0) {
              selectedColumns = isIncludeMode ? selectedColumns.filter((c6) => config.columns?.[c6] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
            }
          } else {
            selectedColumns = Object.keys(tableConfig.columns);
          }
          for (const field of selectedColumns) {
            const column6 = tableConfig.columns[field];
            fieldsSelection.push({ tsKey: field, value: column6 });
          }
          let selectedRelations = [];
          if (config.with) {
            selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
          }
          let extras;
          if (config.extras) {
            extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
            for (const [tsKey, value] of Object.entries(extras)) {
              fieldsSelection.push({
                tsKey,
                value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
              });
            }
          }
          for (const { tsKey, value } of fieldsSelection) {
            selection.push({
              dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
              tsKey,
              field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
              relationTableTsKey: void 0,
              isJson: false,
              selection: []
            });
          }
          let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
          if (!Array.isArray(orderByOrig)) {
            orderByOrig = [orderByOrig];
          }
          orderBy = orderByOrig.map((orderByValue) => {
            if (is(orderByValue, Column)) {
              return aliasedTableColumn(orderByValue, tableAlias);
            }
            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
          });
          limit = config.limit;
          offset = config.offset;
          for (const {
            tsKey: selectedRelationTsKey,
            queryConfig: selectedRelationConfigValue,
            relation
          } of selectedRelations) {
            const normalizedRelation = normalizeRelation(schema6, tableNamesMap, relation);
            const relationTableName = getTableUniqueName(relation.referencedTable);
            const relationTableTsName = tableNamesMap[relationTableName];
            const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
            const joinOn2 = and(
              ...normalizedRelation.fields.map(
                (field2, i8) => eq(
                  aliasedTableColumn(normalizedRelation.references[i8], relationTableAlias),
                  aliasedTableColumn(field2, tableAlias)
                )
              )
            );
            const builtRelation = this.buildRelationalQueryWithoutPK({
              fullSchema,
              schema: schema6,
              tableNamesMap,
              table: fullSchema[relationTableTsName],
              tableConfig: schema6[relationTableTsName],
              queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
              tableAlias: relationTableAlias,
              joinOn: joinOn2,
              nestedQueryRelation: relation
            });
            const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier("data")}`.as(selectedRelationTsKey);
            joins.push({
              on: sql`true`,
              table: new Subquery(builtRelation.sql, {}, relationTableAlias),
              alias: relationTableAlias,
              joinType: "left",
              lateral: true
            });
            selection.push({
              dbKey: selectedRelationTsKey,
              tsKey: selectedRelationTsKey,
              field,
              relationTableTsKey: relationTableTsName,
              isJson: true,
              selection: builtRelation.selection
            });
          }
        }
        if (selection.length === 0) {
          throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
        }
        let result;
        where = and(joinOn, where);
        if (nestedQueryRelation) {
          let field = sql`json_build_array(${sql.join(
            selection.map(
              ({ field: field2, tsKey, isJson: isJson2 }) => isJson2 ? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier("data")}` : is(field2, SQL.Aliased) ? field2.sql : field2
            ),
            sql`, `
          )})`;
          if (is(nestedQueryRelation, Many)) {
            field = sql`coalesce(json_agg(${field}${orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : void 0}), '[]'::json)`;
          }
          const nestedSelection = [{
            dbKey: "data",
            tsKey: "data",
            field: field.as("data"),
            isJson: true,
            relationTableTsKey: tableConfig.tsName,
            selection
          }];
          const needsSubquery = limit !== void 0 || offset !== void 0 || orderBy.length > 0;
          if (needsSubquery) {
            result = this.buildSelectQuery({
              table: aliasedTable(table6, tableAlias),
              fields: {},
              fieldsFlat: [{
                path: [],
                field: sql.raw("*")
              }],
              where,
              limit,
              offset,
              orderBy,
              setOperators: []
            });
            where = void 0;
            limit = void 0;
            offset = void 0;
            orderBy = [];
          } else {
            result = aliasedTable(table6, tableAlias);
          }
          result = this.buildSelectQuery({
            table: is(result, PgTable) ? result : new Subquery(result, {}, tableAlias),
            fields: {},
            fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
              path: [],
              field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        } else {
          result = this.buildSelectQuery({
            table: aliasedTable(table6, tableAlias),
            fields: {},
            fieldsFlat: selection.map(({ field }) => ({
              path: [],
              field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        }
        return {
          tableTsKey: tableConfig.tsName,
          sql: result,
          selection
        };
      }
    };
    __publicField(PgDialect, _a244, "PgDialect");
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/select.js
function createSetOperator2(type, isAll) {
  return (leftSelect, rightSelect, ...restSelects) => {
    const setOperators = [rightSelect, ...restSelects].map((select2) => ({
      type,
      isAll,
      rightSelect: select2
    }));
    for (const setOperator of setOperators) {
      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
        throw new Error(
          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
        );
      }
    }
    return leftSelect.addSetOperators(setOperators);
  };
}
var _a245, PgSelectBuilder, _a246, _b186, PgSelectQueryBuilderBase, _a247, _b187, PgSelectBase, getPgSetOperators, union2, unionAll2, intersect2, intersectAll2, except2, exceptAll2;
var init_select3 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/select.js"() {
    "use strict";
    init_entity();
    init_view_base2();
    init_query_builder();
    init_query_promise();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_table();
    init_tracing();
    init_utils();
    init_utils();
    init_view_common();
    init_utils4();
    _a245 = entityKind;
    PgSelectBuilder = class {
      constructor(config) {
        __publicField(this, "fields");
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "withList", []);
        __publicField(this, "distinct");
        __publicField(this, "authToken");
        this.fields = config.fields;
        this.session = config.session;
        this.dialect = config.dialect;
        if (config.withList) {
          this.withList = config.withList;
        }
        this.distinct = config.distinct;
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
      /**
       * Specify the table, subquery, or other target that you're
       * building a select query against.
       *
       * {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FROM | Postgres from documentation}
       */
      from(source) {
        const isPartialSelect = !!this.fields;
        const src = source;
        let fields;
        if (this.fields) {
          fields = this.fields;
        } else if (is(src, Subquery)) {
          fields = Object.fromEntries(
            Object.keys(src._.selectedFields).map((key) => [key, src[key]])
          );
        } else if (is(src, PgViewBase)) {
          fields = src[ViewBaseConfig].selectedFields;
        } else if (is(src, SQL)) {
          fields = {};
        } else {
          fields = getTableColumns(src);
        }
        return new PgSelectBase({
          table: src,
          fields,
          isPartialSelect,
          session: this.session,
          dialect: this.dialect,
          withList: this.withList,
          distinct: this.distinct
        }).setToken(this.authToken);
      }
    };
    __publicField(PgSelectBuilder, _a245, "PgSelectBuilder");
    PgSelectQueryBuilderBase = class extends (_b186 = TypedQueryBuilder, _a246 = entityKind, _b186) {
      constructor({ table: table6, fields, isPartialSelect, session, dialect: dialect6, withList, distinct }) {
        super();
        __publicField(this, "_");
        __publicField(this, "config");
        __publicField(this, "joinsNotNullableMap");
        __publicField(this, "tableName");
        __publicField(this, "isPartialSelect");
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "cacheConfig");
        __publicField(this, "usedTables", /* @__PURE__ */ new Set());
        /**
         * Executes a `left join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "leftJoin", this.createJoin("left", false));
        /**
         * Executes a `left join lateral` operation by adding subquery to the current query.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#left-join-lateral}
         *
         * @param table the subquery to join.
         * @param on the `on` clause.
         */
        __publicField(this, "leftJoinLateral", this.createJoin("left", true));
        /**
         * Executes a `right join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "rightJoin", this.createJoin("right", false));
        /**
         * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
         *
         * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "innerJoin", this.createJoin("inner", false));
        /**
         * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join-lateral}
         *
         * @param table the subquery to join.
         * @param on the `on` clause.
         */
        __publicField(this, "innerJoinLateral", this.createJoin("inner", true));
        /**
         * Executes a `full join` operation by combining rows from two tables into a new table.
         *
         * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()
         *   .from(users)
         *   .fullJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .fullJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "fullJoin", this.createJoin("full", false));
        /**
         * Executes a `cross join` operation by combining rows from two tables into a new table.
         *
         * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
         *
         * @param table the table to join.
         *
         * @example
         *
         * ```ts
         * // Select all users, each user with every pet
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .crossJoin(pets)
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .crossJoin(pets)
         * ```
         */
        __publicField(this, "crossJoin", this.createJoin("cross", false));
        /**
         * Executes a `cross join lateral` operation by combining rows from two queries into a new table.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}
         *
         * @param table the query to join.
         */
        __publicField(this, "crossJoinLateral", this.createJoin("cross", true));
        /**
         * Adds `union` set operator to the query.
         *
         * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
         *
         * @example
         *
         * ```ts
         * // Select all unique names from customers and users tables
         * await db.select({ name: users.name })
         *   .from(users)
         *   .union(
         *     db.select({ name: customers.name }).from(customers)
         *   );
         * // or
         * import { union } from 'drizzle-orm/pg-core'
         *
         * await union(
         *   db.select({ name: users.name }).from(users),
         *   db.select({ name: customers.name }).from(customers)
         * );
         * ```
         */
        __publicField(this, "union", this.createSetOperator("union", false));
        /**
         * Adds `union all` set operator to the query.
         *
         * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
         *
         * @example
         *
         * ```ts
         * // Select all transaction ids from both online and in-store sales
         * await db.select({ transaction: onlineSales.transactionId })
         *   .from(onlineSales)
         *   .unionAll(
         *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         *   );
         * // or
         * import { unionAll } from 'drizzle-orm/pg-core'
         *
         * await unionAll(
         *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
         *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         * );
         * ```
         */
        __publicField(this, "unionAll", this.createSetOperator("union", true));
        /**
         * Adds `intersect` set operator to the query.
         *
         * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
         *
         * @example
         *
         * ```ts
         * // Select course names that are offered in both departments A and B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .intersect(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { intersect } from 'drizzle-orm/pg-core'
         *
         * await intersect(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "intersect", this.createSetOperator("intersect", false));
        /**
         * Adds `intersect all` set operator to the query.
         *
         * Calling this method will retain only the rows that are present in both result sets including all duplicates.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect-all}
         *
         * @example
         *
         * ```ts
         * // Select all products and quantities that are ordered by both regular and VIP customers
         * await db.select({
         *   productId: regularCustomerOrders.productId,
         *   quantityOrdered: regularCustomerOrders.quantityOrdered
         * })
         * .from(regularCustomerOrders)
         * .intersectAll(
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered
         *   })
         *   .from(vipCustomerOrders)
         * );
         * // or
         * import { intersectAll } from 'drizzle-orm/pg-core'
         *
         * await intersectAll(
         *   db.select({
         *     productId: regularCustomerOrders.productId,
         *     quantityOrdered: regularCustomerOrders.quantityOrdered
         *   })
         *   .from(regularCustomerOrders),
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered
         *   })
         *   .from(vipCustomerOrders)
         * );
         * ```
         */
        __publicField(this, "intersectAll", this.createSetOperator("intersect", true));
        /**
         * Adds `except` set operator to the query.
         *
         * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
         *
         * @example
         *
         * ```ts
         * // Select all courses offered in department A but not in department B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .except(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { except } from 'drizzle-orm/pg-core'
         *
         * await except(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "except", this.createSetOperator("except", false));
        /**
         * Adds `except all` set operator to the query.
         *
         * Calling this method will retrieve all rows from the left query, except for the rows that are present in the result set of the right query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#except-all}
         *
         * @example
         *
         * ```ts
         * // Select all products that are ordered by regular customers but not by VIP customers
         * await db.select({
         *   productId: regularCustomerOrders.productId,
         *   quantityOrdered: regularCustomerOrders.quantityOrdered,
         * })
         * .from(regularCustomerOrders)
         * .exceptAll(
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered,
         *   })
         *   .from(vipCustomerOrders)
         * );
         * // or
         * import { exceptAll } from 'drizzle-orm/pg-core'
         *
         * await exceptAll(
         *   db.select({
         *     productId: regularCustomerOrders.productId,
         *     quantityOrdered: regularCustomerOrders.quantityOrdered
         *   })
         *   .from(regularCustomerOrders),
         *   db.select({
         *     productId: vipCustomerOrders.productId,
         *     quantityOrdered: vipCustomerOrders.quantityOrdered
         *   })
         *   .from(vipCustomerOrders)
         * );
         * ```
         */
        __publicField(this, "exceptAll", this.createSetOperator("except", true));
        this.config = {
          withList,
          table: table6,
          fields: { ...fields },
          distinct,
          setOperators: []
        };
        this.isPartialSelect = isPartialSelect;
        this.session = session;
        this.dialect = dialect6;
        this._ = {
          selectedFields: fields,
          config: this.config
        };
        this.tableName = getTableLikeName(table6);
        this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
        for (const item of extractUsedTable2(table6)) this.usedTables.add(item);
      }
      /** @internal */
      getUsedTables() {
        return [...this.usedTables];
      }
      createJoin(joinType, lateral) {
        return (table6, on3) => {
          const baseTableName = this.tableName;
          const tableName = getTableLikeName(table6);
          for (const item of extractUsedTable2(table6)) this.usedTables.add(item);
          if (typeof tableName === "string" && this.config.joins?.some((join7) => join7.alias === tableName)) {
            throw new Error(`Alias "${tableName}" is already used in this query`);
          }
          if (!this.isPartialSelect) {
            if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") {
              this.config.fields = {
                [baseTableName]: this.config.fields
              };
            }
            if (typeof tableName === "string" && !is(table6, SQL)) {
              const selection = is(table6, Subquery) ? table6._.selectedFields : is(table6, View) ? table6[ViewBaseConfig].selectedFields : table6[Table.Symbol.Columns];
              this.config.fields[tableName] = selection;
            }
          }
          if (typeof on3 === "function") {
            on3 = on3(
              new Proxy(
                this.config.fields,
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              )
            );
          }
          if (!this.config.joins) {
            this.config.joins = [];
          }
          this.config.joins.push({ on: on3, table: table6, joinType, alias: tableName, lateral });
          if (typeof tableName === "string") {
            switch (joinType) {
              case "left": {
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
              case "right": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "cross":
              case "inner": {
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "full": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
            }
          }
          return this;
        };
      }
      createSetOperator(type, isAll) {
        return (rightSelection) => {
          const rightSelect = typeof rightSelection === "function" ? rightSelection(getPgSetOperators()) : rightSelection;
          if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
            throw new Error(
              "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
            );
          }
          this.config.setOperators.push({ type, isAll, rightSelect });
          return this;
        };
      }
      /** @internal */
      addSetOperators(setOperators) {
        this.config.setOperators.push(...setOperators);
        return this;
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be selected.
       *
       * ```ts
       * // Select all cars with green color
       * await db.select().from(cars).where(eq(cars.color, 'green'));
       * // or
       * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Select all BMW cars with a green color
       * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Select all cars with the green or blue color
       * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        if (typeof where === "function") {
          where = where(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.where = where;
        return this;
      }
      /**
       * Adds a `having` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
       *
       * @param having the `having` clause.
       *
       * @example
       *
       * ```ts
       * // Select all brands with more than one car
       * await db.select({
       * 	brand: cars.brand,
       * 	count: sql<number>`cast(count(${cars.id}) as int)`,
       * })
       *   .from(cars)
       *   .groupBy(cars.brand)
       *   .having(({ count }) => gt(count, 1));
       * ```
       */
      having(having) {
        if (typeof having === "function") {
          having = having(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.having = having;
        return this;
      }
      groupBy(...columns) {
        if (typeof columns[0] === "function") {
          const groupBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
        } else {
          this.config.groupBy = columns;
        }
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        } else {
          const orderByArray = columns;
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        }
        return this;
      }
      /**
       * Adds a `limit` clause to the query.
       *
       * Calling this method will set the maximum number of rows that will be returned by this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param limit the `limit` clause.
       *
       * @example
       *
       * ```ts
       * // Get the first 10 people from this query.
       * await db.select().from(people).limit(10);
       * ```
       */
      limit(limit) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).limit = limit;
        } else {
          this.config.limit = limit;
        }
        return this;
      }
      /**
       * Adds an `offset` clause to the query.
       *
       * Calling this method will skip a number of rows when returning results from this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param offset the `offset` clause.
       *
       * @example
       *
       * ```ts
       * // Get the 10th-20th people from this query.
       * await db.select().from(people).offset(10).limit(10);
       * ```
       */
      offset(offset) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).offset = offset;
        } else {
          this.config.offset = offset;
        }
        return this;
      }
      /**
       * Adds a `for` clause to the query.
       *
       * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
       *
       * See docs: {@link https://www.postgresql.org/docs/current/sql-select.html#SQL-FOR-UPDATE-SHARE}
       *
       * @param strength the lock strength.
       * @param config the lock configuration.
       */
      for(strength, config = {}) {
        this.config.lockingClause = { strength, config };
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildSelectQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      as(alias2) {
        const usedTables = [];
        usedTables.push(...extractUsedTable2(this.config.table));
        if (this.config.joins) {
          for (const it2 of this.config.joins) usedTables.push(...extractUsedTable2(it2.table));
        }
        return new Proxy(
          new Subquery(this.getSQL(), this.config.fields, alias2, false, [...new Set(usedTables)]),
          new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      /** @internal */
      getSelectedFields() {
        return new Proxy(
          this.config.fields,
          new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      $dynamic() {
        return this;
      }
      $withCache(config) {
        this.cacheConfig = config === void 0 ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };
        return this;
      }
    };
    __publicField(PgSelectQueryBuilderBase, _a246, "PgSelectQueryBuilder");
    PgSelectBase = class extends (_b187 = PgSelectQueryBuilderBase, _a247 = entityKind, _b187) {
      constructor() {
        super(...arguments);
        __publicField(this, "authToken");
        __publicField(this, "execute", (placeholderValues) => {
          return tracer.startActiveSpan("drizzle.operation", () => {
            return this._prepare().execute(placeholderValues, this.authToken);
          });
        });
      }
      /** @internal */
      _prepare(name3) {
        const { session, config, dialect: dialect6, joinsNotNullableMap, authToken, cacheConfig, usedTables } = this;
        if (!session) {
          throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
        }
        const { fields } = config;
        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
          const fieldsList = orderSelectedFields(fields);
          const query = session.prepareQuery(dialect6.sqlToQuery(this.getSQL()), fieldsList, name3, true, void 0, {
            type: "select",
            tables: [...usedTables]
          }, cacheConfig);
          query.joinsNotNullableMap = joinsNotNullableMap;
          return query.setToken(authToken);
        });
      }
      /**
       * Create a prepared statement for this query. This allows
       * the database to remember this query for the given session
       * and call it by name, rather than specifying the full query.
       *
       * {@link https://www.postgresql.org/docs/current/sql-prepare.html | Postgres prepare documentation}
       */
      prepare(name3) {
        return this._prepare(name3);
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
    };
    __publicField(PgSelectBase, _a247, "PgSelect");
    applyMixins(PgSelectBase, [QueryPromise]);
    getPgSetOperators = () => ({
      union: union2,
      unionAll: unionAll2,
      intersect: intersect2,
      intersectAll: intersectAll2,
      except: except2,
      exceptAll: exceptAll2
    });
    union2 = createSetOperator2("union", false);
    unionAll2 = createSetOperator2("union", true);
    intersect2 = createSetOperator2("intersect", false);
    intersectAll2 = createSetOperator2("intersect", true);
    except2 = createSetOperator2("except", false);
    exceptAll2 = createSetOperator2("except", true);
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/query-builder.js
var _a248, QueryBuilder2;
var init_query_builder3 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/query-builder.js"() {
    "use strict";
    init_entity();
    init_dialect2();
    init_selection_proxy();
    init_subquery();
    init_select3();
    _a248 = entityKind;
    QueryBuilder2 = class {
      constructor(dialect6) {
        __publicField(this, "dialect");
        __publicField(this, "dialectConfig");
        __publicField(this, "$with", (alias2, selection) => {
          const queryBuilder = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(queryBuilder);
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        this.dialect = is(dialect6, PgDialect) ? dialect6 : void 0;
        this.dialectConfig = is(dialect6, PgDialect) ? void 0 : dialect6;
      }
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new PgSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new PgSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            distinct: true
          });
        }
        function selectDistinctOn(on3, fields) {
          return new PgSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            distinct: { on: on3 }
          });
        }
        return { select: select2, selectDistinct, selectDistinctOn };
      }
      select(fields) {
        return new PgSelectBuilder({
          fields: fields ?? void 0,
          session: void 0,
          dialect: this.getDialect()
        });
      }
      selectDistinct(fields) {
        return new PgSelectBuilder({
          fields: fields ?? void 0,
          session: void 0,
          dialect: this.getDialect(),
          distinct: true
        });
      }
      selectDistinctOn(on3, fields) {
        return new PgSelectBuilder({
          fields: fields ?? void 0,
          session: void 0,
          dialect: this.getDialect(),
          distinct: { on: on3 }
        });
      }
      // Lazy load dialect to avoid circular dependency
      getDialect() {
        if (!this.dialect) {
          this.dialect = new PgDialect(this.dialectConfig);
        }
        return this.dialect;
      }
    };
    __publicField(QueryBuilder2, _a248, "PgQueryBuilder");
  }
});

// ../drizzle-orm/dist/pg-core/view.js
function pgViewWithSchema(name3, selection, schema6) {
  if (selection) {
    return new ManualViewBuilder2(name3, selection, schema6);
  }
  return new ViewBuilder2(name3, schema6);
}
function pgMaterializedViewWithSchema(name3, selection, schema6) {
  if (selection) {
    return new ManualMaterializedViewBuilder(name3, selection, schema6);
  }
  return new MaterializedViewBuilder(name3, schema6);
}
function pgView(name3, columns) {
  return pgViewWithSchema(name3, columns, void 0);
}
function pgMaterializedView(name3, columns) {
  return pgMaterializedViewWithSchema(name3, columns, void 0);
}
function isPgView(obj) {
  return is(obj, PgView);
}
function isPgMaterializedView(obj) {
  return is(obj, PgMaterializedView);
}
var _a249, DefaultViewBuilderCore, _a250, _b188, ViewBuilder2, _a251, _b189, ManualViewBuilder2, _a252, MaterializedViewBuilderCore, _a253, _b190, MaterializedViewBuilder, _a254, _b191, ManualMaterializedViewBuilder, _a255, _b192, _c7, PgView, PgMaterializedViewConfig, _a256, _b193, _c8, PgMaterializedView;
var init_view2 = __esm({
  "../drizzle-orm/dist/pg-core/view.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_utils();
    init_query_builder3();
    init_table2();
    init_view_base2();
    init_view_common3();
    _a249 = entityKind;
    DefaultViewBuilderCore = class {
      constructor(name3, schema6) {
        __publicField(this, "config", {});
        this.name = name3;
        this.schema = schema6;
      }
      with(config) {
        this.config.with = config;
        return this;
      }
    };
    __publicField(DefaultViewBuilderCore, _a249, "PgDefaultViewBuilderCore");
    ViewBuilder2 = class extends (_b188 = DefaultViewBuilderCore, _a250 = entityKind, _b188) {
      as(qb) {
        if (typeof qb === "function") {
          qb = qb(new QueryBuilder2());
        }
        const selectionProxy = new SelectionProxyHandler({
          alias: this.name,
          sqlBehavior: "error",
          sqlAliasedBehavior: "alias",
          replaceOriginalName: true
        });
        const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
        return new Proxy(
          new PgView({
            pgConfig: this.config,
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: aliasedSelection,
              query: qb.getSQL().inlineParams()
            }
          }),
          selectionProxy
        );
      }
    };
    __publicField(ViewBuilder2, _a250, "PgViewBuilder");
    ManualViewBuilder2 = class extends (_b189 = DefaultViewBuilderCore, _a251 = entityKind, _b189) {
      constructor(name3, columns, schema6) {
        super(name3, schema6);
        __publicField(this, "columns");
        this.columns = getTableColumns(pgTable(name3, columns));
      }
      existing() {
        return new Proxy(
          new PgView({
            pgConfig: void 0,
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: this.columns,
              query: void 0
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
      as(query) {
        return new Proxy(
          new PgView({
            pgConfig: this.config,
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: this.columns,
              query: query.inlineParams()
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
    };
    __publicField(ManualViewBuilder2, _a251, "PgManualViewBuilder");
    _a252 = entityKind;
    MaterializedViewBuilderCore = class {
      constructor(name3, schema6) {
        __publicField(this, "config", {});
        this.name = name3;
        this.schema = schema6;
      }
      using(using) {
        this.config.using = using;
        return this;
      }
      with(config) {
        this.config.with = config;
        return this;
      }
      tablespace(tablespace) {
        this.config.tablespace = tablespace;
        return this;
      }
      withNoData() {
        this.config.withNoData = true;
        return this;
      }
    };
    __publicField(MaterializedViewBuilderCore, _a252, "PgMaterializedViewBuilderCore");
    MaterializedViewBuilder = class extends (_b190 = MaterializedViewBuilderCore, _a253 = entityKind, _b190) {
      as(qb) {
        if (typeof qb === "function") {
          qb = qb(new QueryBuilder2());
        }
        const selectionProxy = new SelectionProxyHandler({
          alias: this.name,
          sqlBehavior: "error",
          sqlAliasedBehavior: "alias",
          replaceOriginalName: true
        });
        const aliasedSelection = new Proxy(qb.getSelectedFields(), selectionProxy);
        return new Proxy(
          new PgMaterializedView({
            pgConfig: {
              with: this.config.with,
              using: this.config.using,
              tablespace: this.config.tablespace,
              withNoData: this.config.withNoData
            },
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: aliasedSelection,
              query: qb.getSQL().inlineParams()
            }
          }),
          selectionProxy
        );
      }
    };
    __publicField(MaterializedViewBuilder, _a253, "PgMaterializedViewBuilder");
    ManualMaterializedViewBuilder = class extends (_b191 = MaterializedViewBuilderCore, _a254 = entityKind, _b191) {
      constructor(name3, columns, schema6) {
        super(name3, schema6);
        __publicField(this, "columns");
        this.columns = getTableColumns(pgTable(name3, columns));
      }
      existing() {
        return new Proxy(
          new PgMaterializedView({
            pgConfig: {
              tablespace: this.config.tablespace,
              using: this.config.using,
              with: this.config.with,
              withNoData: this.config.withNoData
            },
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: this.columns,
              query: void 0
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
      as(query) {
        return new Proxy(
          new PgMaterializedView({
            pgConfig: {
              tablespace: this.config.tablespace,
              using: this.config.using,
              with: this.config.with,
              withNoData: this.config.withNoData
            },
            config: {
              name: this.name,
              schema: this.schema,
              selectedFields: this.columns,
              query: query.inlineParams()
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
    };
    __publicField(ManualMaterializedViewBuilder, _a254, "PgManualMaterializedViewBuilder");
    PgView = class extends (_c7 = PgViewBase, _b192 = entityKind, _a255 = PgViewConfig, _c7) {
      constructor({ pgConfig, config }) {
        super(config);
        __publicField(this, _a255);
        if (pgConfig) {
          this[PgViewConfig] = {
            with: pgConfig.with
          };
        }
      }
    };
    __publicField(PgView, _b192, "PgView");
    PgMaterializedViewConfig = Symbol.for("drizzle:PgMaterializedViewConfig");
    PgMaterializedView = class extends (_c8 = PgViewBase, _b193 = entityKind, _a256 = PgMaterializedViewConfig, _c8) {
      constructor({ pgConfig, config }) {
        super(config);
        __publicField(this, _a256);
        this[PgMaterializedViewConfig] = {
          with: pgConfig?.with,
          using: pgConfig?.using,
          tablespace: pgConfig?.tablespace,
          withNoData: pgConfig?.withNoData
        };
      }
    };
    __publicField(PgMaterializedView, _b193, "PgMaterializedView");
  }
});

// ../drizzle-orm/dist/pg-core/utils.js
function getTableConfig2(table6) {
  const columns = Object.values(table6[Table.Symbol.Columns]);
  const indexes = [];
  const checks = [];
  const primaryKeys = [];
  const foreignKeys = Object.values(table6[PgTable.Symbol.InlineForeignKeys]);
  const uniqueConstraints = [];
  const name3 = table6[Table.Symbol.Name];
  const schema6 = table6[Table.Symbol.Schema];
  const policies = [];
  const enableRLS = table6[PgTable.Symbol.EnableRLS];
  const extraConfigBuilder = table6[PgTable.Symbol.ExtraConfigBuilder];
  if (extraConfigBuilder !== void 0) {
    const extraConfig = extraConfigBuilder(table6[Table.Symbol.ExtraConfigColumns]);
    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);
    for (const builder of extraValues) {
      if (is(builder, IndexBuilder2)) {
        indexes.push(builder.build(table6));
      } else if (is(builder, CheckBuilder2)) {
        checks.push(builder.build(table6));
      } else if (is(builder, UniqueConstraintBuilder)) {
        uniqueConstraints.push(builder.build(table6));
      } else if (is(builder, PrimaryKeyBuilder)) {
        primaryKeys.push(builder.build(table6));
      } else if (is(builder, ForeignKeyBuilder)) {
        foreignKeys.push(builder.build(table6));
      } else if (is(builder, PgPolicy)) {
        policies.push(builder);
      }
    }
  }
  return {
    columns,
    indexes,
    foreignKeys,
    checks,
    primaryKeys,
    uniqueConstraints,
    name: name3,
    schema: schema6,
    policies,
    enableRLS
  };
}
function extractUsedTable2(table6) {
  if (is(table6, PgTable)) {
    return [table6[Schema] ? `${table6[Schema]}.${table6[Table.Symbol.BaseName]}` : table6[Table.Symbol.BaseName]];
  }
  if (is(table6, Subquery)) {
    return table6._.usedTables ?? [];
  }
  if (is(table6, SQL)) {
    return table6.usedTables ?? [];
  }
  return [];
}
function getViewConfig2(view5) {
  return {
    ...view5[ViewBaseConfig],
    ...view5[PgViewConfig]
  };
}
function getMaterializedViewConfig(view5) {
  return {
    ...view5[ViewBaseConfig],
    ...view5[PgMaterializedViewConfig]
  };
}
var init_utils4 = __esm({
  "../drizzle-orm/dist/pg-core/utils.js"() {
    "use strict";
    init_entity();
    init_table2();
    init_sql();
    init_subquery();
    init_table();
    init_view_common();
    init_checks2();
    init_foreign_keys();
    init_indexes2();
    init_policies();
    init_primary_keys();
    init_unique_constraint();
    init_view_common3();
    init_view2();
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/delete.js
var _a257, _b194, PgDeleteBase;
var init_delete2 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/delete.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_table();
    init_tracing();
    init_utils();
    init_utils4();
    PgDeleteBase = class extends (_b194 = QueryPromise, _a257 = entityKind, _b194) {
      constructor(table6, session, dialect6, withList) {
        super();
        __publicField(this, "config");
        __publicField(this, "cacheConfig");
        __publicField(this, "authToken");
        __publicField(this, "execute", (placeholderValues) => {
          return tracer.startActiveSpan("drizzle.operation", () => {
            return this._prepare().execute(placeholderValues, this.authToken);
          });
        });
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, withList };
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will delete only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be deleted.
       *
       * ```ts
       * // Delete all cars with green color
       * await db.delete(cars).where(eq(cars.color, 'green'));
       * // or
       * await db.delete(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Delete all BMW cars with a green color
       * await db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Delete all cars with the green or blue color
       * await db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      returning(fields = this.config.table[Table.Symbol.Columns]) {
        this.config.returningFields = fields;
        this.config.returning = orderSelectedFields(fields);
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildDeleteQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      /** @internal */
      _prepare(name3) {
        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name3, true, void 0, {
            type: "delete",
            tables: extractUsedTable2(this.config.table)
          }, this.cacheConfig);
        });
      }
      prepare(name3) {
        return this._prepare(name3);
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
      /** @internal */
      getSelectedFields() {
        return this.config.returningFields ? new Proxy(
          this.config.returningFields,
          new SelectionProxyHandler({
            alias: getTableName(this.config.table),
            sqlAliasedBehavior: "alias",
            sqlBehavior: "error"
          })
        ) : void 0;
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(PgDeleteBase, _a257, "PgDelete");
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/insert.js
var _a258, PgInsertBuilder, _a259, _b195, PgInsertBase;
var init_insert2 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/insert.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_sql();
    init_table();
    init_tracing();
    init_utils();
    init_utils4();
    init_query_builder3();
    _a258 = entityKind;
    PgInsertBuilder = class {
      constructor(table6, session, dialect6, withList, overridingSystemValue_) {
        __publicField(this, "authToken");
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.withList = withList;
        this.overridingSystemValue_ = overridingSystemValue_;
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
      overridingSystemValue() {
        this.overridingSystemValue_ = true;
        return this;
      }
      values(values2) {
        values2 = Array.isArray(values2) ? values2 : [values2];
        if (values2.length === 0) {
          throw new Error("values() must be called with at least one value");
        }
        const mappedValues = values2.map((entry) => {
          const result = {};
          const cols = this.table[Table.Symbol.Columns];
          for (const colKey of Object.keys(entry)) {
            const colValue = entry[colKey];
            result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
          }
          return result;
        });
        return new PgInsertBase(
          this.table,
          mappedValues,
          this.session,
          this.dialect,
          this.withList,
          false,
          this.overridingSystemValue_
        ).setToken(this.authToken);
      }
      select(selectQuery) {
        const select2 = typeof selectQuery === "function" ? selectQuery(new QueryBuilder2()) : selectQuery;
        if (!is(select2, SQL) && !haveSameKeys(this.table[Columns], select2._.selectedFields)) {
          throw new Error(
            "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
          );
        }
        return new PgInsertBase(this.table, select2, this.session, this.dialect, this.withList, true);
      }
    };
    __publicField(PgInsertBuilder, _a258, "PgInsertBuilder");
    PgInsertBase = class extends (_b195 = QueryPromise, _a259 = entityKind, _b195) {
      constructor(table6, values2, session, dialect6, withList, select2, overridingSystemValue_) {
        super();
        __publicField(this, "config");
        __publicField(this, "cacheConfig");
        __publicField(this, "authToken");
        __publicField(this, "execute", (placeholderValues) => {
          return tracer.startActiveSpan("drizzle.operation", () => {
            return this._prepare().execute(placeholderValues, this.authToken);
          });
        });
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, values: values2, withList, select: select2, overridingSystemValue_ };
      }
      returning(fields = this.config.table[Table.Symbol.Columns]) {
        this.config.returningFields = fields;
        this.config.returning = orderSelectedFields(fields);
        return this;
      }
      /**
       * Adds an `on conflict do nothing` clause to the query.
       *
       * Calling this method simply avoids inserting a row as its alternative action.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
       *
       * @param config The `target` and `where` clauses.
       *
       * @example
       * ```ts
       * // Insert one row and cancel the insert if there's a conflict
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoNothing();
       *
       * // Explicitly specify conflict target
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoNothing({ target: cars.id });
       * ```
       */
      onConflictDoNothing(config = {}) {
        if (config.target === void 0) {
          this.config.onConflict = sql`do nothing`;
        } else {
          let targetColumn = "";
          targetColumn = Array.isArray(config.target) ? config.target.map((it2) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it2))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
          const whereSql = config.where ? sql` where ${config.where}` : void 0;
          this.config.onConflict = sql`(${sql.raw(targetColumn)})${whereSql} do nothing`;
        }
        return this;
      }
      /**
       * Adds an `on conflict do update` clause to the query.
       *
       * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
       *
       * @param config The `target`, `set` and `where` clauses.
       *
       * @example
       * ```ts
       * // Update the row if there's a conflict
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoUpdate({
       *     target: cars.id,
       *     set: { brand: 'Porsche' }
       *   });
       *
       * // Upsert with 'where' clause
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoUpdate({
       *     target: cars.id,
       *     set: { brand: 'newBMW' },
       *     targetWhere: sql`${cars.createdAt} > '2023-01-01'::date`,
       *   });
       * ```
       */
      onConflictDoUpdate(config) {
        if (config.where && (config.targetWhere || config.setWhere)) {
          throw new Error(
            'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
          );
        }
        const whereSql = config.where ? sql` where ${config.where}` : void 0;
        const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
        const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
        const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
        let targetColumn = "";
        targetColumn = Array.isArray(config.target) ? config.target.map((it2) => this.dialect.escapeName(this.dialect.casing.getColumnCasing(it2))).join(",") : this.dialect.escapeName(this.dialect.casing.getColumnCasing(config.target));
        this.config.onConflict = sql`(${sql.raw(targetColumn)})${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`;
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildInsertQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      /** @internal */
      _prepare(name3) {
        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name3, true, void 0, {
            type: "insert",
            tables: extractUsedTable2(this.config.table)
          }, this.cacheConfig);
        });
      }
      prepare(name3) {
        return this._prepare(name3);
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
      /** @internal */
      getSelectedFields() {
        return this.config.returningFields ? new Proxy(
          this.config.returningFields,
          new SelectionProxyHandler({
            alias: getTableName(this.config.table),
            sqlAliasedBehavior: "alias",
            sqlBehavior: "error"
          })
        ) : void 0;
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(PgInsertBase, _a259, "PgInsert");
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js
var _a260, _b196, PgRefreshMaterializedView;
var init_refresh_materialized_view = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/refresh-materialized-view.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_tracing();
    PgRefreshMaterializedView = class extends (_b196 = QueryPromise, _a260 = entityKind, _b196) {
      constructor(view5, session, dialect6) {
        super();
        __publicField(this, "config");
        __publicField(this, "authToken");
        __publicField(this, "execute", (placeholderValues) => {
          return tracer.startActiveSpan("drizzle.operation", () => {
            return this._prepare().execute(placeholderValues, this.authToken);
          });
        });
        this.session = session;
        this.dialect = dialect6;
        this.config = { view: view5 };
      }
      concurrently() {
        if (this.config.withNoData !== void 0) {
          throw new Error("Cannot use concurrently and withNoData together");
        }
        this.config.concurrently = true;
        return this;
      }
      withNoData() {
        if (this.config.concurrently !== void 0) {
          throw new Error("Cannot use concurrently and withNoData together");
        }
        this.config.withNoData = true;
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildRefreshMaterializedViewQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      /** @internal */
      _prepare(name3) {
        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
          return this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), void 0, name3, true);
        });
      }
      prepare(name3) {
        return this._prepare(name3);
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
    };
    __publicField(PgRefreshMaterializedView, _a260, "PgRefreshMaterializedView");
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/select.types.js
var init_select_types2 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/select.types.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/update.js
var _a261, PgUpdateBuilder, _a262, _b197, PgUpdateBase;
var init_update2 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/update.js"() {
    "use strict";
    init_entity();
    init_table2();
    init_query_promise();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_utils4();
    _a261 = entityKind;
    PgUpdateBuilder = class {
      constructor(table6, session, dialect6, withList) {
        __publicField(this, "authToken");
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.withList = withList;
      }
      setToken(token) {
        this.authToken = token;
        return this;
      }
      set(values2) {
        return new PgUpdateBase(
          this.table,
          mapUpdateSet(this.table, values2),
          this.session,
          this.dialect,
          this.withList
        ).setToken(this.authToken);
      }
    };
    __publicField(PgUpdateBuilder, _a261, "PgUpdateBuilder");
    PgUpdateBase = class extends (_b197 = QueryPromise, _a262 = entityKind, _b197) {
      constructor(table6, set, session, dialect6, withList) {
        super();
        __publicField(this, "config");
        __publicField(this, "tableName");
        __publicField(this, "joinsNotNullableMap");
        __publicField(this, "cacheConfig");
        __publicField(this, "leftJoin", this.createJoin("left"));
        __publicField(this, "rightJoin", this.createJoin("right"));
        __publicField(this, "innerJoin", this.createJoin("inner"));
        __publicField(this, "fullJoin", this.createJoin("full"));
        __publicField(this, "authToken");
        __publicField(this, "execute", (placeholderValues) => {
          return this._prepare().execute(placeholderValues, this.authToken);
        });
        this.session = session;
        this.dialect = dialect6;
        this.config = { set, table: table6, withList, joins: [] };
        this.tableName = getTableLikeName(table6);
        this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
      }
      from(source) {
        const src = source;
        const tableName = getTableLikeName(src);
        if (typeof tableName === "string") {
          this.joinsNotNullableMap[tableName] = true;
        }
        this.config.from = src;
        return this;
      }
      getTableLikeFields(table6) {
        if (is(table6, PgTable)) {
          return table6[Table.Symbol.Columns];
        } else if (is(table6, Subquery)) {
          return table6._.selectedFields;
        }
        return table6[ViewBaseConfig].selectedFields;
      }
      createJoin(joinType) {
        return (table6, on3) => {
          const tableName = getTableLikeName(table6);
          if (typeof tableName === "string" && this.config.joins.some((join7) => join7.alias === tableName)) {
            throw new Error(`Alias "${tableName}" is already used in this query`);
          }
          if (typeof on3 === "function") {
            const from = this.config.from && !is(this.config.from, SQL) ? this.getTableLikeFields(this.config.from) : void 0;
            on3 = on3(
              new Proxy(
                this.config.table[Table.Symbol.Columns],
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              ),
              from && new Proxy(
                from,
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              )
            );
          }
          this.config.joins.push({ on: on3, table: table6, joinType, alias: tableName });
          if (typeof tableName === "string") {
            switch (joinType) {
              case "left": {
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
              case "right": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "inner": {
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "full": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
            }
          }
          return this;
        };
      }
      /**
       * Adds a 'where' clause to the query.
       *
       * Calling this method will update only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param where the 'where' clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be updated.
       *
       * ```ts
       * // Update all cars with green color
       * await db.update(cars).set({ color: 'red' })
       *   .where(eq(cars.color, 'green'));
       * // or
       * await db.update(cars).set({ color: 'red' })
       *   .where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Update all BMW cars with a green color
       * await db.update(cars).set({ color: 'red' })
       *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Update all cars with the green or blue color
       * await db.update(cars).set({ color: 'red' })
       *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      returning(fields) {
        if (!fields) {
          fields = Object.assign({}, this.config.table[Table.Symbol.Columns]);
          if (this.config.from) {
            const tableName = getTableLikeName(this.config.from);
            if (typeof tableName === "string" && this.config.from && !is(this.config.from, SQL)) {
              const fromFields = this.getTableLikeFields(this.config.from);
              fields[tableName] = fromFields;
            }
            for (const join7 of this.config.joins) {
              const tableName2 = getTableLikeName(join7.table);
              if (typeof tableName2 === "string" && !is(join7.table, SQL)) {
                const fromFields = this.getTableLikeFields(join7.table);
                fields[tableName2] = fromFields;
              }
            }
          }
        }
        this.config.returningFields = fields;
        this.config.returning = orderSelectedFields(fields);
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildUpdateQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      /** @internal */
      _prepare(name3) {
        const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), this.config.returning, name3, true, void 0, {
          type: "insert",
          tables: extractUsedTable2(this.config.table)
        }, this.cacheConfig);
        query.joinsNotNullableMap = this.joinsNotNullableMap;
        return query;
      }
      prepare(name3) {
        return this._prepare(name3);
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
      /** @internal */
      getSelectedFields() {
        return this.config.returningFields ? new Proxy(
          this.config.returningFields,
          new SelectionProxyHandler({
            alias: getTableName(this.config.table),
            sqlAliasedBehavior: "alias",
            sqlBehavior: "error"
          })
        ) : void 0;
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(PgUpdateBase, _a262, "PgUpdate");
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/index.js
var init_query_builders2 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/index.js"() {
    "use strict";
    init_delete2();
    init_insert2();
    init_query_builder3();
    init_refresh_materialized_view();
    init_select3();
    init_select_types2();
    init_update2();
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/count.js
var _a263, _b198, _c9, _PgCountBuilder, PgCountBuilder;
var init_count2 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/count.js"() {
    "use strict";
    init_entity();
    init_sql();
    _PgCountBuilder = class _PgCountBuilder extends (_c9 = SQL, _b198 = entityKind, _a263 = Symbol.toStringTag, _c9) {
      constructor(params) {
        super(_PgCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
        __publicField(this, "sql");
        __publicField(this, "token");
        __publicField(this, _a263, "PgCountBuilder");
        __publicField(this, "session");
        this.params = params;
        this.mapWith(Number);
        this.session = params.session;
        this.sql = _PgCountBuilder.buildCount(
          params.source,
          params.filters
        );
      }
      static buildEmbeddedCount(source, filters) {
        return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
      }
      static buildCount(source, filters) {
        return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters};`;
      }
      /** @intrnal */
      setToken(token) {
        this.token = token;
        return this;
      }
      then(onfulfilled, onrejected) {
        return Promise.resolve(this.session.count(this.sql, this.token)).then(
          onfulfilled,
          onrejected
        );
      }
      catch(onRejected) {
        return this.then(void 0, onRejected);
      }
      finally(onFinally) {
        return this.then(
          (value) => {
            onFinally?.();
            return value;
          },
          (reason) => {
            onFinally?.();
            throw reason;
          }
        );
      }
    };
    __publicField(_PgCountBuilder, _b198, "PgCountBuilder");
    PgCountBuilder = _PgCountBuilder;
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/query.js
var _a264, RelationalQueryBuilder2, _a265, _b199, PgRelationalQuery;
var init_query2 = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/query.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_relations();
    init_tracing();
    _a264 = entityKind;
    RelationalQueryBuilder2 = class {
      constructor(fullSchema, schema6, tableNamesMap, table6, tableConfig, dialect6, session) {
        this.fullSchema = fullSchema;
        this.schema = schema6;
        this.tableNamesMap = tableNamesMap;
        this.table = table6;
        this.tableConfig = tableConfig;
        this.dialect = dialect6;
        this.session = session;
      }
      findMany(config) {
        return new PgRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? config : {},
          "many"
        );
      }
      findFirst(config) {
        return new PgRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? { ...config, limit: 1 } : { limit: 1 },
          "first"
        );
      }
    };
    __publicField(RelationalQueryBuilder2, _a264, "PgRelationalQueryBuilder");
    PgRelationalQuery = class extends (_b199 = QueryPromise, _a265 = entityKind, _b199) {
      constructor(fullSchema, schema6, tableNamesMap, table6, tableConfig, dialect6, session, config, mode) {
        super();
        __publicField(this, "authToken");
        this.fullSchema = fullSchema;
        this.schema = schema6;
        this.tableNamesMap = tableNamesMap;
        this.table = table6;
        this.tableConfig = tableConfig;
        this.dialect = dialect6;
        this.session = session;
        this.config = config;
        this.mode = mode;
      }
      /** @internal */
      _prepare(name3) {
        return tracer.startActiveSpan("drizzle.prepareQuery", () => {
          const { query, builtQuery } = this._toSQL();
          return this.session.prepareQuery(
            builtQuery,
            void 0,
            name3,
            true,
            (rawRows, mapColumnValue) => {
              const rows = rawRows.map(
                (row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
              );
              if (this.mode === "first") {
                return rows[0];
              }
              return rows;
            }
          );
        });
      }
      prepare(name3) {
        return this._prepare(name3);
      }
      _getQuery() {
        return this.dialect.buildRelationalQueryWithoutPK({
          fullSchema: this.fullSchema,
          schema: this.schema,
          tableNamesMap: this.tableNamesMap,
          table: this.table,
          tableConfig: this.tableConfig,
          queryConfig: this.config,
          tableAlias: this.tableConfig.tsName
        });
      }
      /** @internal */
      getSQL() {
        return this._getQuery().sql;
      }
      _toSQL() {
        const query = this._getQuery();
        const builtQuery = this.dialect.sqlToQuery(query.sql);
        return { query, builtQuery };
      }
      toSQL() {
        return this._toSQL().builtQuery;
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
      execute() {
        return tracer.startActiveSpan("drizzle.operation", () => {
          return this._prepare().execute(void 0, this.authToken);
        });
      }
    };
    __publicField(PgRelationalQuery, _a265, "PgRelationalQuery");
  }
});

// ../drizzle-orm/dist/pg-core/query-builders/raw.js
var _a266, _b200, PgRaw;
var init_raw = __esm({
  "../drizzle-orm/dist/pg-core/query-builders/raw.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    PgRaw = class extends (_b200 = QueryPromise, _a266 = entityKind, _b200) {
      constructor(execute, sql3, query, mapBatchResult) {
        super();
        this.execute = execute;
        this.sql = sql3;
        this.query = query;
        this.mapBatchResult = mapBatchResult;
      }
      /** @internal */
      getSQL() {
        return this.sql;
      }
      getQuery() {
        return this.query;
      }
      mapResult(result, isFromBatch) {
        return isFromBatch ? this.mapBatchResult(result) : result;
      }
      _prepare() {
        return this;
      }
      /** @internal */
      isResponseInArrayMode() {
        return false;
      }
    };
    __publicField(PgRaw, _a266, "PgRaw");
  }
});

// ../drizzle-orm/dist/pg-core/db.js
var _a267, PgDatabase, withReplicas;
var init_db2 = __esm({
  "../drizzle-orm/dist/pg-core/db.js"() {
    "use strict";
    init_entity();
    init_query_builders2();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_count2();
    init_query2();
    init_raw();
    init_refresh_materialized_view();
    _a267 = entityKind;
    PgDatabase = class {
      constructor(dialect6, session, schema6) {
        __publicField(this, "query");
        /**
         * Creates a subquery that defines a temporary named result set as a CTE.
         *
         * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
         *
         * @param alias The alias for the subquery.
         *
         * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
         *
         * @example
         *
         * ```ts
         * // Create a subquery with alias 'sq' and use it in the select query
         * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
         *
         * const result = await db.with(sq).select().from(sq);
         * ```
         *
         * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
         *
         * ```ts
         * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
         * const sq = db.$with('sq').as(db.select({
         *   name: sql<string>`upper(${users.name})`.as('name'),
         * })
         * .from(users));
         *
         * const result = await db.with(sq).select({ name: sq.name }).from(sq);
         * ```
         */
        __publicField(this, "$with", (alias2, selection) => {
          const self2 = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(new QueryBuilder2(self2.dialect));
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        __publicField(this, "$cache");
        __publicField(this, "authToken");
        this.dialect = dialect6;
        this.session = session;
        this._ = schema6 ? {
          schema: schema6.schema,
          fullSchema: schema6.fullSchema,
          tableNamesMap: schema6.tableNamesMap,
          session
        } : {
          schema: void 0,
          fullSchema: {},
          tableNamesMap: {},
          session
        };
        this.query = {};
        if (this._.schema) {
          for (const [tableName, columns] of Object.entries(this._.schema)) {
            this.query[tableName] = new RelationalQueryBuilder2(
              schema6.fullSchema,
              this._.schema,
              this._.tableNamesMap,
              schema6.fullSchema[tableName],
              columns,
              dialect6,
              session
            );
          }
        }
        this.$cache = { invalidate: async (_params2) => {
        } };
      }
      $count(source, filters) {
        return new PgCountBuilder({ source, filters, session: this.session });
      }
      /**
       * Incorporates a previously defined CTE (using `$with`) into the main query.
       *
       * This method allows the main query to reference a temporary named result set.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
       *
       * @param queries The CTEs to incorporate into the main query.
       *
       * @example
       *
       * ```ts
       * // Define a subquery 'sq' as a CTE using $with
       * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
       *
       * // Incorporate the CTE 'sq' into the main query and select from it
       * const result = await db.with(sq).select().from(sq);
       * ```
       */
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new PgSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new PgSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries,
            distinct: true
          });
        }
        function selectDistinctOn(on3, fields) {
          return new PgSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries,
            distinct: { on: on3 }
          });
        }
        function update(table6) {
          return new PgUpdateBuilder(table6, self2.session, self2.dialect, queries);
        }
        function insert(table6) {
          return new PgInsertBuilder(table6, self2.session, self2.dialect, queries);
        }
        function delete_(table6) {
          return new PgDeleteBase(table6, self2.session, self2.dialect, queries);
        }
        return { select: select2, selectDistinct, selectDistinctOn, update, insert, delete: delete_ };
      }
      select(fields) {
        return new PgSelectBuilder({
          fields: fields ?? void 0,
          session: this.session,
          dialect: this.dialect
        });
      }
      selectDistinct(fields) {
        return new PgSelectBuilder({
          fields: fields ?? void 0,
          session: this.session,
          dialect: this.dialect,
          distinct: true
        });
      }
      selectDistinctOn(on3, fields) {
        return new PgSelectBuilder({
          fields: fields ?? void 0,
          session: this.session,
          dialect: this.dialect,
          distinct: { on: on3 }
        });
      }
      /**
       * Creates an update query.
       *
       * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
       *
       * Use `.set()` method to specify which values to update.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param table The table to update.
       *
       * @example
       *
       * ```ts
       * // Update all rows in the 'cars' table
       * await db.update(cars).set({ color: 'red' });
       *
       * // Update rows with filters and conditions
       * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
       *
       * // Update with returning clause
       * const updatedCar: Car[] = await db.update(cars)
       *   .set({ color: 'red' })
       *   .where(eq(cars.id, 1))
       *   .returning();
       * ```
       */
      update(table6) {
        return new PgUpdateBuilder(table6, this.session, this.dialect);
      }
      /**
       * Creates an insert query.
       *
       * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert}
       *
       * @param table The table to insert into.
       *
       * @example
       *
       * ```ts
       * // Insert one row
       * await db.insert(cars).values({ brand: 'BMW' });
       *
       * // Insert multiple rows
       * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
       *
       * // Insert with returning clause
       * const insertedCar: Car[] = await db.insert(cars)
       *   .values({ brand: 'BMW' })
       *   .returning();
       * ```
       */
      insert(table6) {
        return new PgInsertBuilder(table6, this.session, this.dialect);
      }
      /**
       * Creates a delete query.
       *
       * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param table The table to delete from.
       *
       * @example
       *
       * ```ts
       * // Delete all rows in the 'cars' table
       * await db.delete(cars);
       *
       * // Delete rows with filters and conditions
       * await db.delete(cars).where(eq(cars.color, 'green'));
       *
       * // Delete with returning clause
       * const deletedCar: Car[] = await db.delete(cars)
       *   .where(eq(cars.id, 1))
       *   .returning();
       * ```
       */
      delete(table6) {
        return new PgDeleteBase(table6, this.session, this.dialect);
      }
      refreshMaterializedView(view5) {
        return new PgRefreshMaterializedView(view5, this.session, this.dialect);
      }
      execute(query) {
        const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
        const builtQuery = this.dialect.sqlToQuery(sequel);
        const prepared = this.session.prepareQuery(
          builtQuery,
          void 0,
          void 0,
          false
        );
        return new PgRaw(
          () => prepared.execute(void 0, this.authToken),
          sequel,
          builtQuery,
          (result) => prepared.mapResult(result, true)
        );
      }
      transaction(transaction, config) {
        return this.session.transaction(transaction, config);
      }
    };
    __publicField(PgDatabase, _a267, "PgDatabase");
    withReplicas = (primary, replicas, getReplica = () => replicas[Math.floor(Math.random() * replicas.length)]) => {
      const select2 = (...args2) => getReplica(replicas).select(...args2);
      const selectDistinct = (...args2) => getReplica(replicas).selectDistinct(...args2);
      const selectDistinctOn = (...args2) => getReplica(replicas).selectDistinctOn(...args2);
      const $count = (...args2) => getReplica(replicas).$count(...args2);
      const _with = (...args2) => getReplica(replicas).with(...args2);
      const $with = (arg) => getReplica(replicas).$with(arg);
      const update = (...args2) => primary.update(...args2);
      const insert = (...args2) => primary.insert(...args2);
      const $delete = (...args2) => primary.delete(...args2);
      const execute = (...args2) => primary.execute(...args2);
      const transaction = (...args2) => primary.transaction(...args2);
      const refreshMaterializedView = (...args2) => primary.refreshMaterializedView(...args2);
      return {
        ...primary,
        update,
        insert,
        delete: $delete,
        execute,
        transaction,
        refreshMaterializedView,
        $primary: primary,
        $replicas: replicas,
        select: select2,
        selectDistinct,
        selectDistinctOn,
        $count,
        $with,
        with: _with,
        get query() {
          return getReplica(replicas).query;
        }
      };
    };
  }
});

// ../drizzle-orm/dist/pg-core/roles.js
function pgRole(name3, config) {
  return new PgRole(name3, config);
}
var _a268, PgRole;
var init_roles = __esm({
  "../drizzle-orm/dist/pg-core/roles.js"() {
    "use strict";
    init_entity();
    _a268 = entityKind;
    PgRole = class {
      constructor(name3, config) {
        /** @internal */
        __publicField(this, "_existing");
        /** @internal */
        __publicField(this, "createDb");
        /** @internal */
        __publicField(this, "createRole");
        /** @internal */
        __publicField(this, "inherit");
        this.name = name3;
        if (config) {
          this.createDb = config.createDb;
          this.createRole = config.createRole;
          this.inherit = config.inherit;
        }
      }
      existing() {
        this._existing = true;
        return this;
      }
    };
    __publicField(PgRole, _a268, "PgRole");
  }
});

// ../drizzle-orm/dist/pg-core/sequence.js
function pgSequence(name3, options) {
  return pgSequenceWithSchema(name3, options, void 0);
}
function pgSequenceWithSchema(name3, options, schema6) {
  return new PgSequence(name3, options, schema6);
}
function isPgSequence(obj) {
  return is(obj, PgSequence);
}
var _a269, PgSequence;
var init_sequence = __esm({
  "../drizzle-orm/dist/pg-core/sequence.js"() {
    "use strict";
    init_entity();
    _a269 = entityKind;
    PgSequence = class {
      constructor(seqName, seqOptions, schema6) {
        this.seqName = seqName;
        this.seqOptions = seqOptions;
        this.schema = schema6;
      }
    };
    __publicField(PgSequence, _a269, "PgSequence");
  }
});

// ../drizzle-orm/dist/pg-core/schema.js
function isPgSchema(obj) {
  return is(obj, PgSchema);
}
function pgSchema(name3) {
  if (name3 === "public") {
    throw new Error(
      `You can't specify 'public' as schema name. Postgres is using public schema by default. If you want to use 'public' schema, just use pgTable() instead of creating a schema`
    );
  }
  return new PgSchema(name3);
}
var _a270, PgSchema;
var init_schema2 = __esm({
  "../drizzle-orm/dist/pg-core/schema.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_enum();
    init_sequence();
    init_table2();
    init_view2();
    _a270 = entityKind;
    PgSchema = class {
      constructor(schemaName) {
        __publicField(this, "table", (name3, columns, extraConfig) => {
          return pgTableWithSchema(name3, columns, extraConfig, this.schemaName);
        });
        __publicField(this, "view", (name3, columns) => {
          return pgViewWithSchema(name3, columns, this.schemaName);
        });
        __publicField(this, "materializedView", (name3, columns) => {
          return pgMaterializedViewWithSchema(name3, columns, this.schemaName);
        });
        __publicField(this, "sequence", (name3, options) => {
          return pgSequenceWithSchema(name3, options, this.schemaName);
        });
        this.schemaName = schemaName;
      }
      enum(enumName, input) {
        return Array.isArray(input) ? pgEnumWithSchema(
          enumName,
          [...input],
          this.schemaName
        ) : pgEnumObjectWithSchema(enumName, input, this.schemaName);
      }
      getSQL() {
        return new SQL([sql.identifier(this.schemaName)]);
      }
      shouldOmitSQLParens() {
        return true;
      }
    };
    __publicField(PgSchema, _a270, "PgSchema");
  }
});

// ../drizzle-orm/dist/pg-core/session.js
var _a271, PgPreparedQuery, _a272, PgSession, _a273, _b201, PgTransaction;
var init_session2 = __esm({
  "../drizzle-orm/dist/pg-core/session.js"() {
    "use strict";
    init_cache();
    init_entity();
    init_errors();
    init_sql2();
    init_tracing();
    init_db2();
    _a271 = entityKind;
    PgPreparedQuery = class {
      constructor(query, cache5, queryMetadata, cacheConfig) {
        __publicField(this, "authToken");
        /** @internal */
        __publicField(this, "joinsNotNullableMap");
        this.query = query;
        this.cache = cache5;
        this.queryMetadata = queryMetadata;
        this.cacheConfig = cacheConfig;
        if (cache5 && cache5.strategy() === "all" && cacheConfig === void 0) {
          this.cacheConfig = { enable: true, autoInvalidate: true };
        }
        if (!this.cacheConfig?.enable) {
          this.cacheConfig = void 0;
        }
      }
      getQuery() {
        return this.query;
      }
      mapResult(response, _isFromBatch) {
        return response;
      }
      /** @internal */
      setToken(token) {
        this.authToken = token;
        return this;
      }
      /** @internal */
      async queryWithCache(queryString, params, query) {
        if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.cacheConfig && !this.cacheConfig.enable) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) {
          try {
            const [res] = await Promise.all([
              query(),
              this.cache.onMutate({ tables: this.queryMetadata.tables })
            ]);
            return res;
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (!this.cacheConfig) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.queryMetadata.type === "select") {
          const fromCache = await this.cache.get(
            this.cacheConfig.tag ?? await hashQuery(queryString, params),
            this.queryMetadata.tables,
            this.cacheConfig.tag !== void 0,
            this.cacheConfig.autoInvalidate
          );
          if (fromCache === void 0) {
            let result;
            try {
              result = await query();
            } catch (e6) {
              throw new DrizzleQueryError(queryString, params, e6);
            }
            await this.cache.put(
              this.cacheConfig.tag ?? await hashQuery(queryString, params),
              result,
              // make sure we send tables that were used in a query only if user wants to invalidate it on each write
              this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
              this.cacheConfig.tag !== void 0,
              this.cacheConfig.config
            );
            return result;
          }
          return fromCache;
        }
        try {
          return await query();
        } catch (e6) {
          throw new DrizzleQueryError(queryString, params, e6);
        }
      }
    };
    __publicField(PgPreparedQuery, _a271, "PgPreparedQuery");
    _a272 = entityKind;
    PgSession = class {
      constructor(dialect6) {
        this.dialect = dialect6;
      }
      /** @internal */
      execute(query, token) {
        return tracer.startActiveSpan("drizzle.operation", () => {
          const prepared = tracer.startActiveSpan("drizzle.prepareQuery", () => {
            return this.prepareQuery(
              this.dialect.sqlToQuery(query),
              void 0,
              void 0,
              false
            );
          });
          return prepared.setToken(token).execute(void 0, token);
        });
      }
      all(query) {
        return this.prepareQuery(
          this.dialect.sqlToQuery(query),
          void 0,
          void 0,
          false
        ).all();
      }
      /** @internal */
      async count(sql22, token) {
        const res = await this.execute(sql22, token);
        return Number(
          res[0]["count"]
        );
      }
    };
    __publicField(PgSession, _a272, "PgSession");
    PgTransaction = class extends (_b201 = PgDatabase, _a273 = entityKind, _b201) {
      constructor(dialect6, session, schema6, nestedIndex = 0) {
        super(dialect6, session, schema6);
        this.schema = schema6;
        this.nestedIndex = nestedIndex;
      }
      rollback() {
        throw new TransactionRollbackError();
      }
      /** @internal */
      getTransactionConfigSQL(config) {
        const chunks = [];
        if (config.isolationLevel) {
          chunks.push(`isolation level ${config.isolationLevel}`);
        }
        if (config.accessMode) {
          chunks.push(config.accessMode);
        }
        if (typeof config.deferrable === "boolean") {
          chunks.push(config.deferrable ? "deferrable" : "not deferrable");
        }
        return sql.raw(chunks.join(" "));
      }
      setTransaction(config) {
        return this.session.execute(sql`set transaction ${this.getTransactionConfigSQL(config)}`);
      }
    };
    __publicField(PgTransaction, _a273, "PgTransaction");
  }
});

// ../drizzle-orm/dist/pg-core/subquery.js
var init_subquery3 = __esm({
  "../drizzle-orm/dist/pg-core/subquery.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/pg-core/utils/index.js
var init_utils5 = __esm({
  "../drizzle-orm/dist/pg-core/utils/index.js"() {
    "use strict";
    init_array();
  }
});

// ../drizzle-orm/dist/pg-core/index.js
var pg_core_exports = {};
__export(pg_core_exports, {
  Check: () => Check2,
  CheckBuilder: () => CheckBuilder2,
  DefaultViewBuilderCore: () => DefaultViewBuilderCore,
  EnableRLS: () => EnableRLS,
  ExtraConfigColumn: () => ExtraConfigColumn,
  ForeignKey: () => ForeignKey,
  ForeignKeyBuilder: () => ForeignKeyBuilder,
  Index: () => Index2,
  IndexBuilder: () => IndexBuilder2,
  IndexBuilderOn: () => IndexBuilderOn2,
  IndexedColumn: () => IndexedColumn,
  InlineForeignKeys: () => InlineForeignKeys,
  ManualMaterializedViewBuilder: () => ManualMaterializedViewBuilder,
  ManualViewBuilder: () => ManualViewBuilder2,
  MaterializedViewBuilder: () => MaterializedViewBuilder,
  MaterializedViewBuilderCore: () => MaterializedViewBuilderCore,
  PgArray: () => PgArray,
  PgArrayBuilder: () => PgArrayBuilder,
  PgBigInt53: () => PgBigInt53,
  PgBigInt53Builder: () => PgBigInt53Builder,
  PgBigInt64: () => PgBigInt64,
  PgBigInt64Builder: () => PgBigInt64Builder,
  PgBigSerial53: () => PgBigSerial53,
  PgBigSerial53Builder: () => PgBigSerial53Builder,
  PgBigSerial64: () => PgBigSerial64,
  PgBigSerial64Builder: () => PgBigSerial64Builder,
  PgBinaryVector: () => PgBinaryVector,
  PgBinaryVectorBuilder: () => PgBinaryVectorBuilder,
  PgBoolean: () => PgBoolean,
  PgBooleanBuilder: () => PgBooleanBuilder,
  PgChar: () => PgChar,
  PgCharBuilder: () => PgCharBuilder,
  PgCidr: () => PgCidr,
  PgCidrBuilder: () => PgCidrBuilder,
  PgColumn: () => PgColumn,
  PgColumnBuilder: () => PgColumnBuilder,
  PgCustomColumn: () => PgCustomColumn,
  PgCustomColumnBuilder: () => PgCustomColumnBuilder,
  PgDatabase: () => PgDatabase,
  PgDate: () => PgDate,
  PgDateBuilder: () => PgDateBuilder,
  PgDateString: () => PgDateString,
  PgDateStringBuilder: () => PgDateStringBuilder,
  PgDeleteBase: () => PgDeleteBase,
  PgDialect: () => PgDialect,
  PgDoublePrecision: () => PgDoublePrecision,
  PgDoublePrecisionBuilder: () => PgDoublePrecisionBuilder,
  PgEnumColumn: () => PgEnumColumn,
  PgEnumColumnBuilder: () => PgEnumColumnBuilder,
  PgEnumObjectColumn: () => PgEnumObjectColumn,
  PgEnumObjectColumnBuilder: () => PgEnumObjectColumnBuilder,
  PgGeometry: () => PgGeometry,
  PgGeometryBuilder: () => PgGeometryBuilder,
  PgGeometryObject: () => PgGeometryObject,
  PgGeometryObjectBuilder: () => PgGeometryObjectBuilder,
  PgHalfVector: () => PgHalfVector,
  PgHalfVectorBuilder: () => PgHalfVectorBuilder,
  PgInet: () => PgInet,
  PgInetBuilder: () => PgInetBuilder,
  PgInsertBase: () => PgInsertBase,
  PgInsertBuilder: () => PgInsertBuilder,
  PgIntColumnBaseBuilder: () => PgIntColumnBaseBuilder,
  PgInteger: () => PgInteger,
  PgIntegerBuilder: () => PgIntegerBuilder,
  PgInterval: () => PgInterval,
  PgIntervalBuilder: () => PgIntervalBuilder,
  PgJson: () => PgJson,
  PgJsonBuilder: () => PgJsonBuilder,
  PgJsonb: () => PgJsonb,
  PgJsonbBuilder: () => PgJsonbBuilder,
  PgLineABC: () => PgLineABC,
  PgLineABCBuilder: () => PgLineABCBuilder,
  PgLineBuilder: () => PgLineBuilder,
  PgLineTuple: () => PgLineTuple,
  PgMacaddr: () => PgMacaddr,
  PgMacaddr8: () => PgMacaddr8,
  PgMacaddr8Builder: () => PgMacaddr8Builder,
  PgMacaddrBuilder: () => PgMacaddrBuilder,
  PgMaterializedView: () => PgMaterializedView,
  PgMaterializedViewConfig: () => PgMaterializedViewConfig,
  PgNumeric: () => PgNumeric,
  PgNumericBigInt: () => PgNumericBigInt,
  PgNumericBigIntBuilder: () => PgNumericBigIntBuilder,
  PgNumericBuilder: () => PgNumericBuilder,
  PgNumericNumber: () => PgNumericNumber,
  PgNumericNumberBuilder: () => PgNumericNumberBuilder,
  PgPointObject: () => PgPointObject,
  PgPointObjectBuilder: () => PgPointObjectBuilder,
  PgPointTuple: () => PgPointTuple,
  PgPointTupleBuilder: () => PgPointTupleBuilder,
  PgPolicy: () => PgPolicy,
  PgPreparedQuery: () => PgPreparedQuery,
  PgReal: () => PgReal,
  PgRealBuilder: () => PgRealBuilder,
  PgRefreshMaterializedView: () => PgRefreshMaterializedView,
  PgRole: () => PgRole,
  PgSchema: () => PgSchema,
  PgSelectBase: () => PgSelectBase,
  PgSelectBuilder: () => PgSelectBuilder,
  PgSelectQueryBuilderBase: () => PgSelectQueryBuilderBase,
  PgSequence: () => PgSequence,
  PgSerial: () => PgSerial,
  PgSerialBuilder: () => PgSerialBuilder,
  PgSession: () => PgSession,
  PgSmallInt: () => PgSmallInt,
  PgSmallIntBuilder: () => PgSmallIntBuilder,
  PgSmallSerial: () => PgSmallSerial,
  PgSmallSerialBuilder: () => PgSmallSerialBuilder,
  PgSparseVector: () => PgSparseVector,
  PgSparseVectorBuilder: () => PgSparseVectorBuilder,
  PgTable: () => PgTable,
  PgText: () => PgText,
  PgTextBuilder: () => PgTextBuilder,
  PgTime: () => PgTime,
  PgTimeBuilder: () => PgTimeBuilder,
  PgTimestamp: () => PgTimestamp,
  PgTimestampBuilder: () => PgTimestampBuilder,
  PgTimestampString: () => PgTimestampString,
  PgTimestampStringBuilder: () => PgTimestampStringBuilder,
  PgTransaction: () => PgTransaction,
  PgUUID: () => PgUUID,
  PgUUIDBuilder: () => PgUUIDBuilder,
  PgUpdateBase: () => PgUpdateBase,
  PgUpdateBuilder: () => PgUpdateBuilder,
  PgVarchar: () => PgVarchar,
  PgVarcharBuilder: () => PgVarcharBuilder,
  PgVector: () => PgVector,
  PgVectorBuilder: () => PgVectorBuilder,
  PgView: () => PgView,
  PgViewConfig: () => PgViewConfig,
  PrimaryKey: () => PrimaryKey,
  PrimaryKeyBuilder: () => PrimaryKeyBuilder,
  QueryBuilder: () => QueryBuilder2,
  UniqueConstraint: () => UniqueConstraint,
  UniqueConstraintBuilder: () => UniqueConstraintBuilder,
  UniqueOnConstraintBuilder: () => UniqueOnConstraintBuilder,
  ViewBuilder: () => ViewBuilder2,
  alias: () => alias,
  bigint: () => bigint,
  bigserial: () => bigserial,
  bit: () => bit,
  boolean: () => boolean,
  char: () => char,
  check: () => check,
  cidr: () => cidr,
  customType: () => customType,
  date: () => date,
  decimal: () => decimal,
  doublePrecision: () => doublePrecision,
  except: () => except2,
  exceptAll: () => exceptAll2,
  extractUsedTable: () => extractUsedTable2,
  foreignKey: () => foreignKey,
  geometry: () => geometry,
  getMaterializedViewConfig: () => getMaterializedViewConfig,
  getTableConfig: () => getTableConfig2,
  getViewConfig: () => getViewConfig2,
  halfvec: () => halfvec,
  index: () => index,
  inet: () => inet,
  integer: () => integer,
  intersect: () => intersect2,
  intersectAll: () => intersectAll2,
  interval: () => interval,
  isPgEnum: () => isPgEnum,
  isPgMaterializedView: () => isPgMaterializedView,
  isPgSchema: () => isPgSchema,
  isPgSequence: () => isPgSequence,
  isPgView: () => isPgView,
  json: () => json,
  jsonb: () => jsonb,
  line: () => line,
  macaddr: () => macaddr,
  macaddr8: () => macaddr8,
  makePgArray: () => makePgArray,
  numeric: () => numeric,
  parsePgArray: () => parsePgArray,
  parsePgNestedArray: () => parsePgNestedArray,
  pgEnum: () => pgEnum,
  pgEnumObjectWithSchema: () => pgEnumObjectWithSchema,
  pgEnumWithSchema: () => pgEnumWithSchema,
  pgMaterializedView: () => pgMaterializedView,
  pgMaterializedViewWithSchema: () => pgMaterializedViewWithSchema,
  pgPolicy: () => pgPolicy,
  pgRole: () => pgRole,
  pgSchema: () => pgSchema,
  pgSequence: () => pgSequence,
  pgSequenceWithSchema: () => pgSequenceWithSchema,
  pgTable: () => pgTable,
  pgTableCreator: () => pgTableCreator,
  pgTableWithSchema: () => pgTableWithSchema,
  pgView: () => pgView,
  pgViewWithSchema: () => pgViewWithSchema,
  point: () => point,
  primaryKey: () => primaryKey,
  real: () => real,
  serial: () => serial,
  smallint: () => smallint,
  smallserial: () => smallserial,
  sparsevec: () => sparsevec,
  text: () => text,
  time: () => time,
  timestamp: () => timestamp,
  union: () => union2,
  unionAll: () => unionAll2,
  unique: () => unique,
  uniqueIndex: () => uniqueIndex,
  uniqueKeyName: () => uniqueKeyName,
  uuid: () => uuid,
  varchar: () => varchar,
  vector: () => vector,
  withReplicas: () => withReplicas
});
var init_pg_core = __esm({
  "../drizzle-orm/dist/pg-core/index.js"() {
    "use strict";
    init_alias3();
    init_checks2();
    init_columns2();
    init_db2();
    init_dialect2();
    init_foreign_keys();
    init_indexes2();
    init_policies();
    init_primary_keys();
    init_query_builders2();
    init_roles();
    init_schema2();
    init_sequence();
    init_session2();
    init_subquery3();
    init_table2();
    init_unique_constraint();
    init_utils4();
    init_utils5();
    init_view_common3();
    init_view2();
  }
});

// ../drizzle-orm/dist/singlestore-core/alias.js
var init_alias4 = __esm({
  "../drizzle-orm/dist/singlestore-core/alias.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/singlestore-core/unique-constraint.js
function uniqueKeyName3(table6, columns) {
  return `${table6[TableName]}_${columns.join("_")}_unique`;
}
var _a274, UniqueConstraintBuilder3, _a275, UniqueOnConstraintBuilder3, _a276, UniqueConstraint3;
var init_unique_constraint3 = __esm({
  "../drizzle-orm/dist/singlestore-core/unique-constraint.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    _a274 = entityKind;
    UniqueConstraintBuilder3 = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        this.name = name3;
        this.columns = columns;
      }
      /** @internal */
      build(table6) {
        return new UniqueConstraint3(table6, this.columns, this.name);
      }
    };
    __publicField(UniqueConstraintBuilder3, _a274, "SingleStoreUniqueConstraintBuilder");
    _a275 = entityKind;
    UniqueOnConstraintBuilder3 = class {
      constructor(name3) {
        /** @internal */
        __publicField(this, "name");
        this.name = name3;
      }
      on(...columns) {
        return new UniqueConstraintBuilder3(columns, this.name);
      }
    };
    __publicField(UniqueOnConstraintBuilder3, _a275, "SingleStoreUniqueOnConstraintBuilder");
    _a276 = entityKind;
    UniqueConstraint3 = class {
      constructor(table6, columns, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        __publicField(this, "nullsNotDistinct", false);
        this.table = table6;
        this.columns = columns;
        this.name = name3 ?? uniqueKeyName3(this.table, this.columns.map((column6) => column6.name));
      }
      getName() {
        return this.name;
      }
    };
    __publicField(UniqueConstraint3, _a276, "SingleStoreUniqueConstraint");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/common.js
var _a277, _b202, SingleStoreColumnBuilder, _a278, _b203, SingleStoreColumn, _a279, _b204, SingleStoreColumnBuilderWithAutoIncrement, _a280, _b205, SingleStoreColumnWithAutoIncrement;
var init_common3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/common.js"() {
    "use strict";
    init_column_builder();
    init_column();
    init_entity();
    init_unique_constraint3();
    SingleStoreColumnBuilder = class extends (_b202 = ColumnBuilder, _a277 = entityKind, _b202) {
      unique(name3) {
        this.config.isUnique = true;
        this.config.uniqueName = name3;
        return this;
      }
      // TODO: Implement generated columns for SingleStore (https://docs.singlestore.com/cloud/create-a-database/using-persistent-computed-columns/)
      /** @internal */
      generatedAlwaysAs(as, config) {
        this.config.generated = {
          as,
          type: "always",
          mode: config?.mode ?? "virtual"
        };
        return this;
      }
    };
    __publicField(SingleStoreColumnBuilder, _a277, "SingleStoreColumnBuilder");
    SingleStoreColumn = class extends (_b203 = Column, _a278 = entityKind, _b203) {
      constructor(table6, config) {
        if (!config.uniqueName) {
          config.uniqueName = uniqueKeyName3(table6, [config.name]);
        }
        super(table6, config);
        this.table = table6;
      }
    };
    __publicField(SingleStoreColumn, _a278, "SingleStoreColumn");
    SingleStoreColumnBuilderWithAutoIncrement = class extends (_b204 = SingleStoreColumnBuilder, _a279 = entityKind, _b204) {
      constructor(name3, dataType, columnType) {
        super(name3, dataType, columnType);
        this.config.autoIncrement = false;
      }
      autoincrement() {
        this.config.autoIncrement = true;
        this.config.hasDefault = true;
        return this;
      }
    };
    __publicField(SingleStoreColumnBuilderWithAutoIncrement, _a279, "SingleStoreColumnBuilderWithAutoIncrement");
    SingleStoreColumnWithAutoIncrement = class extends (_b205 = SingleStoreColumn, _a280 = entityKind, _b205) {
      constructor() {
        super(...arguments);
        __publicField(this, "autoIncrement", this.config.autoIncrement);
      }
    };
    __publicField(SingleStoreColumnWithAutoIncrement, _a280, "SingleStoreColumnWithAutoIncrement");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/bigint.js
function bigint3(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config.mode === "number") {
    return new SingleStoreBigInt53Builder(name3, config.unsigned);
  }
  return new SingleStoreBigInt64Builder(name3, config.unsigned);
}
var _a281, _b206, SingleStoreBigInt53Builder, _a282, _b207, SingleStoreBigInt53, _a283, _b208, SingleStoreBigInt64Builder, _a284, _b209, SingleStoreBigInt64;
var init_bigint3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/bigint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreBigInt53Builder = class extends (_b206 = SingleStoreColumnBuilderWithAutoIncrement, _a281 = entityKind, _b206) {
      constructor(name3, unsigned = false) {
        super(name3, "number", "SingleStoreBigInt53");
        this.config.unsigned = unsigned;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreBigInt53(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreBigInt53Builder, _a281, "SingleStoreBigInt53Builder");
    SingleStoreBigInt53 = class extends (_b207 = SingleStoreColumnWithAutoIncrement, _a282 = entityKind, _b207) {
      getSQLType() {
        return `bigint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") {
          return value;
        }
        return Number(value);
      }
    };
    __publicField(SingleStoreBigInt53, _a282, "SingleStoreBigInt53");
    SingleStoreBigInt64Builder = class extends (_b208 = SingleStoreColumnBuilderWithAutoIncrement, _a283 = entityKind, _b208) {
      constructor(name3, unsigned = false) {
        super(name3, "bigint", "SingleStoreBigInt64");
        this.config.unsigned = unsigned;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreBigInt64(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreBigInt64Builder, _a283, "SingleStoreBigInt64Builder");
    SingleStoreBigInt64 = class extends (_b209 = SingleStoreColumnWithAutoIncrement, _a284 = entityKind, _b209) {
      getSQLType() {
        return `bigint${this.config.unsigned ? " unsigned" : ""}`;
      }
      // eslint-disable-next-line unicorn/prefer-native-coercion-functions
      mapFromDriverValue(value) {
        return BigInt(value);
      }
    };
    __publicField(SingleStoreBigInt64, _a284, "SingleStoreBigInt64");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/binary.js
function binary3(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreBinaryBuilder(name3, config.length);
}
var _a285, _b210, SingleStoreBinaryBuilder, _a286, _b211, SingleStoreBinary;
var init_binary2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/binary.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreBinaryBuilder = class extends (_b210 = SingleStoreColumnBuilder, _a285 = entityKind, _b210) {
      constructor(name3, length) {
        super(name3, "string", "SingleStoreBinary");
        this.config.length = length;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreBinary(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreBinaryBuilder, _a285, "SingleStoreBinaryBuilder");
    SingleStoreBinary = class extends (_b211 = SingleStoreColumn, _a286 = entityKind, _b211) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        if (Buffer.isBuffer(value)) return value.toString();
        const str = [];
        for (const v11 of value) {
          str.push(v11 === 49 ? "1" : "0");
        }
        return str.join("");
      }
      getSQLType() {
        return this.length === void 0 ? `binary` : `binary(${this.length})`;
      }
    };
    __publicField(SingleStoreBinary, _a286, "SingleStoreBinary");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/boolean.js
function boolean3(name3) {
  return new SingleStoreBooleanBuilder(name3 ?? "");
}
var _a287, _b212, SingleStoreBooleanBuilder, _a288, _b213, SingleStoreBoolean;
var init_boolean3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/boolean.js"() {
    "use strict";
    init_entity();
    init_common3();
    SingleStoreBooleanBuilder = class extends (_b212 = SingleStoreColumnBuilder, _a287 = entityKind, _b212) {
      constructor(name3) {
        super(name3, "boolean", "SingleStoreBoolean");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreBoolean(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreBooleanBuilder, _a287, "SingleStoreBooleanBuilder");
    SingleStoreBoolean = class extends (_b213 = SingleStoreColumn, _a288 = entityKind, _b213) {
      getSQLType() {
        return "boolean";
      }
      mapFromDriverValue(value) {
        if (typeof value === "boolean") {
          return value;
        }
        return value === 1;
      }
    };
    __publicField(SingleStoreBoolean, _a288, "SingleStoreBoolean");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/char.js
function char3(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreCharBuilder(name3, config);
}
var _a289, _b214, SingleStoreCharBuilder, _a290, _b215, SingleStoreChar;
var init_char3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/char.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreCharBuilder = class extends (_b214 = SingleStoreColumnBuilder, _a289 = entityKind, _b214) {
      constructor(name3, config) {
        super(name3, "string", "SingleStoreChar");
        this.config.length = config.length;
        this.config.enum = config.enum;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreChar(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreCharBuilder, _a289, "SingleStoreCharBuilder");
    SingleStoreChar = class extends (_b215 = SingleStoreColumn, _a290 = entityKind, _b215) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
        __publicField(this, "enumValues", this.config.enum);
      }
      getSQLType() {
        return this.length === void 0 ? `char` : `char(${this.length})`;
      }
    };
    __publicField(SingleStoreChar, _a290, "SingleStoreChar");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/custom.js
function customType3(customTypeParams) {
  return (a9, b9) => {
    const { name: name3, config } = getColumnNameAndConfig(a9, b9);
    return new SingleStoreCustomColumnBuilder(name3, config, customTypeParams);
  };
}
var _a291, _b216, SingleStoreCustomColumnBuilder, _a292, _b217, SingleStoreCustomColumn;
var init_custom3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/custom.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreCustomColumnBuilder = class extends (_b216 = SingleStoreColumnBuilder, _a291 = entityKind, _b216) {
      constructor(name3, fieldConfig, customTypeParams) {
        super(name3, "custom", "SingleStoreCustomColumn");
        this.config.fieldConfig = fieldConfig;
        this.config.customTypeParams = customTypeParams;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreCustomColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreCustomColumnBuilder, _a291, "SingleStoreCustomColumnBuilder");
    SingleStoreCustomColumn = class extends (_b217 = SingleStoreColumn, _a292 = entityKind, _b217) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "sqlName");
        __publicField(this, "mapTo");
        __publicField(this, "mapFrom");
        this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
        this.mapTo = config.customTypeParams.toDriver;
        this.mapFrom = config.customTypeParams.fromDriver;
      }
      getSQLType() {
        return this.sqlName;
      }
      mapFromDriverValue(value) {
        return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
      }
      mapToDriverValue(value) {
        return typeof this.mapTo === "function" ? this.mapTo(value) : value;
      }
    };
    __publicField(SingleStoreCustomColumn, _a292, "SingleStoreCustomColumn");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/date.js
function date3(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "string") {
    return new SingleStoreDateStringBuilder(name3);
  }
  return new SingleStoreDateBuilder(name3);
}
var _a293, _b218, SingleStoreDateBuilder, _a294, _b219, SingleStoreDate, _a295, _b220, SingleStoreDateStringBuilder, _a296, _b221, SingleStoreDateString;
var init_date3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/date.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreDateBuilder = class extends (_b218 = SingleStoreColumnBuilder, _a293 = entityKind, _b218) {
      constructor(name3) {
        super(name3, "date", "SingleStoreDate");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDate(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDateBuilder, _a293, "SingleStoreDateBuilder");
    SingleStoreDate = class extends (_b219 = SingleStoreColumn, _a294 = entityKind, _b219) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return `date`;
      }
      mapFromDriverValue(value) {
        return new Date(value);
      }
    };
    __publicField(SingleStoreDate, _a294, "SingleStoreDate");
    SingleStoreDateStringBuilder = class extends (_b220 = SingleStoreColumnBuilder, _a295 = entityKind, _b220) {
      constructor(name3) {
        super(name3, "string", "SingleStoreDateString");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDateString(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDateStringBuilder, _a295, "SingleStoreDateStringBuilder");
    SingleStoreDateString = class extends (_b221 = SingleStoreColumn, _a296 = entityKind, _b221) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return `date`;
      }
    };
    __publicField(SingleStoreDateString, _a296, "SingleStoreDateString");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/datetime.js
function datetime2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "string") {
    return new SingleStoreDateTimeStringBuilder(name3);
  }
  return new SingleStoreDateTimeBuilder(name3);
}
var _a297, _b222, SingleStoreDateTimeBuilder, _a298, _b223, SingleStoreDateTime, _a299, _b224, SingleStoreDateTimeStringBuilder, _a300, _b225, SingleStoreDateTimeString;
var init_datetime2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/datetime.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreDateTimeBuilder = class extends (_b222 = SingleStoreColumnBuilder, _a297 = entityKind, _b222) {
      /** @internal */
      // TODO: we need to add a proper support for SingleStore
      generatedAlwaysAs(_as, _config) {
        throw new Error("Method not implemented.");
      }
      constructor(name3) {
        super(name3, "date", "SingleStoreDateTime");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDateTime(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDateTimeBuilder, _a297, "SingleStoreDateTimeBuilder");
    SingleStoreDateTime = class extends (_b223 = SingleStoreColumn, _a298 = entityKind, _b223) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return `datetime`;
      }
      mapToDriverValue(value) {
        return value.toISOString().replace("T", " ").replace("Z", "");
      }
      mapFromDriverValue(value) {
        return /* @__PURE__ */ new Date(value.replace(" ", "T") + "Z");
      }
    };
    __publicField(SingleStoreDateTime, _a298, "SingleStoreDateTime");
    SingleStoreDateTimeStringBuilder = class extends (_b224 = SingleStoreColumnBuilder, _a299 = entityKind, _b224) {
      /** @internal */
      // TODO: we need to add a proper support for SingleStore
      generatedAlwaysAs(_as, _config) {
        throw new Error("Method not implemented.");
      }
      constructor(name3) {
        super(name3, "string", "SingleStoreDateTimeString");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDateTimeString(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDateTimeStringBuilder, _a299, "SingleStoreDateTimeStringBuilder");
    SingleStoreDateTimeString = class extends (_b225 = SingleStoreColumn, _a300 = entityKind, _b225) {
      constructor(table6, config) {
        super(table6, config);
      }
      getSQLType() {
        return `datetime`;
      }
    };
    __publicField(SingleStoreDateTimeString, _a300, "SingleStoreDateTimeString");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/decimal.js
function decimal3(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  const mode = config?.mode;
  return mode === "number" ? new SingleStoreDecimalNumberBuilder(name3, config) : mode === "bigint" ? new SingleStoreDecimalBigIntBuilder(name3, config) : new SingleStoreDecimalBuilder(name3, config);
}
var _a301, _b226, SingleStoreDecimalBuilder, _a302, _b227, SingleStoreDecimal, _a303, _b228, SingleStoreDecimalNumberBuilder, _a304, _b229, SingleStoreDecimalNumber, _a305, _b230, SingleStoreDecimalBigIntBuilder, _a306, _b231, SingleStoreDecimalBigInt;
var init_decimal2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/decimal.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreDecimalBuilder = class extends (_b226 = SingleStoreColumnBuilderWithAutoIncrement, _a301 = entityKind, _b226) {
      constructor(name3, config) {
        super(name3, "string", "SingleStoreDecimal");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDecimal(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDecimalBuilder, _a301, "SingleStoreDecimalBuilder");
    SingleStoreDecimal = class extends (_b227 = SingleStoreColumnWithAutoIncrement, _a302 = entityKind, _b227) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        return String(value);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `decimal(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "decimal";
        } else {
          type += `decimal(${this.precision})`;
        }
        type = type === "decimal(10,0)" || type === "decimal(10)" ? "decimal" : type;
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(SingleStoreDecimal, _a302, "SingleStoreDecimal");
    SingleStoreDecimalNumberBuilder = class extends (_b228 = SingleStoreColumnBuilderWithAutoIncrement, _a303 = entityKind, _b228) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreDecimalNumber");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDecimalNumber(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDecimalNumberBuilder, _a303, "SingleStoreDecimalNumberBuilder");
    SingleStoreDecimalNumber = class extends (_b229 = SingleStoreColumnWithAutoIncrement, _a304 = entityKind, _b229) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
        __publicField(this, "mapToDriverValue", String);
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") return value;
        return Number(value);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `decimal(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "decimal";
        } else {
          type += `decimal(${this.precision})`;
        }
        type = type === "decimal(10,0)" || type === "decimal(10)" ? "decimal" : type;
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(SingleStoreDecimalNumber, _a304, "SingleStoreDecimalNumber");
    SingleStoreDecimalBigIntBuilder = class extends (_b230 = SingleStoreColumnBuilderWithAutoIncrement, _a305 = entityKind, _b230) {
      constructor(name3, config) {
        super(name3, "bigint", "SingleStoreDecimalBigInt");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDecimalBigInt(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDecimalBigIntBuilder, _a305, "SingleStoreDecimalBigIntBuilder");
    SingleStoreDecimalBigInt = class extends (_b231 = SingleStoreColumnWithAutoIncrement, _a306 = entityKind, _b231) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
        __publicField(this, "mapFromDriverValue", BigInt);
        __publicField(this, "mapToDriverValue", String);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `decimal(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "decimal";
        } else {
          type += `decimal(${this.precision})`;
        }
        type = type === "decimal(10,0)" || type === "decimal(10)" ? "decimal" : type;
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(SingleStoreDecimalBigInt, _a306, "SingleStoreDecimalBigInt");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/double.js
function double2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreDoubleBuilder(name3, config);
}
var _a307, _b232, SingleStoreDoubleBuilder, _a308, _b233, SingleStoreDouble;
var init_double2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/double.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreDoubleBuilder = class extends (_b232 = SingleStoreColumnBuilderWithAutoIncrement, _a307 = entityKind, _b232) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreDouble");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreDouble(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreDoubleBuilder, _a307, "SingleStoreDoubleBuilder");
    SingleStoreDouble = class extends (_b233 = SingleStoreColumnWithAutoIncrement, _a308 = entityKind, _b233) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `double(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "double";
        } else {
          type += `double(${this.precision})`;
        }
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(SingleStoreDouble, _a308, "SingleStoreDouble");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/enum.js
function singlestoreEnum(a9, b9) {
  const { name: name3, config: values2 } = getColumnNameAndConfig(a9, b9);
  if (values2.length === 0) {
    throw new Error(`You have an empty array for "${name3}" enum values`);
  }
  return new SingleStoreEnumColumnBuilder(name3, values2);
}
var _a309, _b234, SingleStoreEnumColumnBuilder, _a310, _b235, SingleStoreEnumColumn;
var init_enum3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/enum.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreEnumColumnBuilder = class extends (_b234 = SingleStoreColumnBuilder, _a309 = entityKind, _b234) {
      // eslint-disable-next-line @typescript-eslint/no-unused-vars
      generatedAlwaysAs(as, config) {
        throw new Error("Method not implemented.");
      }
      constructor(name3, values2) {
        super(name3, "string", "SingleStoreEnumColumn");
        this.config.enumValues = values2;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreEnumColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreEnumColumnBuilder, _a309, "SingleStoreEnumColumnBuilder");
    SingleStoreEnumColumn = class extends (_b235 = SingleStoreColumn, _a310 = entityKind, _b235) {
      constructor() {
        super(...arguments);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return `enum(${this.enumValues.map((value) => `'${value}'`).join(",")})`;
      }
    };
    __publicField(SingleStoreEnumColumn, _a310, "SingleStoreEnumColumn");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/float.js
function float2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreFloatBuilder(name3, config);
}
var _a311, _b236, SingleStoreFloatBuilder, _a312, _b237, SingleStoreFloat;
var init_float2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/float.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreFloatBuilder = class extends (_b236 = SingleStoreColumnBuilderWithAutoIncrement, _a311 = entityKind, _b236) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreFloat");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
        this.config.unsigned = config?.unsigned;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreFloat(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreFloatBuilder, _a311, "SingleStoreFloatBuilder");
    SingleStoreFloat = class extends (_b237 = SingleStoreColumnWithAutoIncrement, _a312 = entityKind, _b237) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
        __publicField(this, "unsigned", this.config.unsigned);
      }
      getSQLType() {
        let type = "";
        if (this.precision !== void 0 && this.scale !== void 0) {
          type += `float(${this.precision},${this.scale})`;
        } else if (this.precision === void 0) {
          type += "float";
        } else {
          type += `float(${this.precision},0)`;
        }
        return this.unsigned ? `${type} unsigned` : type;
      }
    };
    __publicField(SingleStoreFloat, _a312, "SingleStoreFloat");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/int.js
function int2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreIntBuilder(name3, config);
}
var _a313, _b238, SingleStoreIntBuilder, _a314, _b239, SingleStoreInt;
var init_int2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/int.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreIntBuilder = class extends (_b238 = SingleStoreColumnBuilderWithAutoIncrement, _a313 = entityKind, _b238) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreInt(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreIntBuilder, _a313, "SingleStoreIntBuilder");
    SingleStoreInt = class extends (_b239 = SingleStoreColumnWithAutoIncrement, _a314 = entityKind, _b239) {
      getSQLType() {
        return `int${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(SingleStoreInt, _a314, "SingleStoreInt");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/json.js
function json3(name3) {
  return new SingleStoreJsonBuilder(name3 ?? "");
}
var _a315, _b240, SingleStoreJsonBuilder, _a316, _b241, SingleStoreJson;
var init_json3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/json.js"() {
    "use strict";
    init_entity();
    init_common3();
    SingleStoreJsonBuilder = class extends (_b240 = SingleStoreColumnBuilder, _a315 = entityKind, _b240) {
      constructor(name3) {
        super(name3, "json", "SingleStoreJson");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreJson(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreJsonBuilder, _a315, "SingleStoreJsonBuilder");
    SingleStoreJson = class extends (_b241 = SingleStoreColumn, _a316 = entityKind, _b241) {
      getSQLType() {
        return "json";
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
    };
    __publicField(SingleStoreJson, _a316, "SingleStoreJson");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/mediumint.js
function mediumint2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreMediumIntBuilder(name3, config);
}
var _a317, _b242, SingleStoreMediumIntBuilder, _a318, _b243, SingleStoreMediumInt;
var init_mediumint2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/mediumint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreMediumIntBuilder = class extends (_b242 = SingleStoreColumnBuilderWithAutoIncrement, _a317 = entityKind, _b242) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreMediumInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreMediumInt(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreMediumIntBuilder, _a317, "SingleStoreMediumIntBuilder");
    SingleStoreMediumInt = class extends (_b243 = SingleStoreColumnWithAutoIncrement, _a318 = entityKind, _b243) {
      getSQLType() {
        return `mediumint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(SingleStoreMediumInt, _a318, "SingleStoreMediumInt");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/real.js
function real3(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreRealBuilder(name3, config);
}
var _a319, _b244, SingleStoreRealBuilder, _a320, _b245, SingleStoreReal;
var init_real3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/real.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreRealBuilder = class extends (_b244 = SingleStoreColumnBuilderWithAutoIncrement, _a319 = entityKind, _b244) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreReal");
        this.config.precision = config?.precision;
        this.config.scale = config?.scale;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreReal(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreRealBuilder, _a319, "SingleStoreRealBuilder");
    SingleStoreReal = class extends (_b245 = SingleStoreColumnWithAutoIncrement, _a320 = entityKind, _b245) {
      constructor() {
        super(...arguments);
        __publicField(this, "precision", this.config.precision);
        __publicField(this, "scale", this.config.scale);
      }
      getSQLType() {
        if (this.precision !== void 0 && this.scale !== void 0) {
          return `real(${this.precision}, ${this.scale})`;
        } else if (this.precision === void 0) {
          return "real";
        } else {
          return `real(${this.precision})`;
        }
      }
    };
    __publicField(SingleStoreReal, _a320, "SingleStoreReal");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/serial.js
function serial3(name3) {
  return new SingleStoreSerialBuilder(name3 ?? "");
}
var _a321, _b246, SingleStoreSerialBuilder, _a322, _b247, SingleStoreSerial;
var init_serial3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/serial.js"() {
    "use strict";
    init_entity();
    init_common3();
    SingleStoreSerialBuilder = class extends (_b246 = SingleStoreColumnBuilderWithAutoIncrement, _a321 = entityKind, _b246) {
      constructor(name3) {
        super(name3, "number", "SingleStoreSerial");
        this.config.hasDefault = true;
        this.config.autoIncrement = true;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreSerial(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreSerialBuilder, _a321, "SingleStoreSerialBuilder");
    SingleStoreSerial = class extends (_b247 = SingleStoreColumnWithAutoIncrement, _a322 = entityKind, _b247) {
      getSQLType() {
        return "serial";
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(SingleStoreSerial, _a322, "SingleStoreSerial");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/smallint.js
function smallint3(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreSmallIntBuilder(name3, config);
}
var _a323, _b248, SingleStoreSmallIntBuilder, _a324, _b249, SingleStoreSmallInt;
var init_smallint3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/smallint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreSmallIntBuilder = class extends (_b248 = SingleStoreColumnBuilderWithAutoIncrement, _a323 = entityKind, _b248) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreSmallInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreSmallInt(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreSmallIntBuilder, _a323, "SingleStoreSmallIntBuilder");
    SingleStoreSmallInt = class extends (_b249 = SingleStoreColumnWithAutoIncrement, _a324 = entityKind, _b249) {
      getSQLType() {
        return `smallint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(SingleStoreSmallInt, _a324, "SingleStoreSmallInt");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/text.js
function text3(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreTextBuilder(name3, "text", config);
}
function tinytext2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreTextBuilder(name3, "tinytext", config);
}
function mediumtext2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreTextBuilder(name3, "mediumtext", config);
}
function longtext2(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreTextBuilder(name3, "longtext", config);
}
var _a325, _b250, SingleStoreTextBuilder, _a326, _b251, SingleStoreText;
var init_text3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/text.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreTextBuilder = class extends (_b250 = SingleStoreColumnBuilder, _a325 = entityKind, _b250) {
      constructor(name3, textType, config) {
        super(name3, "string", "SingleStoreText");
        this.config.textType = textType;
        this.config.enumValues = config.enum;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreText(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreTextBuilder, _a325, "SingleStoreTextBuilder");
    SingleStoreText = class extends (_b251 = SingleStoreColumn, _a326 = entityKind, _b251) {
      constructor() {
        super(...arguments);
        __publicField(this, "textType", this.config.textType);
        __publicField(this, "enumValues", this.config.enumValues);
      }
      getSQLType() {
        return this.textType;
      }
    };
    __publicField(SingleStoreText, _a326, "SingleStoreText");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/time.js
function time3(name3) {
  return new SingleStoreTimeBuilder(name3 ?? "");
}
var _a327, _b252, SingleStoreTimeBuilder, _a328, _b253, SingleStoreTime;
var init_time3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/time.js"() {
    "use strict";
    init_entity();
    init_common3();
    SingleStoreTimeBuilder = class extends (_b252 = SingleStoreColumnBuilder, _a327 = entityKind, _b252) {
      constructor(name3) {
        super(name3, "string", "SingleStoreTime");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreTime(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreTimeBuilder, _a327, "SingleStoreTimeBuilder");
    SingleStoreTime = class extends (_b253 = SingleStoreColumn, _a328 = entityKind, _b253) {
      getSQLType() {
        return `time`;
      }
    };
    __publicField(SingleStoreTime, _a328, "SingleStoreTime");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/date.common.js
var _a329, _b254, SingleStoreDateColumnBaseBuilder, _a330, _b255, SingleStoreDateBaseColumn;
var init_date_common3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/date.common.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_common3();
    SingleStoreDateColumnBaseBuilder = class extends (_b254 = SingleStoreColumnBuilder, _a329 = entityKind, _b254) {
      defaultNow() {
        return this.default(sql`now()`);
      }
      onUpdateNow() {
        this.config.hasOnUpdateNow = true;
        this.config.hasDefault = true;
        return this;
      }
    };
    __publicField(SingleStoreDateColumnBaseBuilder, _a329, "SingleStoreDateColumnBuilder");
    SingleStoreDateBaseColumn = class extends (_b255 = SingleStoreColumn, _a330 = entityKind, _b255) {
      constructor() {
        super(...arguments);
        __publicField(this, "hasOnUpdateNow", this.config.hasOnUpdateNow);
      }
    };
    __publicField(SingleStoreDateBaseColumn, _a330, "SingleStoreDateColumn");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/timestamp.js
function timestamp3(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "string") {
    return new SingleStoreTimestampStringBuilder(name3);
  }
  return new SingleStoreTimestampBuilder(name3);
}
var _a331, _b256, SingleStoreTimestampBuilder, _a332, _b257, SingleStoreTimestamp, _a333, _b258, SingleStoreTimestampStringBuilder, _a334, _b259, SingleStoreTimestampString;
var init_timestamp3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/timestamp.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_utils();
    init_date_common3();
    SingleStoreTimestampBuilder = class extends (_b256 = SingleStoreDateColumnBaseBuilder, _a331 = entityKind, _b256) {
      constructor(name3) {
        super(name3, "date", "SingleStoreTimestamp");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreTimestamp(
          table6,
          this.config
        );
      }
      defaultNow() {
        return this.default(sql`CURRENT_TIMESTAMP`);
      }
    };
    __publicField(SingleStoreTimestampBuilder, _a331, "SingleStoreTimestampBuilder");
    SingleStoreTimestamp = class extends (_b257 = SingleStoreDateBaseColumn, _a332 = entityKind, _b257) {
      getSQLType() {
        return `timestamp`;
      }
      mapFromDriverValue(value) {
        return /* @__PURE__ */ new Date(value + "+0000");
      }
      mapToDriverValue(value) {
        return value.toISOString().slice(0, -1).replace("T", " ");
      }
    };
    __publicField(SingleStoreTimestamp, _a332, "SingleStoreTimestamp");
    SingleStoreTimestampStringBuilder = class extends (_b258 = SingleStoreDateColumnBaseBuilder, _a333 = entityKind, _b258) {
      constructor(name3) {
        super(name3, "string", "SingleStoreTimestampString");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreTimestampString(
          table6,
          this.config
        );
      }
      defaultNow() {
        return this.default(sql`CURRENT_TIMESTAMP`);
      }
    };
    __publicField(SingleStoreTimestampStringBuilder, _a333, "SingleStoreTimestampStringBuilder");
    SingleStoreTimestampString = class extends (_b259 = SingleStoreDateBaseColumn, _a334 = entityKind, _b259) {
      getSQLType() {
        return `timestamp`;
      }
    };
    __publicField(SingleStoreTimestampString, _a334, "SingleStoreTimestampString");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/tinyint.js
function tinyint2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreTinyIntBuilder(name3, config);
}
var _a335, _b260, SingleStoreTinyIntBuilder, _a336, _b261, SingleStoreTinyInt;
var init_tinyint2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/tinyint.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreTinyIntBuilder = class extends (_b260 = SingleStoreColumnBuilderWithAutoIncrement, _a335 = entityKind, _b260) {
      constructor(name3, config) {
        super(name3, "number", "SingleStoreTinyInt");
        this.config.unsigned = config ? config.unsigned : false;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreTinyInt(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreTinyIntBuilder, _a335, "SingleStoreTinyIntBuilder");
    SingleStoreTinyInt = class extends (_b261 = SingleStoreColumnWithAutoIncrement, _a336 = entityKind, _b261) {
      getSQLType() {
        return `tinyint${this.config.unsigned ? " unsigned" : ""}`;
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") {
          return Number(value);
        }
        return value;
      }
    };
    __publicField(SingleStoreTinyInt, _a336, "SingleStoreTinyInt");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/varbinary.js
function varbinary2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreVarBinaryBuilder(name3, config);
}
var _a337, _b262, SingleStoreVarBinaryBuilder, _a338, _b263, SingleStoreVarBinary;
var init_varbinary2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/varbinary.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreVarBinaryBuilder = class extends (_b262 = SingleStoreColumnBuilder, _a337 = entityKind, _b262) {
      /** @internal */
      constructor(name3, config) {
        super(name3, "string", "SingleStoreVarBinary");
        this.config.length = config?.length;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreVarBinary(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreVarBinaryBuilder, _a337, "SingleStoreVarBinaryBuilder");
    SingleStoreVarBinary = class extends (_b263 = SingleStoreColumn, _a338 = entityKind, _b263) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
      }
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        if (Buffer.isBuffer(value)) return value.toString();
        const str = [];
        for (const v11 of value) {
          str.push(v11 === 49 ? "1" : "0");
        }
        return str.join("");
      }
      getSQLType() {
        return this.length === void 0 ? `varbinary` : `varbinary(${this.length})`;
      }
    };
    __publicField(SingleStoreVarBinary, _a338, "SingleStoreVarBinary");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/varchar.js
function varchar3(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreVarCharBuilder(name3, config);
}
var _a339, _b264, SingleStoreVarCharBuilder, _a340, _b265, SingleStoreVarChar;
var init_varchar3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/varchar.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreVarCharBuilder = class extends (_b264 = SingleStoreColumnBuilder, _a339 = entityKind, _b264) {
      /** @internal */
      constructor(name3, config) {
        super(name3, "string", "SingleStoreVarChar");
        this.config.length = config.length;
        this.config.enum = config.enum;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreVarChar(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreVarCharBuilder, _a339, "SingleStoreVarCharBuilder");
    SingleStoreVarChar = class extends (_b265 = SingleStoreColumn, _a340 = entityKind, _b265) {
      constructor() {
        super(...arguments);
        __publicField(this, "length", this.config.length);
        __publicField(this, "enumValues", this.config.enum);
      }
      getSQLType() {
        return this.length === void 0 ? `varchar` : `varchar(${this.length})`;
      }
    };
    __publicField(SingleStoreVarChar, _a340, "SingleStoreVarChar");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/vector.js
function vector2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  return new SingleStoreVectorBuilder(name3, config);
}
var _a341, _b266, SingleStoreVectorBuilder, _a342, _b267, SingleStoreVector;
var init_vector3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/vector.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common3();
    SingleStoreVectorBuilder = class extends (_b266 = SingleStoreColumnBuilder, _a341 = entityKind, _b266) {
      constructor(name3, config) {
        super(name3, "array", "SingleStoreVector");
        this.config.dimensions = config.dimensions;
        this.config.elementType = config.elementType;
      }
      /** @internal */
      build(table6) {
        return new SingleStoreVector(
          table6,
          this.config
        );
      }
      /** @internal */
      generatedAlwaysAs(as, config) {
        throw new Error("not implemented");
      }
    };
    __publicField(SingleStoreVectorBuilder, _a341, "SingleStoreVectorBuilder");
    SingleStoreVector = class extends (_b267 = SingleStoreColumn, _a342 = entityKind, _b267) {
      constructor() {
        super(...arguments);
        __publicField(this, "dimensions", this.config.dimensions);
        __publicField(this, "elementType", this.config.elementType);
      }
      getSQLType() {
        return `vector(${this.dimensions}, ${this.elementType || "F32"})`;
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
      mapFromDriverValue(value) {
        return JSON.parse(value);
      }
    };
    __publicField(SingleStoreVector, _a342, "SingleStoreVector");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/year.js
function year2(name3) {
  return new SingleStoreYearBuilder(name3 ?? "");
}
var _a343, _b268, SingleStoreYearBuilder, _a344, _b269, SingleStoreYear;
var init_year2 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/year.js"() {
    "use strict";
    init_entity();
    init_common3();
    SingleStoreYearBuilder = class extends (_b268 = SingleStoreColumnBuilder, _a343 = entityKind, _b268) {
      constructor(name3) {
        super(name3, "number", "SingleStoreYear");
      }
      /** @internal */
      build(table6) {
        return new SingleStoreYear(
          table6,
          this.config
        );
      }
    };
    __publicField(SingleStoreYearBuilder, _a343, "SingleStoreYearBuilder");
    SingleStoreYear = class extends (_b269 = SingleStoreColumn, _a344 = entityKind, _b269) {
      getSQLType() {
        return `year`;
      }
    };
    __publicField(SingleStoreYear, _a344, "SingleStoreYear");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/index.js
var init_columns3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/index.js"() {
    "use strict";
    init_bigint3();
    init_binary2();
    init_boolean3();
    init_char3();
    init_common3();
    init_custom3();
    init_date3();
    init_datetime2();
    init_decimal2();
    init_double2();
    init_enum3();
    init_float2();
    init_int2();
    init_json3();
    init_mediumint2();
    init_real3();
    init_serial3();
    init_smallint3();
    init_text3();
    init_time3();
    init_timestamp3();
    init_tinyint2();
    init_varbinary2();
    init_varchar3();
    init_vector3();
    init_year2();
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/count.js
var _a345, _b270, _c10, _SingleStoreCountBuilder, SingleStoreCountBuilder;
var init_count3 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/count.js"() {
    "use strict";
    init_entity();
    init_sql();
    _SingleStoreCountBuilder = class _SingleStoreCountBuilder extends (_c10 = SQL, _b270 = entityKind, _a345 = Symbol.toStringTag, _c10) {
      constructor(params) {
        super(_SingleStoreCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
        __publicField(this, "sql");
        __publicField(this, _a345, "SingleStoreCountBuilder");
        __publicField(this, "session");
        this.params = params;
        this.mapWith(Number);
        this.session = params.session;
        this.sql = _SingleStoreCountBuilder.buildCount(
          params.source,
          params.filters
        );
      }
      static buildEmbeddedCount(source, filters) {
        return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
      }
      static buildCount(source, filters) {
        return sql`select count(*) as count from ${source}${sql.raw(" where ").if(filters)}${filters}`;
      }
      then(onfulfilled, onrejected) {
        return Promise.resolve(this.session.count(this.sql)).then(
          onfulfilled,
          onrejected
        );
      }
      catch(onRejected) {
        return this.then(void 0, onRejected);
      }
      finally(onFinally) {
        return this.then(
          (value) => {
            onFinally?.();
            return value;
          },
          (reason) => {
            onFinally?.();
            throw reason;
          }
        );
      }
    };
    __publicField(_SingleStoreCountBuilder, _b270, "SingleStoreCountBuilder");
    SingleStoreCountBuilder = _SingleStoreCountBuilder;
  }
});

// ../drizzle-orm/dist/singlestore-core/indexes.js
var _a346, IndexBuilderOn3, _a347, IndexBuilder3, _a348, Index3;
var init_indexes3 = __esm({
  "../drizzle-orm/dist/singlestore-core/indexes.js"() {
    "use strict";
    init_entity();
    _a346 = entityKind;
    IndexBuilderOn3 = class {
      constructor(name3, unique2) {
        this.name = name3;
        this.unique = unique2;
      }
      on(...columns) {
        return new IndexBuilder3(this.name, columns, this.unique);
      }
    };
    __publicField(IndexBuilderOn3, _a346, "SingleStoreIndexBuilderOn");
    _a347 = entityKind;
    IndexBuilder3 = class {
      constructor(name3, columns, unique2) {
        /** @internal */
        __publicField(this, "config");
        this.config = {
          name: name3,
          columns,
          unique: unique2
        };
      }
      using(using) {
        this.config.using = using;
        return this;
      }
      algorythm(algorythm) {
        this.config.algorythm = algorythm;
        return this;
      }
      lock(lock) {
        this.config.lock = lock;
        return this;
      }
      /** @internal */
      build(table6) {
        return new Index3(this.config, table6);
      }
    };
    __publicField(IndexBuilder3, _a347, "SingleStoreIndexBuilder");
    _a348 = entityKind;
    Index3 = class {
      constructor(config, table6) {
        __publicField(this, "config");
        this.config = { ...config, table: table6 };
      }
    };
    __publicField(Index3, _a348, "SingleStoreIndex");
  }
});

// ../drizzle-orm/dist/singlestore-core/columns/all.js
function getSingleStoreColumnBuilders() {
  return {
    bigint: bigint3,
    binary: binary3,
    boolean: boolean3,
    char: char3,
    customType: customType3,
    date: date3,
    datetime: datetime2,
    decimal: decimal3,
    double: double2,
    singlestoreEnum,
    float: float2,
    int: int2,
    json: json3,
    mediumint: mediumint2,
    real: real3,
    serial: serial3,
    smallint: smallint3,
    longtext: longtext2,
    mediumtext: mediumtext2,
    text: text3,
    tinytext: tinytext2,
    time: time3,
    timestamp: timestamp3,
    tinyint: tinyint2,
    varbinary: varbinary2,
    varchar: varchar3,
    vector: vector2,
    year: year2
  };
}
var init_all3 = __esm({
  "../drizzle-orm/dist/singlestore-core/columns/all.js"() {
    "use strict";
    init_bigint3();
    init_binary2();
    init_boolean3();
    init_char3();
    init_custom3();
    init_date3();
    init_datetime2();
    init_decimal2();
    init_double2();
    init_enum3();
    init_float2();
    init_int2();
    init_json3();
    init_mediumint2();
    init_real3();
    init_serial3();
    init_smallint3();
    init_text3();
    init_time3();
    init_timestamp3();
    init_tinyint2();
    init_varbinary2();
    init_varchar3();
    init_vector3();
    init_year2();
  }
});

// ../drizzle-orm/dist/singlestore-core/table.js
function singlestoreTableWithSchema(name3, columns, extraConfig, schema6, baseName = name3) {
  const rawTable = new SingleStoreTable(name3, schema6, baseName);
  const parsedColumns = typeof columns === "function" ? columns(getSingleStoreColumnBuilders()) : columns;
  const builtColumns = Object.fromEntries(
    Object.entries(parsedColumns).map(([name22, colBuilderBase]) => {
      const colBuilder = colBuilderBase;
      colBuilder.setName(name22);
      const column6 = colBuilder.build(rawTable);
      return [name22, column6];
    })
  );
  const table6 = Object.assign(rawTable, builtColumns);
  table6[Table.Symbol.Columns] = builtColumns;
  table6[Table.Symbol.ExtraConfigColumns] = builtColumns;
  if (extraConfig) {
    table6[SingleStoreTable.Symbol.ExtraConfigBuilder] = extraConfig;
  }
  return table6;
}
var _a349, _b271, _c11, _d4, SingleStoreTable;
var init_table4 = __esm({
  "../drizzle-orm/dist/singlestore-core/table.js"() {
    "use strict";
    init_entity();
    init_table();
    init_all3();
    SingleStoreTable = class extends (_d4 = Table, _c11 = entityKind, _b271 = Table.Symbol.Columns, _a349 = Table.Symbol.ExtraConfigBuilder, _d4) {
      constructor() {
        super(...arguments);
        /** @internal */
        __publicField(this, _b271);
        /** @internal */
        __publicField(this, _a349);
      }
    };
    __publicField(SingleStoreTable, _c11, "SingleStoreTable");
    /** @internal */
    __publicField(SingleStoreTable, "Symbol", Object.assign({}, Table.Symbol, {}));
  }
});

// ../drizzle-orm/dist/singlestore-core/primary-keys.js
var _a350, PrimaryKeyBuilder3, _a351, PrimaryKey3;
var init_primary_keys3 = __esm({
  "../drizzle-orm/dist/singlestore-core/primary-keys.js"() {
    "use strict";
    init_entity();
    init_table4();
    _a350 = entityKind;
    PrimaryKeyBuilder3 = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        /** @internal */
        __publicField(this, "name");
        this.columns = columns;
        this.name = name3;
      }
      /** @internal */
      build(table6) {
        return new PrimaryKey3(table6, this.columns, this.name);
      }
    };
    __publicField(PrimaryKeyBuilder3, _a350, "SingleStorePrimaryKeyBuilder");
    _a351 = entityKind;
    PrimaryKey3 = class {
      constructor(table6, columns, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        this.table = table6;
        this.columns = columns;
        this.name = name3;
      }
      getName() {
        return this.name ?? `${this.table[SingleStoreTable.Symbol.Name]}_${this.columns.map((column6) => column6.name).join("_")}_pk`;
      }
    };
    __publicField(PrimaryKey3, _a351, "SingleStorePrimaryKey");
  }
});

// ../drizzle-orm/dist/singlestore-core/utils.js
function extractUsedTable3(table6) {
  if (is(table6, SingleStoreTable)) {
    return [`${table6[Table.Symbol.BaseName]}`];
  }
  if (is(table6, Subquery)) {
    return table6._.usedTables ?? [];
  }
  if (is(table6, SQL)) {
    return table6.usedTables ?? [];
  }
  return [];
}
function getTableConfig3(table6) {
  const columns = Object.values(table6[SingleStoreTable.Symbol.Columns]);
  const indexes = [];
  const primaryKeys = [];
  const uniqueConstraints = [];
  const name3 = table6[Table.Symbol.Name];
  const schema6 = table6[Table.Symbol.Schema];
  const baseName = table6[Table.Symbol.BaseName];
  const extraConfigBuilder = table6[SingleStoreTable.Symbol.ExtraConfigBuilder];
  if (extraConfigBuilder !== void 0) {
    const extraConfig = extraConfigBuilder(table6[SingleStoreTable.Symbol.Columns]);
    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);
    for (const builder of Object.values(extraValues)) {
      if (is(builder, IndexBuilder3)) {
        indexes.push(builder.build(table6));
      } else if (is(builder, UniqueConstraintBuilder3)) {
        uniqueConstraints.push(builder.build(table6));
      } else if (is(builder, PrimaryKeyBuilder3)) {
        primaryKeys.push(builder.build(table6));
      }
    }
  }
  return {
    columns,
    indexes,
    primaryKeys,
    uniqueConstraints,
    name: name3,
    schema: schema6,
    baseName
  };
}
var init_utils6 = __esm({
  "../drizzle-orm/dist/singlestore-core/utils.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_subquery();
    init_table();
    init_indexes3();
    init_primary_keys3();
    init_table4();
    init_unique_constraint3();
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/delete.js
var _a352, _b272, SingleStoreDeleteBase;
var init_delete3 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/delete.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_table();
    init_utils6();
    SingleStoreDeleteBase = class extends (_b272 = QueryPromise, _a352 = entityKind, _b272) {
      constructor(table6, session, dialect6, withList) {
        super();
        __publicField(this, "config");
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, withList };
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will delete only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be deleted.
       *
       * ```ts
       * // Delete all cars with green color
       * db.delete(cars).where(eq(cars.color, 'green'));
       * // or
       * db.delete(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Delete all BMW cars with a green color
       * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Delete all cars with the green or blue color
       * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.table[Table.Symbol.Columns],
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          this.config.orderBy = orderByArray;
        } else {
          const orderByArray = columns;
          this.config.orderBy = orderByArray;
        }
        return this;
      }
      limit(limit) {
        this.config.limit = limit;
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildDeleteQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      prepare() {
        return this.session.prepareQuery(
          this.dialect.sqlToQuery(this.getSQL()),
          this.config.returning,
          void 0,
          void 0,
          void 0,
          {
            type: "delete",
            tables: extractUsedTable3(this.config.table)
          }
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SingleStoreDeleteBase, _a352, "SingleStoreDelete");
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/insert.js
var _a353, SingleStoreInsertBuilder, _a354, _b273, SingleStoreInsertBase;
var init_insert3 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/insert.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_sql();
    init_table();
    init_utils();
    init_utils6();
    _a353 = entityKind;
    SingleStoreInsertBuilder = class {
      constructor(table6, session, dialect6) {
        __publicField(this, "shouldIgnore", false);
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
      }
      ignore() {
        this.shouldIgnore = true;
        return this;
      }
      values(values2) {
        values2 = Array.isArray(values2) ? values2 : [values2];
        if (values2.length === 0) {
          throw new Error("values() must be called with at least one value");
        }
        const mappedValues = values2.map((entry) => {
          const result = {};
          const cols = this.table[Table.Symbol.Columns];
          for (const colKey of Object.keys(entry)) {
            const colValue = entry[colKey];
            result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
          }
          return result;
        });
        return new SingleStoreInsertBase(this.table, mappedValues, this.shouldIgnore, this.session, this.dialect);
      }
    };
    __publicField(SingleStoreInsertBuilder, _a353, "SingleStoreInsertBuilder");
    SingleStoreInsertBase = class extends (_b273 = QueryPromise, _a354 = entityKind, _b273) {
      constructor(table6, values2, ignore, session, dialect6) {
        super();
        __publicField(this, "config");
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, values: values2, ignore };
      }
      /**
       * Adds an `on duplicate key update` clause to the query.
       *
       * Calling this method will update update the row if any unique index conflicts. MySQL will automatically determine the conflict target based on the primary key and unique indexes.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert#on-duplicate-key-update}
       *
       * @param config The `set` clause
       *
       * @example
       * ```ts
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW'})
       *   .onDuplicateKeyUpdate({ set: { brand: 'Porsche' }});
       * ```
       *
       * While MySQL does not directly support doing nothing on conflict, you can perform a no-op by setting any column's value to itself and achieve the same effect:
       *
       * ```ts
       * import { sql } from 'drizzle-orm';
       *
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onDuplicateKeyUpdate({ set: { id: sql`id` } });
       * ```
       */
      onDuplicateKeyUpdate(config) {
        const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
        this.config.onConflict = sql`update ${setSql}`;
        return this;
      }
      $returningId() {
        const returning = [];
        for (const [key, value] of Object.entries(this.config.table[Table.Symbol.Columns])) {
          if (value.primary) {
            returning.push({ field: value, path: [key] });
          }
        }
        this.config.returning = orderSelectedFields(this.config.table[Table.Symbol.Columns]);
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildInsertQuery(this.config).sql;
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      prepare() {
        const { sql: sql22, generatedIds } = this.dialect.buildInsertQuery(this.config);
        return this.session.prepareQuery(
          this.dialect.sqlToQuery(sql22),
          void 0,
          void 0,
          generatedIds,
          this.config.returning,
          {
            type: "delete",
            tables: extractUsedTable3(this.config.table)
          }
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SingleStoreInsertBase, _a354, "SingleStoreInsert");
  }
});

// ../drizzle-orm/dist/singlestore-core/dialect.js
var _a355, SingleStoreDialect;
var init_dialect3 = __esm({
  "../drizzle-orm/dist/singlestore-core/dialect.js"() {
    "use strict";
    init_alias();
    init_casing();
    init_column();
    init_entity();
    init_errors();
    init_relations();
    init_expressions();
    init_sql();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_common3();
    init_table4();
    _a355 = entityKind;
    SingleStoreDialect = class {
      constructor(config) {
        /** @internal */
        __publicField(this, "casing");
        this.casing = new CasingCache(config?.casing);
      }
      async migrate(migrations, session, config) {
        const migrationsTable = config.migrationsTable ?? "__drizzle_migrations";
        const migrationTableCreate = sql`
			create table if not exists ${sql.identifier(migrationsTable)} (
				id serial primary key,
				hash text not null,
				created_at bigint
			)
		`;
        await session.execute(migrationTableCreate);
        const dbMigrations = await session.all(
          sql`select id, hash, created_at from ${sql.identifier(migrationsTable)} order by created_at desc limit 1`
        );
        const lastDbMigration = dbMigrations[0];
        await session.transaction(async (tx) => {
          for (const migration of migrations) {
            if (!lastDbMigration || Number(lastDbMigration.created_at) < migration.folderMillis) {
              for (const stmt of migration.sql) {
                await tx.execute(sql.raw(stmt));
              }
              await tx.execute(
                sql`insert into ${sql.identifier(migrationsTable)} (\`hash\`, \`created_at\`) values(${migration.hash}, ${migration.folderMillis})`
              );
            }
          }
        });
      }
      escapeName(name3) {
        return `\`${name3}\``;
      }
      escapeParam(_num) {
        return `?`;
      }
      escapeString(str) {
        return `'${str.replace(/'/g, "''")}'`;
      }
      buildWithCTE(queries) {
        if (!queries?.length) return void 0;
        const withSqlChunks = [sql`with `];
        for (const [i8, w10] of queries.entries()) {
          withSqlChunks.push(sql`${sql.identifier(w10._.alias)} as (${w10._.sql})`);
          if (i8 < queries.length - 1) {
            withSqlChunks.push(sql`, `);
          }
        }
        withSqlChunks.push(sql` `);
        return sql.join(withSqlChunks);
      }
      buildDeleteQuery({ table: table6, where, returning, withList, limit, orderBy }) {
        const withSql = this.buildWithCTE(withList);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const limitSql = this.buildLimit(limit);
        return sql`${withSql}delete from ${table6}${whereSql}${orderBySql}${limitSql}${returningSql}`;
      }
      buildUpdateSet(table6, set) {
        const tableColumns = table6[Table.Symbol.Columns];
        const columnNames = Object.keys(tableColumns).filter(
          (colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0
        );
        const setSize = columnNames.length;
        return sql.join(columnNames.flatMap((colName, i8) => {
          const col = tableColumns[colName];
          const value = set[colName] ?? sql.param(col.onUpdateFn(), col);
          const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
          if (i8 < setSize - 1) {
            return [res, sql.raw(", ")];
          }
          return [res];
        }));
      }
      buildUpdateQuery({ table: table6, set, where, returning, withList, limit, orderBy }) {
        const withSql = this.buildWithCTE(withList);
        const setSql = this.buildUpdateSet(table6, set);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const limitSql = this.buildLimit(limit);
        return sql`${withSql}update ${table6} set ${setSql}${whereSql}${orderBySql}${limitSql}${returningSql}`;
      }
      /**
       * Builds selection SQL with provided fields/expressions
       *
       * Examples:
       *
       * `select <selection> from`
       *
       * `insert ... returning <selection>`
       *
       * If `isSingleTable` is true, then columns won't be prefixed with table name
       */
      buildSelection(fields, { isSingleTable = false } = {}) {
        const columnsLen = fields.length;
        const chunks = fields.flatMap(({ field }, i8) => {
          const chunk = [];
          if (is(field, SQL.Aliased) && field.isSelectionField) {
            chunk.push(sql.identifier(field.fieldAlias));
          } else if (is(field, SQL.Aliased) || is(field, SQL)) {
            const query = is(field, SQL.Aliased) ? field.sql : field;
            if (isSingleTable) {
              chunk.push(
                new SQL(
                  query.queryChunks.map((c6) => {
                    if (is(c6, SingleStoreColumn)) {
                      return sql.identifier(this.casing.getColumnCasing(c6));
                    }
                    return c6;
                  })
                )
              );
            } else {
              chunk.push(query);
            }
            if (is(field, SQL.Aliased)) {
              chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
            }
          } else if (is(field, Column)) {
            if (isSingleTable) {
              chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
            } else {
              chunk.push(field);
            }
          }
          if (i8 < columnsLen - 1) {
            chunk.push(sql`, `);
          }
          return chunk;
        });
        return sql.join(chunks);
      }
      buildLimit(limit) {
        return typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
      }
      buildOrderBy(orderBy) {
        return orderBy && orderBy.length > 0 ? sql` order by ${sql.join(orderBy, sql`, `)}` : void 0;
      }
      buildSelectQuery({
        withList,
        fields,
        fieldsFlat,
        where,
        having,
        table: table6,
        joins,
        orderBy,
        groupBy,
        limit,
        offset,
        lockingClause,
        distinct,
        setOperators
      }) {
        const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
        for (const f9 of fieldsList) {
          if (is(f9.field, Column) && getTableName(f9.field.table) !== (is(table6, Subquery) ? table6._.alias : is(table6, SQL) ? void 0 : getTableName(table6)) && !((table22) => joins?.some(
            ({ alias: alias2 }) => alias2 === (table22[Table.Symbol.IsAlias] ? getTableName(table22) : table22[Table.Symbol.BaseName])
          ))(f9.field.table)) {
            const tableName = getTableName(f9.field.table);
            throw new Error(
              `Your "${f9.path.join("->")}" field references a column "${tableName}"."${f9.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`
            );
          }
        }
        const isSingleTable = !joins || joins.length === 0;
        const withSql = this.buildWithCTE(withList);
        const distinctSql = distinct ? sql` distinct` : void 0;
        const selection = this.buildSelection(fieldsList, { isSingleTable });
        const tableSql = (() => {
          if (is(table6, Table) && table6[Table.Symbol.IsAlias]) {
            return sql`${sql`${sql.identifier(table6[Table.Symbol.Schema] ?? "")}.`.if(table6[Table.Symbol.Schema])}${sql.identifier(table6[Table.Symbol.OriginalName])} ${sql.identifier(table6[Table.Symbol.Name])}`;
          }
          return table6;
        })();
        const joinsArray = [];
        if (joins) {
          for (const [index7, joinMeta] of joins.entries()) {
            if (index7 === 0) {
              joinsArray.push(sql` `);
            }
            const table22 = joinMeta.table;
            const lateralSql = joinMeta.lateral ? sql` lateral` : void 0;
            const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : void 0;
            if (is(table22, SingleStoreTable)) {
              const tableName = table22[SingleStoreTable.Symbol.Name];
              const tableSchema = table22[SingleStoreTable.Symbol.Schema];
              const origTableName = table22[SingleStoreTable.Symbol.OriginalName];
              const alias2 = tableName === origTableName ? void 0 : joinMeta.alias;
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias2 && sql` ${sql.identifier(alias2)}`}${onSql}`
              );
            } else if (is(table22, View)) {
              const viewName = table22[ViewBaseConfig].name;
              const viewSchema = table22[ViewBaseConfig].schema;
              const origViewName = table22[ViewBaseConfig].originalName;
              const alias2 = viewName === origViewName ? void 0 : joinMeta.alias;
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${viewSchema ? sql`${sql.identifier(viewSchema)}.` : void 0}${sql.identifier(origViewName)}${alias2 && sql` ${sql.identifier(alias2)}`}${onSql}`
              );
            } else {
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join${lateralSql} ${table22}${onSql}`
              );
            }
            if (index7 < joins.length - 1) {
              joinsArray.push(sql` `);
            }
          }
        }
        const joinsSql = sql.join(joinsArray);
        const whereSql = where ? sql` where ${where}` : void 0;
        const havingSql = having ? sql` having ${having}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const groupBySql = groupBy && groupBy.length > 0 ? sql` group by ${sql.join(groupBy, sql`, `)}` : void 0;
        const limitSql = this.buildLimit(limit);
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        let lockingClausesSql;
        if (lockingClause) {
          const { config, strength } = lockingClause;
          lockingClausesSql = sql` for ${sql.raw(strength)}`;
          if (config.noWait) {
            lockingClausesSql.append(sql` nowait`);
          } else if (config.skipLocked) {
            lockingClausesSql.append(sql` skip locked`);
          }
        }
        const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}${lockingClausesSql}`;
        if (setOperators.length > 0) {
          return this.buildSetOperations(finalQuery, setOperators);
        }
        return finalQuery;
      }
      buildSetOperations(leftSelect, setOperators) {
        const [setOperator, ...rest] = setOperators;
        if (!setOperator) {
          throw new Error("Cannot pass undefined values to any set operator");
        }
        if (rest.length === 0) {
          return this.buildSetOperationQuery({ leftSelect, setOperator });
        }
        return this.buildSetOperations(
          this.buildSetOperationQuery({ leftSelect, setOperator }),
          rest
        );
      }
      buildSetOperationQuery({
        leftSelect,
        setOperator: { type, isAll, rightSelect, limit, orderBy, offset }
      }) {
        const leftChunk = sql`(${leftSelect.getSQL()}) `;
        const rightChunk = sql`(${rightSelect.getSQL()})`;
        let orderBySql;
        if (orderBy && orderBy.length > 0) {
          const orderByValues = [];
          for (const orderByUnit of orderBy) {
            if (is(orderByUnit, SingleStoreColumn)) {
              orderByValues.push(sql.identifier(this.casing.getColumnCasing(orderByUnit)));
            } else if (is(orderByUnit, SQL)) {
              for (let i8 = 0; i8 < orderByUnit.queryChunks.length; i8++) {
                const chunk = orderByUnit.queryChunks[i8];
                if (is(chunk, SingleStoreColumn)) {
                  orderByUnit.queryChunks[i8] = sql.identifier(this.casing.getColumnCasing(chunk));
                }
              }
              orderByValues.push(sql`${orderByUnit}`);
            } else {
              orderByValues.push(sql`${orderByUnit}`);
            }
          }
          orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)} `;
        }
        const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
        const operatorChunk = sql.raw(`${type} ${isAll ? "all " : ""}`);
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
      }
      buildInsertQuery({ table: table6, values: values2, ignore, onConflict }) {
        const valuesSqlList = [];
        const columns = table6[Table.Symbol.Columns];
        const colEntries = Object.entries(columns).filter(
          ([_7, col]) => !col.shouldDisableInsert()
        );
        const insertOrder = colEntries.map(([, column6]) => sql.identifier(this.casing.getColumnCasing(column6)));
        const generatedIdsResponse = [];
        for (const [valueIndex, value] of values2.entries()) {
          const generatedIds = {};
          const valueList = [];
          for (const [fieldName, col] of colEntries) {
            const colValue = value[fieldName];
            if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
              if (col.defaultFn !== void 0) {
                const defaultFnResult = col.defaultFn();
                generatedIds[fieldName] = defaultFnResult;
                const defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
                valueList.push(defaultValue);
              } else if (!col.default && col.onUpdateFn !== void 0) {
                const onUpdateFnResult = col.onUpdateFn();
                const newValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
                valueList.push(newValue);
              } else {
                valueList.push(sql`default`);
              }
            } else {
              if (col.defaultFn && is(colValue, Param)) {
                generatedIds[fieldName] = colValue.value;
              }
              valueList.push(colValue);
            }
          }
          generatedIdsResponse.push(generatedIds);
          valuesSqlList.push(valueList);
          if (valueIndex < values2.length - 1) {
            valuesSqlList.push(sql`, `);
          }
        }
        const valuesSql = sql.join(valuesSqlList);
        const ignoreSql = ignore ? sql` ignore` : void 0;
        const onConflictSql = onConflict ? sql` on duplicate key ${onConflict}` : void 0;
        return {
          sql: sql`insert${ignoreSql} into ${table6} ${insertOrder} values ${valuesSql}${onConflictSql}`,
          generatedIds: generatedIdsResponse
        };
      }
      sqlToQuery(sql22, invokeSource) {
        return sql22.toQuery({
          casing: this.casing,
          escapeName: this.escapeName,
          escapeParam: this.escapeParam,
          escapeString: this.escapeString,
          invokeSource
        });
      }
      buildRelationalQuery({
        fullSchema,
        schema: schema6,
        tableNamesMap,
        table: table6,
        tableConfig,
        queryConfig: config,
        tableAlias,
        nestedQueryRelation,
        joinOn
      }) {
        let selection = [];
        let limit, offset, orderBy, where;
        const joins = [];
        if (config === true) {
          const selectionEntries = Object.entries(tableConfig.columns);
          selection = selectionEntries.map(([key, value]) => ({
            dbKey: value.name,
            tsKey: key,
            field: aliasedTableColumn(value, tableAlias),
            relationTableTsKey: void 0,
            isJson: false,
            selection: []
          }));
        } else {
          const aliasedColumns = Object.fromEntries(
            Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)])
          );
          if (config.where) {
            const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
          }
          const fieldsSelection = [];
          let selectedColumns = [];
          if (config.columns) {
            let isIncludeMode = false;
            for (const [field, value] of Object.entries(config.columns)) {
              if (value === void 0) {
                continue;
              }
              if (field in tableConfig.columns) {
                if (!isIncludeMode && value === true) {
                  isIncludeMode = true;
                }
                selectedColumns.push(field);
              }
            }
            if (selectedColumns.length > 0) {
              selectedColumns = isIncludeMode ? selectedColumns.filter((c6) => config.columns?.[c6] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
            }
          } else {
            selectedColumns = Object.keys(tableConfig.columns);
          }
          for (const field of selectedColumns) {
            const column6 = tableConfig.columns[field];
            fieldsSelection.push({ tsKey: field, value: column6 });
          }
          let selectedRelations = [];
          if (config.with) {
            selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
          }
          let extras;
          if (config.extras) {
            extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
            for (const [tsKey, value] of Object.entries(extras)) {
              fieldsSelection.push({
                tsKey,
                value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
              });
            }
          }
          for (const { tsKey, value } of fieldsSelection) {
            selection.push({
              dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
              tsKey,
              field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
              relationTableTsKey: void 0,
              isJson: false,
              selection: []
            });
          }
          let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
          if (!Array.isArray(orderByOrig)) {
            orderByOrig = [orderByOrig];
          }
          orderBy = orderByOrig.map((orderByValue) => {
            if (is(orderByValue, Column)) {
              return aliasedTableColumn(orderByValue, tableAlias);
            }
            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
          });
          limit = config.limit;
          offset = config.offset;
          for (const {
            tsKey: selectedRelationTsKey,
            queryConfig: selectedRelationConfigValue,
            relation
          } of selectedRelations) {
            const normalizedRelation = normalizeRelation(schema6, tableNamesMap, relation);
            const relationTableName = getTableUniqueName(relation.referencedTable);
            const relationTableTsName = tableNamesMap[relationTableName];
            const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
            const joinOn2 = and(
              ...normalizedRelation.fields.map(
                (field2, i8) => eq(
                  aliasedTableColumn(normalizedRelation.references[i8], relationTableAlias),
                  aliasedTableColumn(field2, tableAlias)
                )
              )
            );
            const builtRelation = this.buildRelationalQuery({
              fullSchema,
              schema: schema6,
              tableNamesMap,
              table: fullSchema[relationTableTsName],
              tableConfig: schema6[relationTableTsName],
              queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
              tableAlias: relationTableAlias,
              joinOn: joinOn2,
              nestedQueryRelation: relation
            });
            const field = sql`${sql.identifier(relationTableAlias)}.${sql.identifier("data")}`.as(selectedRelationTsKey);
            joins.push({
              on: sql`true`,
              table: new Subquery(builtRelation.sql, {}, relationTableAlias),
              alias: relationTableAlias,
              joinType: "left",
              lateral: true
            });
            selection.push({
              dbKey: selectedRelationTsKey,
              tsKey: selectedRelationTsKey,
              field,
              relationTableTsKey: relationTableTsName,
              isJson: true,
              selection: builtRelation.selection
            });
          }
        }
        if (selection.length === 0) {
          throw new DrizzleError({ message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}")` });
        }
        let result;
        where = and(joinOn, where);
        if (nestedQueryRelation) {
          let field = sql`JSON_TO_ARRAY(${sql.join(
            selection.map(
              ({ field: field2, tsKey, isJson: isJson2 }) => isJson2 ? sql`${sql.identifier(`${tableAlias}_${tsKey}`)}.${sql.identifier("data")}` : is(field2, SQL.Aliased) ? field2.sql : field2
            ),
            sql`, `
          )})`;
          if (is(nestedQueryRelation, Many)) {
            field = sql`json_agg(${field})`;
          }
          const nestedSelection = [{
            dbKey: "data",
            tsKey: "data",
            field: field.as("data"),
            isJson: true,
            relationTableTsKey: tableConfig.tsName,
            selection
          }];
          const needsSubquery = limit !== void 0 || offset !== void 0 || (orderBy?.length ?? 0) > 0;
          if (needsSubquery) {
            result = this.buildSelectQuery({
              table: aliasedTable(table6, tableAlias),
              fields: {},
              fieldsFlat: [
                {
                  path: [],
                  field: sql.raw("*")
                },
                ...(orderBy?.length ?? 0) > 0 ? [{
                  path: [],
                  field: sql`row_number() over (order by ${sql.join(orderBy, sql`, `)})`
                }] : []
              ],
              where,
              limit,
              offset,
              setOperators: []
            });
            where = void 0;
            limit = void 0;
            offset = void 0;
            orderBy = void 0;
          } else {
            result = aliasedTable(table6, tableAlias);
          }
          result = this.buildSelectQuery({
            table: is(result, SingleStoreTable) ? result : new Subquery(result, {}, tableAlias),
            fields: {},
            fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
              path: [],
              field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        } else {
          result = this.buildSelectQuery({
            table: aliasedTable(table6, tableAlias),
            fields: {},
            fieldsFlat: selection.map(({ field }) => ({
              path: [],
              field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        }
        return {
          tableTsKey: tableConfig.tsName,
          sql: result,
          selection
        };
      }
    };
    __publicField(SingleStoreDialect, _a355, "SingleStoreDialect");
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/select.js
function createSetOperator3(type, isAll) {
  return (leftSelect, rightSelect, ...restSelects) => {
    const setOperators = [rightSelect, ...restSelects].map((select2) => ({
      type,
      isAll,
      rightSelect: select2
    }));
    for (const setOperator of setOperators) {
      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
        throw new Error(
          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
        );
      }
    }
    return leftSelect.addSetOperators(setOperators);
  };
}
var _a356, SingleStoreSelectBuilder, _a357, _b274, SingleStoreSelectQueryBuilderBase, _a358, _b275, SingleStoreSelectBase, getSingleStoreSetOperators, union3, unionAll3, intersect3, except3, minus;
var init_select4 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/select.js"() {
    "use strict";
    init_entity();
    init_query_builder();
    init_query_promise();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_table();
    init_utils();
    init_utils6();
    _a356 = entityKind;
    SingleStoreSelectBuilder = class {
      constructor(config) {
        __publicField(this, "fields");
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "withList", []);
        __publicField(this, "distinct");
        this.fields = config.fields;
        this.session = config.session;
        this.dialect = config.dialect;
        if (config.withList) {
          this.withList = config.withList;
        }
        this.distinct = config.distinct;
      }
      from(source) {
        const isPartialSelect = !!this.fields;
        let fields;
        if (this.fields) {
          fields = this.fields;
        } else if (is(source, Subquery)) {
          fields = Object.fromEntries(
            Object.keys(source._.selectedFields).map((key) => [key, source[key]])
          );
        } else if (is(source, SQL)) {
          fields = {};
        } else {
          fields = getTableColumns(source);
        }
        return new SingleStoreSelectBase(
          {
            table: source,
            fields,
            isPartialSelect,
            session: this.session,
            dialect: this.dialect,
            withList: this.withList,
            distinct: this.distinct
          }
        );
      }
    };
    __publicField(SingleStoreSelectBuilder, _a356, "SingleStoreSelectBuilder");
    SingleStoreSelectQueryBuilderBase = class extends (_b274 = TypedQueryBuilder, _a357 = entityKind, _b274) {
      constructor({ table: table6, fields, isPartialSelect, session, dialect: dialect6, withList, distinct }) {
        super();
        __publicField(this, "_");
        __publicField(this, "config");
        __publicField(this, "joinsNotNullableMap");
        __publicField(this, "tableName");
        __publicField(this, "isPartialSelect");
        /** @internal */
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "cacheConfig");
        __publicField(this, "usedTables", /* @__PURE__ */ new Set());
        /**
         * Executes a `left join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "leftJoin", this.createJoin("left", false));
        /**
         * Executes a `left join lateral` operation by adding subquery to the current query.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#left-join-lateral}
         *
         * @param table the subquery to join.
         * @param on the `on` clause.
         */
        __publicField(this, "leftJoinLateral", this.createJoin("left", true));
        /**
         * Executes a `right join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "rightJoin", this.createJoin("right", false));
        /**
         * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
         *
         * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "innerJoin", this.createJoin("inner", false));
        /**
         * Executes an `inner join lateral` operation, creating a new table by combining rows from two queries that have matching values.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join-lateral}
         *
         * @param table the subquery to join.
         * @param on the `on` clause.
         */
        __publicField(this, "innerJoinLateral", this.createJoin("inner", true));
        /**
         * Executes a `full join` operation by combining rows from two tables into a new table.
         *
         * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()
         *   .from(users)
         *   .fullJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .fullJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "fullJoin", this.createJoin("full", false));
        /**
         * Executes a `cross join` operation by combining rows from two tables into a new table.
         *
         * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
         *
         * @param table the table to join.
         *
         * @example
         *
         * ```ts
         * // Select all users, each user with every pet
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .crossJoin(pets)
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .crossJoin(pets)
         * ```
         */
        __publicField(this, "crossJoin", this.createJoin("cross", false));
        /**
         * Executes a `cross join lateral` operation by combining rows from two queries into a new table.
         *
         * A `lateral` join allows the right-hand expression to refer to columns from the left-hand side.
         *
         * Calling this method retrieves all rows from both main and joined queries, merging all rows from each query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join-lateral}
         *
         * @param table the query to join.
         */
        __publicField(this, "crossJoinLateral", this.createJoin("cross", true));
        /**
         * Adds `union` set operator to the query.
         *
         * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
         *
         * @example
         *
         * ```ts
         * // Select all unique names from customers and users tables
         * await db.select({ name: users.name })
         *   .from(users)
         *   .union(
         *     db.select({ name: customers.name }).from(customers)
         *   );
         * // or
         * import { union } from 'drizzle-orm/singlestore-core'
         *
         * await union(
         *   db.select({ name: users.name }).from(users),
         *   db.select({ name: customers.name }).from(customers)
         * );
         * ```
         */
        __publicField(this, "union", this.createSetOperator("union", false));
        /**
         * Adds `union all` set operator to the query.
         *
         * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
         *
         * @example
         *
         * ```ts
         * // Select all transaction ids from both online and in-store sales
         * await db.select({ transaction: onlineSales.transactionId })
         *   .from(onlineSales)
         *   .unionAll(
         *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         *   );
         * // or
         * import { unionAll } from 'drizzle-orm/singlestore-core'
         *
         * await unionAll(
         *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
         *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         * );
         * ```
         */
        __publicField(this, "unionAll", this.createSetOperator("union", true));
        /**
         * Adds `intersect` set operator to the query.
         *
         * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
         *
         * @example
         *
         * ```ts
         * // Select course names that are offered in both departments A and B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .intersect(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { intersect } from 'drizzle-orm/singlestore-core'
         *
         * await intersect(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "intersect", this.createSetOperator("intersect", false));
        /**
         * Adds `except` set operator to the query.
         *
         * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
         *
         * @example
         *
         * ```ts
         * // Select all courses offered in department A but not in department B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .except(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { except } from 'drizzle-orm/singlestore-core'
         *
         * await except(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "except", this.createSetOperator("except", false));
        /**
         * Adds `minus` set operator to the query.
         *
         * This is an alias of `except` supported by SingleStore.
         *
         * @example
         *
         * ```ts
         * // Select all courses offered in department A but not in department B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .minus(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { minus } from 'drizzle-orm/singlestore-core'
         *
         * await minus(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "minus", this.createSetOperator("except", false));
        this.config = {
          withList,
          table: table6,
          fields: { ...fields },
          distinct,
          setOperators: []
        };
        this.isPartialSelect = isPartialSelect;
        this.session = session;
        this.dialect = dialect6;
        this._ = {
          selectedFields: fields,
          config: this.config
        };
        this.tableName = getTableLikeName(table6);
        this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
        for (const item of extractUsedTable3(table6)) this.usedTables.add(item);
      }
      /** @internal */
      getUsedTables() {
        return [...this.usedTables];
      }
      createJoin(joinType, lateral) {
        return (table6, on3) => {
          const baseTableName = this.tableName;
          const tableName = getTableLikeName(table6);
          for (const item of extractUsedTable3(table6)) this.usedTables.add(item);
          if (typeof tableName === "string" && this.config.joins?.some((join7) => join7.alias === tableName)) {
            throw new Error(`Alias "${tableName}" is already used in this query`);
          }
          if (!this.isPartialSelect) {
            if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") {
              this.config.fields = {
                [baseTableName]: this.config.fields
              };
            }
            if (typeof tableName === "string" && !is(table6, SQL)) {
              const selection = is(table6, Subquery) ? table6._.selectedFields : table6[Table.Symbol.Columns];
              this.config.fields[tableName] = selection;
            }
          }
          if (typeof on3 === "function") {
            on3 = on3(
              new Proxy(
                this.config.fields,
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              )
            );
          }
          if (!this.config.joins) {
            this.config.joins = [];
          }
          this.config.joins.push({ on: on3, table: table6, joinType, alias: tableName, lateral });
          if (typeof tableName === "string") {
            switch (joinType) {
              case "left": {
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
              case "right": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "cross":
              case "inner": {
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "full": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
            }
          }
          return this;
        };
      }
      createSetOperator(type, isAll) {
        return (rightSelection) => {
          const rightSelect = typeof rightSelection === "function" ? rightSelection(getSingleStoreSetOperators()) : rightSelection;
          if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
            throw new Error(
              "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
            );
          }
          this.config.setOperators.push({ type, isAll, rightSelect });
          return this;
        };
      }
      /** @internal */
      addSetOperators(setOperators) {
        this.config.setOperators.push(...setOperators);
        return this;
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be selected.
       *
       * ```ts
       * // Select all cars with green color
       * await db.select().from(cars).where(eq(cars.color, 'green'));
       * // or
       * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Select all BMW cars with a green color
       * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Select all cars with the green or blue color
       * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        if (typeof where === "function") {
          where = where(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.where = where;
        return this;
      }
      /**
       * Adds a `having` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
       *
       * @param having the `having` clause.
       *
       * @example
       *
       * ```ts
       * // Select all brands with more than one car
       * await db.select({
       * 	brand: cars.brand,
       * 	count: sql<number>`cast(count(${cars.id}) as int)`,
       * })
       *   .from(cars)
       *   .groupBy(cars.brand)
       *   .having(({ count }) => gt(count, 1));
       * ```
       */
      having(having) {
        if (typeof having === "function") {
          having = having(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.having = having;
        return this;
      }
      groupBy(...columns) {
        if (typeof columns[0] === "function") {
          const groupBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
        } else {
          this.config.groupBy = columns;
        }
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        } else {
          const orderByArray = columns;
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        }
        return this;
      }
      /**
       * Adds a `limit` clause to the query.
       *
       * Calling this method will set the maximum number of rows that will be returned by this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param limit the `limit` clause.
       *
       * @example
       *
       * ```ts
       * // Get the first 10 people from this query.
       * await db.select().from(people).limit(10);
       * ```
       */
      limit(limit) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).limit = limit;
        } else {
          this.config.limit = limit;
        }
        return this;
      }
      /**
       * Adds an `offset` clause to the query.
       *
       * Calling this method will skip a number of rows when returning results from this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param offset the `offset` clause.
       *
       * @example
       *
       * ```ts
       * // Get the 10th-20th people from this query.
       * await db.select().from(people).offset(10).limit(10);
       * ```
       */
      offset(offset) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).offset = offset;
        } else {
          this.config.offset = offset;
        }
        return this;
      }
      /**
       * Adds a `for` clause to the query.
       *
       * Calling this method will specify a lock strength for this query that controls how strictly it acquires exclusive access to the rows being queried.
       *
       * @param strength the lock strength.
       * @param config the lock configuration.
       */
      for(strength, config = {}) {
        this.config.lockingClause = { strength, config };
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildSelectQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      as(alias2) {
        const usedTables = [];
        usedTables.push(...extractUsedTable3(this.config.table));
        if (this.config.joins) {
          for (const it2 of this.config.joins) usedTables.push(...extractUsedTable3(it2.table));
        }
        return new Proxy(
          new Subquery(this.getSQL(), this.config.fields, alias2, false, [...new Set(usedTables)]),
          new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      /** @internal */
      getSelectedFields() {
        return new Proxy(
          this.config.fields,
          new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SingleStoreSelectQueryBuilderBase, _a357, "SingleStoreSelectQueryBuilder");
    SingleStoreSelectBase = class extends (_b275 = SingleStoreSelectQueryBuilderBase, _a358 = entityKind, _b275) {
      constructor() {
        super(...arguments);
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
      }
      prepare() {
        if (!this.session) {
          throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
        }
        const fieldsList = orderSelectedFields(this.config.fields);
        const query = this.session.prepareQuery(this.dialect.sqlToQuery(this.getSQL()), fieldsList, void 0, void 0, void 0, {
          type: "select",
          tables: [...this.usedTables]
        }, this.cacheConfig);
        query.joinsNotNullableMap = this.joinsNotNullableMap;
        return query;
      }
      $withCache(config) {
        this.cacheConfig = config === void 0 ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };
        return this;
      }
    };
    __publicField(SingleStoreSelectBase, _a358, "SingleStoreSelect");
    applyMixins(SingleStoreSelectBase, [QueryPromise]);
    getSingleStoreSetOperators = () => ({
      union: union3,
      unionAll: unionAll3,
      intersect: intersect3,
      except: except3,
      minus
    });
    union3 = createSetOperator3("union", false);
    unionAll3 = createSetOperator3("union", true);
    intersect3 = createSetOperator3("intersect", false);
    except3 = createSetOperator3("except", false);
    minus = createSetOperator3("except", true);
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/query-builder.js
var _a359, QueryBuilder3;
var init_query_builder4 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/query-builder.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_dialect3();
    init_subquery();
    init_select4();
    _a359 = entityKind;
    QueryBuilder3 = class {
      constructor(dialect6) {
        __publicField(this, "dialect");
        __publicField(this, "dialectConfig");
        __publicField(this, "$with", (alias2, selection) => {
          const queryBuilder = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(queryBuilder);
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        this.dialect = is(dialect6, SingleStoreDialect) ? dialect6 : void 0;
        this.dialectConfig = is(dialect6, SingleStoreDialect) ? void 0 : dialect6;
      }
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new SingleStoreSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new SingleStoreSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            withList: queries,
            distinct: true
          });
        }
        return { select: select2, selectDistinct };
      }
      select(fields) {
        return new SingleStoreSelectBuilder({
          fields: fields ?? void 0,
          session: void 0,
          dialect: this.getDialect()
        });
      }
      selectDistinct(fields) {
        return new SingleStoreSelectBuilder({
          fields: fields ?? void 0,
          session: void 0,
          dialect: this.getDialect(),
          distinct: true
        });
      }
      // Lazy load dialect to avoid circular dependency
      getDialect() {
        if (!this.dialect) {
          this.dialect = new SingleStoreDialect(this.dialectConfig);
        }
        return this.dialect;
      }
    };
    __publicField(QueryBuilder3, _a359, "SingleStoreQueryBuilder");
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/select.types.js
var init_select_types3 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/select.types.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/update.js
var _a360, SingleStoreUpdateBuilder, _a361, _b276, SingleStoreUpdateBase;
var init_update3 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/update.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_table();
    init_utils();
    init_utils6();
    _a360 = entityKind;
    SingleStoreUpdateBuilder = class {
      constructor(table6, session, dialect6, withList) {
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.withList = withList;
      }
      set(values2) {
        return new SingleStoreUpdateBase(
          this.table,
          mapUpdateSet(this.table, values2),
          this.session,
          this.dialect,
          this.withList
        );
      }
    };
    __publicField(SingleStoreUpdateBuilder, _a360, "SingleStoreUpdateBuilder");
    SingleStoreUpdateBase = class extends (_b276 = QueryPromise, _a361 = entityKind, _b276) {
      constructor(table6, set, session, dialect6, withList) {
        super();
        __publicField(this, "config");
        __publicField(this, "execute", (placeholderValues) => {
          return this.prepare().execute(placeholderValues);
        });
        __publicField(this, "createIterator", () => {
          const self2 = this;
          return async function* (placeholderValues) {
            yield* self2.prepare().iterator(placeholderValues);
          };
        });
        __publicField(this, "iterator", this.createIterator());
        this.session = session;
        this.dialect = dialect6;
        this.config = { set, table: table6, withList };
      }
      /**
       * Adds a 'where' clause to the query.
       *
       * Calling this method will update only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param where the 'where' clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be updated.
       *
       * ```ts
       * // Update all cars with green color
       * db.update(cars).set({ color: 'red' })
       *   .where(eq(cars.color, 'green'));
       * // or
       * db.update(cars).set({ color: 'red' })
       *   .where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Update all BMW cars with a green color
       * db.update(cars).set({ color: 'red' })
       *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Update all cars with the green or blue color
       * db.update(cars).set({ color: 'red' })
       *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.table[Table.Symbol.Columns],
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          this.config.orderBy = orderByArray;
        } else {
          const orderByArray = columns;
          this.config.orderBy = orderByArray;
        }
        return this;
      }
      limit(limit) {
        this.config.limit = limit;
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildUpdateQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      prepare() {
        return this.session.prepareQuery(
          this.dialect.sqlToQuery(this.getSQL()),
          this.config.returning,
          void 0,
          void 0,
          void 0,
          {
            type: "delete",
            tables: extractUsedTable3(this.config.table)
          }
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SingleStoreUpdateBase, _a361, "SingleStoreUpdate");
  }
});

// ../drizzle-orm/dist/singlestore-core/query-builders/index.js
var init_query_builders3 = __esm({
  "../drizzle-orm/dist/singlestore-core/query-builders/index.js"() {
    "use strict";
    init_delete3();
    init_insert3();
    init_query_builder4();
    init_select4();
    init_select_types3();
    init_update3();
  }
});

// ../drizzle-orm/dist/singlestore-core/db.js
var _a362, SingleStoreDatabase;
var init_db3 = __esm({
  "../drizzle-orm/dist/singlestore-core/db.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_count3();
    init_query_builders3();
    _a362 = entityKind;
    SingleStoreDatabase = class {
      constructor(dialect6, session, schema6) {
        // We are waiting for SingleStore support for `json_array` function
        /**@inrernal */
        __publicField(this, "query");
        /**
         * Creates a subquery that defines a temporary named result set as a CTE.
         *
         * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
         *
         * @param alias The alias for the subquery.
         *
         * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
         *
         * @example
         *
         * ```ts
         * // Create a subquery with alias 'sq' and use it in the select query
         * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
         *
         * const result = await db.with(sq).select().from(sq);
         * ```
         *
         * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
         *
         * ```ts
         * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
         * const sq = db.$with('sq').as(db.select({
         *   name: sql<string>`upper(${users.name})`.as('name'),
         * })
         * .from(users));
         *
         * const result = await db.with(sq).select({ name: sq.name }).from(sq);
         * ```
         */
        __publicField(this, "$with", (alias2, selection) => {
          const self2 = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(new QueryBuilder3(self2.dialect));
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        __publicField(this, "$cache");
        this.dialect = dialect6;
        this.session = session;
        this._ = schema6 ? {
          schema: schema6.schema,
          fullSchema: schema6.fullSchema,
          tableNamesMap: schema6.tableNamesMap
        } : {
          schema: void 0,
          fullSchema: {},
          tableNamesMap: {}
        };
        this.query = {};
        this.$cache = { invalidate: async (_params2) => {
        } };
      }
      $count(source, filters) {
        return new SingleStoreCountBuilder({ source, filters, session: this.session });
      }
      /**
       * Incorporates a previously defined CTE (using `$with`) into the main query.
       *
       * This method allows the main query to reference a temporary named result set.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
       *
       * @param queries The CTEs to incorporate into the main query.
       *
       * @example
       *
       * ```ts
       * // Define a subquery 'sq' as a CTE using $with
       * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
       *
       * // Incorporate the CTE 'sq' into the main query and select from it
       * const result = await db.with(sq).select().from(sq);
       * ```
       */
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new SingleStoreSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new SingleStoreSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries,
            distinct: true
          });
        }
        function update(table6) {
          return new SingleStoreUpdateBuilder(table6, self2.session, self2.dialect, queries);
        }
        function delete_(table6) {
          return new SingleStoreDeleteBase(table6, self2.session, self2.dialect, queries);
        }
        return { select: select2, selectDistinct, update, delete: delete_ };
      }
      select(fields) {
        return new SingleStoreSelectBuilder({ fields: fields ?? void 0, session: this.session, dialect: this.dialect });
      }
      selectDistinct(fields) {
        return new SingleStoreSelectBuilder({
          fields: fields ?? void 0,
          session: this.session,
          dialect: this.dialect,
          distinct: true
        });
      }
      /**
       * Creates an update query.
       *
       * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
       *
       * Use `.set()` method to specify which values to update.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param table The table to update.
       *
       * @example
       *
       * ```ts
       * // Update all rows in the 'cars' table
       * await db.update(cars).set({ color: 'red' });
       *
       * // Update rows with filters and conditions
       * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
       * ```
       */
      update(table6) {
        return new SingleStoreUpdateBuilder(table6, this.session, this.dialect);
      }
      /**
       * Creates an insert query.
       *
       * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert}
       *
       * @param table The table to insert into.
       *
       * @example
       *
       * ```ts
       * // Insert one row
       * await db.insert(cars).values({ brand: 'BMW' });
       *
       * // Insert multiple rows
       * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
       * ```
       */
      insert(table6) {
        return new SingleStoreInsertBuilder(table6, this.session, this.dialect);
      }
      /**
       * Creates a delete query.
       *
       * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param table The table to delete from.
       *
       * @example
       *
       * ```ts
       * // Delete all rows in the 'cars' table
       * await db.delete(cars);
       *
       * // Delete rows with filters and conditions
       * await db.delete(cars).where(eq(cars.color, 'green'));
       * ```
       */
      delete(table6) {
        return new SingleStoreDeleteBase(table6, this.session, this.dialect);
      }
      execute(query) {
        return this.session.execute(typeof query === "string" ? sql.raw(query) : query.getSQL());
      }
      transaction(transaction, config) {
        return this.session.transaction(transaction, config);
      }
    };
    __publicField(SingleStoreDatabase, _a362, "SingleStoreDatabase");
  }
});

// ../drizzle-orm/dist/singlestore-core/schema.js
var _a363, SingleStoreSchema;
var init_schema3 = __esm({
  "../drizzle-orm/dist/singlestore-core/schema.js"() {
    "use strict";
    init_entity();
    init_table4();
    _a363 = entityKind;
    SingleStoreSchema = class {
      constructor(schemaName) {
        __publicField(this, "table", (name3, columns, extraConfig) => {
          return singlestoreTableWithSchema(name3, columns, extraConfig, this.schemaName);
        });
        this.schemaName = schemaName;
      }
      /*
      view = ((name, columns) => {
      	return singlestoreViewWithSchema(name, columns, this.schemaName);
      }) as typeof singlestoreView; */
    };
    __publicField(SingleStoreSchema, _a363, "SingleStoreSchema");
  }
});

// ../drizzle-orm/dist/singlestore-core/session.js
var _a364, SingleStorePreparedQuery, _a365, SingleStoreSession, _a366, _b277, SingleStoreTransaction;
var init_session3 = __esm({
  "../drizzle-orm/dist/singlestore-core/session.js"() {
    "use strict";
    init_cache();
    init_entity();
    init_errors();
    init_sql();
    init_db3();
    _a364 = entityKind;
    SingleStorePreparedQuery = class {
      constructor(cache5, queryMetadata, cacheConfig) {
        /** @internal */
        __publicField(this, "joinsNotNullableMap");
        this.cache = cache5;
        this.queryMetadata = queryMetadata;
        this.cacheConfig = cacheConfig;
        if (cache5 && cache5.strategy() === "all" && cacheConfig === void 0) {
          this.cacheConfig = { enable: true, autoInvalidate: true };
        }
        if (!this.cacheConfig?.enable) {
          this.cacheConfig = void 0;
        }
      }
      /** @internal */
      async queryWithCache(queryString, params, query) {
        if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.cacheConfig && !this.cacheConfig.enable) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) {
          try {
            const [res] = await Promise.all([
              query(),
              this.cache.onMutate({ tables: this.queryMetadata.tables })
            ]);
            return res;
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (!this.cacheConfig) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.queryMetadata.type === "select") {
          const fromCache = await this.cache.get(
            this.cacheConfig.tag ?? await hashQuery(queryString, params),
            this.queryMetadata.tables,
            this.cacheConfig.tag !== void 0,
            this.cacheConfig.autoInvalidate
          );
          if (fromCache === void 0) {
            let result;
            try {
              result = await query();
            } catch (e6) {
              throw new DrizzleQueryError(queryString, params, e6);
            }
            await this.cache.put(
              this.cacheConfig.tag ?? await hashQuery(queryString, params),
              result,
              // make sure we send tables that were used in a query only if user wants to invalidate it on each write
              this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
              this.cacheConfig.tag !== void 0,
              this.cacheConfig.config
            );
            return result;
          }
          return fromCache;
        }
        try {
          return await query();
        } catch (e6) {
          throw new DrizzleQueryError(queryString, params, e6);
        }
      }
    };
    __publicField(SingleStorePreparedQuery, _a364, "SingleStorePreparedQuery");
    _a365 = entityKind;
    SingleStoreSession = class {
      constructor(dialect6) {
        this.dialect = dialect6;
      }
      execute(query) {
        return this.prepareQuery(
          this.dialect.sqlToQuery(query),
          void 0
        ).execute();
      }
      async count(sql22) {
        const res = await this.execute(sql22);
        return Number(
          res[0][0]["count"]
        );
      }
      getSetTransactionSQL(config) {
        const parts2 = [];
        if (config.isolationLevel) {
          parts2.push(`isolation level ${config.isolationLevel}`);
        }
        return parts2.length ? sql`set transaction ${sql.raw(parts2.join(" "))}` : void 0;
      }
      getStartTransactionSQL(config) {
        const parts2 = [];
        if (config.withConsistentSnapshot) {
          parts2.push("with consistent snapshot");
        }
        if (config.accessMode) {
          parts2.push(config.accessMode);
        }
        return parts2.length ? sql`start transaction ${sql.raw(parts2.join(" "))}` : void 0;
      }
    };
    __publicField(SingleStoreSession, _a365, "SingleStoreSession");
    SingleStoreTransaction = class extends (_b277 = SingleStoreDatabase, _a366 = entityKind, _b277) {
      constructor(dialect6, session, schema6, nestedIndex) {
        super(dialect6, session, schema6);
        this.schema = schema6;
        this.nestedIndex = nestedIndex;
      }
      rollback() {
        throw new TransactionRollbackError();
      }
    };
    __publicField(SingleStoreTransaction, _a366, "SingleStoreTransaction");
  }
});

// ../drizzle-orm/dist/singlestore-core/subquery.js
var init_subquery4 = __esm({
  "../drizzle-orm/dist/singlestore-core/subquery.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/singlestore-core/index.js
var init_singlestore_core = __esm({
  "../drizzle-orm/dist/singlestore-core/index.js"() {
    "use strict";
    init_alias4();
    init_columns3();
    init_db3();
    init_dialect3();
    init_indexes3();
    init_primary_keys3();
    init_query_builders3();
    init_schema3();
    init_session3();
    init_subquery4();
    init_table4();
    init_unique_constraint3();
    init_utils6();
  }
});

// ../drizzle-orm/dist/sqlite-core/alias.js
var init_alias5 = __esm({
  "../drizzle-orm/dist/sqlite-core/alias.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/sqlite-core/checks.js
var _a367, CheckBuilder3, _a368, Check3;
var init_checks3 = __esm({
  "../drizzle-orm/dist/sqlite-core/checks.js"() {
    "use strict";
    init_entity();
    _a367 = entityKind;
    CheckBuilder3 = class {
      constructor(name3, value) {
        __publicField(this, "brand");
        this.name = name3;
        this.value = value;
      }
      build(table6) {
        return new Check3(table6, this);
      }
    };
    __publicField(CheckBuilder3, _a367, "SQLiteCheckBuilder");
    _a368 = entityKind;
    Check3 = class {
      constructor(table6, builder) {
        __publicField(this, "name");
        __publicField(this, "value");
        this.table = table6;
        this.name = builder.name;
        this.value = builder.value;
      }
    };
    __publicField(Check3, _a368, "SQLiteCheck");
  }
});

// ../drizzle-orm/dist/sqlite-core/foreign-keys.js
var _a369, ForeignKeyBuilder3, _a370, ForeignKey3;
var init_foreign_keys3 = __esm({
  "../drizzle-orm/dist/sqlite-core/foreign-keys.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    _a369 = entityKind;
    ForeignKeyBuilder3 = class {
      constructor(config, actions) {
        /** @internal */
        __publicField(this, "reference");
        /** @internal */
        __publicField(this, "_onUpdate");
        /** @internal */
        __publicField(this, "_onDelete");
        this.reference = () => {
          const { name: name3, columns, foreignColumns } = config();
          return { name: name3, columns, foreignTable: foreignColumns[0].table, foreignColumns };
        };
        if (actions) {
          this._onUpdate = actions.onUpdate;
          this._onDelete = actions.onDelete;
        }
      }
      onUpdate(action) {
        this._onUpdate = action;
        return this;
      }
      onDelete(action) {
        this._onDelete = action;
        return this;
      }
      /** @internal */
      build(table6) {
        return new ForeignKey3(table6, this);
      }
    };
    __publicField(ForeignKeyBuilder3, _a369, "SQLiteForeignKeyBuilder");
    _a370 = entityKind;
    ForeignKey3 = class {
      constructor(table6, builder) {
        __publicField(this, "reference");
        __publicField(this, "onUpdate");
        __publicField(this, "onDelete");
        this.table = table6;
        this.reference = builder.reference;
        this.onUpdate = builder._onUpdate;
        this.onDelete = builder._onDelete;
      }
      getName() {
        const { name: name3, columns, foreignColumns } = this.reference();
        const columnNames = columns.map((column6) => column6.name);
        const foreignColumnNames = foreignColumns.map((column6) => column6.name);
        const chunks = [
          this.table[TableName],
          ...columnNames,
          foreignColumns[0].table[TableName],
          ...foreignColumnNames
        ];
        return name3 ?? `${chunks.join("_")}_fk`;
      }
    };
    __publicField(ForeignKey3, _a370, "SQLiteForeignKey");
  }
});

// ../drizzle-orm/dist/sqlite-core/unique-constraint.js
function uniqueKeyName4(table6, columns) {
  return `${table6[TableName]}_${columns.join("_")}_unique`;
}
var _a371, UniqueConstraintBuilder4, _a372, UniqueOnConstraintBuilder4, _a373, UniqueConstraint4;
var init_unique_constraint4 = __esm({
  "../drizzle-orm/dist/sqlite-core/unique-constraint.js"() {
    "use strict";
    init_entity();
    init_table_utils();
    _a371 = entityKind;
    UniqueConstraintBuilder4 = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        this.name = name3;
        this.columns = columns;
      }
      /** @internal */
      build(table6) {
        return new UniqueConstraint4(table6, this.columns, this.name);
      }
    };
    __publicField(UniqueConstraintBuilder4, _a371, "SQLiteUniqueConstraintBuilder");
    _a372 = entityKind;
    UniqueOnConstraintBuilder4 = class {
      constructor(name3) {
        /** @internal */
        __publicField(this, "name");
        this.name = name3;
      }
      on(...columns) {
        return new UniqueConstraintBuilder4(columns, this.name);
      }
    };
    __publicField(UniqueOnConstraintBuilder4, _a372, "SQLiteUniqueOnConstraintBuilder");
    _a373 = entityKind;
    UniqueConstraint4 = class {
      constructor(table6, columns, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        this.table = table6;
        this.columns = columns;
        this.name = name3 ?? uniqueKeyName4(this.table, this.columns.map((column6) => column6.name));
      }
      getName() {
        return this.name;
      }
    };
    __publicField(UniqueConstraint4, _a373, "SQLiteUniqueConstraint");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/common.js
var _a374, _b278, SQLiteColumnBuilder, _a375, _b279, SQLiteColumn;
var init_common4 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/common.js"() {
    "use strict";
    init_column_builder();
    init_column();
    init_entity();
    init_foreign_keys3();
    init_unique_constraint4();
    SQLiteColumnBuilder = class extends (_b278 = ColumnBuilder, _a374 = entityKind, _b278) {
      constructor() {
        super(...arguments);
        __publicField(this, "foreignKeyConfigs", []);
      }
      references(ref, actions = {}) {
        this.foreignKeyConfigs.push({ ref, actions });
        return this;
      }
      unique(name3) {
        this.config.isUnique = true;
        this.config.uniqueName = name3;
        return this;
      }
      generatedAlwaysAs(as, config) {
        this.config.generated = {
          as,
          type: "always",
          mode: config?.mode ?? "virtual"
        };
        return this;
      }
      /** @internal */
      buildForeignKeys(column6, table6) {
        return this.foreignKeyConfigs.map(({ ref, actions }) => {
          return ((ref2, actions2) => {
            const builder = new ForeignKeyBuilder3(() => {
              const foreignColumn = ref2();
              return { columns: [column6], foreignColumns: [foreignColumn] };
            });
            if (actions2.onUpdate) {
              builder.onUpdate(actions2.onUpdate);
            }
            if (actions2.onDelete) {
              builder.onDelete(actions2.onDelete);
            }
            return builder.build(table6);
          })(ref, actions);
        });
      }
    };
    __publicField(SQLiteColumnBuilder, _a374, "SQLiteColumnBuilder");
    SQLiteColumn = class extends (_b279 = Column, _a375 = entityKind, _b279) {
      constructor(table6, config) {
        if (!config.uniqueName) {
          config.uniqueName = uniqueKeyName4(table6, [config.name]);
        }
        super(table6, config);
        this.table = table6;
      }
    };
    __publicField(SQLiteColumn, _a375, "SQLiteColumn");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/blob.js
function blob(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "json") {
    return new SQLiteBlobJsonBuilder(name3);
  }
  if (config?.mode === "bigint") {
    return new SQLiteBigIntBuilder(name3);
  }
  return new SQLiteBlobBufferBuilder(name3);
}
var _a376, _b280, SQLiteBigIntBuilder, _a377, _b281, SQLiteBigInt, _a378, _b282, SQLiteBlobJsonBuilder, _a379, _b283, SQLiteBlobJson, _a380, _b284, SQLiteBlobBufferBuilder, _a381, _b285, SQLiteBlobBuffer;
var init_blob = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/blob.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common4();
    SQLiteBigIntBuilder = class extends (_b280 = SQLiteColumnBuilder, _a376 = entityKind, _b280) {
      constructor(name3) {
        super(name3, "bigint", "SQLiteBigInt");
      }
      /** @internal */
      build(table6) {
        return new SQLiteBigInt(table6, this.config);
      }
    };
    __publicField(SQLiteBigIntBuilder, _a376, "SQLiteBigIntBuilder");
    SQLiteBigInt = class extends (_b281 = SQLiteColumn, _a377 = entityKind, _b281) {
      getSQLType() {
        return "blob";
      }
      mapFromDriverValue(value) {
        if (typeof Buffer !== "undefined" && Buffer.from) {
          const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
          return BigInt(buf.toString("utf8"));
        }
        return BigInt(textDecoder.decode(value));
      }
      mapToDriverValue(value) {
        return Buffer.from(value.toString());
      }
    };
    __publicField(SQLiteBigInt, _a377, "SQLiteBigInt");
    SQLiteBlobJsonBuilder = class extends (_b282 = SQLiteColumnBuilder, _a378 = entityKind, _b282) {
      constructor(name3) {
        super(name3, "json", "SQLiteBlobJson");
      }
      /** @internal */
      build(table6) {
        return new SQLiteBlobJson(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteBlobJsonBuilder, _a378, "SQLiteBlobJsonBuilder");
    SQLiteBlobJson = class extends (_b283 = SQLiteColumn, _a379 = entityKind, _b283) {
      getSQLType() {
        return "blob";
      }
      mapFromDriverValue(value) {
        if (typeof Buffer !== "undefined" && Buffer.from) {
          const buf = Buffer.isBuffer(value) ? value : value instanceof ArrayBuffer ? Buffer.from(value) : value.buffer ? Buffer.from(value.buffer, value.byteOffset, value.byteLength) : Buffer.from(value);
          return JSON.parse(buf.toString("utf8"));
        }
        return JSON.parse(textDecoder.decode(value));
      }
      mapToDriverValue(value) {
        return Buffer.from(JSON.stringify(value));
      }
    };
    __publicField(SQLiteBlobJson, _a379, "SQLiteBlobJson");
    SQLiteBlobBufferBuilder = class extends (_b284 = SQLiteColumnBuilder, _a380 = entityKind, _b284) {
      constructor(name3) {
        super(name3, "buffer", "SQLiteBlobBuffer");
      }
      /** @internal */
      build(table6) {
        return new SQLiteBlobBuffer(table6, this.config);
      }
    };
    __publicField(SQLiteBlobBufferBuilder, _a380, "SQLiteBlobBufferBuilder");
    SQLiteBlobBuffer = class extends (_b285 = SQLiteColumn, _a381 = entityKind, _b285) {
      mapFromDriverValue(value) {
        if (Buffer.isBuffer(value)) {
          return value;
        }
        return Buffer.from(value);
      }
      getSQLType() {
        return "blob";
      }
    };
    __publicField(SQLiteBlobBuffer, _a381, "SQLiteBlobBuffer");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/custom.js
function customType4(customTypeParams) {
  return (a9, b9) => {
    const { name: name3, config } = getColumnNameAndConfig(a9, b9);
    return new SQLiteCustomColumnBuilder(
      name3,
      config,
      customTypeParams
    );
  };
}
var _a382, _b286, SQLiteCustomColumnBuilder, _a383, _b287, SQLiteCustomColumn;
var init_custom4 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/custom.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common4();
    SQLiteCustomColumnBuilder = class extends (_b286 = SQLiteColumnBuilder, _a382 = entityKind, _b286) {
      constructor(name3, fieldConfig, customTypeParams) {
        super(name3, "custom", "SQLiteCustomColumn");
        this.config.fieldConfig = fieldConfig;
        this.config.customTypeParams = customTypeParams;
      }
      /** @internal */
      build(table6) {
        return new SQLiteCustomColumn(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteCustomColumnBuilder, _a382, "SQLiteCustomColumnBuilder");
    SQLiteCustomColumn = class extends (_b287 = SQLiteColumn, _a383 = entityKind, _b287) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "sqlName");
        __publicField(this, "mapTo");
        __publicField(this, "mapFrom");
        this.sqlName = config.customTypeParams.dataType(config.fieldConfig);
        this.mapTo = config.customTypeParams.toDriver;
        this.mapFrom = config.customTypeParams.fromDriver;
      }
      getSQLType() {
        return this.sqlName;
      }
      mapFromDriverValue(value) {
        return typeof this.mapFrom === "function" ? this.mapFrom(value) : value;
      }
      mapToDriverValue(value) {
        return typeof this.mapTo === "function" ? this.mapTo(value) : value;
      }
    };
    __publicField(SQLiteCustomColumn, _a383, "SQLiteCustomColumn");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/integer.js
function integer2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config?.mode === "timestamp" || config?.mode === "timestamp_ms") {
    return new SQLiteTimestampBuilder(name3, config.mode);
  }
  if (config?.mode === "boolean") {
    return new SQLiteBooleanBuilder(name3, config.mode);
  }
  return new SQLiteIntegerBuilder(name3);
}
var _a384, _b288, SQLiteBaseIntegerBuilder, _a385, _b289, SQLiteBaseInteger, _a386, _b290, SQLiteIntegerBuilder, _a387, _b291, SQLiteInteger, _a388, _b292, SQLiteTimestampBuilder, _a389, _b293, SQLiteTimestamp, _a390, _b294, SQLiteBooleanBuilder, _a391, _b295, SQLiteBoolean;
var init_integer2 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/integer.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_utils();
    init_common4();
    SQLiteBaseIntegerBuilder = class extends (_b288 = SQLiteColumnBuilder, _a384 = entityKind, _b288) {
      constructor(name3, dataType, columnType) {
        super(name3, dataType, columnType);
        this.config.autoIncrement = false;
      }
      primaryKey(config) {
        if (config?.autoIncrement) {
          this.config.autoIncrement = true;
        }
        this.config.hasDefault = true;
        return super.primaryKey();
      }
    };
    __publicField(SQLiteBaseIntegerBuilder, _a384, "SQLiteBaseIntegerBuilder");
    SQLiteBaseInteger = class extends (_b289 = SQLiteColumn, _a385 = entityKind, _b289) {
      constructor() {
        super(...arguments);
        __publicField(this, "autoIncrement", this.config.autoIncrement);
      }
      getSQLType() {
        return "integer";
      }
    };
    __publicField(SQLiteBaseInteger, _a385, "SQLiteBaseInteger");
    SQLiteIntegerBuilder = class extends (_b290 = SQLiteBaseIntegerBuilder, _a386 = entityKind, _b290) {
      constructor(name3) {
        super(name3, "number", "SQLiteInteger");
      }
      build(table6) {
        return new SQLiteInteger(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteIntegerBuilder, _a386, "SQLiteIntegerBuilder");
    SQLiteInteger = class extends (_b291 = SQLiteBaseInteger, _a387 = entityKind, _b291) {
    };
    __publicField(SQLiteInteger, _a387, "SQLiteInteger");
    SQLiteTimestampBuilder = class extends (_b292 = SQLiteBaseIntegerBuilder, _a388 = entityKind, _b292) {
      constructor(name3, mode) {
        super(name3, "date", "SQLiteTimestamp");
        this.config.mode = mode;
      }
      /**
       * @deprecated Use `default()` with your own expression instead.
       *
       * Adds `DEFAULT (cast((julianday('now') - 2440587.5)*86400000 as integer))` to the column, which is the current epoch timestamp in milliseconds.
       */
      defaultNow() {
        return this.default(sql`(cast((julianday('now') - 2440587.5)*86400000 as integer))`);
      }
      build(table6) {
        return new SQLiteTimestamp(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteTimestampBuilder, _a388, "SQLiteTimestampBuilder");
    SQLiteTimestamp = class extends (_b293 = SQLiteBaseInteger, _a389 = entityKind, _b293) {
      constructor() {
        super(...arguments);
        __publicField(this, "mode", this.config.mode);
      }
      mapFromDriverValue(value) {
        if (this.config.mode === "timestamp") {
          return new Date(value * 1e3);
        }
        return new Date(value);
      }
      mapToDriverValue(value) {
        const unix = value.getTime();
        if (this.config.mode === "timestamp") {
          return Math.floor(unix / 1e3);
        }
        return unix;
      }
    };
    __publicField(SQLiteTimestamp, _a389, "SQLiteTimestamp");
    SQLiteBooleanBuilder = class extends (_b294 = SQLiteBaseIntegerBuilder, _a390 = entityKind, _b294) {
      constructor(name3, mode) {
        super(name3, "boolean", "SQLiteBoolean");
        this.config.mode = mode;
      }
      build(table6) {
        return new SQLiteBoolean(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteBooleanBuilder, _a390, "SQLiteBooleanBuilder");
    SQLiteBoolean = class extends (_b295 = SQLiteBaseInteger, _a391 = entityKind, _b295) {
      constructor() {
        super(...arguments);
        __publicField(this, "mode", this.config.mode);
      }
      mapFromDriverValue(value) {
        return Number(value) === 1;
      }
      mapToDriverValue(value) {
        return value ? 1 : 0;
      }
    };
    __publicField(SQLiteBoolean, _a391, "SQLiteBoolean");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/numeric.js
function numeric2(a9, b9) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  const mode = config?.mode;
  return mode === "number" ? new SQLiteNumericNumberBuilder(name3) : mode === "bigint" ? new SQLiteNumericBigIntBuilder(name3) : new SQLiteNumericBuilder(name3);
}
var _a392, _b296, SQLiteNumericBuilder, _a393, _b297, SQLiteNumeric, _a394, _b298, SQLiteNumericNumberBuilder, _a395, _b299, SQLiteNumericNumber, _a396, _b300, SQLiteNumericBigIntBuilder, _a397, _b301, SQLiteNumericBigInt;
var init_numeric2 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/numeric.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common4();
    SQLiteNumericBuilder = class extends (_b296 = SQLiteColumnBuilder, _a392 = entityKind, _b296) {
      constructor(name3) {
        super(name3, "string", "SQLiteNumeric");
      }
      /** @internal */
      build(table6) {
        return new SQLiteNumeric(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteNumericBuilder, _a392, "SQLiteNumericBuilder");
    SQLiteNumeric = class extends (_b297 = SQLiteColumn, _a393 = entityKind, _b297) {
      mapFromDriverValue(value) {
        if (typeof value === "string") return value;
        return String(value);
      }
      getSQLType() {
        return "numeric";
      }
    };
    __publicField(SQLiteNumeric, _a393, "SQLiteNumeric");
    SQLiteNumericNumberBuilder = class extends (_b298 = SQLiteColumnBuilder, _a394 = entityKind, _b298) {
      constructor(name3) {
        super(name3, "number", "SQLiteNumericNumber");
      }
      /** @internal */
      build(table6) {
        return new SQLiteNumericNumber(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteNumericNumberBuilder, _a394, "SQLiteNumericNumberBuilder");
    SQLiteNumericNumber = class extends (_b299 = SQLiteColumn, _a395 = entityKind, _b299) {
      constructor() {
        super(...arguments);
        __publicField(this, "mapToDriverValue", String);
      }
      mapFromDriverValue(value) {
        if (typeof value === "number") return value;
        return Number(value);
      }
      getSQLType() {
        return "numeric";
      }
    };
    __publicField(SQLiteNumericNumber, _a395, "SQLiteNumericNumber");
    SQLiteNumericBigIntBuilder = class extends (_b300 = SQLiteColumnBuilder, _a396 = entityKind, _b300) {
      constructor(name3) {
        super(name3, "bigint", "SQLiteNumericBigInt");
      }
      /** @internal */
      build(table6) {
        return new SQLiteNumericBigInt(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteNumericBigIntBuilder, _a396, "SQLiteNumericBigIntBuilder");
    SQLiteNumericBigInt = class extends (_b301 = SQLiteColumn, _a397 = entityKind, _b301) {
      constructor() {
        super(...arguments);
        __publicField(this, "mapFromDriverValue", BigInt);
        __publicField(this, "mapToDriverValue", String);
      }
      getSQLType() {
        return "numeric";
      }
    };
    __publicField(SQLiteNumericBigInt, _a397, "SQLiteNumericBigInt");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/real.js
function real4(name3) {
  return new SQLiteRealBuilder(name3 ?? "");
}
var _a398, _b302, SQLiteRealBuilder, _a399, _b303, SQLiteReal;
var init_real4 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/real.js"() {
    "use strict";
    init_entity();
    init_common4();
    SQLiteRealBuilder = class extends (_b302 = SQLiteColumnBuilder, _a398 = entityKind, _b302) {
      constructor(name3) {
        super(name3, "number", "SQLiteReal");
      }
      /** @internal */
      build(table6) {
        return new SQLiteReal(table6, this.config);
      }
    };
    __publicField(SQLiteRealBuilder, _a398, "SQLiteRealBuilder");
    SQLiteReal = class extends (_b303 = SQLiteColumn, _a399 = entityKind, _b303) {
      getSQLType() {
        return "real";
      }
    };
    __publicField(SQLiteReal, _a399, "SQLiteReal");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/text.js
function text4(a9, b9 = {}) {
  const { name: name3, config } = getColumnNameAndConfig(a9, b9);
  if (config.mode === "json") {
    return new SQLiteTextJsonBuilder(name3);
  }
  return new SQLiteTextBuilder(name3, config);
}
var _a400, _b304, SQLiteTextBuilder, _a401, _b305, SQLiteText, _a402, _b306, SQLiteTextJsonBuilder, _a403, _b307, SQLiteTextJson;
var init_text4 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/text.js"() {
    "use strict";
    init_entity();
    init_utils();
    init_common4();
    SQLiteTextBuilder = class extends (_b304 = SQLiteColumnBuilder, _a400 = entityKind, _b304) {
      constructor(name3, config) {
        super(name3, "string", "SQLiteText");
        this.config.enumValues = config.enum;
        this.config.length = config.length;
      }
      /** @internal */
      build(table6) {
        return new SQLiteText(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteTextBuilder, _a400, "SQLiteTextBuilder");
    SQLiteText = class extends (_b305 = SQLiteColumn, _a401 = entityKind, _b305) {
      constructor(table6, config) {
        super(table6, config);
        __publicField(this, "enumValues", this.config.enumValues);
        __publicField(this, "length", this.config.length);
      }
      getSQLType() {
        return `text${this.config.length ? `(${this.config.length})` : ""}`;
      }
    };
    __publicField(SQLiteText, _a401, "SQLiteText");
    SQLiteTextJsonBuilder = class extends (_b306 = SQLiteColumnBuilder, _a402 = entityKind, _b306) {
      constructor(name3) {
        super(name3, "json", "SQLiteTextJson");
      }
      /** @internal */
      build(table6) {
        return new SQLiteTextJson(
          table6,
          this.config
        );
      }
    };
    __publicField(SQLiteTextJsonBuilder, _a402, "SQLiteTextJsonBuilder");
    SQLiteTextJson = class extends (_b307 = SQLiteColumn, _a403 = entityKind, _b307) {
      getSQLType() {
        return "text";
      }
      mapFromDriverValue(value) {
        return JSON.parse(value);
      }
      mapToDriverValue(value) {
        return JSON.stringify(value);
      }
    };
    __publicField(SQLiteTextJson, _a403, "SQLiteTextJson");
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/index.js
var init_columns4 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/index.js"() {
    "use strict";
    init_blob();
    init_common4();
    init_custom4();
    init_integer2();
    init_numeric2();
    init_real4();
    init_text4();
  }
});

// ../drizzle-orm/dist/sqlite-core/columns/all.js
function getSQLiteColumnBuilders() {
  return {
    blob,
    customType: customType4,
    integer: integer2,
    numeric: numeric2,
    real: real4,
    text: text4
  };
}
var init_all4 = __esm({
  "../drizzle-orm/dist/sqlite-core/columns/all.js"() {
    "use strict";
    init_blob();
    init_custom4();
    init_integer2();
    init_numeric2();
    init_real4();
    init_text4();
  }
});

// ../drizzle-orm/dist/sqlite-core/table.js
function sqliteTableBase(name3, columns, extraConfig, schema6, baseName = name3) {
  const rawTable = new SQLiteTable(name3, schema6, baseName);
  const parsedColumns = typeof columns === "function" ? columns(getSQLiteColumnBuilders()) : columns;
  const builtColumns = Object.fromEntries(
    Object.entries(parsedColumns).map(([name22, colBuilderBase]) => {
      const colBuilder = colBuilderBase;
      colBuilder.setName(name22);
      const column6 = colBuilder.build(rawTable);
      rawTable[InlineForeignKeys3].push(...colBuilder.buildForeignKeys(column6, rawTable));
      return [name22, column6];
    })
  );
  const table6 = Object.assign(rawTable, builtColumns);
  table6[Table.Symbol.Columns] = builtColumns;
  table6[Table.Symbol.ExtraConfigColumns] = builtColumns;
  if (extraConfig) {
    table6[SQLiteTable.Symbol.ExtraConfigBuilder] = extraConfig;
  }
  return table6;
}
var InlineForeignKeys3, _a404, _b308, _c12, _d5, _e4, SQLiteTable, sqliteTable;
var init_table5 = __esm({
  "../drizzle-orm/dist/sqlite-core/table.js"() {
    "use strict";
    init_entity();
    init_table();
    init_all4();
    InlineForeignKeys3 = Symbol.for("drizzle:SQLiteInlineForeignKeys");
    SQLiteTable = class extends (_e4 = Table, _d5 = entityKind, _c12 = Table.Symbol.Columns, _b308 = InlineForeignKeys3, _a404 = Table.Symbol.ExtraConfigBuilder, _e4) {
      constructor() {
        super(...arguments);
        /** @internal */
        __publicField(this, _c12);
        /** @internal */
        __publicField(this, _b308, []);
        /** @internal */
        __publicField(this, _a404);
      }
    };
    __publicField(SQLiteTable, _d5, "SQLiteTable");
    /** @internal */
    __publicField(SQLiteTable, "Symbol", Object.assign({}, Table.Symbol, {
      InlineForeignKeys: InlineForeignKeys3
    }));
    sqliteTable = (name3, columns, extraConfig) => {
      return sqliteTableBase(name3, columns, extraConfig);
    };
  }
});

// ../drizzle-orm/dist/sqlite-core/indexes.js
var _a405, IndexBuilderOn4, _a406, IndexBuilder4, _a407, Index4;
var init_indexes4 = __esm({
  "../drizzle-orm/dist/sqlite-core/indexes.js"() {
    "use strict";
    init_entity();
    _a405 = entityKind;
    IndexBuilderOn4 = class {
      constructor(name3, unique2) {
        this.name = name3;
        this.unique = unique2;
      }
      on(...columns) {
        return new IndexBuilder4(this.name, columns, this.unique);
      }
    };
    __publicField(IndexBuilderOn4, _a405, "SQLiteIndexBuilderOn");
    _a406 = entityKind;
    IndexBuilder4 = class {
      constructor(name3, columns, unique2) {
        /** @internal */
        __publicField(this, "config");
        this.config = {
          name: name3,
          columns,
          unique: unique2,
          where: void 0
        };
      }
      /**
       * Condition for partial index.
       */
      where(condition) {
        this.config.where = condition;
        return this;
      }
      /** @internal */
      build(table6) {
        return new Index4(this.config, table6);
      }
    };
    __publicField(IndexBuilder4, _a406, "SQLiteIndexBuilder");
    _a407 = entityKind;
    Index4 = class {
      constructor(config, table6) {
        __publicField(this, "config");
        this.config = { ...config, table: table6 };
      }
    };
    __publicField(Index4, _a407, "SQLiteIndex");
  }
});

// ../drizzle-orm/dist/sqlite-core/primary-keys.js
var _a408, PrimaryKeyBuilder4, _a409, PrimaryKey4;
var init_primary_keys4 = __esm({
  "../drizzle-orm/dist/sqlite-core/primary-keys.js"() {
    "use strict";
    init_entity();
    init_table5();
    _a408 = entityKind;
    PrimaryKeyBuilder4 = class {
      constructor(columns, name3) {
        /** @internal */
        __publicField(this, "columns");
        /** @internal */
        __publicField(this, "name");
        this.columns = columns;
        this.name = name3;
      }
      /** @internal */
      build(table6) {
        return new PrimaryKey4(table6, this.columns, this.name);
      }
    };
    __publicField(PrimaryKeyBuilder4, _a408, "SQLitePrimaryKeyBuilder");
    _a409 = entityKind;
    PrimaryKey4 = class {
      constructor(table6, columns, name3) {
        __publicField(this, "columns");
        __publicField(this, "name");
        this.table = table6;
        this.columns = columns;
        this.name = name3;
      }
      getName() {
        return this.name ?? `${this.table[SQLiteTable.Symbol.Name]}_${this.columns.map((column6) => column6.name).join("_")}_pk`;
      }
    };
    __publicField(PrimaryKey4, _a409, "SQLitePrimaryKey");
  }
});

// ../drizzle-orm/dist/sqlite-core/utils.js
function getTableConfig4(table6) {
  const columns = Object.values(table6[SQLiteTable.Symbol.Columns]);
  const indexes = [];
  const checks = [];
  const primaryKeys = [];
  const uniqueConstraints = [];
  const foreignKeys = Object.values(table6[SQLiteTable.Symbol.InlineForeignKeys]);
  const name3 = table6[Table.Symbol.Name];
  const extraConfigBuilder = table6[SQLiteTable.Symbol.ExtraConfigBuilder];
  if (extraConfigBuilder !== void 0) {
    const extraConfig = extraConfigBuilder(table6[SQLiteTable.Symbol.Columns]);
    const extraValues = Array.isArray(extraConfig) ? extraConfig.flat(1) : Object.values(extraConfig);
    for (const builder of Object.values(extraValues)) {
      if (is(builder, IndexBuilder4)) {
        indexes.push(builder.build(table6));
      } else if (is(builder, CheckBuilder3)) {
        checks.push(builder.build(table6));
      } else if (is(builder, UniqueConstraintBuilder4)) {
        uniqueConstraints.push(builder.build(table6));
      } else if (is(builder, PrimaryKeyBuilder4)) {
        primaryKeys.push(builder.build(table6));
      } else if (is(builder, ForeignKeyBuilder3)) {
        foreignKeys.push(builder.build(table6));
      }
    }
  }
  return {
    columns,
    indexes,
    foreignKeys,
    checks,
    primaryKeys,
    uniqueConstraints,
    name: name3
  };
}
function extractUsedTable4(table6) {
  if (is(table6, SQLiteTable)) {
    return [`${table6[Table.Symbol.BaseName]}`];
  }
  if (is(table6, Subquery)) {
    return table6._.usedTables ?? [];
  }
  if (is(table6, SQL)) {
    return table6.usedTables ?? [];
  }
  return [];
}
function getViewConfig3(view5) {
  return {
    ...view5[ViewBaseConfig]
    // ...view[SQLiteViewConfig],
  };
}
var init_utils7 = __esm({
  "../drizzle-orm/dist/sqlite-core/utils.js"() {
    "use strict";
    init_entity();
    init_sql();
    init_subquery();
    init_table();
    init_view_common();
    init_checks3();
    init_foreign_keys3();
    init_indexes4();
    init_primary_keys4();
    init_table5();
    init_unique_constraint4();
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/delete.js
var _a410, _b309, SQLiteDeleteBase;
var init_delete4 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/delete.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_table5();
    init_table();
    init_utils();
    init_utils7();
    SQLiteDeleteBase = class extends (_b309 = QueryPromise, _a410 = entityKind, _b309) {
      constructor(table6, session, dialect6, withList) {
        super();
        /** @internal */
        __publicField(this, "config");
        __publicField(this, "run", (placeholderValues) => {
          return this._prepare().run(placeholderValues);
        });
        __publicField(this, "all", (placeholderValues) => {
          return this._prepare().all(placeholderValues);
        });
        __publicField(this, "get", (placeholderValues) => {
          return this._prepare().get(placeholderValues);
        });
        __publicField(this, "values", (placeholderValues) => {
          return this._prepare().values(placeholderValues);
        });
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, withList };
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will delete only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be deleted.
       *
       * ```ts
       * // Delete all cars with green color
       * db.delete(cars).where(eq(cars.color, 'green'));
       * // or
       * db.delete(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Delete all BMW cars with a green color
       * db.delete(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Delete all cars with the green or blue color
       * db.delete(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.table[Table.Symbol.Columns],
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          this.config.orderBy = orderByArray;
        } else {
          const orderByArray = columns;
          this.config.orderBy = orderByArray;
        }
        return this;
      }
      limit(limit) {
        this.config.limit = limit;
        return this;
      }
      returning(fields = this.table[SQLiteTable.Symbol.Columns]) {
        this.config.returning = orderSelectedFields(fields);
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildDeleteQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      /** @internal */
      _prepare(isOneTimeQuery = true) {
        return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
          this.dialect.sqlToQuery(this.getSQL()),
          this.config.returning,
          this.config.returning ? "all" : "run",
          true,
          void 0,
          {
            type: "delete",
            tables: extractUsedTable4(this.config.table)
          }
        );
      }
      prepare() {
        return this._prepare(false);
      }
      async execute(placeholderValues) {
        return this._prepare().execute(placeholderValues);
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SQLiteDeleteBase, _a410, "SQLiteDelete");
  }
});

// ../drizzle-orm/dist/sqlite-core/view-base.js
var _a411, _b310, SQLiteViewBase;
var init_view_base3 = __esm({
  "../drizzle-orm/dist/sqlite-core/view-base.js"() {
    "use strict";
    init_entity();
    init_sql();
    SQLiteViewBase = class extends (_b310 = View, _a411 = entityKind, _b310) {
    };
    __publicField(SQLiteViewBase, _a411, "SQLiteViewBase");
  }
});

// ../drizzle-orm/dist/sqlite-core/dialect.js
var _a412, SQLiteDialect, _a413, _b311, SQLiteSyncDialect, _a414, _b312, SQLiteAsyncDialect;
var init_dialect4 = __esm({
  "../drizzle-orm/dist/sqlite-core/dialect.js"() {
    "use strict";
    init_alias();
    init_casing();
    init_column();
    init_entity();
    init_errors();
    init_relations();
    init_sql2();
    init_sql();
    init_columns4();
    init_table5();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_view_base3();
    _a412 = entityKind;
    SQLiteDialect = class {
      constructor(config) {
        /** @internal */
        __publicField(this, "casing");
        this.casing = new CasingCache(config?.casing);
      }
      escapeName(name3) {
        return `"${name3}"`;
      }
      escapeParam(_num) {
        return "?";
      }
      escapeString(str) {
        return `'${str.replace(/'/g, "''")}'`;
      }
      buildWithCTE(queries) {
        if (!queries?.length) return void 0;
        const withSqlChunks = [sql`with `];
        for (const [i8, w10] of queries.entries()) {
          withSqlChunks.push(sql`${sql.identifier(w10._.alias)} as (${w10._.sql})`);
          if (i8 < queries.length - 1) {
            withSqlChunks.push(sql`, `);
          }
        }
        withSqlChunks.push(sql` `);
        return sql.join(withSqlChunks);
      }
      buildDeleteQuery({ table: table6, where, returning, withList, limit, orderBy }) {
        const withSql = this.buildWithCTE(withList);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const limitSql = this.buildLimit(limit);
        return sql`${withSql}delete from ${table6}${whereSql}${returningSql}${orderBySql}${limitSql}`;
      }
      buildUpdateSet(table6, set) {
        const tableColumns = table6[Table.Symbol.Columns];
        const columnNames = Object.keys(tableColumns).filter(
          (colName) => set[colName] !== void 0 || tableColumns[colName]?.onUpdateFn !== void 0
        );
        const setSize = columnNames.length;
        return sql.join(columnNames.flatMap((colName, i8) => {
          const col = tableColumns[colName];
          const value = set[colName] ?? sql.param(col.onUpdateFn(), col);
          const res = sql`${sql.identifier(this.casing.getColumnCasing(col))} = ${value}`;
          if (i8 < setSize - 1) {
            return [res, sql.raw(", ")];
          }
          return [res];
        }));
      }
      buildUpdateQuery({ table: table6, set, where, returning, withList, joins, from, limit, orderBy }) {
        const withSql = this.buildWithCTE(withList);
        const setSql = this.buildUpdateSet(table6, set);
        const fromSql = from && sql.join([sql.raw(" from "), this.buildFromTable(from)]);
        const joinsSql = this.buildJoins(joins);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const whereSql = where ? sql` where ${where}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const limitSql = this.buildLimit(limit);
        return sql`${withSql}update ${table6} set ${setSql}${fromSql}${joinsSql}${whereSql}${returningSql}${orderBySql}${limitSql}`;
      }
      /**
       * Builds selection SQL with provided fields/expressions
       *
       * Examples:
       *
       * `select <selection> from`
       *
       * `insert ... returning <selection>`
       *
       * If `isSingleTable` is true, then columns won't be prefixed with table name
       */
      buildSelection(fields, { isSingleTable = false } = {}) {
        const columnsLen = fields.length;
        const chunks = fields.flatMap(({ field }, i8) => {
          const chunk = [];
          if (is(field, SQL.Aliased) && field.isSelectionField) {
            chunk.push(sql.identifier(field.fieldAlias));
          } else if (is(field, SQL.Aliased) || is(field, SQL)) {
            const query = is(field, SQL.Aliased) ? field.sql : field;
            if (isSingleTable) {
              chunk.push(
                new SQL(
                  query.queryChunks.map((c6) => {
                    if (is(c6, Column)) {
                      return sql.identifier(this.casing.getColumnCasing(c6));
                    }
                    return c6;
                  })
                )
              );
            } else {
              chunk.push(query);
            }
            if (is(field, SQL.Aliased)) {
              chunk.push(sql` as ${sql.identifier(field.fieldAlias)}`);
            }
          } else if (is(field, Column)) {
            const tableName = field.table[Table.Symbol.Name];
            if (field.columnType === "SQLiteNumericBigInt") {
              if (isSingleTable) {
                chunk.push(sql`cast(${sql.identifier(this.casing.getColumnCasing(field))} as text)`);
              } else {
                chunk.push(
                  sql`cast(${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))} as text)`
                );
              }
            } else {
              if (isSingleTable) {
                chunk.push(sql.identifier(this.casing.getColumnCasing(field)));
              } else {
                chunk.push(sql`${sql.identifier(tableName)}.${sql.identifier(this.casing.getColumnCasing(field))}`);
              }
            }
          }
          if (i8 < columnsLen - 1) {
            chunk.push(sql`, `);
          }
          return chunk;
        });
        return sql.join(chunks);
      }
      buildJoins(joins) {
        if (!joins || joins.length === 0) {
          return void 0;
        }
        const joinsArray = [];
        if (joins) {
          for (const [index7, joinMeta] of joins.entries()) {
            if (index7 === 0) {
              joinsArray.push(sql` `);
            }
            const table6 = joinMeta.table;
            const onSql = joinMeta.on ? sql` on ${joinMeta.on}` : void 0;
            if (is(table6, SQLiteTable)) {
              const tableName = table6[SQLiteTable.Symbol.Name];
              const tableSchema = table6[SQLiteTable.Symbol.Schema];
              const origTableName = table6[SQLiteTable.Symbol.OriginalName];
              const alias2 = tableName === origTableName ? void 0 : joinMeta.alias;
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join ${tableSchema ? sql`${sql.identifier(tableSchema)}.` : void 0}${sql.identifier(origTableName)}${alias2 && sql` ${sql.identifier(alias2)}`}${onSql}`
              );
            } else {
              joinsArray.push(
                sql`${sql.raw(joinMeta.joinType)} join ${table6}${onSql}`
              );
            }
            if (index7 < joins.length - 1) {
              joinsArray.push(sql` `);
            }
          }
        }
        return sql.join(joinsArray);
      }
      buildLimit(limit) {
        return typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
      }
      buildOrderBy(orderBy) {
        const orderByList = [];
        if (orderBy) {
          for (const [index7, orderByValue] of orderBy.entries()) {
            orderByList.push(orderByValue);
            if (index7 < orderBy.length - 1) {
              orderByList.push(sql`, `);
            }
          }
        }
        return orderByList.length > 0 ? sql` order by ${sql.join(orderByList)}` : void 0;
      }
      buildFromTable(table6) {
        if (is(table6, Table) && table6[Table.Symbol.IsAlias]) {
          return sql`${sql`${sql.identifier(table6[Table.Symbol.Schema] ?? "")}.`.if(table6[Table.Symbol.Schema])}${sql.identifier(table6[Table.Symbol.OriginalName])} ${sql.identifier(table6[Table.Symbol.Name])}`;
        }
        return table6;
      }
      buildSelectQuery({
        withList,
        fields,
        fieldsFlat,
        where,
        having,
        table: table6,
        joins,
        orderBy,
        groupBy,
        limit,
        offset,
        distinct,
        setOperators
      }) {
        const fieldsList = fieldsFlat ?? orderSelectedFields(fields);
        for (const f9 of fieldsList) {
          if (is(f9.field, Column) && getTableName(f9.field.table) !== (is(table6, Subquery) ? table6._.alias : is(table6, SQLiteViewBase) ? table6[ViewBaseConfig].name : is(table6, SQL) ? void 0 : getTableName(table6)) && !((table22) => joins?.some(
            ({ alias: alias2 }) => alias2 === (table22[Table.Symbol.IsAlias] ? getTableName(table22) : table22[Table.Symbol.BaseName])
          ))(f9.field.table)) {
            const tableName = getTableName(f9.field.table);
            throw new Error(
              `Your "${f9.path.join("->")}" field references a column "${tableName}"."${f9.field.name}", but the table "${tableName}" is not part of the query! Did you forget to join it?`
            );
          }
        }
        const isSingleTable = !joins || joins.length === 0;
        const withSql = this.buildWithCTE(withList);
        const distinctSql = distinct ? sql` distinct` : void 0;
        const selection = this.buildSelection(fieldsList, { isSingleTable });
        const tableSql = this.buildFromTable(table6);
        const joinsSql = this.buildJoins(joins);
        const whereSql = where ? sql` where ${where}` : void 0;
        const havingSql = having ? sql` having ${having}` : void 0;
        const groupByList = [];
        if (groupBy) {
          for (const [index7, groupByValue] of groupBy.entries()) {
            groupByList.push(groupByValue);
            if (index7 < groupBy.length - 1) {
              groupByList.push(sql`, `);
            }
          }
        }
        const groupBySql = groupByList.length > 0 ? sql` group by ${sql.join(groupByList)}` : void 0;
        const orderBySql = this.buildOrderBy(orderBy);
        const limitSql = this.buildLimit(limit);
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        const finalQuery = sql`${withSql}select${distinctSql} ${selection} from ${tableSql}${joinsSql}${whereSql}${groupBySql}${havingSql}${orderBySql}${limitSql}${offsetSql}`;
        if (setOperators.length > 0) {
          return this.buildSetOperations(finalQuery, setOperators);
        }
        return finalQuery;
      }
      buildSetOperations(leftSelect, setOperators) {
        const [setOperator, ...rest] = setOperators;
        if (!setOperator) {
          throw new Error("Cannot pass undefined values to any set operator");
        }
        if (rest.length === 0) {
          return this.buildSetOperationQuery({ leftSelect, setOperator });
        }
        return this.buildSetOperations(
          this.buildSetOperationQuery({ leftSelect, setOperator }),
          rest
        );
      }
      buildSetOperationQuery({
        leftSelect,
        setOperator: { type, isAll, rightSelect, limit, orderBy, offset }
      }) {
        const leftChunk = sql`${leftSelect.getSQL()} `;
        const rightChunk = sql`${rightSelect.getSQL()}`;
        let orderBySql;
        if (orderBy && orderBy.length > 0) {
          const orderByValues = [];
          for (const singleOrderBy of orderBy) {
            if (is(singleOrderBy, SQLiteColumn)) {
              orderByValues.push(sql.identifier(singleOrderBy.name));
            } else if (is(singleOrderBy, SQL)) {
              for (let i8 = 0; i8 < singleOrderBy.queryChunks.length; i8++) {
                const chunk = singleOrderBy.queryChunks[i8];
                if (is(chunk, SQLiteColumn)) {
                  singleOrderBy.queryChunks[i8] = sql.identifier(this.casing.getColumnCasing(chunk));
                }
              }
              orderByValues.push(sql`${singleOrderBy}`);
            } else {
              orderByValues.push(sql`${singleOrderBy}`);
            }
          }
          orderBySql = sql` order by ${sql.join(orderByValues, sql`, `)}`;
        }
        const limitSql = typeof limit === "object" || typeof limit === "number" && limit >= 0 ? sql` limit ${limit}` : void 0;
        const operatorChunk = sql.raw(`${type} ${isAll ? "all " : ""}`);
        const offsetSql = offset ? sql` offset ${offset}` : void 0;
        return sql`${leftChunk}${operatorChunk}${rightChunk}${orderBySql}${limitSql}${offsetSql}`;
      }
      buildInsertQuery({ table: table6, values: valuesOrSelect, onConflict, returning, withList, select: select2 }) {
        const valuesSqlList = [];
        const columns = table6[Table.Symbol.Columns];
        const colEntries = Object.entries(columns).filter(
          ([_7, col]) => !col.shouldDisableInsert()
        );
        const insertOrder = colEntries.map(([, column6]) => sql.identifier(this.casing.getColumnCasing(column6)));
        if (select2) {
          const select22 = valuesOrSelect;
          if (is(select22, SQL)) {
            valuesSqlList.push(select22);
          } else {
            valuesSqlList.push(select22.getSQL());
          }
        } else {
          const values2 = valuesOrSelect;
          valuesSqlList.push(sql.raw("values "));
          for (const [valueIndex, value] of values2.entries()) {
            const valueList = [];
            for (const [fieldName, col] of colEntries) {
              const colValue = value[fieldName];
              if (colValue === void 0 || is(colValue, Param) && colValue.value === void 0) {
                let defaultValue;
                if (col.default !== null && col.default !== void 0) {
                  defaultValue = is(col.default, SQL) ? col.default : sql.param(col.default, col);
                } else if (col.defaultFn !== void 0) {
                  const defaultFnResult = col.defaultFn();
                  defaultValue = is(defaultFnResult, SQL) ? defaultFnResult : sql.param(defaultFnResult, col);
                } else if (!col.default && col.onUpdateFn !== void 0) {
                  const onUpdateFnResult = col.onUpdateFn();
                  defaultValue = is(onUpdateFnResult, SQL) ? onUpdateFnResult : sql.param(onUpdateFnResult, col);
                } else {
                  defaultValue = sql`null`;
                }
                valueList.push(defaultValue);
              } else {
                valueList.push(colValue);
              }
            }
            valuesSqlList.push(valueList);
            if (valueIndex < values2.length - 1) {
              valuesSqlList.push(sql`, `);
            }
          }
        }
        const withSql = this.buildWithCTE(withList);
        const valuesSql = sql.join(valuesSqlList);
        const returningSql = returning ? sql` returning ${this.buildSelection(returning, { isSingleTable: true })}` : void 0;
        const onConflictSql = onConflict?.length ? sql.join(onConflict) : void 0;
        return sql`${withSql}insert into ${table6} ${insertOrder} ${valuesSql}${onConflictSql}${returningSql}`;
      }
      sqlToQuery(sql22, invokeSource) {
        return sql22.toQuery({
          casing: this.casing,
          escapeName: this.escapeName,
          escapeParam: this.escapeParam,
          escapeString: this.escapeString,
          invokeSource
        });
      }
      buildRelationalQuery({
        fullSchema,
        schema: schema6,
        tableNamesMap,
        table: table6,
        tableConfig,
        queryConfig: config,
        tableAlias,
        nestedQueryRelation,
        joinOn
      }) {
        let selection = [];
        let limit, offset, orderBy = [], where;
        const joins = [];
        if (config === true) {
          const selectionEntries = Object.entries(tableConfig.columns);
          selection = selectionEntries.map(([key, value]) => ({
            dbKey: value.name,
            tsKey: key,
            field: aliasedTableColumn(value, tableAlias),
            relationTableTsKey: void 0,
            isJson: false,
            selection: []
          }));
        } else {
          const aliasedColumns = Object.fromEntries(
            Object.entries(tableConfig.columns).map(([key, value]) => [key, aliasedTableColumn(value, tableAlias)])
          );
          if (config.where) {
            const whereSql = typeof config.where === "function" ? config.where(aliasedColumns, getOperators()) : config.where;
            where = whereSql && mapColumnsInSQLToAlias(whereSql, tableAlias);
          }
          const fieldsSelection = [];
          let selectedColumns = [];
          if (config.columns) {
            let isIncludeMode = false;
            for (const [field, value] of Object.entries(config.columns)) {
              if (value === void 0) {
                continue;
              }
              if (field in tableConfig.columns) {
                if (!isIncludeMode && value === true) {
                  isIncludeMode = true;
                }
                selectedColumns.push(field);
              }
            }
            if (selectedColumns.length > 0) {
              selectedColumns = isIncludeMode ? selectedColumns.filter((c6) => config.columns?.[c6] === true) : Object.keys(tableConfig.columns).filter((key) => !selectedColumns.includes(key));
            }
          } else {
            selectedColumns = Object.keys(tableConfig.columns);
          }
          for (const field of selectedColumns) {
            const column6 = tableConfig.columns[field];
            fieldsSelection.push({ tsKey: field, value: column6 });
          }
          let selectedRelations = [];
          if (config.with) {
            selectedRelations = Object.entries(config.with).filter((entry) => !!entry[1]).map(([tsKey, queryConfig]) => ({ tsKey, queryConfig, relation: tableConfig.relations[tsKey] }));
          }
          let extras;
          if (config.extras) {
            extras = typeof config.extras === "function" ? config.extras(aliasedColumns, { sql }) : config.extras;
            for (const [tsKey, value] of Object.entries(extras)) {
              fieldsSelection.push({
                tsKey,
                value: mapColumnsInAliasedSQLToAlias(value, tableAlias)
              });
            }
          }
          for (const { tsKey, value } of fieldsSelection) {
            selection.push({
              dbKey: is(value, SQL.Aliased) ? value.fieldAlias : tableConfig.columns[tsKey].name,
              tsKey,
              field: is(value, Column) ? aliasedTableColumn(value, tableAlias) : value,
              relationTableTsKey: void 0,
              isJson: false,
              selection: []
            });
          }
          let orderByOrig = typeof config.orderBy === "function" ? config.orderBy(aliasedColumns, getOrderByOperators()) : config.orderBy ?? [];
          if (!Array.isArray(orderByOrig)) {
            orderByOrig = [orderByOrig];
          }
          orderBy = orderByOrig.map((orderByValue) => {
            if (is(orderByValue, Column)) {
              return aliasedTableColumn(orderByValue, tableAlias);
            }
            return mapColumnsInSQLToAlias(orderByValue, tableAlias);
          });
          limit = config.limit;
          offset = config.offset;
          for (const {
            tsKey: selectedRelationTsKey,
            queryConfig: selectedRelationConfigValue,
            relation
          } of selectedRelations) {
            const normalizedRelation = normalizeRelation(schema6, tableNamesMap, relation);
            const relationTableName = getTableUniqueName(relation.referencedTable);
            const relationTableTsName = tableNamesMap[relationTableName];
            const relationTableAlias = `${tableAlias}_${selectedRelationTsKey}`;
            const joinOn2 = and(
              ...normalizedRelation.fields.map(
                (field2, i8) => eq(
                  aliasedTableColumn(normalizedRelation.references[i8], relationTableAlias),
                  aliasedTableColumn(field2, tableAlias)
                )
              )
            );
            const builtRelation = this.buildRelationalQuery({
              fullSchema,
              schema: schema6,
              tableNamesMap,
              table: fullSchema[relationTableTsName],
              tableConfig: schema6[relationTableTsName],
              queryConfig: is(relation, One) ? selectedRelationConfigValue === true ? { limit: 1 } : { ...selectedRelationConfigValue, limit: 1 } : selectedRelationConfigValue,
              tableAlias: relationTableAlias,
              joinOn: joinOn2,
              nestedQueryRelation: relation
            });
            const field = sql`(${builtRelation.sql})`.as(selectedRelationTsKey);
            selection.push({
              dbKey: selectedRelationTsKey,
              tsKey: selectedRelationTsKey,
              field,
              relationTableTsKey: relationTableTsName,
              isJson: true,
              selection: builtRelation.selection
            });
          }
        }
        if (selection.length === 0) {
          throw new DrizzleError({
            message: `No fields selected for table "${tableConfig.tsName}" ("${tableAlias}"). You need to have at least one item in "columns", "with" or "extras". If you need to select all columns, omit the "columns" key or set it to undefined.`
          });
        }
        let result;
        where = and(joinOn, where);
        if (nestedQueryRelation) {
          let field = sql`json_array(${sql.join(
            selection.map(
              ({ field: field2 }) => is(field2, SQLiteColumn) ? sql.identifier(this.casing.getColumnCasing(field2)) : is(field2, SQL.Aliased) ? field2.sql : field2
            ),
            sql`, `
          )})`;
          if (is(nestedQueryRelation, Many)) {
            field = sql`coalesce(json_group_array(${field}), json_array())`;
          }
          const nestedSelection = [{
            dbKey: "data",
            tsKey: "data",
            field: field.as("data"),
            isJson: true,
            relationTableTsKey: tableConfig.tsName,
            selection
          }];
          const needsSubquery = limit !== void 0 || offset !== void 0 || orderBy.length > 0;
          if (needsSubquery) {
            result = this.buildSelectQuery({
              table: aliasedTable(table6, tableAlias),
              fields: {},
              fieldsFlat: [
                {
                  path: [],
                  field: sql.raw("*")
                }
              ],
              where,
              limit,
              offset,
              orderBy,
              setOperators: []
            });
            where = void 0;
            limit = void 0;
            offset = void 0;
            orderBy = void 0;
          } else {
            result = aliasedTable(table6, tableAlias);
          }
          result = this.buildSelectQuery({
            table: is(result, SQLiteTable) ? result : new Subquery(result, {}, tableAlias),
            fields: {},
            fieldsFlat: nestedSelection.map(({ field: field2 }) => ({
              path: [],
              field: is(field2, Column) ? aliasedTableColumn(field2, tableAlias) : field2
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        } else {
          result = this.buildSelectQuery({
            table: aliasedTable(table6, tableAlias),
            fields: {},
            fieldsFlat: selection.map(({ field }) => ({
              path: [],
              field: is(field, Column) ? aliasedTableColumn(field, tableAlias) : field
            })),
            joins,
            where,
            limit,
            offset,
            orderBy,
            setOperators: []
          });
        }
        return {
          tableTsKey: tableConfig.tsName,
          sql: result,
          selection
        };
      }
    };
    __publicField(SQLiteDialect, _a412, "SQLiteDialect");
    SQLiteSyncDialect = class extends (_b311 = SQLiteDialect, _a413 = entityKind, _b311) {
      migrate(migrations, session, config) {
        const migrationsTable = config === void 0 ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
        const migrationTableCreate = sql`
			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
				id SERIAL PRIMARY KEY,
				hash text NOT NULL,
				created_at numeric
			)
		`;
        session.run(migrationTableCreate);
        const dbMigrations = session.values(
          sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
        );
        const lastDbMigration = dbMigrations[0] ?? void 0;
        session.run(sql`BEGIN`);
        try {
          for (const migration of migrations) {
            if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
              for (const stmt of migration.sql) {
                session.run(sql.raw(stmt));
              }
              session.run(
                sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`
              );
            }
          }
          session.run(sql`COMMIT`);
        } catch (e6) {
          session.run(sql`ROLLBACK`);
          throw e6;
        }
      }
    };
    __publicField(SQLiteSyncDialect, _a413, "SQLiteSyncDialect");
    SQLiteAsyncDialect = class extends (_b312 = SQLiteDialect, _a414 = entityKind, _b312) {
      async migrate(migrations, session, config) {
        const migrationsTable = config === void 0 ? "__drizzle_migrations" : typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
        const migrationTableCreate = sql`
			CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
				id SERIAL PRIMARY KEY,
				hash text NOT NULL,
				created_at numeric
			)
		`;
        await session.run(migrationTableCreate);
        const dbMigrations = await session.values(
          sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
        );
        const lastDbMigration = dbMigrations[0] ?? void 0;
        await session.transaction(async (tx) => {
          for (const migration of migrations) {
            if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
              for (const stmt of migration.sql) {
                await tx.run(sql.raw(stmt));
              }
              await tx.run(
                sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`
              );
            }
          }
        });
      }
    };
    __publicField(SQLiteAsyncDialect, _a414, "SQLiteAsyncDialect");
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/select.js
function createSetOperator4(type, isAll) {
  return (leftSelect, rightSelect, ...restSelects) => {
    const setOperators = [rightSelect, ...restSelects].map((select2) => ({
      type,
      isAll,
      rightSelect: select2
    }));
    for (const setOperator of setOperators) {
      if (!haveSameKeys(leftSelect.getSelectedFields(), setOperator.rightSelect.getSelectedFields())) {
        throw new Error(
          "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
        );
      }
    }
    return leftSelect.addSetOperators(setOperators);
  };
}
var _a415, SQLiteSelectBuilder, _a416, _b313, SQLiteSelectQueryBuilderBase, _a417, _b314, SQLiteSelectBase, getSQLiteSetOperators, union4, unionAll4, intersect4, except4;
var init_select5 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/select.js"() {
    "use strict";
    init_entity();
    init_query_builder();
    init_query_promise();
    init_selection_proxy();
    init_sql();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_utils7();
    init_view_base3();
    _a415 = entityKind;
    SQLiteSelectBuilder = class {
      constructor(config) {
        __publicField(this, "fields");
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "withList");
        __publicField(this, "distinct");
        this.fields = config.fields;
        this.session = config.session;
        this.dialect = config.dialect;
        this.withList = config.withList;
        this.distinct = config.distinct;
      }
      from(source) {
        const isPartialSelect = !!this.fields;
        let fields;
        if (this.fields) {
          fields = this.fields;
        } else if (is(source, Subquery)) {
          fields = Object.fromEntries(
            Object.keys(source._.selectedFields).map((key) => [key, source[key]])
          );
        } else if (is(source, SQLiteViewBase)) {
          fields = source[ViewBaseConfig].selectedFields;
        } else if (is(source, SQL)) {
          fields = {};
        } else {
          fields = getTableColumns(source);
        }
        return new SQLiteSelectBase({
          table: source,
          fields,
          isPartialSelect,
          session: this.session,
          dialect: this.dialect,
          withList: this.withList,
          distinct: this.distinct
        });
      }
    };
    __publicField(SQLiteSelectBuilder, _a415, "SQLiteSelectBuilder");
    SQLiteSelectQueryBuilderBase = class extends (_b313 = TypedQueryBuilder, _a416 = entityKind, _b313) {
      constructor({ table: table6, fields, isPartialSelect, session, dialect: dialect6, withList, distinct }) {
        super();
        __publicField(this, "_");
        /** @internal */
        __publicField(this, "config");
        __publicField(this, "joinsNotNullableMap");
        __publicField(this, "tableName");
        __publicField(this, "isPartialSelect");
        __publicField(this, "session");
        __publicField(this, "dialect");
        __publicField(this, "cacheConfig");
        __publicField(this, "usedTables", /* @__PURE__ */ new Set());
        /**
         * Executes a `left join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the table with the corresponding row from the joined table, if a match is found. If no matching row exists, it sets all columns of the joined table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#left-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet | null; }[] = await db.select()
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .leftJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "leftJoin", this.createJoin("left"));
        /**
         * Executes a `right join` operation by adding another table to the current query.
         *
         * Calling this method associates each row of the joined table with the corresponding row from the main table, if a match is found. If no matching row exists, it sets all columns of the main table to null.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#right-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User | null; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number | null; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .rightJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "rightJoin", this.createJoin("right"));
        /**
         * Executes an `inner join` operation, creating a new table by combining rows from two tables that have matching values.
         *
         * Calling this method retrieves rows that have corresponding entries in both joined tables. Rows without matching entries in either table are excluded, resulting in a table that includes only matching pairs.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#inner-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .innerJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "innerJoin", this.createJoin("inner"));
        /**
         * Executes a `full join` operation by combining rows from two tables into a new table.
         *
         * Calling this method retrieves all rows from both main and joined tables, merging rows with matching values and filling in `null` for non-matching columns.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#full-join}
         *
         * @param table the table to join.
         * @param on the `on` clause.
         *
         * @example
         *
         * ```ts
         * // Select all users and their pets
         * const usersWithPets: { user: User | null; pets: Pet | null; }[] = await db.select()
         *   .from(users)
         *   .fullJoin(pets, eq(users.id, pets.ownerId))
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number | null; petId: number | null; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .fullJoin(pets, eq(users.id, pets.ownerId))
         * ```
         */
        __publicField(this, "fullJoin", this.createJoin("full"));
        /**
         * Executes a `cross join` operation by combining rows from two tables into a new table.
         *
         * Calling this method retrieves all rows from both main and joined tables, merging all rows from each table.
         *
         * See docs: {@link https://orm.drizzle.team/docs/joins#cross-join}
         *
         * @param table the table to join.
         *
         * @example
         *
         * ```ts
         * // Select all users, each user with every pet
         * const usersWithPets: { user: User; pets: Pet; }[] = await db.select()
         *   .from(users)
         *   .crossJoin(pets)
         *
         * // Select userId and petId
         * const usersIdsAndPetIds: { userId: number; petId: number; }[] = await db.select({
         *   userId: users.id,
         *   petId: pets.id,
         * })
         *   .from(users)
         *   .crossJoin(pets)
         * ```
         */
        __publicField(this, "crossJoin", this.createJoin("cross"));
        /**
         * Adds `union` set operator to the query.
         *
         * Calling this method will combine the result sets of the `select` statements and remove any duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union}
         *
         * @example
         *
         * ```ts
         * // Select all unique names from customers and users tables
         * await db.select({ name: users.name })
         *   .from(users)
         *   .union(
         *     db.select({ name: customers.name }).from(customers)
         *   );
         * // or
         * import { union } from 'drizzle-orm/sqlite-core'
         *
         * await union(
         *   db.select({ name: users.name }).from(users),
         *   db.select({ name: customers.name }).from(customers)
         * );
         * ```
         */
        __publicField(this, "union", this.createSetOperator("union", false));
        /**
         * Adds `union all` set operator to the query.
         *
         * Calling this method will combine the result-set of the `select` statements and keep all duplicate rows that appear across them.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#union-all}
         *
         * @example
         *
         * ```ts
         * // Select all transaction ids from both online and in-store sales
         * await db.select({ transaction: onlineSales.transactionId })
         *   .from(onlineSales)
         *   .unionAll(
         *     db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         *   );
         * // or
         * import { unionAll } from 'drizzle-orm/sqlite-core'
         *
         * await unionAll(
         *   db.select({ transaction: onlineSales.transactionId }).from(onlineSales),
         *   db.select({ transaction: inStoreSales.transactionId }).from(inStoreSales)
         * );
         * ```
         */
        __publicField(this, "unionAll", this.createSetOperator("union", true));
        /**
         * Adds `intersect` set operator to the query.
         *
         * Calling this method will retain only the rows that are present in both result sets and eliminate duplicates.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#intersect}
         *
         * @example
         *
         * ```ts
         * // Select course names that are offered in both departments A and B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .intersect(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { intersect } from 'drizzle-orm/sqlite-core'
         *
         * await intersect(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "intersect", this.createSetOperator("intersect", false));
        /**
         * Adds `except` set operator to the query.
         *
         * Calling this method will retrieve all unique rows from the left query, except for the rows that are present in the result set of the right query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/set-operations#except}
         *
         * @example
         *
         * ```ts
         * // Select all courses offered in department A but not in department B
         * await db.select({ courseName: depA.courseName })
         *   .from(depA)
         *   .except(
         *     db.select({ courseName: depB.courseName }).from(depB)
         *   );
         * // or
         * import { except } from 'drizzle-orm/sqlite-core'
         *
         * await except(
         *   db.select({ courseName: depA.courseName }).from(depA),
         *   db.select({ courseName: depB.courseName }).from(depB)
         * );
         * ```
         */
        __publicField(this, "except", this.createSetOperator("except", false));
        this.config = {
          withList,
          table: table6,
          fields: { ...fields },
          distinct,
          setOperators: []
        };
        this.isPartialSelect = isPartialSelect;
        this.session = session;
        this.dialect = dialect6;
        this._ = {
          selectedFields: fields,
          config: this.config
        };
        this.tableName = getTableLikeName(table6);
        this.joinsNotNullableMap = typeof this.tableName === "string" ? { [this.tableName]: true } : {};
        for (const item of extractUsedTable4(table6)) this.usedTables.add(item);
      }
      /** @internal */
      getUsedTables() {
        return [...this.usedTables];
      }
      createJoin(joinType) {
        return (table6, on3) => {
          const baseTableName = this.tableName;
          const tableName = getTableLikeName(table6);
          for (const item of extractUsedTable4(table6)) this.usedTables.add(item);
          if (typeof tableName === "string" && this.config.joins?.some((join7) => join7.alias === tableName)) {
            throw new Error(`Alias "${tableName}" is already used in this query`);
          }
          if (!this.isPartialSelect) {
            if (Object.keys(this.joinsNotNullableMap).length === 1 && typeof baseTableName === "string") {
              this.config.fields = {
                [baseTableName]: this.config.fields
              };
            }
            if (typeof tableName === "string" && !is(table6, SQL)) {
              const selection = is(table6, Subquery) ? table6._.selectedFields : is(table6, View) ? table6[ViewBaseConfig].selectedFields : table6[Table.Symbol.Columns];
              this.config.fields[tableName] = selection;
            }
          }
          if (typeof on3 === "function") {
            on3 = on3(
              new Proxy(
                this.config.fields,
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              )
            );
          }
          if (!this.config.joins) {
            this.config.joins = [];
          }
          this.config.joins.push({ on: on3, table: table6, joinType, alias: tableName });
          if (typeof tableName === "string") {
            switch (joinType) {
              case "left": {
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
              case "right": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "cross":
              case "inner": {
                this.joinsNotNullableMap[tableName] = true;
                break;
              }
              case "full": {
                this.joinsNotNullableMap = Object.fromEntries(
                  Object.entries(this.joinsNotNullableMap).map(([key]) => [key, false])
                );
                this.joinsNotNullableMap[tableName] = false;
                break;
              }
            }
          }
          return this;
        };
      }
      createSetOperator(type, isAll) {
        return (rightSelection) => {
          const rightSelect = typeof rightSelection === "function" ? rightSelection(getSQLiteSetOperators()) : rightSelection;
          if (!haveSameKeys(this.getSelectedFields(), rightSelect.getSelectedFields())) {
            throw new Error(
              "Set operator error (union / intersect / except): selected fields are not the same or are in a different order"
            );
          }
          this.config.setOperators.push({ type, isAll, rightSelect });
          return this;
        };
      }
      /** @internal */
      addSetOperators(setOperators) {
        this.config.setOperators.push(...setOperators);
        return this;
      }
      /**
       * Adds a `where` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#filtering}
       *
       * @param where the `where` clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be selected.
       *
       * ```ts
       * // Select all cars with green color
       * await db.select().from(cars).where(eq(cars.color, 'green'));
       * // or
       * await db.select().from(cars).where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Select all BMW cars with a green color
       * await db.select().from(cars).where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Select all cars with the green or blue color
       * await db.select().from(cars).where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        if (typeof where === "function") {
          where = where(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.where = where;
        return this;
      }
      /**
       * Adds a `having` clause to the query.
       *
       * Calling this method will select only those rows that fulfill a specified condition. It is typically used with aggregate functions to filter the aggregated data based on a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#aggregations}
       *
       * @param having the `having` clause.
       *
       * @example
       *
       * ```ts
       * // Select all brands with more than one car
       * await db.select({
       * 	brand: cars.brand,
       * 	count: sql<number>`cast(count(${cars.id}) as int)`,
       * })
       *   .from(cars)
       *   .groupBy(cars.brand)
       *   .having(({ count }) => gt(count, 1));
       * ```
       */
      having(having) {
        if (typeof having === "function") {
          having = having(
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
            )
          );
        }
        this.config.having = having;
        return this;
      }
      groupBy(...columns) {
        if (typeof columns[0] === "function") {
          const groupBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          this.config.groupBy = Array.isArray(groupBy) ? groupBy : [groupBy];
        } else {
          this.config.groupBy = columns;
        }
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.fields,
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        } else {
          const orderByArray = columns;
          if (this.config.setOperators.length > 0) {
            this.config.setOperators.at(-1).orderBy = orderByArray;
          } else {
            this.config.orderBy = orderByArray;
          }
        }
        return this;
      }
      /**
       * Adds a `limit` clause to the query.
       *
       * Calling this method will set the maximum number of rows that will be returned by this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param limit the `limit` clause.
       *
       * @example
       *
       * ```ts
       * // Get the first 10 people from this query.
       * await db.select().from(people).limit(10);
       * ```
       */
      limit(limit) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).limit = limit;
        } else {
          this.config.limit = limit;
        }
        return this;
      }
      /**
       * Adds an `offset` clause to the query.
       *
       * Calling this method will skip a number of rows when returning results from this query.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#limit--offset}
       *
       * @param offset the `offset` clause.
       *
       * @example
       *
       * ```ts
       * // Get the 10th-20th people from this query.
       * await db.select().from(people).offset(10).limit(10);
       * ```
       */
      offset(offset) {
        if (this.config.setOperators.length > 0) {
          this.config.setOperators.at(-1).offset = offset;
        } else {
          this.config.offset = offset;
        }
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildSelectQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      as(alias2) {
        const usedTables = [];
        usedTables.push(...extractUsedTable4(this.config.table));
        if (this.config.joins) {
          for (const it2 of this.config.joins) usedTables.push(...extractUsedTable4(it2.table));
        }
        return new Proxy(
          new Subquery(this.getSQL(), this.config.fields, alias2, false, [...new Set(usedTables)]),
          new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      /** @internal */
      getSelectedFields() {
        return new Proxy(
          this.config.fields,
          new SelectionProxyHandler({ alias: this.tableName, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
        );
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SQLiteSelectQueryBuilderBase, _a416, "SQLiteSelectQueryBuilder");
    SQLiteSelectBase = class extends (_b314 = SQLiteSelectQueryBuilderBase, _a417 = entityKind, _b314) {
      constructor() {
        super(...arguments);
        __publicField(this, "run", (placeholderValues) => {
          return this._prepare().run(placeholderValues);
        });
        __publicField(this, "all", (placeholderValues) => {
          return this._prepare().all(placeholderValues);
        });
        __publicField(this, "get", (placeholderValues) => {
          return this._prepare().get(placeholderValues);
        });
        __publicField(this, "values", (placeholderValues) => {
          return this._prepare().values(placeholderValues);
        });
      }
      /** @internal */
      _prepare(isOneTimeQuery = true) {
        if (!this.session) {
          throw new Error("Cannot execute a query on a query builder. Please use a database instance instead.");
        }
        const fieldsList = orderSelectedFields(this.config.fields);
        const query = this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
          this.dialect.sqlToQuery(this.getSQL()),
          fieldsList,
          "all",
          true,
          void 0,
          {
            type: "select",
            tables: [...this.usedTables]
          },
          this.cacheConfig
        );
        query.joinsNotNullableMap = this.joinsNotNullableMap;
        return query;
      }
      $withCache(config) {
        this.cacheConfig = config === void 0 ? { config: {}, enable: true, autoInvalidate: true } : config === false ? { enable: false } : { enable: true, autoInvalidate: true, ...config };
        return this;
      }
      prepare() {
        return this._prepare(false);
      }
      async execute() {
        return this.all();
      }
    };
    __publicField(SQLiteSelectBase, _a417, "SQLiteSelect");
    applyMixins(SQLiteSelectBase, [QueryPromise]);
    getSQLiteSetOperators = () => ({
      union: union4,
      unionAll: unionAll4,
      intersect: intersect4,
      except: except4
    });
    union4 = createSetOperator4("union", false);
    unionAll4 = createSetOperator4("union", true);
    intersect4 = createSetOperator4("intersect", false);
    except4 = createSetOperator4("except", false);
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/query-builder.js
var _a418, QueryBuilder4;
var init_query_builder5 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/query-builder.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_dialect4();
    init_subquery();
    init_select5();
    _a418 = entityKind;
    QueryBuilder4 = class {
      constructor(dialect6) {
        __publicField(this, "dialect");
        __publicField(this, "dialectConfig");
        __publicField(this, "$with", (alias2, selection) => {
          const queryBuilder = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(queryBuilder);
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        this.dialect = is(dialect6, SQLiteDialect) ? dialect6 : void 0;
        this.dialectConfig = is(dialect6, SQLiteDialect) ? void 0 : dialect6;
      }
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new SQLiteSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new SQLiteSelectBuilder({
            fields: fields ?? void 0,
            session: void 0,
            dialect: self2.getDialect(),
            withList: queries,
            distinct: true
          });
        }
        return { select: select2, selectDistinct };
      }
      select(fields) {
        return new SQLiteSelectBuilder({ fields: fields ?? void 0, session: void 0, dialect: this.getDialect() });
      }
      selectDistinct(fields) {
        return new SQLiteSelectBuilder({
          fields: fields ?? void 0,
          session: void 0,
          dialect: this.getDialect(),
          distinct: true
        });
      }
      // Lazy load dialect to avoid circular dependency
      getDialect() {
        if (!this.dialect) {
          this.dialect = new SQLiteSyncDialect(this.dialectConfig);
        }
        return this.dialect;
      }
    };
    __publicField(QueryBuilder4, _a418, "SQLiteQueryBuilder");
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/insert.js
var _a419, SQLiteInsertBuilder, _a420, _b315, SQLiteInsertBase;
var init_insert4 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/insert.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_sql();
    init_table5();
    init_table();
    init_utils();
    init_utils7();
    init_query_builder5();
    _a419 = entityKind;
    SQLiteInsertBuilder = class {
      constructor(table6, session, dialect6, withList) {
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.withList = withList;
      }
      values(values2) {
        values2 = Array.isArray(values2) ? values2 : [values2];
        if (values2.length === 0) {
          throw new Error("values() must be called with at least one value");
        }
        const mappedValues = values2.map((entry) => {
          const result = {};
          const cols = this.table[Table.Symbol.Columns];
          for (const colKey of Object.keys(entry)) {
            const colValue = entry[colKey];
            result[colKey] = is(colValue, SQL) ? colValue : new Param(colValue, cols[colKey]);
          }
          return result;
        });
        return new SQLiteInsertBase(this.table, mappedValues, this.session, this.dialect, this.withList);
      }
      select(selectQuery) {
        const select2 = typeof selectQuery === "function" ? selectQuery(new QueryBuilder4()) : selectQuery;
        if (!is(select2, SQL) && !haveSameKeys(this.table[Columns], select2._.selectedFields)) {
          throw new Error(
            "Insert select error: selected fields are not the same or are in a different order compared to the table definition"
          );
        }
        return new SQLiteInsertBase(this.table, select2, this.session, this.dialect, this.withList, true);
      }
    };
    __publicField(SQLiteInsertBuilder, _a419, "SQLiteInsertBuilder");
    SQLiteInsertBase = class extends (_b315 = QueryPromise, _a420 = entityKind, _b315) {
      constructor(table6, values2, session, dialect6, withList, select2) {
        super();
        /** @internal */
        __publicField(this, "config");
        __publicField(this, "run", (placeholderValues) => {
          return this._prepare().run(placeholderValues);
        });
        __publicField(this, "all", (placeholderValues) => {
          return this._prepare().all(placeholderValues);
        });
        __publicField(this, "get", (placeholderValues) => {
          return this._prepare().get(placeholderValues);
        });
        __publicField(this, "values", (placeholderValues) => {
          return this._prepare().values(placeholderValues);
        });
        this.session = session;
        this.dialect = dialect6;
        this.config = { table: table6, values: values2, withList, select: select2 };
      }
      returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
        this.config.returning = orderSelectedFields(fields);
        return this;
      }
      /**
       * Adds an `on conflict do nothing` clause to the query.
       *
       * Calling this method simply avoids inserting a row as its alternative action.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert#on-conflict-do-nothing}
       *
       * @param config The `target` and `where` clauses.
       *
       * @example
       * ```ts
       * // Insert one row and cancel the insert if there's a conflict
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoNothing();
       *
       * // Explicitly specify conflict target
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoNothing({ target: cars.id });
       * ```
       */
      onConflictDoNothing(config = {}) {
        if (!this.config.onConflict) this.config.onConflict = [];
        if (config.target === void 0) {
          this.config.onConflict.push(sql` on conflict do nothing`);
        } else {
          const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
          const whereSql = config.where ? sql` where ${config.where}` : sql``;
          this.config.onConflict.push(sql` on conflict ${targetSql} do nothing${whereSql}`);
        }
        return this;
      }
      /**
       * Adds an `on conflict do update` clause to the query.
       *
       * Calling this method will update the existing row that conflicts with the row proposed for insertion as its alternative action.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert#upserts-and-conflicts}
       *
       * @param config The `target`, `set` and `where` clauses.
       *
       * @example
       * ```ts
       * // Update the row if there's a conflict
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoUpdate({
       *     target: cars.id,
       *     set: { brand: 'Porsche' }
       *   });
       *
       * // Upsert with 'where' clause
       * await db.insert(cars)
       *   .values({ id: 1, brand: 'BMW' })
       *   .onConflictDoUpdate({
       *     target: cars.id,
       *     set: { brand: 'newBMW' },
       *     where: sql`${cars.createdAt} > '2023-01-01'::date`,
       *   });
       * ```
       */
      onConflictDoUpdate(config) {
        if (config.where && (config.targetWhere || config.setWhere)) {
          throw new Error(
            'You cannot use both "where" and "targetWhere"/"setWhere" at the same time - "where" is deprecated, use "targetWhere" or "setWhere" instead.'
          );
        }
        if (!this.config.onConflict) this.config.onConflict = [];
        const whereSql = config.where ? sql` where ${config.where}` : void 0;
        const targetWhereSql = config.targetWhere ? sql` where ${config.targetWhere}` : void 0;
        const setWhereSql = config.setWhere ? sql` where ${config.setWhere}` : void 0;
        const targetSql = Array.isArray(config.target) ? sql`${config.target}` : sql`${[config.target]}`;
        const setSql = this.dialect.buildUpdateSet(this.config.table, mapUpdateSet(this.config.table, config.set));
        this.config.onConflict.push(
          sql` on conflict ${targetSql}${targetWhereSql} do update set ${setSql}${whereSql}${setWhereSql}`
        );
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildInsertQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      /** @internal */
      _prepare(isOneTimeQuery = true) {
        return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
          this.dialect.sqlToQuery(this.getSQL()),
          this.config.returning,
          this.config.returning ? "all" : "run",
          true,
          void 0,
          {
            type: "insert",
            tables: extractUsedTable4(this.config.table)
          }
        );
      }
      prepare() {
        return this._prepare(false);
      }
      async execute() {
        return this.config.returning ? this.all() : this.run();
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SQLiteInsertBase, _a420, "SQLiteInsert");
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/select.types.js
var init_select_types4 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/select.types.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/update.js
var _a421, SQLiteUpdateBuilder, _a422, _b316, SQLiteUpdateBase;
var init_update4 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/update.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_selection_proxy();
    init_table5();
    init_subquery();
    init_table();
    init_utils();
    init_view_common();
    init_utils7();
    init_view_base3();
    _a421 = entityKind;
    SQLiteUpdateBuilder = class {
      constructor(table6, session, dialect6, withList) {
        this.table = table6;
        this.session = session;
        this.dialect = dialect6;
        this.withList = withList;
      }
      set(values2) {
        return new SQLiteUpdateBase(
          this.table,
          mapUpdateSet(this.table, values2),
          this.session,
          this.dialect,
          this.withList
        );
      }
    };
    __publicField(SQLiteUpdateBuilder, _a421, "SQLiteUpdateBuilder");
    SQLiteUpdateBase = class extends (_b316 = QueryPromise, _a422 = entityKind, _b316) {
      constructor(table6, set, session, dialect6, withList) {
        super();
        /** @internal */
        __publicField(this, "config");
        __publicField(this, "leftJoin", this.createJoin("left"));
        __publicField(this, "rightJoin", this.createJoin("right"));
        __publicField(this, "innerJoin", this.createJoin("inner"));
        __publicField(this, "fullJoin", this.createJoin("full"));
        __publicField(this, "run", (placeholderValues) => {
          return this._prepare().run(placeholderValues);
        });
        __publicField(this, "all", (placeholderValues) => {
          return this._prepare().all(placeholderValues);
        });
        __publicField(this, "get", (placeholderValues) => {
          return this._prepare().get(placeholderValues);
        });
        __publicField(this, "values", (placeholderValues) => {
          return this._prepare().values(placeholderValues);
        });
        this.session = session;
        this.dialect = dialect6;
        this.config = { set, table: table6, withList, joins: [] };
      }
      from(source) {
        this.config.from = source;
        return this;
      }
      createJoin(joinType) {
        return (table6, on3) => {
          const tableName = getTableLikeName(table6);
          if (typeof tableName === "string" && this.config.joins.some((join7) => join7.alias === tableName)) {
            throw new Error(`Alias "${tableName}" is already used in this query`);
          }
          if (typeof on3 === "function") {
            const from = this.config.from ? is(table6, SQLiteTable) ? table6[Table.Symbol.Columns] : is(table6, Subquery) ? table6._.selectedFields : is(table6, SQLiteViewBase) ? table6[ViewBaseConfig].selectedFields : void 0 : void 0;
            on3 = on3(
              new Proxy(
                this.config.table[Table.Symbol.Columns],
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              ),
              from && new Proxy(
                from,
                new SelectionProxyHandler({ sqlAliasedBehavior: "sql", sqlBehavior: "sql" })
              )
            );
          }
          this.config.joins.push({ on: on3, table: table6, joinType, alias: tableName });
          return this;
        };
      }
      /**
       * Adds a 'where' clause to the query.
       *
       * Calling this method will update only those rows that fulfill a specified condition.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param where the 'where' clause.
       *
       * @example
       * You can use conditional operators and `sql function` to filter the rows to be updated.
       *
       * ```ts
       * // Update all cars with green color
       * db.update(cars).set({ color: 'red' })
       *   .where(eq(cars.color, 'green'));
       * // or
       * db.update(cars).set({ color: 'red' })
       *   .where(sql`${cars.color} = 'green'`)
       * ```
       *
       * You can logically combine conditional operators with `and()` and `or()` operators:
       *
       * ```ts
       * // Update all BMW cars with a green color
       * db.update(cars).set({ color: 'red' })
       *   .where(and(eq(cars.color, 'green'), eq(cars.brand, 'BMW')));
       *
       * // Update all cars with the green or blue color
       * db.update(cars).set({ color: 'red' })
       *   .where(or(eq(cars.color, 'green'), eq(cars.color, 'blue')));
       * ```
       */
      where(where) {
        this.config.where = where;
        return this;
      }
      orderBy(...columns) {
        if (typeof columns[0] === "function") {
          const orderBy = columns[0](
            new Proxy(
              this.config.table[Table.Symbol.Columns],
              new SelectionProxyHandler({ sqlAliasedBehavior: "alias", sqlBehavior: "sql" })
            )
          );
          const orderByArray = Array.isArray(orderBy) ? orderBy : [orderBy];
          this.config.orderBy = orderByArray;
        } else {
          const orderByArray = columns;
          this.config.orderBy = orderByArray;
        }
        return this;
      }
      limit(limit) {
        this.config.limit = limit;
        return this;
      }
      returning(fields = this.config.table[SQLiteTable.Symbol.Columns]) {
        this.config.returning = orderSelectedFields(fields);
        return this;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildUpdateQuery(this.config);
      }
      toSQL() {
        const { typings: _typings, ...rest } = this.dialect.sqlToQuery(this.getSQL());
        return rest;
      }
      /** @internal */
      _prepare(isOneTimeQuery = true) {
        return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
          this.dialect.sqlToQuery(this.getSQL()),
          this.config.returning,
          this.config.returning ? "all" : "run",
          true,
          void 0,
          {
            type: "insert",
            tables: extractUsedTable4(this.config.table)
          }
        );
      }
      prepare() {
        return this._prepare(false);
      }
      async execute() {
        return this.config.returning ? this.all() : this.run();
      }
      $dynamic() {
        return this;
      }
    };
    __publicField(SQLiteUpdateBase, _a422, "SQLiteUpdate");
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/index.js
var init_query_builders4 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/index.js"() {
    "use strict";
    init_delete4();
    init_insert4();
    init_query_builder5();
    init_select5();
    init_select_types4();
    init_update4();
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/count.js
var _a423, _b317, _c13, _SQLiteCountBuilder, SQLiteCountBuilder;
var init_count4 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/count.js"() {
    "use strict";
    init_entity();
    init_sql();
    _SQLiteCountBuilder = class _SQLiteCountBuilder extends (_c13 = SQL, _b317 = entityKind, _a423 = Symbol.toStringTag, _c13) {
      constructor(params) {
        super(_SQLiteCountBuilder.buildEmbeddedCount(params.source, params.filters).queryChunks);
        __publicField(this, "sql");
        __publicField(this, _a423, "SQLiteCountBuilderAsync");
        __publicField(this, "session");
        this.params = params;
        this.session = params.session;
        this.sql = _SQLiteCountBuilder.buildCount(
          params.source,
          params.filters
        );
      }
      static buildEmbeddedCount(source, filters) {
        return sql`(select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters})`;
      }
      static buildCount(source, filters) {
        return sql`select count(*) from ${source}${sql.raw(" where ").if(filters)}${filters}`;
      }
      then(onfulfilled, onrejected) {
        return Promise.resolve(this.session.count(this.sql)).then(
          onfulfilled,
          onrejected
        );
      }
      catch(onRejected) {
        return this.then(void 0, onRejected);
      }
      finally(onFinally) {
        return this.then(
          (value) => {
            onFinally?.();
            return value;
          },
          (reason) => {
            onFinally?.();
            throw reason;
          }
        );
      }
    };
    __publicField(_SQLiteCountBuilder, _b317, "SQLiteCountBuilderAsync");
    SQLiteCountBuilder = _SQLiteCountBuilder;
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/query.js
var _a424, RelationalQueryBuilder3, _a425, _b318, SQLiteRelationalQuery, _a426, _b319, SQLiteSyncRelationalQuery;
var init_query3 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/query.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    init_relations();
    _a424 = entityKind;
    RelationalQueryBuilder3 = class {
      constructor(mode, fullSchema, schema6, tableNamesMap, table6, tableConfig, dialect6, session) {
        this.mode = mode;
        this.fullSchema = fullSchema;
        this.schema = schema6;
        this.tableNamesMap = tableNamesMap;
        this.table = table6;
        this.tableConfig = tableConfig;
        this.dialect = dialect6;
        this.session = session;
      }
      findMany(config) {
        return this.mode === "sync" ? new SQLiteSyncRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? config : {},
          "many"
        ) : new SQLiteRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? config : {},
          "many"
        );
      }
      findFirst(config) {
        return this.mode === "sync" ? new SQLiteSyncRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? { ...config, limit: 1 } : { limit: 1 },
          "first"
        ) : new SQLiteRelationalQuery(
          this.fullSchema,
          this.schema,
          this.tableNamesMap,
          this.table,
          this.tableConfig,
          this.dialect,
          this.session,
          config ? { ...config, limit: 1 } : { limit: 1 },
          "first"
        );
      }
    };
    __publicField(RelationalQueryBuilder3, _a424, "SQLiteAsyncRelationalQueryBuilder");
    SQLiteRelationalQuery = class extends (_b318 = QueryPromise, _a425 = entityKind, _b318) {
      constructor(fullSchema, schema6, tableNamesMap, table6, tableConfig, dialect6, session, config, mode) {
        super();
        /** @internal */
        __publicField(this, "mode");
        this.fullSchema = fullSchema;
        this.schema = schema6;
        this.tableNamesMap = tableNamesMap;
        this.table = table6;
        this.tableConfig = tableConfig;
        this.dialect = dialect6;
        this.session = session;
        this.config = config;
        this.mode = mode;
      }
      /** @internal */
      getSQL() {
        return this.dialect.buildRelationalQuery({
          fullSchema: this.fullSchema,
          schema: this.schema,
          tableNamesMap: this.tableNamesMap,
          table: this.table,
          tableConfig: this.tableConfig,
          queryConfig: this.config,
          tableAlias: this.tableConfig.tsName
        }).sql;
      }
      /** @internal */
      _prepare(isOneTimeQuery = false) {
        const { query, builtQuery } = this._toSQL();
        return this.session[isOneTimeQuery ? "prepareOneTimeQuery" : "prepareQuery"](
          builtQuery,
          void 0,
          this.mode === "first" ? "get" : "all",
          true,
          (rawRows, mapColumnValue) => {
            const rows = rawRows.map(
              (row) => mapRelationalRow(this.schema, this.tableConfig, row, query.selection, mapColumnValue)
            );
            if (this.mode === "first") {
              return rows[0];
            }
            return rows;
          }
        );
      }
      prepare() {
        return this._prepare(false);
      }
      _toSQL() {
        const query = this.dialect.buildRelationalQuery({
          fullSchema: this.fullSchema,
          schema: this.schema,
          tableNamesMap: this.tableNamesMap,
          table: this.table,
          tableConfig: this.tableConfig,
          queryConfig: this.config,
          tableAlias: this.tableConfig.tsName
        });
        const builtQuery = this.dialect.sqlToQuery(query.sql);
        return { query, builtQuery };
      }
      toSQL() {
        return this._toSQL().builtQuery;
      }
      /** @internal */
      executeRaw() {
        if (this.mode === "first") {
          return this._prepare(false).get();
        }
        return this._prepare(false).all();
      }
      async execute() {
        return this.executeRaw();
      }
    };
    __publicField(SQLiteRelationalQuery, _a425, "SQLiteAsyncRelationalQuery");
    SQLiteSyncRelationalQuery = class extends (_b319 = SQLiteRelationalQuery, _a426 = entityKind, _b319) {
      sync() {
        return this.executeRaw();
      }
    };
    __publicField(SQLiteSyncRelationalQuery, _a426, "SQLiteSyncRelationalQuery");
  }
});

// ../drizzle-orm/dist/sqlite-core/query-builders/raw.js
var _a427, _b320, SQLiteRaw;
var init_raw2 = __esm({
  "../drizzle-orm/dist/sqlite-core/query-builders/raw.js"() {
    "use strict";
    init_entity();
    init_query_promise();
    SQLiteRaw = class extends (_b320 = QueryPromise, _a427 = entityKind, _b320) {
      constructor(execute, getSQL, action, dialect6, mapBatchResult) {
        super();
        /** @internal */
        __publicField(this, "config");
        this.execute = execute;
        this.getSQL = getSQL;
        this.dialect = dialect6;
        this.mapBatchResult = mapBatchResult;
        this.config = { action };
      }
      getQuery() {
        return { ...this.dialect.sqlToQuery(this.getSQL()), method: this.config.action };
      }
      mapResult(result, isFromBatch) {
        return isFromBatch ? this.mapBatchResult(result) : result;
      }
      _prepare() {
        return this;
      }
      /** @internal */
      isResponseInArrayMode() {
        return false;
      }
    };
    __publicField(SQLiteRaw, _a427, "SQLiteRaw");
  }
});

// ../drizzle-orm/dist/sqlite-core/db.js
var _a428, BaseSQLiteDatabase;
var init_db4 = __esm({
  "../drizzle-orm/dist/sqlite-core/db.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_sql();
    init_query_builders4();
    init_subquery();
    init_count4();
    init_query3();
    init_raw2();
    _a428 = entityKind;
    BaseSQLiteDatabase = class {
      constructor(resultKind, dialect6, session, schema6) {
        __publicField(this, "query");
        /**
         * Creates a subquery that defines a temporary named result set as a CTE.
         *
         * It is useful for breaking down complex queries into simpler parts and for reusing the result set in subsequent parts of the query.
         *
         * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
         *
         * @param alias The alias for the subquery.
         *
         * Failure to provide an alias will result in a DrizzleTypeError, preventing the subquery from being referenced in other queries.
         *
         * @example
         *
         * ```ts
         * // Create a subquery with alias 'sq' and use it in the select query
         * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
         *
         * const result = await db.with(sq).select().from(sq);
         * ```
         *
         * To select arbitrary SQL values as fields in a CTE and reference them in other CTEs or in the main query, you need to add aliases to them:
         *
         * ```ts
         * // Select an arbitrary SQL value as a field in a CTE and reference it in the main query
         * const sq = db.$with('sq').as(db.select({
         *   name: sql<string>`upper(${users.name})`.as('name'),
         * })
         * .from(users));
         *
         * const result = await db.with(sq).select({ name: sq.name }).from(sq);
         * ```
         */
        __publicField(this, "$with", (alias2, selection) => {
          const self2 = this;
          const as = (qb) => {
            if (typeof qb === "function") {
              qb = qb(new QueryBuilder4(self2.dialect));
            }
            return new Proxy(
              new WithSubquery(
                qb.getSQL(),
                selection ?? ("getSelectedFields" in qb ? qb.getSelectedFields() ?? {} : {}),
                alias2,
                true
              ),
              new SelectionProxyHandler({ alias: alias2, sqlAliasedBehavior: "alias", sqlBehavior: "error" })
            );
          };
          return { as };
        });
        __publicField(this, "$cache");
        this.resultKind = resultKind;
        this.dialect = dialect6;
        this.session = session;
        this._ = schema6 ? {
          schema: schema6.schema,
          fullSchema: schema6.fullSchema,
          tableNamesMap: schema6.tableNamesMap
        } : {
          schema: void 0,
          fullSchema: {},
          tableNamesMap: {}
        };
        this.query = {};
        const query = this.query;
        if (this._.schema) {
          for (const [tableName, columns] of Object.entries(this._.schema)) {
            query[tableName] = new RelationalQueryBuilder3(
              resultKind,
              schema6.fullSchema,
              this._.schema,
              this._.tableNamesMap,
              schema6.fullSchema[tableName],
              columns,
              dialect6,
              session
            );
          }
        }
        this.$cache = { invalidate: async (_params2) => {
        } };
      }
      $count(source, filters) {
        return new SQLiteCountBuilder({ source, filters, session: this.session });
      }
      /**
       * Incorporates a previously defined CTE (using `$with`) into the main query.
       *
       * This method allows the main query to reference a temporary named result set.
       *
       * See docs: {@link https://orm.drizzle.team/docs/select#with-clause}
       *
       * @param queries The CTEs to incorporate into the main query.
       *
       * @example
       *
       * ```ts
       * // Define a subquery 'sq' as a CTE using $with
       * const sq = db.$with('sq').as(db.select().from(users).where(eq(users.id, 42)));
       *
       * // Incorporate the CTE 'sq' into the main query and select from it
       * const result = await db.with(sq).select().from(sq);
       * ```
       */
      with(...queries) {
        const self2 = this;
        function select2(fields) {
          return new SQLiteSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries
          });
        }
        function selectDistinct(fields) {
          return new SQLiteSelectBuilder({
            fields: fields ?? void 0,
            session: self2.session,
            dialect: self2.dialect,
            withList: queries,
            distinct: true
          });
        }
        function update(table6) {
          return new SQLiteUpdateBuilder(table6, self2.session, self2.dialect, queries);
        }
        function insert(into) {
          return new SQLiteInsertBuilder(into, self2.session, self2.dialect, queries);
        }
        function delete_(from) {
          return new SQLiteDeleteBase(from, self2.session, self2.dialect, queries);
        }
        return { select: select2, selectDistinct, update, insert, delete: delete_ };
      }
      select(fields) {
        return new SQLiteSelectBuilder({ fields: fields ?? void 0, session: this.session, dialect: this.dialect });
      }
      selectDistinct(fields) {
        return new SQLiteSelectBuilder({
          fields: fields ?? void 0,
          session: this.session,
          dialect: this.dialect,
          distinct: true
        });
      }
      /**
       * Creates an update query.
       *
       * Calling this method without `.where()` clause will update all rows in a table. The `.where()` clause specifies which rows should be updated.
       *
       * Use `.set()` method to specify which values to update.
       *
       * See docs: {@link https://orm.drizzle.team/docs/update}
       *
       * @param table The table to update.
       *
       * @example
       *
       * ```ts
       * // Update all rows in the 'cars' table
       * await db.update(cars).set({ color: 'red' });
       *
       * // Update rows with filters and conditions
       * await db.update(cars).set({ color: 'red' }).where(eq(cars.brand, 'BMW'));
       *
       * // Update with returning clause
       * const updatedCar: Car[] = await db.update(cars)
       *   .set({ color: 'red' })
       *   .where(eq(cars.id, 1))
       *   .returning();
       * ```
       */
      update(table6) {
        return new SQLiteUpdateBuilder(table6, this.session, this.dialect);
      }
      /**
       * Creates an insert query.
       *
       * Calling this method will create new rows in a table. Use `.values()` method to specify which values to insert.
       *
       * See docs: {@link https://orm.drizzle.team/docs/insert}
       *
       * @param table The table to insert into.
       *
       * @example
       *
       * ```ts
       * // Insert one row
       * await db.insert(cars).values({ brand: 'BMW' });
       *
       * // Insert multiple rows
       * await db.insert(cars).values([{ brand: 'BMW' }, { brand: 'Porsche' }]);
       *
       * // Insert with returning clause
       * const insertedCar: Car[] = await db.insert(cars)
       *   .values({ brand: 'BMW' })
       *   .returning();
       * ```
       */
      insert(into) {
        return new SQLiteInsertBuilder(into, this.session, this.dialect);
      }
      /**
       * Creates a delete query.
       *
       * Calling this method without `.where()` clause will delete all rows in a table. The `.where()` clause specifies which rows should be deleted.
       *
       * See docs: {@link https://orm.drizzle.team/docs/delete}
       *
       * @param table The table to delete from.
       *
       * @example
       *
       * ```ts
       * // Delete all rows in the 'cars' table
       * await db.delete(cars);
       *
       * // Delete rows with filters and conditions
       * await db.delete(cars).where(eq(cars.color, 'green'));
       *
       * // Delete with returning clause
       * const deletedCar: Car[] = await db.delete(cars)
       *   .where(eq(cars.id, 1))
       *   .returning();
       * ```
       */
      delete(from) {
        return new SQLiteDeleteBase(from, this.session, this.dialect);
      }
      run(query) {
        const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
        if (this.resultKind === "async") {
          return new SQLiteRaw(
            async () => this.session.run(sequel),
            () => sequel,
            "run",
            this.dialect,
            this.session.extractRawRunValueFromBatchResult.bind(this.session)
          );
        }
        return this.session.run(sequel);
      }
      all(query) {
        const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
        if (this.resultKind === "async") {
          return new SQLiteRaw(
            async () => this.session.all(sequel),
            () => sequel,
            "all",
            this.dialect,
            this.session.extractRawAllValueFromBatchResult.bind(this.session)
          );
        }
        return this.session.all(sequel);
      }
      get(query) {
        const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
        if (this.resultKind === "async") {
          return new SQLiteRaw(
            async () => this.session.get(sequel),
            () => sequel,
            "get",
            this.dialect,
            this.session.extractRawGetValueFromBatchResult.bind(this.session)
          );
        }
        return this.session.get(sequel);
      }
      values(query) {
        const sequel = typeof query === "string" ? sql.raw(query) : query.getSQL();
        if (this.resultKind === "async") {
          return new SQLiteRaw(
            async () => this.session.values(sequel),
            () => sequel,
            "values",
            this.dialect,
            this.session.extractRawValuesValueFromBatchResult.bind(this.session)
          );
        }
        return this.session.values(sequel);
      }
      transaction(transaction, config) {
        return this.session.transaction(transaction, config);
      }
    };
    __publicField(BaseSQLiteDatabase, _a428, "BaseSQLiteDatabase");
  }
});

// ../drizzle-orm/dist/sqlite-core/session.js
var _a429, _b321, ExecuteResultSync, _a430, SQLitePreparedQuery, _a431, SQLiteSession, _a432, _b322, SQLiteTransaction;
var init_session4 = __esm({
  "../drizzle-orm/dist/sqlite-core/session.js"() {
    "use strict";
    init_cache();
    init_entity();
    init_errors();
    init_query_promise();
    init_db4();
    ExecuteResultSync = class extends (_b321 = QueryPromise, _a429 = entityKind, _b321) {
      constructor(resultCb) {
        super();
        this.resultCb = resultCb;
      }
      async execute() {
        return this.resultCb();
      }
      sync() {
        return this.resultCb();
      }
    };
    __publicField(ExecuteResultSync, _a429, "ExecuteResultSync");
    _a430 = entityKind;
    SQLitePreparedQuery = class {
      constructor(mode, executeMethod, query, cache5, queryMetadata, cacheConfig) {
        /** @internal */
        __publicField(this, "joinsNotNullableMap");
        this.mode = mode;
        this.executeMethod = executeMethod;
        this.query = query;
        this.cache = cache5;
        this.queryMetadata = queryMetadata;
        this.cacheConfig = cacheConfig;
        if (cache5 && cache5.strategy() === "all" && cacheConfig === void 0) {
          this.cacheConfig = { enable: true, autoInvalidate: true };
        }
        if (!this.cacheConfig?.enable) {
          this.cacheConfig = void 0;
        }
      }
      /** @internal */
      async queryWithCache(queryString, params, query) {
        if (this.cache === void 0 || is(this.cache, NoopCache) || this.queryMetadata === void 0) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.cacheConfig && !this.cacheConfig.enable) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if ((this.queryMetadata.type === "insert" || this.queryMetadata.type === "update" || this.queryMetadata.type === "delete") && this.queryMetadata.tables.length > 0) {
          try {
            const [res] = await Promise.all([
              query(),
              this.cache.onMutate({ tables: this.queryMetadata.tables })
            ]);
            return res;
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (!this.cacheConfig) {
          try {
            return await query();
          } catch (e6) {
            throw new DrizzleQueryError(queryString, params, e6);
          }
        }
        if (this.queryMetadata.type === "select") {
          const fromCache = await this.cache.get(
            this.cacheConfig.tag ?? await hashQuery(queryString, params),
            this.queryMetadata.tables,
            this.cacheConfig.tag !== void 0,
            this.cacheConfig.autoInvalidate
          );
          if (fromCache === void 0) {
            let result;
            try {
              result = await query();
            } catch (e6) {
              throw new DrizzleQueryError(queryString, params, e6);
            }
            await this.cache.put(
              this.cacheConfig.tag ?? await hashQuery(queryString, params),
              result,
              // make sure we send tables that were used in a query only if user wants to invalidate it on each write
              this.cacheConfig.autoInvalidate ? this.queryMetadata.tables : [],
              this.cacheConfig.tag !== void 0,
              this.cacheConfig.config
            );
            return result;
          }
          return fromCache;
        }
        try {
          return await query();
        } catch (e6) {
          throw new DrizzleQueryError(queryString, params, e6);
        }
      }
      getQuery() {
        return this.query;
      }
      mapRunResult(result, _isFromBatch) {
        return result;
      }
      mapAllResult(_result, _isFromBatch) {
        throw new Error("Not implemented");
      }
      mapGetResult(_result, _isFromBatch) {
        throw new Error("Not implemented");
      }
      execute(placeholderValues) {
        if (this.mode === "async") {
          return this[this.executeMethod](placeholderValues);
        }
        return new ExecuteResultSync(() => this[this.executeMethod](placeholderValues));
      }
      mapResult(response, isFromBatch) {
        switch (this.executeMethod) {
          case "run": {
            return this.mapRunResult(response, isFromBatch);
          }
          case "all": {
            return this.mapAllResult(response, isFromBatch);
          }
          case "get": {
            return this.mapGetResult(response, isFromBatch);
          }
        }
      }
    };
    __publicField(SQLitePreparedQuery, _a430, "PreparedQuery");
    _a431 = entityKind;
    SQLiteSession = class {
      constructor(dialect6) {
        this.dialect = dialect6;
      }
      prepareOneTimeQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return this.prepareQuery(
          query,
          fields,
          executeMethod,
          isResponseInArrayMode,
          customResultMapper,
          queryMetadata,
          cacheConfig
        );
      }
      run(query) {
        const staticQuery = this.dialect.sqlToQuery(query);
        try {
          return this.prepareOneTimeQuery(staticQuery, void 0, "run", false).run();
        } catch (err3) {
          throw new DrizzleError({ cause: err3, message: `Failed to run the query '${staticQuery.sql}'` });
        }
      }
      /** @internal */
      extractRawRunValueFromBatchResult(result) {
        return result;
      }
      all(query) {
        return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), void 0, "run", false).all();
      }
      /** @internal */
      extractRawAllValueFromBatchResult(_result) {
        throw new Error("Not implemented");
      }
      get(query) {
        return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), void 0, "run", false).get();
      }
      /** @internal */
      extractRawGetValueFromBatchResult(_result) {
        throw new Error("Not implemented");
      }
      values(query) {
        return this.prepareOneTimeQuery(this.dialect.sqlToQuery(query), void 0, "run", false).values();
      }
      async count(sql3) {
        const result = await this.values(sql3);
        return result[0][0];
      }
      /** @internal */
      extractRawValuesValueFromBatchResult(_result) {
        throw new Error("Not implemented");
      }
    };
    __publicField(SQLiteSession, _a431, "SQLiteSession");
    SQLiteTransaction = class extends (_b322 = BaseSQLiteDatabase, _a432 = entityKind, _b322) {
      constructor(resultType, dialect6, session, schema6, nestedIndex = 0) {
        super(resultType, dialect6, session, schema6);
        this.schema = schema6;
        this.nestedIndex = nestedIndex;
      }
      rollback() {
        throw new TransactionRollbackError();
      }
    };
    __publicField(SQLiteTransaction, _a432, "SQLiteTransaction");
  }
});

// ../drizzle-orm/dist/sqlite-core/subquery.js
var init_subquery5 = __esm({
  "../drizzle-orm/dist/sqlite-core/subquery.js"() {
    "use strict";
  }
});

// ../drizzle-orm/dist/sqlite-core/view.js
var _a433, ViewBuilderCore2, _a434, _b323, ViewBuilder3, _a435, _b324, ManualViewBuilder3, _a436, _b325, SQLiteView;
var init_view3 = __esm({
  "../drizzle-orm/dist/sqlite-core/view.js"() {
    "use strict";
    init_entity();
    init_selection_proxy();
    init_utils();
    init_query_builder5();
    init_table5();
    init_view_base3();
    _a433 = entityKind;
    ViewBuilderCore2 = class {
      constructor(name3) {
        __publicField(this, "config", {});
        this.name = name3;
      }
    };
    __publicField(ViewBuilderCore2, _a433, "SQLiteViewBuilderCore");
    ViewBuilder3 = class extends (_b323 = ViewBuilderCore2, _a434 = entityKind, _b323) {
      as(qb) {
        if (typeof qb === "function") {
          qb = qb(new QueryBuilder4());
        }
        const selectionProxy = new SelectionProxyHandler({
          alias: this.name,
          sqlBehavior: "error",
          sqlAliasedBehavior: "alias",
          replaceOriginalName: true
        });
        const aliasedSelectedFields = qb.getSelectedFields();
        return new Proxy(
          new SQLiteView({
            // sqliteConfig: this.config,
            config: {
              name: this.name,
              schema: void 0,
              selectedFields: aliasedSelectedFields,
              query: qb.getSQL().inlineParams()
            }
          }),
          selectionProxy
        );
      }
    };
    __publicField(ViewBuilder3, _a434, "SQLiteViewBuilder");
    ManualViewBuilder3 = class extends (_b324 = ViewBuilderCore2, _a435 = entityKind, _b324) {
      constructor(name3, columns) {
        super(name3);
        __publicField(this, "columns");
        this.columns = getTableColumns(sqliteTable(name3, columns));
      }
      existing() {
        return new Proxy(
          new SQLiteView({
            config: {
              name: this.name,
              schema: void 0,
              selectedFields: this.columns,
              query: void 0
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
      as(query) {
        return new Proxy(
          new SQLiteView({
            config: {
              name: this.name,
              schema: void 0,
              selectedFields: this.columns,
              query: query.inlineParams()
            }
          }),
          new SelectionProxyHandler({
            alias: this.name,
            sqlBehavior: "error",
            sqlAliasedBehavior: "alias",
            replaceOriginalName: true
          })
        );
      }
    };
    __publicField(ManualViewBuilder3, _a435, "SQLiteManualViewBuilder");
    SQLiteView = class extends (_b325 = SQLiteViewBase, _a436 = entityKind, _b325) {
      constructor({ config }) {
        super(config);
      }
    };
    __publicField(SQLiteView, _a436, "SQLiteView");
  }
});

// ../drizzle-orm/dist/sqlite-core/index.js
var init_sqlite_core = __esm({
  "../drizzle-orm/dist/sqlite-core/index.js"() {
    "use strict";
    init_alias5();
    init_checks3();
    init_columns4();
    init_db4();
    init_dialect4();
    init_foreign_keys3();
    init_indexes4();
    init_primary_keys4();
    init_query_builders4();
    init_session4();
    init_subquery5();
    init_table5();
    init_unique_constraint4();
    init_utils7();
    init_view3();
  }
});

// ../node_modules/.pnpm/chalk@5.4.1/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(hex2) {
        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex2.toString(16));
        if (!matches) {
          return [0, 0, 0];
        }
        let [colorString] = matches;
        if (colorString.length === 3) {
          colorString = [...colorString].map((character) => character + character).join("");
        }
        const integer3 = Number.parseInt(colorString, 16);
        return [
          /* eslint-disable no-bitwise */
          integer3 >> 16 & 255,
          integer3 >> 8 & 255,
          integer3 & 255
          /* eslint-enable no-bitwise */
        ];
      },
      enumerable: false
    },
    hexToAnsi256: {
      value: (hex2) => styles.rgbToAnsi256(...styles.hexToRgb(hex2)),
      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: (hex2) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex2)),
      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.4.1/node_modules/chalk/source/vendor/ansi-styles/index.js"() {
    "use strict";
    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.4.1/node_modules/chalk/source/vendor/supports-color/index.js
function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
  const prefix2 = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
  const position = argv.indexOf(prefix2 + 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 min2 = forceColor || 0;
  if (env.TERM === "dumb") {
    return min2;
  }
  if (import_node_process.default.platform === "win32") {
    const osRelease = import_node_os.default.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", "GITEA_ACTIONS", "CIRCLECI"].some((key) => key in env)) {
      return 3;
    }
    if (["TRAVIS", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
      return 1;
    }
    return min2;
  }
  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 version3 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
    switch (env.TERM_PROGRAM) {
      case "iTerm.app": {
        return version3 >= 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 min2;
}
function createSupportsColor(stream, options = {}) {
  const level = _supportsColor(stream, {
    streamIsTTY: stream && stream.isTTY,
    ...options
  });
  return translateLevel(level);
}
var import_node_process, import_node_os, import_node_tty, env, flagForceColor, supportsColor, supports_color_default;
var init_supports_color = __esm({
  "../node_modules/.pnpm/chalk@5.4.1/node_modules/chalk/source/vendor/supports-color/index.js"() {
    "use strict";
    import_node_process = __toESM(require("process"), 1);
    import_node_os = __toESM(require("os"), 1);
    import_node_tty = __toESM(require("tty"), 1);
    ({ env } = import_node_process.default);
    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: import_node_tty.default.isatty(1) }),
      stderr: createSupportsColor({ isTTY: import_node_tty.default.isatty(2) })
    };
    supports_color_default = supportsColor;
  }
});

// ../node_modules/.pnpm/chalk@5.4.1/node_modules/chalk/source/utilities.js
function stringReplaceAll(string2, substring2, replacer) {
  let index7 = string2.indexOf(substring2);
  if (index7 === -1) {
    return string2;
  }
  const substringLength = substring2.length;
  let endIndex = 0;
  let returnValue = "";
  do {
    returnValue += string2.slice(endIndex, index7) + substring2 + replacer;
    endIndex = index7 + substringLength;
    index7 = string2.indexOf(substring2, endIndex);
  } while (index7 !== -1);
  returnValue += string2.slice(endIndex);
  return returnValue;
}
function stringEncaseCRLFWithFirstIndex(string2, prefix2, postfix, index7) {
  let endIndex = 0;
  let returnValue = "";
  do {
    const gotCR = string2[index7 - 1] === "\r";
    returnValue += string2.slice(endIndex, gotCR ? index7 - 1 : index7) + prefix2 + (gotCR ? "\r\n" : "\n") + postfix;
    endIndex = index7 + 1;
    index7 = string2.indexOf("\n", endIndex);
  } while (index7 !== -1);
  returnValue += string2.slice(endIndex);
  return returnValue;
}
var init_utilities = __esm({
  "../node_modules/.pnpm/chalk@5.4.1/node_modules/chalk/source/utilities.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/chalk@5.4.1/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, source_default;
var init_source = __esm({
  "../node_modules/.pnpm/chalk@5.4.1/node_modules/chalk/source/index.js"() {
    "use strict";
    init_ansi_styles();
    init_supports_color();
    init_utilities();
    ({ 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 = (object2, 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;
      object2.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_2) => {
      if (model === "rgb") {
        if (level === "ansi16m") {
          return ansi_styles_default[type].ansi16m(...arguments_2);
        }
        if (level === "ansi256") {
          return ansi_styles_default[type].ansi256(ansi_styles_default.rgbToAnsi256(...arguments_2));
        }
        return ansi_styles_default[type].ansi(ansi_styles_default.rgbToAnsi(...arguments_2));
      }
      if (model === "hex") {
        return getModelAnsi("rgb", level, type, ...ansi_styles_default.hexToRgb(...arguments_2));
      }
      return ansi_styles_default[type][model](...arguments_2);
    };
    usedModels = ["rgb", "hex", "ansi256"];
    for (const model of usedModels) {
      styles2[model] = {
        get() {
          const { level } = this;
          return function(...arguments_2) {
            const styler = createStyler(getModelAnsi(model, levelMapping[level], "color", ...arguments_2), 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_2) {
            const styler = createStyler(getModelAnsi(model, levelMapping[level], "bgColor", ...arguments_2), 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_2) => applyStyle(builder, arguments_2.length === 1 ? "" + arguments_2[0] : arguments_2.join(" "));
      Object.setPrototypeOf(builder, proto);
      builder[GENERATOR] = self2;
      builder[STYLER] = _styler;
      builder[IS_EMPTY] = _isEmpty;
      return builder;
    };
    applyStyle = (self2, string2) => {
      if (self2.level <= 0 || !string2) {
        return self2[IS_EMPTY] ? "" : string2;
      }
      let styler = self2[STYLER];
      if (styler === void 0) {
        return string2;
      }
      const { openAll, closeAll } = styler;
      if (string2.includes("\x1B")) {
        while (styler !== void 0) {
          string2 = stringReplaceAll(string2, styler.close, styler.open);
          styler = styler.parent;
        }
      }
      const lfIndex = string2.indexOf("\n");
      if (lfIndex !== -1) {
        string2 = stringEncaseCRLFWithFirstIndex(string2, closeAll, openAll, lfIndex);
      }
      return openAll + string2 + closeAll;
    };
    Object.defineProperties(createChalk.prototype, styles2);
    chalk = createChalk();
    chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
    source_default = chalk;
  }
});

// ../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js
var require_old = __commonJS({
  "../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/old.js"(exports2) {
    "use strict";
    var pathModule = require("path");
    var isWindows = process.platform === "win32";
    var fs9 = require("fs");
    var DEBUG = process.env.NODE_DEBUG && /fs/.test(process.env.NODE_DEBUG);
    function rethrow() {
      var callback;
      if (DEBUG) {
        var backtrace = new Error();
        callback = debugCallback;
      } else
        callback = missingCallback;
      return callback;
      function debugCallback(err3) {
        if (err3) {
          backtrace.message = err3.message;
          err3 = backtrace;
          missingCallback(err3);
        }
      }
      function missingCallback(err3) {
        if (err3) {
          if (process.throwDeprecation)
            throw err3;
          else if (!process.noDeprecation) {
            var msg = "fs: missing callback " + (err3.stack || err3.message);
            if (process.traceDeprecation)
              console.trace(msg);
            else
              console.error(msg);
          }
        }
      }
    }
    function maybeCallback(cb) {
      return typeof cb === "function" ? cb : rethrow();
    }
    var normalize = pathModule.normalize;
    if (isWindows) {
      nextPartRe = /(.*?)(?:[\/\\]+|$)/g;
    } else {
      nextPartRe = /(.*?)(?:[\/]+|$)/g;
    }
    var nextPartRe;
    if (isWindows) {
      splitRootRe = /^(?:[a-zA-Z]:|[\\\/]{2}[^\\\/]+[\\\/][^\\\/]+)?[\\\/]*/;
    } else {
      splitRootRe = /^[\/]*/;
    }
    var splitRootRe;
    exports2.realpathSync = function realpathSync(p11, cache5) {
      p11 = pathModule.resolve(p11);
      if (cache5 && Object.prototype.hasOwnProperty.call(cache5, p11)) {
        return cache5[p11];
      }
      var original = p11, seenLinks = {}, knownHard = {};
      var pos;
      var current;
      var base;
      var previous;
      start2();
      function start2() {
        var m12 = splitRootRe.exec(p11);
        pos = m12[0].length;
        current = m12[0];
        base = m12[0];
        previous = "";
        if (isWindows && !knownHard[base]) {
          fs9.lstatSync(base);
          knownHard[base] = true;
        }
      }
      while (pos < p11.length) {
        nextPartRe.lastIndex = pos;
        var result = nextPartRe.exec(p11);
        previous = current;
        current += result[0];
        base = previous + result[1];
        pos = nextPartRe.lastIndex;
        if (knownHard[base] || cache5 && cache5[base] === base) {
          continue;
        }
        var resolvedLink;
        if (cache5 && Object.prototype.hasOwnProperty.call(cache5, base)) {
          resolvedLink = cache5[base];
        } else {
          var stat2 = fs9.lstatSync(base);
          if (!stat2.isSymbolicLink()) {
            knownHard[base] = true;
            if (cache5) cache5[base] = base;
            continue;
          }
          var linkTarget = null;
          if (!isWindows) {
            var id = stat2.dev.toString(32) + ":" + stat2.ino.toString(32);
            if (seenLinks.hasOwnProperty(id)) {
              linkTarget = seenLinks[id];
            }
          }
          if (linkTarget === null) {
            fs9.statSync(base);
            linkTarget = fs9.readlinkSync(base);
          }
          resolvedLink = pathModule.resolve(previous, linkTarget);
          if (cache5) cache5[base] = resolvedLink;
          if (!isWindows) seenLinks[id] = linkTarget;
        }
        p11 = pathModule.resolve(resolvedLink, p11.slice(pos));
        start2();
      }
      if (cache5) cache5[original] = p11;
      return p11;
    };
    exports2.realpath = function realpath(p11, cache5, cb) {
      if (typeof cb !== "function") {
        cb = maybeCallback(cache5);
        cache5 = null;
      }
      p11 = pathModule.resolve(p11);
      if (cache5 && Object.prototype.hasOwnProperty.call(cache5, p11)) {
        return process.nextTick(cb.bind(null, null, cache5[p11]));
      }
      var original = p11, seenLinks = {}, knownHard = {};
      var pos;
      var current;
      var base;
      var previous;
      start2();
      function start2() {
        var m12 = splitRootRe.exec(p11);
        pos = m12[0].length;
        current = m12[0];
        base = m12[0];
        previous = "";
        if (isWindows && !knownHard[base]) {
          fs9.lstat(base, function(err3) {
            if (err3) return cb(err3);
            knownHard[base] = true;
            LOOP();
          });
        } else {
          process.nextTick(LOOP);
        }
      }
      function LOOP() {
        if (pos >= p11.length) {
          if (cache5) cache5[original] = p11;
          return cb(null, p11);
        }
        nextPartRe.lastIndex = pos;
        var result = nextPartRe.exec(p11);
        previous = current;
        current += result[0];
        base = previous + result[1];
        pos = nextPartRe.lastIndex;
        if (knownHard[base] || cache5 && cache5[base] === base) {
          return process.nextTick(LOOP);
        }
        if (cache5 && Object.prototype.hasOwnProperty.call(cache5, base)) {
          return gotResolvedLink(cache5[base]);
        }
        return fs9.lstat(base, gotStat);
      }
      function gotStat(err3, stat2) {
        if (err3) return cb(err3);
        if (!stat2.isSymbolicLink()) {
          knownHard[base] = true;
          if (cache5) cache5[base] = base;
          return process.nextTick(LOOP);
        }
        if (!isWindows) {
          var id = stat2.dev.toString(32) + ":" + stat2.ino.toString(32);
          if (seenLinks.hasOwnProperty(id)) {
            return gotTarget(null, seenLinks[id], base);
          }
        }
        fs9.stat(base, function(err4) {
          if (err4) return cb(err4);
          fs9.readlink(base, function(err5, target) {
            if (!isWindows) seenLinks[id] = target;
            gotTarget(err5, target);
          });
        });
      }
      function gotTarget(err3, target, base2) {
        if (err3) return cb(err3);
        var resolvedLink = pathModule.resolve(previous, target);
        if (cache5) cache5[base2] = resolvedLink;
        gotResolvedLink(resolvedLink);
      }
      function gotResolvedLink(resolvedLink) {
        p11 = pathModule.resolve(resolvedLink, p11.slice(pos));
        start2();
      }
    };
  }
});

// ../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js
var require_fs = __commonJS({
  "../node_modules/.pnpm/fs.realpath@1.0.0/node_modules/fs.realpath/index.js"(exports2, module2) {
    "use strict";
    module2.exports = realpath;
    realpath.realpath = realpath;
    realpath.sync = realpathSync;
    realpath.realpathSync = realpathSync;
    realpath.monkeypatch = monkeypatch;
    realpath.unmonkeypatch = unmonkeypatch;
    var fs9 = require("fs");
    var origRealpath = fs9.realpath;
    var origRealpathSync = fs9.realpathSync;
    var version3 = process.version;
    var ok = /^v[0-5]\./.test(version3);
    var old = require_old();
    function newError(er3) {
      return er3 && er3.syscall === "realpath" && (er3.code === "ELOOP" || er3.code === "ENOMEM" || er3.code === "ENAMETOOLONG");
    }
    function realpath(p11, cache5, cb) {
      if (ok) {
        return origRealpath(p11, cache5, cb);
      }
      if (typeof cache5 === "function") {
        cb = cache5;
        cache5 = null;
      }
      origRealpath(p11, cache5, function(er3, result) {
        if (newError(er3)) {
          old.realpath(p11, cache5, cb);
        } else {
          cb(er3, result);
        }
      });
    }
    function realpathSync(p11, cache5) {
      if (ok) {
        return origRealpathSync(p11, cache5);
      }
      try {
        return origRealpathSync(p11, cache5);
      } catch (er3) {
        if (newError(er3)) {
          return old.realpathSync(p11, cache5);
        } else {
          throw er3;
        }
      }
    }
    function monkeypatch() {
      fs9.realpath = realpath;
      fs9.realpathSync = realpathSync;
    }
    function unmonkeypatch() {
      fs9.realpath = origRealpath;
      fs9.realpathSync = origRealpathSync;
    }
  }
});

// ../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/lib/path.js
var require_path = __commonJS({
  "../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/lib/path.js"(exports2, module2) {
    "use strict";
    var isWindows = typeof process === "object" && process && process.platform === "win32";
    module2.exports = isWindows ? { sep: "\\" } : { sep: "/" };
  }
});

// ../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"(exports2, module2) {
    "use strict";
    module2.exports = balanced;
    function balanced(a9, b9, str) {
      if (a9 instanceof RegExp) a9 = maybeMatch(a9, str);
      if (b9 instanceof RegExp) b9 = maybeMatch(b9, str);
      var r6 = range(a9, b9, str);
      return r6 && {
        start: r6[0],
        end: r6[1],
        pre: str.slice(0, r6[0]),
        body: str.slice(r6[0] + a9.length, r6[1]),
        post: str.slice(r6[1] + b9.length)
      };
    }
    function maybeMatch(reg, str) {
      var m12 = str.match(reg);
      return m12 ? m12[0] : null;
    }
    balanced.range = range;
    function range(a9, b9, str) {
      var begs, beg, left, right, result;
      var ai = str.indexOf(a9);
      var bi = str.indexOf(b9, ai + 1);
      var i8 = ai;
      if (ai >= 0 && bi > 0) {
        if (a9 === b9) {
          return [ai, bi];
        }
        begs = [];
        left = str.length;
        while (i8 >= 0 && !result) {
          if (i8 == ai) {
            begs.push(i8);
            ai = str.indexOf(a9, i8 + 1);
          } else if (begs.length == 1) {
            result = [begs.pop(), bi];
          } else {
            beg = begs.pop();
            if (beg < left) {
              left = beg;
              right = bi;
            }
            bi = str.indexOf(b9, i8 + 1);
          }
          i8 = 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"(exports2, module2) {
    "use strict";
    var balanced = require_balanced_match();
    module2.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 numeric3(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 parts2 = [];
      var m12 = balanced("{", "}", str);
      if (!m12)
        return str.split(",");
      var pre = m12.pre;
      var body2 = m12.body;
      var post = m12.post;
      var p11 = pre.split(",");
      p11[p11.length - 1] += "{" + body2 + "}";
      var postParts = parseCommaParts(post);
      if (post.length) {
        p11[p11.length - 1] += postParts.shift();
        p11.push.apply(p11, postParts);
      }
      parts2.push.apply(parts2, p11);
      return parts2;
    }
    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 lte2(i8, y7) {
      return i8 <= y7;
    }
    function gte2(i8, y7) {
      return i8 >= y7;
    }
    function expand2(str, isTop) {
      var expansions = [];
      var m12 = balanced("{", "}", str);
      if (!m12) return [str];
      var pre = m12.pre;
      var post = m12.post.length ? expand2(m12.post, false) : [""];
      if (/\$$/.test(m12.pre)) {
        for (var k9 = 0; k9 < post.length; k9++) {
          var expansion = pre + "{" + m12.body + "}" + post[k9];
          expansions.push(expansion);
        }
      } else {
        var isNumericSequence = /^-?\d+\.\.-?\d+(?:\.\.-?\d+)?$/.test(m12.body);
        var isAlphaSequence = /^[a-zA-Z]\.\.[a-zA-Z](?:\.\.-?\d+)?$/.test(m12.body);
        var isSequence = isNumericSequence || isAlphaSequence;
        var isOptions = m12.body.indexOf(",") >= 0;
        if (!isSequence && !isOptions) {
          if (m12.post.match(/,.*\}/)) {
            str = m12.pre + "{" + m12.body + escClose + m12.post;
            return expand2(str);
          }
          return [str];
        }
        var n7;
        if (isSequence) {
          n7 = m12.body.split(/\.\./);
        } else {
          n7 = parseCommaParts(m12.body);
          if (n7.length === 1) {
            n7 = expand2(n7[0], false).map(embrace);
            if (n7.length === 1) {
              return post.map(function(p11) {
                return m12.pre + n7[0] + p11;
              });
            }
          }
        }
        var N5;
        if (isSequence) {
          var x11 = numeric3(n7[0]);
          var y7 = numeric3(n7[1]);
          var width = Math.max(n7[0].length, n7[1].length);
          var incr = n7.length == 3 ? Math.abs(numeric3(n7[2])) : 1;
          var test = lte2;
          var reverse = y7 < x11;
          if (reverse) {
            incr *= -1;
            test = gte2;
          }
          var pad = n7.some(isPadded);
          N5 = [];
          for (var i8 = x11; test(i8, y7); i8 += incr) {
            var c6;
            if (isAlphaSequence) {
              c6 = String.fromCharCode(i8);
              if (c6 === "\\")
                c6 = "";
            } else {
              c6 = String(i8);
              if (pad) {
                var need = width - c6.length;
                if (need > 0) {
                  var z6 = new Array(need + 1).join("0");
                  if (i8 < 0)
                    c6 = "-" + z6 + c6.slice(1);
                  else
                    c6 = z6 + c6;
                }
              }
            }
            N5.push(c6);
          }
        } else {
          N5 = [];
          for (var j7 = 0; j7 < n7.length; j7++) {
            N5.push.apply(N5, expand2(n7[j7], false));
          }
        }
        for (var j7 = 0; j7 < N5.length; j7++) {
          for (var k9 = 0; k9 < post.length; k9++) {
            var expansion = pre + N5[j7] + post[k9];
            if (!isTop || isSequence || expansion)
              expansions.push(expansion);
          }
        }
      }
      return expansions;
    }
  }
});

// ../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/minimatch.js
var require_minimatch = __commonJS({
  "../node_modules/.pnpm/minimatch@5.1.6/node_modules/minimatch/minimatch.js"(exports2, module2) {
    "use strict";
    var minimatch2 = module2.exports = (p11, pattern, options = {}) => {
      assertValidPattern2(pattern);
      if (!options.nocomment && pattern.charAt(0) === "#") {
        return false;
      }
      return new Minimatch2(pattern, options).match(p11);
    };
    module2.exports = minimatch2;
    var path3 = require_path();
    minimatch2.sep = path3.sep;
    var GLOBSTAR2 = Symbol("globstar **");
    minimatch2.GLOBSTAR = GLOBSTAR2;
    var expand2 = require_brace_expansion();
    var plTypes2 = {
      "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
      "?": { open: "(?:", close: ")?" },
      "+": { open: "(?:", close: ")+" },
      "*": { open: "(?:", close: ")*" },
      "@": { open: "(?:", close: ")" }
    };
    var qmark2 = "[^/]";
    var star2 = qmark2 + "*?";
    var twoStarDot2 = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
    var twoStarNoDot2 = "(?:(?!(?:\\/|^)\\.).)*?";
    var charSet2 = (s10) => s10.split("").reduce((set, c6) => {
      set[c6] = true;
      return set;
    }, {});
    var reSpecials2 = charSet2("().*{}+?[]^$\\!");
    var addPatternStartSet2 = charSet2("[.(");
    var slashSplit = /\/+/;
    minimatch2.filter = (pattern, options = {}) => (p11, i8, list) => minimatch2(p11, pattern, options);
    var ext2 = (a9, b9 = {}) => {
      const t6 = {};
      Object.keys(a9).forEach((k9) => t6[k9] = a9[k9]);
      Object.keys(b9).forEach((k9) => t6[k9] = b9[k9]);
      return t6;
    };
    minimatch2.defaults = (def) => {
      if (!def || typeof def !== "object" || !Object.keys(def).length) {
        return minimatch2;
      }
      const orig = minimatch2;
      const m12 = (p11, pattern, options) => orig(p11, pattern, ext2(def, options));
      m12.Minimatch = class Minimatch extends orig.Minimatch {
        constructor(pattern, options) {
          super(pattern, ext2(def, options));
        }
      };
      m12.Minimatch.defaults = (options) => orig.defaults(ext2(def, options)).Minimatch;
      m12.filter = (pattern, options) => orig.filter(pattern, ext2(def, options));
      m12.defaults = (options) => orig.defaults(ext2(def, options));
      m12.makeRe = (pattern, options) => orig.makeRe(pattern, ext2(def, options));
      m12.braceExpand = (pattern, options) => orig.braceExpand(pattern, ext2(def, options));
      m12.match = (list, pattern, options) => orig.match(list, pattern, ext2(def, options));
      return m12;
    };
    minimatch2.braceExpand = (pattern, options) => braceExpand2(pattern, options);
    var braceExpand2 = (pattern, options = {}) => {
      assertValidPattern2(pattern);
      if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
        return [pattern];
      }
      return expand2(pattern);
    };
    var MAX_PATTERN_LENGTH2 = 1024 * 64;
    var assertValidPattern2 = (pattern) => {
      if (typeof pattern !== "string") {
        throw new TypeError("invalid pattern");
      }
      if (pattern.length > MAX_PATTERN_LENGTH2) {
        throw new TypeError("pattern is too long");
      }
    };
    var SUBPARSE = Symbol("subparse");
    minimatch2.makeRe = (pattern, options) => new Minimatch2(pattern, options || {}).makeRe();
    minimatch2.match = (list, pattern, options = {}) => {
      const mm = new Minimatch2(pattern, options);
      list = list.filter((f9) => mm.match(f9));
      if (mm.options.nonull && !list.length) {
        list.push(pattern);
      }
      return list;
    };
    var globUnescape2 = (s10) => s10.replace(/\\(.)/g, "$1");
    var charUnescape = (s10) => s10.replace(/\\([^-\]])/g, "$1");
    var regExpEscape2 = (s10) => s10.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
    var braExpEscape = (s10) => s10.replace(/[[\]\\]/g, "\\$&");
    var Minimatch2 = class {
      constructor(pattern, options) {
        assertValidPattern2(pattern);
        if (!options) options = {};
        this.options = options;
        this.set = [];
        this.pattern = pattern;
        this.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
        if (this.windowsPathsNoEscape) {
          this.pattern = this.pattern.replace(/\\/g, "/");
        }
        this.regexp = null;
        this.negate = false;
        this.comment = false;
        this.empty = false;
        this.partial = !!options.partial;
        this.make();
      }
      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();
        let set = this.globSet = this.braceExpand();
        if (options.debug) this.debug = (...args2) => console.error(...args2);
        this.debug(this.pattern, set);
        set = this.globParts = set.map((s10) => s10.split(slashSplit));
        this.debug(this.pattern, set);
        set = set.map((s10, si2, set2) => s10.map(this.parse, this));
        this.debug(this.pattern, set);
        set = set.filter((s10) => s10.indexOf(false) === -1);
        this.debug(this.pattern, set);
        this.set = set;
      }
      parseNegate() {
        if (this.options.nonegate) return;
        const pattern = this.pattern;
        let negate2 = false;
        let negateOffset = 0;
        for (let i8 = 0; i8 < pattern.length && pattern.charAt(i8) === "!"; i8++) {
          negate2 = !negate2;
          negateOffset++;
        }
        if (negateOffset) this.pattern = pattern.slice(negateOffset);
        this.negate = negate2;
      }
      // 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) {
        var options = this.options;
        this.debug(
          "matchOne",
          { "this": this, file, pattern }
        );
        this.debug("matchOne", file.length, pattern.length);
        for (var fi2 = 0, pi2 = 0, fl = file.length, pl = pattern.length; fi2 < fl && pi2 < pl; fi2++, pi2++) {
          this.debug("matchOne loop");
          var p11 = pattern[pi2];
          var f9 = file[fi2];
          this.debug(pattern, p11, f9);
          if (p11 === false) return false;
          if (p11 === GLOBSTAR2) {
            this.debug("GLOBSTAR", [pattern, p11, f9]);
            var fr3 = fi2;
            var pr2 = pi2 + 1;
            if (pr2 === pl) {
              this.debug("** at the end");
              for (; fi2 < fl; fi2++) {
                if (file[fi2] === "." || file[fi2] === ".." || !options.dot && file[fi2].charAt(0) === ".") return false;
              }
              return true;
            }
            while (fr3 < fl) {
              var swallowee = file[fr3];
              this.debug("\nglobstar while", file, fr3, pattern, pr2, swallowee);
              if (this.matchOne(file.slice(fr3), pattern.slice(pr2), partial)) {
                this.debug("globstar found match!", fr3, fl, swallowee);
                return true;
              } else {
                if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
                  this.debug("dot detected!", file, fr3, pattern, pr2);
                  break;
                }
                this.debug("globstar swallow a segment, and continue");
                fr3++;
              }
            }
            if (partial) {
              this.debug("\n>>> no match, partial?", file, fr3, pattern, pr2);
              if (fr3 === fl) return true;
            }
            return false;
          }
          var hit;
          if (typeof p11 === "string") {
            hit = f9 === p11;
            this.debug("string match", p11, f9, hit);
          } else {
            hit = f9.match(p11);
            this.debug("pattern match", p11, f9, hit);
          }
          if (!hit) return false;
        }
        if (fi2 === fl && pi2 === pl) {
          return true;
        } else if (fi2 === fl) {
          return partial;
        } else if (pi2 === pl) {
          return fi2 === fl - 1 && file[fi2] === "";
        }
        throw new Error("wtf?");
      }
      braceExpand() {
        return braceExpand2(this.pattern, this.options);
      }
      parse(pattern, isSub) {
        assertValidPattern2(pattern);
        const options = this.options;
        if (pattern === "**") {
          if (!options.noglobstar)
            return GLOBSTAR2;
          else
            pattern = "*";
        }
        if (pattern === "") return "";
        let re3 = "";
        let hasMagic = false;
        let escaping = false;
        const patternListStack = [];
        const negativeLists = [];
        let stateChar;
        let inClass = false;
        let reClassStart = -1;
        let classStart = -1;
        let cs2;
        let pl;
        let sp;
        let dotTravAllowed = pattern.charAt(0) === ".";
        let dotFileAllowed = options.dot || dotTravAllowed;
        const patternStart = () => dotTravAllowed ? "" : dotFileAllowed ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
        const subPatternStart = (p11) => p11.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
        const clearStateChar = () => {
          if (stateChar) {
            switch (stateChar) {
              case "*":
                re3 += star2;
                hasMagic = true;
                break;
              case "?":
                re3 += qmark2;
                hasMagic = true;
                break;
              default:
                re3 += "\\" + stateChar;
                break;
            }
            this.debug("clearStateChar %j %j", stateChar, re3);
            stateChar = false;
          }
        };
        for (let i8 = 0, c6; i8 < pattern.length && (c6 = pattern.charAt(i8)); i8++) {
          this.debug("%s	%s %s %j", pattern, i8, re3, c6);
          if (escaping) {
            if (c6 === "/") {
              return false;
            }
            if (reSpecials2[c6]) {
              re3 += "\\";
            }
            re3 += c6;
            escaping = false;
            continue;
          }
          switch (c6) {
            /* istanbul ignore next */
            case "/": {
              return false;
            }
            case "\\":
              if (inClass && pattern.charAt(i8 + 1) === "-") {
                re3 += c6;
                continue;
              }
              clearStateChar();
              escaping = true;
              continue;
            // the various stateChar values
            // for the "extglob" stuff.
            case "?":
            case "*":
            case "+":
            case "@":
            case "!":
              this.debug("%s	%s %s %j <-- stateChar", pattern, i8, re3, c6);
              if (inClass) {
                this.debug("  in class");
                if (c6 === "!" && i8 === classStart + 1) c6 = "^";
                re3 += c6;
                continue;
              }
              this.debug("call clearStateChar %j", stateChar);
              clearStateChar();
              stateChar = c6;
              if (options.noext) clearStateChar();
              continue;
            case "(": {
              if (inClass) {
                re3 += "(";
                continue;
              }
              if (!stateChar) {
                re3 += "\\(";
                continue;
              }
              const plEntry = {
                type: stateChar,
                start: i8 - 1,
                reStart: re3.length,
                open: plTypes2[stateChar].open,
                close: plTypes2[stateChar].close
              };
              this.debug(this.pattern, "	", plEntry);
              patternListStack.push(plEntry);
              re3 += plEntry.open;
              if (plEntry.start === 0 && plEntry.type !== "!") {
                dotTravAllowed = true;
                re3 += subPatternStart(pattern.slice(i8 + 1));
              }
              this.debug("plType %j %j", stateChar, re3);
              stateChar = false;
              continue;
            }
            case ")": {
              const plEntry = patternListStack[patternListStack.length - 1];
              if (inClass || !plEntry) {
                re3 += "\\)";
                continue;
              }
              patternListStack.pop();
              clearStateChar();
              hasMagic = true;
              pl = plEntry;
              re3 += pl.close;
              if (pl.type === "!") {
                negativeLists.push(Object.assign(pl, { reEnd: re3.length }));
              }
              continue;
            }
            case "|": {
              const plEntry = patternListStack[patternListStack.length - 1];
              if (inClass || !plEntry) {
                re3 += "\\|";
                continue;
              }
              clearStateChar();
              re3 += "|";
              if (plEntry.start === 0 && plEntry.type !== "!") {
                dotTravAllowed = true;
                re3 += subPatternStart(pattern.slice(i8 + 1));
              }
              continue;
            }
            // these are mostly the same in regexp and glob
            case "[":
              clearStateChar();
              if (inClass) {
                re3 += "\\" + c6;
                continue;
              }
              inClass = true;
              classStart = i8;
              reClassStart = re3.length;
              re3 += c6;
              continue;
            case "]":
              if (i8 === classStart + 1 || !inClass) {
                re3 += "\\" + c6;
                continue;
              }
              cs2 = pattern.substring(classStart + 1, i8);
              try {
                RegExp("[" + braExpEscape(charUnescape(cs2)) + "]");
                re3 += c6;
              } catch (er3) {
                re3 = re3.substring(0, reClassStart) + "(?:$.)";
              }
              hasMagic = true;
              inClass = false;
              continue;
            default:
              clearStateChar();
              if (reSpecials2[c6] && !(c6 === "^" && inClass)) {
                re3 += "\\";
              }
              re3 += c6;
              break;
          }
        }
        if (inClass) {
          cs2 = pattern.slice(classStart + 1);
          sp = this.parse(cs2, SUBPARSE);
          re3 = re3.substring(0, reClassStart) + "\\[" + sp[0];
          hasMagic = hasMagic || sp[1];
        }
        for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
          let tail;
          tail = re3.slice(pl.reStart + pl.open.length);
          this.debug("setting tail", re3, pl);
          tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_7, $1, $22) => {
            if (!$22) {
              $22 = "\\";
            }
            return $1 + $1 + $22 + "|";
          });
          this.debug("tail=%j\n   %s", tail, tail, pl, re3);
          const t6 = pl.type === "*" ? star2 : pl.type === "?" ? qmark2 : "\\" + pl.type;
          hasMagic = true;
          re3 = re3.slice(0, pl.reStart) + t6 + "\\(" + tail;
        }
        clearStateChar();
        if (escaping) {
          re3 += "\\\\";
        }
        const addPatternStart = addPatternStartSet2[re3.charAt(0)];
        for (let n7 = negativeLists.length - 1; n7 > -1; n7--) {
          const nl = negativeLists[n7];
          const nlBefore = re3.slice(0, nl.reStart);
          const nlFirst = re3.slice(nl.reStart, nl.reEnd - 8);
          let nlAfter = re3.slice(nl.reEnd);
          const nlLast = re3.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
          const closeParensBefore = nlBefore.split(")").length;
          const openParensBefore = nlBefore.split("(").length - closeParensBefore;
          let cleanAfter = nlAfter;
          for (let i8 = 0; i8 < openParensBefore; i8++) {
            cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
          }
          nlAfter = cleanAfter;
          const dollar = nlAfter === "" && isSub !== SUBPARSE ? "(?:$|\\/)" : "";
          re3 = nlBefore + nlFirst + nlAfter + dollar + nlLast;
        }
        if (re3 !== "" && hasMagic) {
          re3 = "(?=.)" + re3;
        }
        if (addPatternStart) {
          re3 = patternStart() + re3;
        }
        if (isSub === SUBPARSE) {
          return [re3, hasMagic];
        }
        if (options.nocase && !hasMagic) {
          hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();
        }
        if (!hasMagic) {
          return globUnescape2(pattern);
        }
        const flags2 = options.nocase ? "i" : "";
        try {
          return Object.assign(new RegExp("^" + re3 + "$", flags2), {
            _glob: pattern,
            _src: re3
          });
        } catch (er3) {
          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 ? star2 : options.dot ? twoStarDot2 : twoStarNoDot2;
        const flags2 = options.nocase ? "i" : "";
        let re3 = set.map((pattern) => {
          pattern = pattern.map(
            (p11) => typeof p11 === "string" ? regExpEscape2(p11) : p11 === GLOBSTAR2 ? GLOBSTAR2 : p11._src
          ).reduce((set2, p11) => {
            if (!(set2[set2.length - 1] === GLOBSTAR2 && p11 === GLOBSTAR2)) {
              set2.push(p11);
            }
            return set2;
          }, []);
          pattern.forEach((p11, i8) => {
            if (p11 !== GLOBSTAR2 || pattern[i8 - 1] === GLOBSTAR2) {
              return;
            }
            if (i8 === 0) {
              if (pattern.length > 1) {
                pattern[i8 + 1] = "(?:\\/|" + twoStar + "\\/)?" + pattern[i8 + 1];
              } else {
                pattern[i8] = twoStar;
              }
            } else if (i8 === pattern.length - 1) {
              pattern[i8 - 1] += "(?:\\/|" + twoStar + ")?";
            } else {
              pattern[i8 - 1] += "(?:\\/|\\/" + twoStar + "\\/)" + pattern[i8 + 1];
              pattern[i8 + 1] = GLOBSTAR2;
            }
          });
          return pattern.filter((p11) => p11 !== GLOBSTAR2).join("/");
        }).join("|");
        re3 = "^(?:" + re3 + ")$";
        if (this.negate) re3 = "^(?!" + re3 + ").*$";
        try {
          this.regexp = new RegExp(re3, flags2);
        } catch (ex) {
          this.regexp = false;
        }
        return this.regexp;
      }
      match(f9, partial = this.partial) {
        this.debug("match", f9, this.pattern);
        if (this.comment) return false;
        if (this.empty) return f9 === "";
        if (f9 === "/" && partial) return true;
        const options = this.options;
        if (path3.sep !== "/") {
          f9 = f9.split(path3.sep).join("/");
        }
        f9 = f9.split(slashSplit);
        this.debug(this.pattern, "split", f9);
        const set = this.set;
        this.debug(this.pattern, "set", set);
        let filename;
        for (let i8 = f9.length - 1; i8 >= 0; i8--) {
          filename = f9[i8];
          if (filename) break;
        }
        for (let i8 = 0; i8 < set.length; i8++) {
          const pattern = set[i8];
          let file = f9;
          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 minimatch2.defaults(def).Minimatch;
      }
    };
    minimatch2.Minimatch = Minimatch2;
  }
});

// ../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js
var require_inherits_browser = __commonJS({
  "../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits_browser.js"(exports2, module2) {
    "use strict";
    if (typeof Object.create === "function") {
      module2.exports = function inherits(ctor, superCtor) {
        if (superCtor) {
          ctor.super_ = superCtor;
          ctor.prototype = Object.create(superCtor.prototype, {
            constructor: {
              value: ctor,
              enumerable: false,
              writable: true,
              configurable: true
            }
          });
        }
      };
    } else {
      module2.exports = function inherits(ctor, superCtor) {
        if (superCtor) {
          ctor.super_ = superCtor;
          var TempCtor = function() {
          };
          TempCtor.prototype = superCtor.prototype;
          ctor.prototype = new TempCtor();
          ctor.prototype.constructor = ctor;
        }
      };
    }
  }
});

// ../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js
var require_inherits = __commonJS({
  "../node_modules/.pnpm/inherits@2.0.4/node_modules/inherits/inherits.js"(exports2, module2) {
    "use strict";
    try {
      util2 = require("util");
      if (typeof util2.inherits !== "function") throw "";
      module2.exports = util2.inherits;
    } catch (e6) {
      module2.exports = require_inherits_browser();
    }
    var util2;
  }
});

// ../node_modules/.pnpm/glob@8.1.0/node_modules/glob/common.js
var require_common = __commonJS({
  "../node_modules/.pnpm/glob@8.1.0/node_modules/glob/common.js"(exports2) {
    "use strict";
    exports2.setopts = setopts;
    exports2.ownProp = ownProp;
    exports2.makeAbs = makeAbs;
    exports2.finish = finish;
    exports2.mark = mark;
    exports2.isIgnored = isIgnored;
    exports2.childrenIgnored = childrenIgnored;
    function ownProp(obj, field) {
      return Object.prototype.hasOwnProperty.call(obj, field);
    }
    var fs9 = require("fs");
    var path3 = require("path");
    var minimatch2 = require_minimatch();
    var isAbsolute = require("path").isAbsolute;
    var Minimatch2 = minimatch2.Minimatch;
    function alphasort(a9, b9) {
      return a9.localeCompare(b9, "en");
    }
    function setupIgnores(self2, options) {
      self2.ignore = options.ignore || [];
      if (!Array.isArray(self2.ignore))
        self2.ignore = [self2.ignore];
      if (self2.ignore.length) {
        self2.ignore = self2.ignore.map(ignoreMap);
      }
    }
    function ignoreMap(pattern) {
      var gmatcher = null;
      if (pattern.slice(-3) === "/**") {
        var gpattern = pattern.replace(/(\/\*\*)+$/, "");
        gmatcher = new Minimatch2(gpattern, { dot: true });
      }
      return {
        matcher: new Minimatch2(pattern, { dot: true }),
        gmatcher
      };
    }
    function setopts(self2, pattern, options) {
      if (!options)
        options = {};
      if (options.matchBase && -1 === pattern.indexOf("/")) {
        if (options.noglobstar) {
          throw new Error("base matching requires globstar");
        }
        pattern = "**/" + pattern;
      }
      self2.windowsPathsNoEscape = !!options.windowsPathsNoEscape || options.allowWindowsEscape === false;
      if (self2.windowsPathsNoEscape) {
        pattern = pattern.replace(/\\/g, "/");
      }
      self2.silent = !!options.silent;
      self2.pattern = pattern;
      self2.strict = options.strict !== false;
      self2.realpath = !!options.realpath;
      self2.realpathCache = options.realpathCache || /* @__PURE__ */ Object.create(null);
      self2.follow = !!options.follow;
      self2.dot = !!options.dot;
      self2.mark = !!options.mark;
      self2.nodir = !!options.nodir;
      if (self2.nodir)
        self2.mark = true;
      self2.sync = !!options.sync;
      self2.nounique = !!options.nounique;
      self2.nonull = !!options.nonull;
      self2.nosort = !!options.nosort;
      self2.nocase = !!options.nocase;
      self2.stat = !!options.stat;
      self2.noprocess = !!options.noprocess;
      self2.absolute = !!options.absolute;
      self2.fs = options.fs || fs9;
      self2.maxLength = options.maxLength || Infinity;
      self2.cache = options.cache || /* @__PURE__ */ Object.create(null);
      self2.statCache = options.statCache || /* @__PURE__ */ Object.create(null);
      self2.symlinks = options.symlinks || /* @__PURE__ */ Object.create(null);
      setupIgnores(self2, options);
      self2.changedCwd = false;
      var cwd = process.cwd();
      if (!ownProp(options, "cwd"))
        self2.cwd = path3.resolve(cwd);
      else {
        self2.cwd = path3.resolve(options.cwd);
        self2.changedCwd = self2.cwd !== cwd;
      }
      self2.root = options.root || path3.resolve(self2.cwd, "/");
      self2.root = path3.resolve(self2.root);
      self2.cwdAbs = isAbsolute(self2.cwd) ? self2.cwd : makeAbs(self2, self2.cwd);
      self2.nomount = !!options.nomount;
      if (process.platform === "win32") {
        self2.root = self2.root.replace(/\\/g, "/");
        self2.cwd = self2.cwd.replace(/\\/g, "/");
        self2.cwdAbs = self2.cwdAbs.replace(/\\/g, "/");
      }
      options.nonegate = true;
      options.nocomment = true;
      self2.minimatch = new Minimatch2(pattern, options);
      self2.options = self2.minimatch.options;
    }
    function finish(self2) {
      var nou = self2.nounique;
      var all = nou ? [] : /* @__PURE__ */ Object.create(null);
      for (var i8 = 0, l7 = self2.matches.length; i8 < l7; i8++) {
        var matches = self2.matches[i8];
        if (!matches || Object.keys(matches).length === 0) {
          if (self2.nonull) {
            var literal = self2.minimatch.globSet[i8];
            if (nou)
              all.push(literal);
            else
              all[literal] = true;
          }
        } else {
          var m12 = Object.keys(matches);
          if (nou)
            all.push.apply(all, m12);
          else
            m12.forEach(function(m13) {
              all[m13] = true;
            });
        }
      }
      if (!nou)
        all = Object.keys(all);
      if (!self2.nosort)
        all = all.sort(alphasort);
      if (self2.mark) {
        for (var i8 = 0; i8 < all.length; i8++) {
          all[i8] = self2._mark(all[i8]);
        }
        if (self2.nodir) {
          all = all.filter(function(e6) {
            var notDir = !/\/$/.test(e6);
            var c6 = self2.cache[e6] || self2.cache[makeAbs(self2, e6)];
            if (notDir && c6)
              notDir = c6 !== "DIR" && !Array.isArray(c6);
            return notDir;
          });
        }
      }
      if (self2.ignore.length)
        all = all.filter(function(m13) {
          return !isIgnored(self2, m13);
        });
      self2.found = all;
    }
    function mark(self2, p11) {
      var abs = makeAbs(self2, p11);
      var c6 = self2.cache[abs];
      var m12 = p11;
      if (c6) {
        var isDir = c6 === "DIR" || Array.isArray(c6);
        var slash = p11.slice(-1) === "/";
        if (isDir && !slash)
          m12 += "/";
        else if (!isDir && slash)
          m12 = m12.slice(0, -1);
        if (m12 !== p11) {
          var mabs = makeAbs(self2, m12);
          self2.statCache[mabs] = self2.statCache[abs];
          self2.cache[mabs] = self2.cache[abs];
        }
      }
      return m12;
    }
    function makeAbs(self2, f9) {
      var abs = f9;
      if (f9.charAt(0) === "/") {
        abs = path3.join(self2.root, f9);
      } else if (isAbsolute(f9) || f9 === "") {
        abs = f9;
      } else if (self2.changedCwd) {
        abs = path3.resolve(self2.cwd, f9);
      } else {
        abs = path3.resolve(f9);
      }
      if (process.platform === "win32")
        abs = abs.replace(/\\/g, "/");
      return abs;
    }
    function isIgnored(self2, path4) {
      if (!self2.ignore.length)
        return false;
      return self2.ignore.some(function(item) {
        return item.matcher.match(path4) || !!(item.gmatcher && item.gmatcher.match(path4));
      });
    }
    function childrenIgnored(self2, path4) {
      if (!self2.ignore.length)
        return false;
      return self2.ignore.some(function(item) {
        return !!(item.gmatcher && item.gmatcher.match(path4));
      });
    }
  }
});

// ../node_modules/.pnpm/glob@8.1.0/node_modules/glob/sync.js
var require_sync = __commonJS({
  "../node_modules/.pnpm/glob@8.1.0/node_modules/glob/sync.js"(exports2, module2) {
    "use strict";
    module2.exports = globSync;
    globSync.GlobSync = GlobSync;
    var rp = require_fs();
    var minimatch2 = require_minimatch();
    var Minimatch2 = minimatch2.Minimatch;
    var Glob = require_glob().Glob;
    var util2 = require("util");
    var path3 = require("path");
    var assert2 = require("assert");
    var isAbsolute = require("path").isAbsolute;
    var common = require_common();
    var setopts = common.setopts;
    var ownProp = common.ownProp;
    var childrenIgnored = common.childrenIgnored;
    var isIgnored = common.isIgnored;
    function globSync(pattern, options) {
      if (typeof options === "function" || arguments.length === 3)
        throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
      return new GlobSync(pattern, options).found;
    }
    function GlobSync(pattern, options) {
      if (!pattern)
        throw new Error("must provide pattern");
      if (typeof options === "function" || arguments.length === 3)
        throw new TypeError("callback provided to sync glob\nSee: https://github.com/isaacs/node-glob/issues/167");
      if (!(this instanceof GlobSync))
        return new GlobSync(pattern, options);
      setopts(this, pattern, options);
      if (this.noprocess)
        return this;
      var n7 = this.minimatch.set.length;
      this.matches = new Array(n7);
      for (var i8 = 0; i8 < n7; i8++) {
        this._process(this.minimatch.set[i8], i8, false);
      }
      this._finish();
    }
    GlobSync.prototype._finish = function() {
      assert2.ok(this instanceof GlobSync);
      if (this.realpath) {
        var self2 = this;
        this.matches.forEach(function(matchset, index7) {
          var set = self2.matches[index7] = /* @__PURE__ */ Object.create(null);
          for (var p11 in matchset) {
            try {
              p11 = self2._makeAbs(p11);
              var real5 = rp.realpathSync(p11, self2.realpathCache);
              set[real5] = true;
            } catch (er3) {
              if (er3.syscall === "stat")
                set[self2._makeAbs(p11)] = true;
              else
                throw er3;
            }
          }
        });
      }
      common.finish(this);
    };
    GlobSync.prototype._process = function(pattern, index7, inGlobStar) {
      assert2.ok(this instanceof GlobSync);
      var n7 = 0;
      while (typeof pattern[n7] === "string") {
        n7++;
      }
      var prefix2;
      switch (n7) {
        // if not, then this is rather simple
        case pattern.length:
          this._processSimple(pattern.join("/"), index7);
          return;
        case 0:
          prefix2 = null;
          break;
        default:
          prefix2 = pattern.slice(0, n7).join("/");
          break;
      }
      var remain = pattern.slice(n7);
      var read;
      if (prefix2 === null)
        read = ".";
      else if (isAbsolute(prefix2) || isAbsolute(pattern.map(function(p11) {
        return typeof p11 === "string" ? p11 : "[*]";
      }).join("/"))) {
        if (!prefix2 || !isAbsolute(prefix2))
          prefix2 = "/" + prefix2;
        read = prefix2;
      } else
        read = prefix2;
      var abs = this._makeAbs(read);
      if (childrenIgnored(this, read))
        return;
      var isGlobStar = remain[0] === minimatch2.GLOBSTAR;
      if (isGlobStar)
        this._processGlobStar(prefix2, read, abs, remain, index7, inGlobStar);
      else
        this._processReaddir(prefix2, read, abs, remain, index7, inGlobStar);
    };
    GlobSync.prototype._processReaddir = function(prefix2, read, abs, remain, index7, inGlobStar) {
      var entries = this._readdir(abs, inGlobStar);
      if (!entries)
        return;
      var pn2 = remain[0];
      var negate2 = !!this.minimatch.negate;
      var rawGlob = pn2._glob;
      var dotOk = this.dot || rawGlob.charAt(0) === ".";
      var matchedEntries = [];
      for (var i8 = 0; i8 < entries.length; i8++) {
        var e6 = entries[i8];
        if (e6.charAt(0) !== "." || dotOk) {
          var m12;
          if (negate2 && !prefix2) {
            m12 = !e6.match(pn2);
          } else {
            m12 = e6.match(pn2);
          }
          if (m12)
            matchedEntries.push(e6);
        }
      }
      var len = matchedEntries.length;
      if (len === 0)
        return;
      if (remain.length === 1 && !this.mark && !this.stat) {
        if (!this.matches[index7])
          this.matches[index7] = /* @__PURE__ */ Object.create(null);
        for (var i8 = 0; i8 < len; i8++) {
          var e6 = matchedEntries[i8];
          if (prefix2) {
            if (prefix2.slice(-1) !== "/")
              e6 = prefix2 + "/" + e6;
            else
              e6 = prefix2 + e6;
          }
          if (e6.charAt(0) === "/" && !this.nomount) {
            e6 = path3.join(this.root, e6);
          }
          this._emitMatch(index7, e6);
        }
        return;
      }
      remain.shift();
      for (var i8 = 0; i8 < len; i8++) {
        var e6 = matchedEntries[i8];
        var newPattern;
        if (prefix2)
          newPattern = [prefix2, e6];
        else
          newPattern = [e6];
        this._process(newPattern.concat(remain), index7, inGlobStar);
      }
    };
    GlobSync.prototype._emitMatch = function(index7, e6) {
      if (isIgnored(this, e6))
        return;
      var abs = this._makeAbs(e6);
      if (this.mark)
        e6 = this._mark(e6);
      if (this.absolute) {
        e6 = abs;
      }
      if (this.matches[index7][e6])
        return;
      if (this.nodir) {
        var c6 = this.cache[abs];
        if (c6 === "DIR" || Array.isArray(c6))
          return;
      }
      this.matches[index7][e6] = true;
      if (this.stat)
        this._stat(e6);
    };
    GlobSync.prototype._readdirInGlobStar = function(abs) {
      if (this.follow)
        return this._readdir(abs, false);
      var entries;
      var lstat;
      var stat2;
      try {
        lstat = this.fs.lstatSync(abs);
      } catch (er3) {
        if (er3.code === "ENOENT") {
          return null;
        }
      }
      var isSym = lstat && lstat.isSymbolicLink();
      this.symlinks[abs] = isSym;
      if (!isSym && lstat && !lstat.isDirectory())
        this.cache[abs] = "FILE";
      else
        entries = this._readdir(abs, false);
      return entries;
    };
    GlobSync.prototype._readdir = function(abs, inGlobStar) {
      var entries;
      if (inGlobStar && !ownProp(this.symlinks, abs))
        return this._readdirInGlobStar(abs);
      if (ownProp(this.cache, abs)) {
        var c6 = this.cache[abs];
        if (!c6 || c6 === "FILE")
          return null;
        if (Array.isArray(c6))
          return c6;
      }
      try {
        return this._readdirEntries(abs, this.fs.readdirSync(abs));
      } catch (er3) {
        this._readdirError(abs, er3);
        return null;
      }
    };
    GlobSync.prototype._readdirEntries = function(abs, entries) {
      if (!this.mark && !this.stat) {
        for (var i8 = 0; i8 < entries.length; i8++) {
          var e6 = entries[i8];
          if (abs === "/")
            e6 = abs + e6;
          else
            e6 = abs + "/" + e6;
          this.cache[e6] = true;
        }
      }
      this.cache[abs] = entries;
      return entries;
    };
    GlobSync.prototype._readdirError = function(f9, er3) {
      switch (er3.code) {
        case "ENOTSUP":
        // https://github.com/isaacs/node-glob/issues/205
        case "ENOTDIR":
          var abs = this._makeAbs(f9);
          this.cache[abs] = "FILE";
          if (abs === this.cwdAbs) {
            var error2 = new Error(er3.code + " invalid cwd " + this.cwd);
            error2.path = this.cwd;
            error2.code = er3.code;
            throw error2;
          }
          break;
        case "ENOENT":
        // not terribly unusual
        case "ELOOP":
        case "ENAMETOOLONG":
        case "UNKNOWN":
          this.cache[this._makeAbs(f9)] = false;
          break;
        default:
          this.cache[this._makeAbs(f9)] = false;
          if (this.strict)
            throw er3;
          if (!this.silent)
            console.error("glob error", er3);
          break;
      }
    };
    GlobSync.prototype._processGlobStar = function(prefix2, read, abs, remain, index7, inGlobStar) {
      var entries = this._readdir(abs, inGlobStar);
      if (!entries)
        return;
      var remainWithoutGlobStar = remain.slice(1);
      var gspref = prefix2 ? [prefix2] : [];
      var noGlobStar = gspref.concat(remainWithoutGlobStar);
      this._process(noGlobStar, index7, false);
      var len = entries.length;
      var isSym = this.symlinks[abs];
      if (isSym && inGlobStar)
        return;
      for (var i8 = 0; i8 < len; i8++) {
        var e6 = entries[i8];
        if (e6.charAt(0) === "." && !this.dot)
          continue;
        var instead = gspref.concat(entries[i8], remainWithoutGlobStar);
        this._process(instead, index7, true);
        var below = gspref.concat(entries[i8], remain);
        this._process(below, index7, true);
      }
    };
    GlobSync.prototype._processSimple = function(prefix2, index7) {
      var exists2 = this._stat(prefix2);
      if (!this.matches[index7])
        this.matches[index7] = /* @__PURE__ */ Object.create(null);
      if (!exists2)
        return;
      if (prefix2 && isAbsolute(prefix2) && !this.nomount) {
        var trail = /[\/\\]$/.test(prefix2);
        if (prefix2.charAt(0) === "/") {
          prefix2 = path3.join(this.root, prefix2);
        } else {
          prefix2 = path3.resolve(this.root, prefix2);
          if (trail)
            prefix2 += "/";
        }
      }
      if (process.platform === "win32")
        prefix2 = prefix2.replace(/\\/g, "/");
      this._emitMatch(index7, prefix2);
    };
    GlobSync.prototype._stat = function(f9) {
      var abs = this._makeAbs(f9);
      var needDir = f9.slice(-1) === "/";
      if (f9.length > this.maxLength)
        return false;
      if (!this.stat && ownProp(this.cache, abs)) {
        var c6 = this.cache[abs];
        if (Array.isArray(c6))
          c6 = "DIR";
        if (!needDir || c6 === "DIR")
          return c6;
        if (needDir && c6 === "FILE")
          return false;
      }
      var exists2;
      var stat2 = this.statCache[abs];
      if (!stat2) {
        var lstat;
        try {
          lstat = this.fs.lstatSync(abs);
        } catch (er3) {
          if (er3 && (er3.code === "ENOENT" || er3.code === "ENOTDIR")) {
            this.statCache[abs] = false;
            return false;
          }
        }
        if (lstat && lstat.isSymbolicLink()) {
          try {
            stat2 = this.fs.statSync(abs);
          } catch (er3) {
            stat2 = lstat;
          }
        } else {
          stat2 = lstat;
        }
      }
      this.statCache[abs] = stat2;
      var c6 = true;
      if (stat2)
        c6 = stat2.isDirectory() ? "DIR" : "FILE";
      this.cache[abs] = this.cache[abs] || c6;
      if (needDir && c6 === "FILE")
        return false;
      return c6;
    };
    GlobSync.prototype._mark = function(p11) {
      return common.mark(this, p11);
    };
    GlobSync.prototype._makeAbs = function(f9) {
      return common.makeAbs(this, f9);
    };
  }
});

// ../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js
var require_wrappy = __commonJS({
  "../node_modules/.pnpm/wrappy@1.0.2/node_modules/wrappy/wrappy.js"(exports2, module2) {
    "use strict";
    module2.exports = wrappy;
    function wrappy(fn3, cb) {
      if (fn3 && cb) return wrappy(fn3)(cb);
      if (typeof fn3 !== "function")
        throw new TypeError("need wrapper function");
      Object.keys(fn3).forEach(function(k9) {
        wrapper[k9] = fn3[k9];
      });
      return wrapper;
      function wrapper() {
        var args2 = new Array(arguments.length);
        for (var i8 = 0; i8 < args2.length; i8++) {
          args2[i8] = arguments[i8];
        }
        var ret = fn3.apply(this, args2);
        var cb2 = args2[args2.length - 1];
        if (typeof ret === "function" && ret !== cb2) {
          Object.keys(cb2).forEach(function(k9) {
            ret[k9] = cb2[k9];
          });
        }
        return ret;
      }
    }
  }
});

// ../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js
var require_once = __commonJS({
  "../node_modules/.pnpm/once@1.4.0/node_modules/once/once.js"(exports2, module2) {
    "use strict";
    var wrappy = require_wrappy();
    module2.exports = wrappy(once3);
    module2.exports.strict = wrappy(onceStrict);
    once3.proto = once3(function() {
      Object.defineProperty(Function.prototype, "once", {
        value: function() {
          return once3(this);
        },
        configurable: true
      });
      Object.defineProperty(Function.prototype, "onceStrict", {
        value: function() {
          return onceStrict(this);
        },
        configurable: true
      });
    });
    function once3(fn3) {
      var f9 = function() {
        if (f9.called) return f9.value;
        f9.called = true;
        return f9.value = fn3.apply(this, arguments);
      };
      f9.called = false;
      return f9;
    }
    function onceStrict(fn3) {
      var f9 = function() {
        if (f9.called)
          throw new Error(f9.onceError);
        f9.called = true;
        return f9.value = fn3.apply(this, arguments);
      };
      var name3 = fn3.name || "Function wrapped with `once`";
      f9.onceError = name3 + " shouldn't be called more than once";
      f9.called = false;
      return f9;
    }
  }
});

// ../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js
var require_inflight = __commonJS({
  "../node_modules/.pnpm/inflight@1.0.6/node_modules/inflight/inflight.js"(exports2, module2) {
    "use strict";
    var wrappy = require_wrappy();
    var reqs = /* @__PURE__ */ Object.create(null);
    var once3 = require_once();
    module2.exports = wrappy(inflight);
    function inflight(key, cb) {
      if (reqs[key]) {
        reqs[key].push(cb);
        return null;
      } else {
        reqs[key] = [cb];
        return makeres(key);
      }
    }
    function makeres(key) {
      return once3(function RES() {
        var cbs = reqs[key];
        var len = cbs.length;
        var args2 = slice(arguments);
        try {
          for (var i8 = 0; i8 < len; i8++) {
            cbs[i8].apply(null, args2);
          }
        } finally {
          if (cbs.length > len) {
            cbs.splice(0, len);
            process.nextTick(function() {
              RES.apply(null, args2);
            });
          } else {
            delete reqs[key];
          }
        }
      });
    }
    function slice(args2) {
      var length = args2.length;
      var array3 = [];
      for (var i8 = 0; i8 < length; i8++) array3[i8] = args2[i8];
      return array3;
    }
  }
});

// ../node_modules/.pnpm/glob@8.1.0/node_modules/glob/glob.js
var require_glob = __commonJS({
  "../node_modules/.pnpm/glob@8.1.0/node_modules/glob/glob.js"(exports2, module2) {
    "use strict";
    module2.exports = glob2;
    var rp = require_fs();
    var minimatch2 = require_minimatch();
    var Minimatch2 = minimatch2.Minimatch;
    var inherits = require_inherits();
    var EE = require("events").EventEmitter;
    var path3 = require("path");
    var assert2 = require("assert");
    var isAbsolute = require("path").isAbsolute;
    var globSync = require_sync();
    var common = require_common();
    var setopts = common.setopts;
    var ownProp = common.ownProp;
    var inflight = require_inflight();
    var util2 = require("util");
    var childrenIgnored = common.childrenIgnored;
    var isIgnored = common.isIgnored;
    var once3 = require_once();
    function glob2(pattern, options, cb) {
      if (typeof options === "function") cb = options, options = {};
      if (!options) options = {};
      if (options.sync) {
        if (cb)
          throw new TypeError("callback provided to sync glob");
        return globSync(pattern, options);
      }
      return new Glob(pattern, options, cb);
    }
    glob2.sync = globSync;
    var GlobSync = glob2.GlobSync = globSync.GlobSync;
    glob2.glob = glob2;
    function extend(origin, add) {
      if (add === null || typeof add !== "object") {
        return origin;
      }
      var keys = Object.keys(add);
      var i8 = keys.length;
      while (i8--) {
        origin[keys[i8]] = add[keys[i8]];
      }
      return origin;
    }
    glob2.hasMagic = function(pattern, options_) {
      var options = extend({}, options_);
      options.noprocess = true;
      var g10 = new Glob(pattern, options);
      var set = g10.minimatch.set;
      if (!pattern)
        return false;
      if (set.length > 1)
        return true;
      for (var j7 = 0; j7 < set[0].length; j7++) {
        if (typeof set[0][j7] !== "string")
          return true;
      }
      return false;
    };
    glob2.Glob = Glob;
    inherits(Glob, EE);
    function Glob(pattern, options, cb) {
      if (typeof options === "function") {
        cb = options;
        options = null;
      }
      if (options && options.sync) {
        if (cb)
          throw new TypeError("callback provided to sync glob");
        return new GlobSync(pattern, options);
      }
      if (!(this instanceof Glob))
        return new Glob(pattern, options, cb);
      setopts(this, pattern, options);
      this._didRealPath = false;
      var n7 = this.minimatch.set.length;
      this.matches = new Array(n7);
      if (typeof cb === "function") {
        cb = once3(cb);
        this.on("error", cb);
        this.on("end", function(matches) {
          cb(null, matches);
        });
      }
      var self2 = this;
      this._processing = 0;
      this._emitQueue = [];
      this._processQueue = [];
      this.paused = false;
      if (this.noprocess)
        return this;
      if (n7 === 0)
        return done();
      var sync2 = true;
      for (var i8 = 0; i8 < n7; i8++) {
        this._process(this.minimatch.set[i8], i8, false, done);
      }
      sync2 = false;
      function done() {
        --self2._processing;
        if (self2._processing <= 0) {
          if (sync2) {
            process.nextTick(function() {
              self2._finish();
            });
          } else {
            self2._finish();
          }
        }
      }
    }
    Glob.prototype._finish = function() {
      assert2(this instanceof Glob);
      if (this.aborted)
        return;
      if (this.realpath && !this._didRealpath)
        return this._realpath();
      common.finish(this);
      this.emit("end", this.found);
    };
    Glob.prototype._realpath = function() {
      if (this._didRealpath)
        return;
      this._didRealpath = true;
      var n7 = this.matches.length;
      if (n7 === 0)
        return this._finish();
      var self2 = this;
      for (var i8 = 0; i8 < this.matches.length; i8++)
        this._realpathSet(i8, next);
      function next() {
        if (--n7 === 0)
          self2._finish();
      }
    };
    Glob.prototype._realpathSet = function(index7, cb) {
      var matchset = this.matches[index7];
      if (!matchset)
        return cb();
      var found = Object.keys(matchset);
      var self2 = this;
      var n7 = found.length;
      if (n7 === 0)
        return cb();
      var set = this.matches[index7] = /* @__PURE__ */ Object.create(null);
      found.forEach(function(p11, i8) {
        p11 = self2._makeAbs(p11);
        rp.realpath(p11, self2.realpathCache, function(er3, real5) {
          if (!er3)
            set[real5] = true;
          else if (er3.syscall === "stat")
            set[p11] = true;
          else
            self2.emit("error", er3);
          if (--n7 === 0) {
            self2.matches[index7] = set;
            cb();
          }
        });
      });
    };
    Glob.prototype._mark = function(p11) {
      return common.mark(this, p11);
    };
    Glob.prototype._makeAbs = function(f9) {
      return common.makeAbs(this, f9);
    };
    Glob.prototype.abort = function() {
      this.aborted = true;
      this.emit("abort");
    };
    Glob.prototype.pause = function() {
      if (!this.paused) {
        this.paused = true;
        this.emit("pause");
      }
    };
    Glob.prototype.resume = function() {
      if (this.paused) {
        this.emit("resume");
        this.paused = false;
        if (this._emitQueue.length) {
          var eq2 = this._emitQueue.slice(0);
          this._emitQueue.length = 0;
          for (var i8 = 0; i8 < eq2.length; i8++) {
            var e6 = eq2[i8];
            this._emitMatch(e6[0], e6[1]);
          }
        }
        if (this._processQueue.length) {
          var pq = this._processQueue.slice(0);
          this._processQueue.length = 0;
          for (var i8 = 0; i8 < pq.length; i8++) {
            var p11 = pq[i8];
            this._processing--;
            this._process(p11[0], p11[1], p11[2], p11[3]);
          }
        }
      }
    };
    Glob.prototype._process = function(pattern, index7, inGlobStar, cb) {
      assert2(this instanceof Glob);
      assert2(typeof cb === "function");
      if (this.aborted)
        return;
      this._processing++;
      if (this.paused) {
        this._processQueue.push([pattern, index7, inGlobStar, cb]);
        return;
      }
      var n7 = 0;
      while (typeof pattern[n7] === "string") {
        n7++;
      }
      var prefix2;
      switch (n7) {
        // if not, then this is rather simple
        case pattern.length:
          this._processSimple(pattern.join("/"), index7, cb);
          return;
        case 0:
          prefix2 = null;
          break;
        default:
          prefix2 = pattern.slice(0, n7).join("/");
          break;
      }
      var remain = pattern.slice(n7);
      var read;
      if (prefix2 === null)
        read = ".";
      else if (isAbsolute(prefix2) || isAbsolute(pattern.map(function(p11) {
        return typeof p11 === "string" ? p11 : "[*]";
      }).join("/"))) {
        if (!prefix2 || !isAbsolute(prefix2))
          prefix2 = "/" + prefix2;
        read = prefix2;
      } else
        read = prefix2;
      var abs = this._makeAbs(read);
      if (childrenIgnored(this, read))
        return cb();
      var isGlobStar = remain[0] === minimatch2.GLOBSTAR;
      if (isGlobStar)
        this._processGlobStar(prefix2, read, abs, remain, index7, inGlobStar, cb);
      else
        this._processReaddir(prefix2, read, abs, remain, index7, inGlobStar, cb);
    };
    Glob.prototype._processReaddir = function(prefix2, read, abs, remain, index7, inGlobStar, cb) {
      var self2 = this;
      this._readdir(abs, inGlobStar, function(er3, entries) {
        return self2._processReaddir2(prefix2, read, abs, remain, index7, inGlobStar, entries, cb);
      });
    };
    Glob.prototype._processReaddir2 = function(prefix2, read, abs, remain, index7, inGlobStar, entries, cb) {
      if (!entries)
        return cb();
      var pn2 = remain[0];
      var negate2 = !!this.minimatch.negate;
      var rawGlob = pn2._glob;
      var dotOk = this.dot || rawGlob.charAt(0) === ".";
      var matchedEntries = [];
      for (var i8 = 0; i8 < entries.length; i8++) {
        var e6 = entries[i8];
        if (e6.charAt(0) !== "." || dotOk) {
          var m12;
          if (negate2 && !prefix2) {
            m12 = !e6.match(pn2);
          } else {
            m12 = e6.match(pn2);
          }
          if (m12)
            matchedEntries.push(e6);
        }
      }
      var len = matchedEntries.length;
      if (len === 0)
        return cb();
      if (remain.length === 1 && !this.mark && !this.stat) {
        if (!this.matches[index7])
          this.matches[index7] = /* @__PURE__ */ Object.create(null);
        for (var i8 = 0; i8 < len; i8++) {
          var e6 = matchedEntries[i8];
          if (prefix2) {
            if (prefix2 !== "/")
              e6 = prefix2 + "/" + e6;
            else
              e6 = prefix2 + e6;
          }
          if (e6.charAt(0) === "/" && !this.nomount) {
            e6 = path3.join(this.root, e6);
          }
          this._emitMatch(index7, e6);
        }
        return cb();
      }
      remain.shift();
      for (var i8 = 0; i8 < len; i8++) {
        var e6 = matchedEntries[i8];
        var newPattern;
        if (prefix2) {
          if (prefix2 !== "/")
            e6 = prefix2 + "/" + e6;
          else
            e6 = prefix2 + e6;
        }
        this._process([e6].concat(remain), index7, inGlobStar, cb);
      }
      cb();
    };
    Glob.prototype._emitMatch = function(index7, e6) {
      if (this.aborted)
        return;
      if (isIgnored(this, e6))
        return;
      if (this.paused) {
        this._emitQueue.push([index7, e6]);
        return;
      }
      var abs = isAbsolute(e6) ? e6 : this._makeAbs(e6);
      if (this.mark)
        e6 = this._mark(e6);
      if (this.absolute)
        e6 = abs;
      if (this.matches[index7][e6])
        return;
      if (this.nodir) {
        var c6 = this.cache[abs];
        if (c6 === "DIR" || Array.isArray(c6))
          return;
      }
      this.matches[index7][e6] = true;
      var st2 = this.statCache[abs];
      if (st2)
        this.emit("stat", e6, st2);
      this.emit("match", e6);
    };
    Glob.prototype._readdirInGlobStar = function(abs, cb) {
      if (this.aborted)
        return;
      if (this.follow)
        return this._readdir(abs, false, cb);
      var lstatkey = "lstat\0" + abs;
      var self2 = this;
      var lstatcb = inflight(lstatkey, lstatcb_);
      if (lstatcb)
        self2.fs.lstat(abs, lstatcb);
      function lstatcb_(er3, lstat) {
        if (er3 && er3.code === "ENOENT")
          return cb();
        var isSym = lstat && lstat.isSymbolicLink();
        self2.symlinks[abs] = isSym;
        if (!isSym && lstat && !lstat.isDirectory()) {
          self2.cache[abs] = "FILE";
          cb();
        } else
          self2._readdir(abs, false, cb);
      }
    };
    Glob.prototype._readdir = function(abs, inGlobStar, cb) {
      if (this.aborted)
        return;
      cb = inflight("readdir\0" + abs + "\0" + inGlobStar, cb);
      if (!cb)
        return;
      if (inGlobStar && !ownProp(this.symlinks, abs))
        return this._readdirInGlobStar(abs, cb);
      if (ownProp(this.cache, abs)) {
        var c6 = this.cache[abs];
        if (!c6 || c6 === "FILE")
          return cb();
        if (Array.isArray(c6))
          return cb(null, c6);
      }
      var self2 = this;
      self2.fs.readdir(abs, readdirCb(this, abs, cb));
    };
    function readdirCb(self2, abs, cb) {
      return function(er3, entries) {
        if (er3)
          self2._readdirError(abs, er3, cb);
        else
          self2._readdirEntries(abs, entries, cb);
      };
    }
    Glob.prototype._readdirEntries = function(abs, entries, cb) {
      if (this.aborted)
        return;
      if (!this.mark && !this.stat) {
        for (var i8 = 0; i8 < entries.length; i8++) {
          var e6 = entries[i8];
          if (abs === "/")
            e6 = abs + e6;
          else
            e6 = abs + "/" + e6;
          this.cache[e6] = true;
        }
      }
      this.cache[abs] = entries;
      return cb(null, entries);
    };
    Glob.prototype._readdirError = function(f9, er3, cb) {
      if (this.aborted)
        return;
      switch (er3.code) {
        case "ENOTSUP":
        // https://github.com/isaacs/node-glob/issues/205
        case "ENOTDIR":
          var abs = this._makeAbs(f9);
          this.cache[abs] = "FILE";
          if (abs === this.cwdAbs) {
            var error2 = new Error(er3.code + " invalid cwd " + this.cwd);
            error2.path = this.cwd;
            error2.code = er3.code;
            this.emit("error", error2);
            this.abort();
          }
          break;
        case "ENOENT":
        // not terribly unusual
        case "ELOOP":
        case "ENAMETOOLONG":
        case "UNKNOWN":
          this.cache[this._makeAbs(f9)] = false;
          break;
        default:
          this.cache[this._makeAbs(f9)] = false;
          if (this.strict) {
            this.emit("error", er3);
            this.abort();
          }
          if (!this.silent)
            console.error("glob error", er3);
          break;
      }
      return cb();
    };
    Glob.prototype._processGlobStar = function(prefix2, read, abs, remain, index7, inGlobStar, cb) {
      var self2 = this;
      this._readdir(abs, inGlobStar, function(er3, entries) {
        self2._processGlobStar2(prefix2, read, abs, remain, index7, inGlobStar, entries, cb);
      });
    };
    Glob.prototype._processGlobStar2 = function(prefix2, read, abs, remain, index7, inGlobStar, entries, cb) {
      if (!entries)
        return cb();
      var remainWithoutGlobStar = remain.slice(1);
      var gspref = prefix2 ? [prefix2] : [];
      var noGlobStar = gspref.concat(remainWithoutGlobStar);
      this._process(noGlobStar, index7, false, cb);
      var isSym = this.symlinks[abs];
      var len = entries.length;
      if (isSym && inGlobStar)
        return cb();
      for (var i8 = 0; i8 < len; i8++) {
        var e6 = entries[i8];
        if (e6.charAt(0) === "." && !this.dot)
          continue;
        var instead = gspref.concat(entries[i8], remainWithoutGlobStar);
        this._process(instead, index7, true, cb);
        var below = gspref.concat(entries[i8], remain);
        this._process(below, index7, true, cb);
      }
      cb();
    };
    Glob.prototype._processSimple = function(prefix2, index7, cb) {
      var self2 = this;
      this._stat(prefix2, function(er3, exists2) {
        self2._processSimple2(prefix2, index7, er3, exists2, cb);
      });
    };
    Glob.prototype._processSimple2 = function(prefix2, index7, er3, exists2, cb) {
      if (!this.matches[index7])
        this.matches[index7] = /* @__PURE__ */ Object.create(null);
      if (!exists2)
        return cb();
      if (prefix2 && isAbsolute(prefix2) && !this.nomount) {
        var trail = /[\/\\]$/.test(prefix2);
        if (prefix2.charAt(0) === "/") {
          prefix2 = path3.join(this.root, prefix2);
        } else {
          prefix2 = path3.resolve(this.root, prefix2);
          if (trail)
            prefix2 += "/";
        }
      }
      if (process.platform === "win32")
        prefix2 = prefix2.replace(/\\/g, "/");
      this._emitMatch(index7, prefix2);
      cb();
    };
    Glob.prototype._stat = function(f9, cb) {
      var abs = this._makeAbs(f9);
      var needDir = f9.slice(-1) === "/";
      if (f9.length > this.maxLength)
        return cb();
      if (!this.stat && ownProp(this.cache, abs)) {
        var c6 = this.cache[abs];
        if (Array.isArray(c6))
          c6 = "DIR";
        if (!needDir || c6 === "DIR")
          return cb(null, c6);
        if (needDir && c6 === "FILE")
          return cb();
      }
      var exists2;
      var stat2 = this.statCache[abs];
      if (stat2 !== void 0) {
        if (stat2 === false)
          return cb(null, stat2);
        else {
          var type = stat2.isDirectory() ? "DIR" : "FILE";
          if (needDir && type === "FILE")
            return cb();
          else
            return cb(null, type, stat2);
        }
      }
      var self2 = this;
      var statcb = inflight("stat\0" + abs, lstatcb_);
      if (statcb)
        self2.fs.lstat(abs, statcb);
      function lstatcb_(er3, lstat) {
        if (lstat && lstat.isSymbolicLink()) {
          return self2.fs.stat(abs, function(er4, stat3) {
            if (er4)
              self2._stat2(f9, abs, null, lstat, cb);
            else
              self2._stat2(f9, abs, er4, stat3, cb);
          });
        } else {
          self2._stat2(f9, abs, er3, lstat, cb);
        }
      }
    };
    Glob.prototype._stat2 = function(f9, abs, er3, stat2, cb) {
      if (er3 && (er3.code === "ENOENT" || er3.code === "ENOTDIR")) {
        this.statCache[abs] = false;
        return cb();
      }
      var needDir = f9.slice(-1) === "/";
      this.statCache[abs] = stat2;
      if (abs.slice(-1) === "/" && stat2 && !stat2.isDirectory())
        return cb(null, false, stat2);
      var c6 = true;
      if (stat2)
        c6 = stat2.isDirectory() ? "DIR" : "FILE";
      this.cache[abs] = this.cache[abs] || c6;
      if (needDir && c6 === "FILE")
        return cb();
      return cb(null, c6, stat2);
    };
  }
});

// ../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"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.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
      };
    };
    exports2.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"(exports2, module2) {
    "use strict";
    var ESC = "\x1B";
    var CSI = `${ESC}[`;
    var beep = "\x07";
    var cursor = {
      to(x11, y7) {
        if (!y7) return `${CSI}${x11 + 1}G`;
        return `${CSI}${y7 + 1};${x11 + 1}H`;
      },
      move(x11, y7) {
        let ret = "";
        if (x11 < 0) ret += `${CSI}${-x11}D`;
        else if (x11 > 0) ret += `${CSI}${x11}C`;
        if (y7 < 0) ret += `${CSI}${-y7}A`;
        else if (y7 > 0) ret += `${CSI}${y7}B`;
        return ret;
      },
      up: (count2 = 1) => `${CSI}${count2}A`,
      down: (count2 = 1) => `${CSI}${count2}B`,
      forward: (count2 = 1) => `${CSI}${count2}C`,
      backward: (count2 = 1) => `${CSI}${count2}D`,
      nextLine: (count2 = 1) => `${CSI}E`.repeat(count2),
      prevLine: (count2 = 1) => `${CSI}F`.repeat(count2),
      left: `${CSI}G`,
      hide: `${CSI}?25l`,
      show: `${CSI}?25h`,
      save: `${ESC}7`,
      restore: `${ESC}8`
    };
    var scroll = {
      up: (count2 = 1) => `${CSI}S`.repeat(count2),
      down: (count2 = 1) => `${CSI}T`.repeat(count2)
    };
    var erase = {
      screen: `${CSI}2J`,
      up: (count2 = 1) => `${CSI}1J`.repeat(count2),
      down: (count2 = 1) => `${CSI}J`.repeat(count2),
      line: `${CSI}2K`,
      lineEnd: `${CSI}K`,
      lineStart: `${CSI}1K`,
      lines(count2) {
        let clear = "";
        for (let i8 = 0; i8 < count2; i8++)
          clear += this.line + (i8 < count2 - 1 ? cursor.up() : "");
        if (count2)
          clear += cursor.left;
        return clear;
      }
    };
    module2.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"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.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 line2 of lines) {
        rows += 1 + Math.floor(Math.max(stringWidth(line2) - 1, 0) / perLine);
      }
      return sisteransi_1.erase.lines(rows);
    };
    exports2.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"(exports2, module2) {
    "use strict";
    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(func2, wait, options) {
      var lastArgs, lastThis, maxWait, result, timerId, lastCallTime, lastInvokeTime = 0, leading = false, maxing = false, trailing = true;
      if (typeof func2 != "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(time4) {
        var args2 = lastArgs, thisArg = lastThis;
        lastArgs = lastThis = void 0;
        lastInvokeTime = time4;
        result = func2.apply(thisArg, args2);
        return result;
      }
      function leadingEdge(time4) {
        lastInvokeTime = time4;
        timerId = setTimeout(timerExpired, wait);
        return leading ? invokeFunc(time4) : result;
      }
      function remainingWait(time4) {
        var timeSinceLastCall = time4 - lastCallTime, timeSinceLastInvoke = time4 - lastInvokeTime, result2 = wait - timeSinceLastCall;
        return maxing ? nativeMin(result2, maxWait - timeSinceLastInvoke) : result2;
      }
      function shouldInvoke(time4) {
        var timeSinceLastCall = time4 - lastCallTime, timeSinceLastInvoke = time4 - lastInvokeTime;
        return lastCallTime === void 0 || timeSinceLastCall >= wait || timeSinceLastCall < 0 || maxing && timeSinceLastInvoke >= maxWait;
      }
      function timerExpired() {
        var time4 = now();
        if (shouldInvoke(time4)) {
          return trailingEdge(time4);
        }
        timerId = setTimeout(timerExpired, remainingWait(time4));
      }
      function trailingEdge(time4) {
        timerId = void 0;
        if (trailing && lastArgs) {
          return invokeFunc(time4);
        }
        lastArgs = lastThis = void 0;
        return result;
      }
      function cancel() {
        if (timerId !== void 0) {
          clearTimeout(timerId);
        }
        lastInvokeTime = 0;
        lastArgs = lastCallTime = lastThis = timerId = void 0;
      }
      function flush2() {
        return timerId === void 0 ? result : trailingEdge(now());
      }
      function debounced() {
        var time4 = now(), isInvoking = shouldInvoke(time4);
        lastArgs = arguments;
        lastThis = this;
        lastCallTime = time4;
        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 = flush2;
      return debounced;
    }
    function throttle(func2, wait, options) {
      var leading = true, trailing = true;
      if (typeof func2 != "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(func2, 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 isBinary2 = reIsBinary.test(value);
      return isBinary2 || reIsOctal.test(value) ? freeParseInt(value.slice(2), isBinary2 ? 2 : 8) : reIsBadHex.test(value) ? NAN : +value;
    }
    module2.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"(exports2) {
    "use strict";
    var __awaiter = exports2 && exports2.__awaiter || function(thisArg, _arguments, P5, generator) {
      function adopt(value) {
        return value instanceof P5 ? value : new P5(function(resolve2) {
          resolve2(value);
        });
      }
      return new (P5 || (P5 = Promise))(function(resolve2, reject) {
        function fulfilled(value) {
          try {
            step(generator.next(value));
          } catch (e6) {
            reject(e6);
          }
        }
        function rejected(value) {
          try {
            step(generator["throw"](value));
          } catch (e6) {
            reject(e6);
          }
        }
        function step(result) {
          result.done ? resolve2(result.value) : adopt(result.value).then(fulfilled, rejected);
        }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
      });
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.onTerminate = exports2.renderWithTask = exports2.render = exports2.TaskTerminal = exports2.TaskView = exports2.Terminal = exports2.deferred = exports2.SelectState = exports2.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 Prompt3 = 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((it2) => it2(terminal));
      }
      detach(terminal) {
        this.detachCallbacks.forEach((it2) => it2(terminal));
        this.terminal = void 0;
      }
      input(str, key) {
        this.inputCallbacks.forEach((it2) => it2(str, key));
      }
    };
    exports2.Prompt = Prompt3;
    var SelectState3 = 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;
      }
    };
    exports2.SelectState = SelectState3;
    var deferred = () => {
      let resolve2;
      let reject;
      const promise = new Promise((res, rej) => {
        resolve2 = res;
        reject = rej;
      });
      return {
        resolve: resolve2,
        reject,
        promise
      };
    };
    exports2.deferred = deferred;
    var Terminal = class {
      constructor(view5, stdin, stdout, closable) {
        this.view = view5;
        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;
          }
          view5.input(str, key);
        };
        this.stdin.on("keypress", keypress);
        this.view.attach(this);
        const { resolve: resolve2, promise } = (0, exports2.deferred)();
        this.resolve = resolve2;
        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(state2) {
        if (state2 === "hide") {
          this.stdout.write(sisteransi_1.cursor.hide);
        } else {
          this.stdout.write(sisteransi_1.cursor.show);
        }
      }
      requestLayout() {
        const string2 = this.view.render(this.status);
        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
        this.text = string2;
        this.renderFunc(`${clearPrefix}${string2}`);
      }
    };
    exports2.Terminal = Terminal;
    var TaskView2 = class {
      constructor() {
        this.attachCallbacks = [];
        this.detachCallbacks = [];
      }
      requestLayout() {
        this.terminal.requestLayout();
      }
      attach(terminal) {
        this.terminal = terminal;
        this.attachCallbacks.forEach((it2) => it2(terminal));
      }
      detach(terminal) {
        this.detachCallbacks.forEach((it2) => it2(terminal));
        this.terminal = void 0;
      }
      on(type, callback) {
        if (type === "attach") {
          this.attachCallbacks.push(callback);
        } else if (type === "detach") {
          this.detachCallbacks.push(callback);
        }
      }
    };
    exports2.TaskView = TaskView2;
    var TaskTerminal = class {
      constructor(view5, stdout) {
        this.view = view5;
        this.stdout = stdout;
        this.text = "";
        this.view.attach(this);
      }
      requestLayout() {
        const string2 = this.view.render("pending");
        const clearPrefix = this.text ? (0, utils_1.clear)(this.text, this.stdout.columns) : "";
        this.text = string2;
        this.stdout.write(`${clearPrefix}${string2}`);
      }
      clear() {
        const string2 = 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}${string2}`);
      }
    };
    exports2.TaskTerminal = TaskTerminal;
    function render7(view5) {
      const { stdin, stdout, closable } = (0, readline_1.prepareReadLine)();
      if (view5 instanceof Prompt3) {
        const terminal = new Terminal(view5, stdin, stdout, closable);
        terminal.requestLayout();
        return terminal.result();
      }
      stdout.write(`${view5}
`);
      closable.close();
      return;
    }
    exports2.render = render7;
    function renderWithTask5(view5, task) {
      return __awaiter(this, void 0, void 0, function* () {
        const terminal = new TaskTerminal(view5, process.stdout);
        terminal.requestLayout();
        const result = yield task;
        terminal.clear();
        return result;
      });
    }
    exports2.renderWithTask = renderWithTask5;
    var terminateHandler;
    function onTerminate(callback) {
      terminateHandler = callback;
    }
    exports2.onTerminate = onTerminate;
  }
});

// src/global.ts
function assertUnreachable(x11) {
  throw new Error("Didn't expect to get here");
}
var originUUID, snapshotVersion, mapValues, mapKeys, mapEntries, customMapEntries;
var init_global = __esm({
  "src/global.ts"() {
    "use strict";
    originUUID = "00000000-0000-0000-0000-000000000000";
    snapshotVersion = "7";
    mapValues = (obj, map2) => {
      const result = Object.keys(obj).reduce(function(result2, key) {
        result2[key] = map2(obj[key]);
        return result2;
      }, {});
      return result;
    };
    mapKeys = (obj, map2) => {
      const result = Object.fromEntries(
        Object.entries(obj).map(([key, val2]) => {
          const newKey = map2(key, val2);
          return [newKey, val2];
        })
      );
      return result;
    };
    mapEntries = (obj, map2) => {
      const result = Object.fromEntries(
        Object.entries(obj).map(([key, val2]) => {
          const [newKey, newVal] = map2(key, val2);
          return [newKey, newVal];
        })
      );
      return result;
    };
    customMapEntries = (obj, map2) => {
      const result = Object.fromEntries(
        Object.entries(obj).map(([key, val2]) => {
          const [newKey, newVal] = map2(key, val2);
          return [newKey, newVal];
        })
      );
      return result;
    };
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/util.js
var util, objectUtil, ZodParsedType, getParsedType;
var init_util = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/util.js"() {
    "use strict";
    (function(util2) {
      util2.assertEqual = (_7) => {
      };
      function assertIs(_arg) {
      }
      util2.assertIs = assertIs;
      function assertNever(_x) {
        throw new Error();
      }
      util2.assertNever = assertNever;
      util2.arrayToEnum = (items) => {
        const obj = {};
        for (const item of items) {
          obj[item] = item;
        }
        return obj;
      };
      util2.getValidEnumValues = (obj) => {
        const validKeys = util2.objectKeys(obj).filter((k9) => typeof obj[obj[k9]] !== "number");
        const filtered = {};
        for (const k9 of validKeys) {
          filtered[k9] = obj[k9];
        }
        return util2.objectValues(filtered);
      };
      util2.objectValues = (obj) => {
        return util2.objectKeys(obj).map(function(e6) {
          return obj[e6];
        });
      };
      util2.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object2) => {
        const keys = [];
        for (const key in object2) {
          if (Object.prototype.hasOwnProperty.call(object2, key)) {
            keys.push(key);
          }
        }
        return keys;
      };
      util2.find = (arr, checker) => {
        for (const item of arr) {
          if (checker(item))
            return item;
        }
        return void 0;
      };
      util2.isInteger = typeof Number.isInteger === "function" ? (val2) => Number.isInteger(val2) : (val2) => typeof val2 === "number" && Number.isFinite(val2) && Math.floor(val2) === val2;
      function joinValues(array3, separator = " | ") {
        return array3.map((val2) => typeof val2 === "string" ? `'${val2}'` : val2).join(separator);
      }
      util2.joinValues = joinValues;
      util2.jsonStringifyReplacer = (_7, value) => {
        if (typeof value === "bigint") {
          return value.toString();
        }
        return value;
      };
    })(util || (util = {}));
    (function(objectUtil2) {
      objectUtil2.mergeShapes = (first, second) => {
        return {
          ...first,
          ...second
          // second overwrites first
        };
      };
    })(objectUtil || (objectUtil = {}));
    ZodParsedType = util.arrayToEnum([
      "string",
      "nan",
      "number",
      "integer",
      "float",
      "boolean",
      "date",
      "bigint",
      "symbol",
      "function",
      "undefined",
      "null",
      "array",
      "object",
      "unknown",
      "promise",
      "void",
      "never",
      "map",
      "set"
    ]);
    getParsedType = (data) => {
      const t6 = typeof data;
      switch (t6) {
        case "undefined":
          return ZodParsedType.undefined;
        case "string":
          return ZodParsedType.string;
        case "number":
          return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
        case "boolean":
          return ZodParsedType.boolean;
        case "function":
          return ZodParsedType.function;
        case "bigint":
          return ZodParsedType.bigint;
        case "symbol":
          return ZodParsedType.symbol;
        case "object":
          if (Array.isArray(data)) {
            return ZodParsedType.array;
          }
          if (data === null) {
            return ZodParsedType.null;
          }
          if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
            return ZodParsedType.promise;
          }
          if (typeof Map !== "undefined" && data instanceof Map) {
            return ZodParsedType.map;
          }
          if (typeof Set !== "undefined" && data instanceof Set) {
            return ZodParsedType.set;
          }
          if (typeof Date !== "undefined" && data instanceof Date) {
            return ZodParsedType.date;
          }
          return ZodParsedType.object;
        default:
          return ZodParsedType.unknown;
      }
    };
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/ZodError.js
var ZodIssueCode, quotelessJson, ZodError;
var init_ZodError = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/ZodError.js"() {
    "use strict";
    init_util();
    ZodIssueCode = util.arrayToEnum([
      "invalid_type",
      "invalid_literal",
      "custom",
      "invalid_union",
      "invalid_union_discriminator",
      "invalid_enum_value",
      "unrecognized_keys",
      "invalid_arguments",
      "invalid_return_type",
      "invalid_date",
      "invalid_string",
      "too_small",
      "too_big",
      "invalid_intersection_types",
      "not_multiple_of",
      "not_finite"
    ]);
    quotelessJson = (obj) => {
      const json4 = JSON.stringify(obj, null, 2);
      return json4.replace(/"([^"]+)":/g, "$1:");
    };
    ZodError = class _ZodError extends Error {
      get errors() {
        return this.issues;
      }
      constructor(issues) {
        super();
        this.issues = [];
        this.addIssue = (sub) => {
          this.issues = [...this.issues, sub];
        };
        this.addIssues = (subs = []) => {
          this.issues = [...this.issues, ...subs];
        };
        const actualProto = new.target.prototype;
        if (Object.setPrototypeOf) {
          Object.setPrototypeOf(this, actualProto);
        } else {
          this.__proto__ = actualProto;
        }
        this.name = "ZodError";
        this.issues = issues;
      }
      format(_mapper) {
        const mapper = _mapper || function(issue) {
          return issue.message;
        };
        const fieldErrors = { _errors: [] };
        const processError = (error2) => {
          for (const issue of error2.issues) {
            if (issue.code === "invalid_union") {
              issue.unionErrors.map(processError);
            } else if (issue.code === "invalid_return_type") {
              processError(issue.returnTypeError);
            } else if (issue.code === "invalid_arguments") {
              processError(issue.argumentsError);
            } else if (issue.path.length === 0) {
              fieldErrors._errors.push(mapper(issue));
            } else {
              let curr = fieldErrors;
              let i8 = 0;
              while (i8 < issue.path.length) {
                const el = issue.path[i8];
                const terminal = i8 === issue.path.length - 1;
                if (!terminal) {
                  curr[el] = curr[el] || { _errors: [] };
                } else {
                  curr[el] = curr[el] || { _errors: [] };
                  curr[el]._errors.push(mapper(issue));
                }
                curr = curr[el];
                i8++;
              }
            }
          }
        };
        processError(this);
        return fieldErrors;
      }
      static assert(value) {
        if (!(value instanceof _ZodError)) {
          throw new Error(`Not a ZodError: ${value}`);
        }
      }
      toString() {
        return this.message;
      }
      get message() {
        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
      }
      get isEmpty() {
        return this.issues.length === 0;
      }
      flatten(mapper = (issue) => issue.message) {
        const fieldErrors = {};
        const formErrors = [];
        for (const sub of this.issues) {
          if (sub.path.length > 0) {
            fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
            fieldErrors[sub.path[0]].push(mapper(sub));
          } else {
            formErrors.push(mapper(sub));
          }
        }
        return { formErrors, fieldErrors };
      }
      get formErrors() {
        return this.flatten();
      }
    };
    ZodError.create = (issues) => {
      const error2 = new ZodError(issues);
      return error2;
    };
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/locales/en.js
var errorMap, en_default;
var init_en = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/locales/en.js"() {
    "use strict";
    init_ZodError();
    init_util();
    errorMap = (issue, _ctx) => {
      let message;
      switch (issue.code) {
        case ZodIssueCode.invalid_type:
          if (issue.received === ZodParsedType.undefined) {
            message = "Required";
          } else {
            message = `Expected ${issue.expected}, received ${issue.received}`;
          }
          break;
        case ZodIssueCode.invalid_literal:
          message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
          break;
        case ZodIssueCode.unrecognized_keys:
          message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
          break;
        case ZodIssueCode.invalid_union:
          message = `Invalid input`;
          break;
        case ZodIssueCode.invalid_union_discriminator:
          message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
          break;
        case ZodIssueCode.invalid_enum_value:
          message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
          break;
        case ZodIssueCode.invalid_arguments:
          message = `Invalid function arguments`;
          break;
        case ZodIssueCode.invalid_return_type:
          message = `Invalid function return type`;
          break;
        case ZodIssueCode.invalid_date:
          message = `Invalid date`;
          break;
        case ZodIssueCode.invalid_string:
          if (typeof issue.validation === "object") {
            if ("includes" in issue.validation) {
              message = `Invalid input: must include "${issue.validation.includes}"`;
              if (typeof issue.validation.position === "number") {
                message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
              }
            } else if ("startsWith" in issue.validation) {
              message = `Invalid input: must start with "${issue.validation.startsWith}"`;
            } else if ("endsWith" in issue.validation) {
              message = `Invalid input: must end with "${issue.validation.endsWith}"`;
            } else {
              util.assertNever(issue.validation);
            }
          } else if (issue.validation !== "regex") {
            message = `Invalid ${issue.validation}`;
          } else {
            message = "Invalid";
          }
          break;
        case ZodIssueCode.too_small:
          if (issue.type === "array")
            message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
          else if (issue.type === "string")
            message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
          else if (issue.type === "number")
            message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
          else if (issue.type === "date")
            message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
          else
            message = "Invalid input";
          break;
        case ZodIssueCode.too_big:
          if (issue.type === "array")
            message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
          else if (issue.type === "string")
            message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
          else if (issue.type === "number")
            message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
          else if (issue.type === "bigint")
            message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
          else if (issue.type === "date")
            message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
          else
            message = "Invalid input";
          break;
        case ZodIssueCode.custom:
          message = `Invalid input`;
          break;
        case ZodIssueCode.invalid_intersection_types:
          message = `Intersection results could not be merged`;
          break;
        case ZodIssueCode.not_multiple_of:
          message = `Number must be a multiple of ${issue.multipleOf}`;
          break;
        case ZodIssueCode.not_finite:
          message = "Number must be finite";
          break;
        default:
          message = _ctx.defaultError;
          util.assertNever(issue);
      }
      return { message };
    };
    en_default = errorMap;
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/errors.js
function setErrorMap(map2) {
  overrideErrorMap = map2;
}
function getErrorMap() {
  return overrideErrorMap;
}
var overrideErrorMap;
var init_errors2 = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/errors.js"() {
    "use strict";
    init_en();
    overrideErrorMap = en_default;
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/parseUtil.js
function addIssueToContext(ctx, issueData) {
  const overrideMap = getErrorMap();
  const issue = makeIssue({
    issueData,
    data: ctx.data,
    path: ctx.path,
    errorMaps: [
      ctx.common.contextualErrorMap,
      // contextual error map is first priority
      ctx.schemaErrorMap,
      // then schema-bound map if available
      overrideMap,
      // then global override map
      overrideMap === en_default ? void 0 : en_default
      // then global default map
    ].filter((x11) => !!x11)
  });
  ctx.common.issues.push(issue);
}
var makeIssue, EMPTY_PATH, ParseStatus, INVALID, DIRTY, OK, isAborted, isDirty, isValid, isAsync;
var init_parseUtil = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/parseUtil.js"() {
    "use strict";
    init_errors2();
    init_en();
    makeIssue = (params) => {
      const { data, path: path3, errorMaps, issueData } = params;
      const fullPath = [...path3, ...issueData.path || []];
      const fullIssue = {
        ...issueData,
        path: fullPath
      };
      if (issueData.message !== void 0) {
        return {
          ...issueData,
          path: fullPath,
          message: issueData.message
        };
      }
      let errorMessage = "";
      const maps = errorMaps.filter((m12) => !!m12).slice().reverse();
      for (const map2 of maps) {
        errorMessage = map2(fullIssue, { data, defaultError: errorMessage }).message;
      }
      return {
        ...issueData,
        path: fullPath,
        message: errorMessage
      };
    };
    EMPTY_PATH = [];
    ParseStatus = class _ParseStatus {
      constructor() {
        this.value = "valid";
      }
      dirty() {
        if (this.value === "valid")
          this.value = "dirty";
      }
      abort() {
        if (this.value !== "aborted")
          this.value = "aborted";
      }
      static mergeArray(status, results) {
        const arrayValue = [];
        for (const s10 of results) {
          if (s10.status === "aborted")
            return INVALID;
          if (s10.status === "dirty")
            status.dirty();
          arrayValue.push(s10.value);
        }
        return { status: status.value, value: arrayValue };
      }
      static async mergeObjectAsync(status, pairs) {
        const syncPairs = [];
        for (const pair of pairs) {
          const key = await pair.key;
          const value = await pair.value;
          syncPairs.push({
            key,
            value
          });
        }
        return _ParseStatus.mergeObjectSync(status, syncPairs);
      }
      static mergeObjectSync(status, pairs) {
        const finalObject = {};
        for (const pair of pairs) {
          const { key, value } = pair;
          if (key.status === "aborted")
            return INVALID;
          if (value.status === "aborted")
            return INVALID;
          if (key.status === "dirty")
            status.dirty();
          if (value.status === "dirty")
            status.dirty();
          if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
            finalObject[key.value] = value.value;
          }
        }
        return { status: status.value, value: finalObject };
      }
    };
    INVALID = Object.freeze({
      status: "aborted"
    });
    DIRTY = (value) => ({ status: "dirty", value });
    OK = (value) => ({ status: "valid", value });
    isAborted = (x11) => x11.status === "aborted";
    isDirty = (x11) => x11.status === "dirty";
    isValid = (x11) => x11.status === "valid";
    isAsync = (x11) => typeof Promise !== "undefined" && x11 instanceof Promise;
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/typeAliases.js
var init_typeAliases = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/typeAliases.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/errorUtil.js
var errorUtil;
var init_errorUtil = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/helpers/errorUtil.js"() {
    "use strict";
    (function(errorUtil2) {
      errorUtil2.errToObj = (message) => typeof message === "string" ? { message } : message || {};
      errorUtil2.toString = (message) => typeof message === "string" ? message : message?.message;
    })(errorUtil || (errorUtil = {}));
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/types.js
function processCreateParams(params) {
  if (!params)
    return {};
  const { errorMap: errorMap2, invalid_type_error, required_error, description } = params;
  if (errorMap2 && (invalid_type_error || required_error)) {
    throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
  }
  if (errorMap2)
    return { errorMap: errorMap2, description };
  const customMap = (iss, ctx) => {
    const { message } = params;
    if (iss.code === "invalid_enum_value") {
      return { message: message ?? ctx.defaultError };
    }
    if (typeof ctx.data === "undefined") {
      return { message: message ?? required_error ?? ctx.defaultError };
    }
    if (iss.code !== "invalid_type")
      return { message: ctx.defaultError };
    return { message: message ?? invalid_type_error ?? ctx.defaultError };
  };
  return { errorMap: customMap, description };
}
function timeRegexSource(args2) {
  let secondsRegexSource = `[0-5]\\d`;
  if (args2.precision) {
    secondsRegexSource = `${secondsRegexSource}\\.\\d{${args2.precision}}`;
  } else if (args2.precision == null) {
    secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
  }
  const secondsQuantifier = args2.precision ? "+" : "?";
  return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
}
function timeRegex(args2) {
  return new RegExp(`^${timeRegexSource(args2)}$`);
}
function datetimeRegex(args2) {
  let regex = `${dateRegexSource}T${timeRegexSource(args2)}`;
  const opts = [];
  opts.push(args2.local ? `Z?` : `Z`);
  if (args2.offset)
    opts.push(`([+-]\\d{2}:?\\d{2})`);
  regex = `${regex}(${opts.join("|")})`;
  return new RegExp(`^${regex}$`);
}
function isValidIP(ip, version3) {
  if ((version3 === "v4" || !version3) && ipv4Regex.test(ip)) {
    return true;
  }
  if ((version3 === "v6" || !version3) && ipv6Regex.test(ip)) {
    return true;
  }
  return false;
}
function isValidJWT(jwt, alg) {
  if (!jwtRegex.test(jwt))
    return false;
  try {
    const [header] = jwt.split(".");
    const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
    const decoded = JSON.parse(atob(base64));
    if (typeof decoded !== "object" || decoded === null)
      return false;
    if ("typ" in decoded && decoded?.typ !== "JWT")
      return false;
    if (!decoded.alg)
      return false;
    if (alg && decoded.alg !== alg)
      return false;
    return true;
  } catch {
    return false;
  }
}
function isValidCidr(ip, version3) {
  if ((version3 === "v4" || !version3) && ipv4CidrRegex.test(ip)) {
    return true;
  }
  if ((version3 === "v6" || !version3) && ipv6CidrRegex.test(ip)) {
    return true;
  }
  return false;
}
function floatSafeRemainder(val2, step) {
  const valDecCount = (val2.toString().split(".")[1] || "").length;
  const stepDecCount = (step.toString().split(".")[1] || "").length;
  const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
  const valInt = Number.parseInt(val2.toFixed(decCount).replace(".", ""));
  const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
  return valInt % stepInt / 10 ** decCount;
}
function deepPartialify(schema6) {
  if (schema6 instanceof ZodObject) {
    const newShape = {};
    for (const key in schema6.shape) {
      const fieldSchema = schema6.shape[key];
      newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
    }
    return new ZodObject({
      ...schema6._def,
      shape: () => newShape
    });
  } else if (schema6 instanceof ZodArray) {
    return new ZodArray({
      ...schema6._def,
      type: deepPartialify(schema6.element)
    });
  } else if (schema6 instanceof ZodOptional) {
    return ZodOptional.create(deepPartialify(schema6.unwrap()));
  } else if (schema6 instanceof ZodNullable) {
    return ZodNullable.create(deepPartialify(schema6.unwrap()));
  } else if (schema6 instanceof ZodTuple) {
    return ZodTuple.create(schema6.items.map((item) => deepPartialify(item)));
  } else {
    return schema6;
  }
}
function mergeValues(a9, b9) {
  const aType = getParsedType(a9);
  const bType = getParsedType(b9);
  if (a9 === b9) {
    return { valid: true, data: a9 };
  } else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
    const bKeys = util.objectKeys(b9);
    const sharedKeys = util.objectKeys(a9).filter((key) => bKeys.indexOf(key) !== -1);
    const newObj = { ...a9, ...b9 };
    for (const key of sharedKeys) {
      const sharedValue = mergeValues(a9[key], b9[key]);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newObj[key] = sharedValue.data;
    }
    return { valid: true, data: newObj };
  } else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
    if (a9.length !== b9.length) {
      return { valid: false };
    }
    const newArray = [];
    for (let index7 = 0; index7 < a9.length; index7++) {
      const itemA = a9[index7];
      const itemB = b9[index7];
      const sharedValue = mergeValues(itemA, itemB);
      if (!sharedValue.valid) {
        return { valid: false };
      }
      newArray.push(sharedValue.data);
    }
    return { valid: true, data: newArray };
  } else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a9 === +b9) {
    return { valid: true, data: a9 };
  } else {
    return { valid: false };
  }
}
function createZodEnum(values2, params) {
  return new ZodEnum({
    values: values2,
    typeName: ZodFirstPartyTypeKind.ZodEnum,
    ...processCreateParams(params)
  });
}
function cleanParams(params, data) {
  const p11 = typeof params === "function" ? params(data) : typeof params === "string" ? { message: params } : params;
  const p22 = typeof p11 === "string" ? { message: p11 } : p11;
  return p22;
}
function custom(check2, _params2 = {}, fatal) {
  if (check2)
    return ZodAny.create().superRefine((data, ctx) => {
      const r6 = check2(data);
      if (r6 instanceof Promise) {
        return r6.then((r7) => {
          if (!r7) {
            const params = cleanParams(_params2, data);
            const _fatal = params.fatal ?? fatal ?? true;
            ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
          }
        });
      }
      if (!r6) {
        const params = cleanParams(_params2, data);
        const _fatal = params.fatal ?? fatal ?? true;
        ctx.addIssue({ code: "custom", ...params, fatal: _fatal });
      }
      return;
    });
  return ZodAny.create();
}
var ParseInputLazyPath, handleResult, ZodType, cuidRegex, cuid2Regex, ulidRegex, uuidRegex, nanoidRegex, jwtRegex, durationRegex, emailRegex, _emojiRegex, emojiRegex, ipv4Regex, ipv4CidrRegex, ipv6Regex, ipv6CidrRegex, base64Regex, base64urlRegex, dateRegexSource, dateRegex, ZodString, ZodNumber, ZodBigInt, ZodBoolean, ZodDate, ZodSymbol, ZodUndefined, ZodNull, ZodAny, ZodUnknown, ZodNever, ZodVoid, ZodArray, ZodObject, ZodUnion, getDiscriminator, ZodDiscriminatedUnion, ZodIntersection, ZodTuple, ZodRecord, ZodMap, ZodSet, ZodFunction, ZodLazy, ZodLiteral, ZodEnum, ZodNativeEnum, ZodPromise, ZodEffects, ZodOptional, ZodNullable, ZodDefault, ZodCatch, ZodNaN, BRAND, ZodBranded, ZodPipeline, ZodReadonly, late, ZodFirstPartyTypeKind, instanceOfType, stringType, numberType, nanType, bigIntType, booleanType, dateType, symbolType, undefinedType, nullType, anyType, unknownType, neverType, voidType, arrayType, objectType, strictObjectType, unionType, discriminatedUnionType, intersectionType, tupleType, recordType, mapType, setType, functionType, lazyType, literalType, enumType, nativeEnumType, promiseType, effectsType, optionalType, nullableType, preprocessType, pipelineType, ostring, onumber, oboolean, coerce, NEVER;
var init_types = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/types.js"() {
    "use strict";
    init_ZodError();
    init_errors2();
    init_errorUtil();
    init_parseUtil();
    init_util();
    ParseInputLazyPath = class {
      constructor(parent, value, path3, key) {
        this._cachedPath = [];
        this.parent = parent;
        this.data = value;
        this._path = path3;
        this._key = key;
      }
      get path() {
        if (!this._cachedPath.length) {
          if (Array.isArray(this._key)) {
            this._cachedPath.push(...this._path, ...this._key);
          } else {
            this._cachedPath.push(...this._path, this._key);
          }
        }
        return this._cachedPath;
      }
    };
    handleResult = (ctx, result) => {
      if (isValid(result)) {
        return { success: true, data: result.value };
      } else {
        if (!ctx.common.issues.length) {
          throw new Error("Validation failed but no issues detected.");
        }
        return {
          success: false,
          get error() {
            if (this._error)
              return this._error;
            const error2 = new ZodError(ctx.common.issues);
            this._error = error2;
            return this._error;
          }
        };
      }
    };
    ZodType = class {
      get description() {
        return this._def.description;
      }
      _getType(input) {
        return getParsedType(input.data);
      }
      _getOrReturnCtx(input, ctx) {
        return ctx || {
          common: input.parent.common,
          data: input.data,
          parsedType: getParsedType(input.data),
          schemaErrorMap: this._def.errorMap,
          path: input.path,
          parent: input.parent
        };
      }
      _processInputParams(input) {
        return {
          status: new ParseStatus(),
          ctx: {
            common: input.parent.common,
            data: input.data,
            parsedType: getParsedType(input.data),
            schemaErrorMap: this._def.errorMap,
            path: input.path,
            parent: input.parent
          }
        };
      }
      _parseSync(input) {
        const result = this._parse(input);
        if (isAsync(result)) {
          throw new Error("Synchronous parse encountered promise.");
        }
        return result;
      }
      _parseAsync(input) {
        const result = this._parse(input);
        return Promise.resolve(result);
      }
      parse(data, params) {
        const result = this.safeParse(data, params);
        if (result.success)
          return result.data;
        throw result.error;
      }
      safeParse(data, params) {
        const ctx = {
          common: {
            issues: [],
            async: params?.async ?? false,
            contextualErrorMap: params?.errorMap
          },
          path: params?.path || [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: getParsedType(data)
        };
        const result = this._parseSync({ data, path: ctx.path, parent: ctx });
        return handleResult(ctx, result);
      }
      "~validate"(data) {
        const ctx = {
          common: {
            issues: [],
            async: !!this["~standard"].async
          },
          path: [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: getParsedType(data)
        };
        if (!this["~standard"].async) {
          try {
            const result = this._parseSync({ data, path: [], parent: ctx });
            return isValid(result) ? {
              value: result.value
            } : {
              issues: ctx.common.issues
            };
          } catch (err3) {
            if (err3?.message?.toLowerCase()?.includes("encountered")) {
              this["~standard"].async = true;
            }
            ctx.common = {
              issues: [],
              async: true
            };
          }
        }
        return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
          value: result.value
        } : {
          issues: ctx.common.issues
        });
      }
      async parseAsync(data, params) {
        const result = await this.safeParseAsync(data, params);
        if (result.success)
          return result.data;
        throw result.error;
      }
      async safeParseAsync(data, params) {
        const ctx = {
          common: {
            issues: [],
            contextualErrorMap: params?.errorMap,
            async: true
          },
          path: params?.path || [],
          schemaErrorMap: this._def.errorMap,
          parent: null,
          data,
          parsedType: getParsedType(data)
        };
        const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
        const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
        return handleResult(ctx, result);
      }
      refine(check2, message) {
        const getIssueProperties = (val2) => {
          if (typeof message === "string" || typeof message === "undefined") {
            return { message };
          } else if (typeof message === "function") {
            return message(val2);
          } else {
            return message;
          }
        };
        return this._refinement((val2, ctx) => {
          const result = check2(val2);
          const setError = () => ctx.addIssue({
            code: ZodIssueCode.custom,
            ...getIssueProperties(val2)
          });
          if (typeof Promise !== "undefined" && result instanceof Promise) {
            return result.then((data) => {
              if (!data) {
                setError();
                return false;
              } else {
                return true;
              }
            });
          }
          if (!result) {
            setError();
            return false;
          } else {
            return true;
          }
        });
      }
      refinement(check2, refinementData) {
        return this._refinement((val2, ctx) => {
          if (!check2(val2)) {
            ctx.addIssue(typeof refinementData === "function" ? refinementData(val2, ctx) : refinementData);
            return false;
          } else {
            return true;
          }
        });
      }
      _refinement(refinement) {
        return new ZodEffects({
          schema: this,
          typeName: ZodFirstPartyTypeKind.ZodEffects,
          effect: { type: "refinement", refinement }
        });
      }
      superRefine(refinement) {
        return this._refinement(refinement);
      }
      constructor(def) {
        this.spa = this.safeParseAsync;
        this._def = def;
        this.parse = this.parse.bind(this);
        this.safeParse = this.safeParse.bind(this);
        this.parseAsync = this.parseAsync.bind(this);
        this.safeParseAsync = this.safeParseAsync.bind(this);
        this.spa = this.spa.bind(this);
        this.refine = this.refine.bind(this);
        this.refinement = this.refinement.bind(this);
        this.superRefine = this.superRefine.bind(this);
        this.optional = this.optional.bind(this);
        this.nullable = this.nullable.bind(this);
        this.nullish = this.nullish.bind(this);
        this.array = this.array.bind(this);
        this.promise = this.promise.bind(this);
        this.or = this.or.bind(this);
        this.and = this.and.bind(this);
        this.transform = this.transform.bind(this);
        this.brand = this.brand.bind(this);
        this.default = this.default.bind(this);
        this.catch = this.catch.bind(this);
        this.describe = this.describe.bind(this);
        this.pipe = this.pipe.bind(this);
        this.readonly = this.readonly.bind(this);
        this.isNullable = this.isNullable.bind(this);
        this.isOptional = this.isOptional.bind(this);
        this["~standard"] = {
          version: 1,
          vendor: "zod",
          validate: (data) => this["~validate"](data)
        };
      }
      optional() {
        return ZodOptional.create(this, this._def);
      }
      nullable() {
        return ZodNullable.create(this, this._def);
      }
      nullish() {
        return this.nullable().optional();
      }
      array() {
        return ZodArray.create(this);
      }
      promise() {
        return ZodPromise.create(this, this._def);
      }
      or(option) {
        return ZodUnion.create([this, option], this._def);
      }
      and(incoming) {
        return ZodIntersection.create(this, incoming, this._def);
      }
      transform(transform) {
        return new ZodEffects({
          ...processCreateParams(this._def),
          schema: this,
          typeName: ZodFirstPartyTypeKind.ZodEffects,
          effect: { type: "transform", transform }
        });
      }
      default(def) {
        const defaultValueFunc = typeof def === "function" ? def : () => def;
        return new ZodDefault({
          ...processCreateParams(this._def),
          innerType: this,
          defaultValue: defaultValueFunc,
          typeName: ZodFirstPartyTypeKind.ZodDefault
        });
      }
      brand() {
        return new ZodBranded({
          typeName: ZodFirstPartyTypeKind.ZodBranded,
          type: this,
          ...processCreateParams(this._def)
        });
      }
      catch(def) {
        const catchValueFunc = typeof def === "function" ? def : () => def;
        return new ZodCatch({
          ...processCreateParams(this._def),
          innerType: this,
          catchValue: catchValueFunc,
          typeName: ZodFirstPartyTypeKind.ZodCatch
        });
      }
      describe(description) {
        const This = this.constructor;
        return new This({
          ...this._def,
          description
        });
      }
      pipe(target) {
        return ZodPipeline.create(this, target);
      }
      readonly() {
        return ZodReadonly.create(this);
      }
      isOptional() {
        return this.safeParse(void 0).success;
      }
      isNullable() {
        return this.safeParse(null).success;
      }
    };
    cuidRegex = /^c[^\s-]{8,}$/i;
    cuid2Regex = /^[0-9a-z]+$/;
    ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
    uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
    nanoidRegex = /^[a-z0-9_-]{21}$/i;
    jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
    durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
    emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
    _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
    ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
    ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
    ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
    ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
    base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
    base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
    dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
    dateRegex = new RegExp(`^${dateRegexSource}$`);
    ZodString = class _ZodString extends ZodType {
      _parse(input) {
        if (this._def.coerce) {
          input.data = String(input.data);
        }
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.string) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.string,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        const status = new ParseStatus();
        let ctx = void 0;
        for (const check2 of this._def.checks) {
          if (check2.kind === "min") {
            if (input.data.length < check2.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_small,
                minimum: check2.value,
                type: "string",
                inclusive: true,
                exact: false,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "max") {
            if (input.data.length > check2.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_big,
                maximum: check2.value,
                type: "string",
                inclusive: true,
                exact: false,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "length") {
            const tooBig = input.data.length > check2.value;
            const tooSmall = input.data.length < check2.value;
            if (tooBig || tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              if (tooBig) {
                addIssueToContext(ctx, {
                  code: ZodIssueCode.too_big,
                  maximum: check2.value,
                  type: "string",
                  inclusive: true,
                  exact: true,
                  message: check2.message
                });
              } else if (tooSmall) {
                addIssueToContext(ctx, {
                  code: ZodIssueCode.too_small,
                  minimum: check2.value,
                  type: "string",
                  inclusive: true,
                  exact: true,
                  message: check2.message
                });
              }
              status.dirty();
            }
          } else if (check2.kind === "email") {
            if (!emailRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "email",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "emoji") {
            if (!emojiRegex) {
              emojiRegex = new RegExp(_emojiRegex, "u");
            }
            if (!emojiRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "emoji",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "uuid") {
            if (!uuidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "uuid",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "nanoid") {
            if (!nanoidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "nanoid",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "cuid") {
            if (!cuidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "cuid",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "cuid2") {
            if (!cuid2Regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "cuid2",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "ulid") {
            if (!ulidRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "ulid",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "url") {
            try {
              new URL(input.data);
            } catch {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "url",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "regex") {
            check2.regex.lastIndex = 0;
            const testResult = check2.regex.test(input.data);
            if (!testResult) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "regex",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "trim") {
            input.data = input.data.trim();
          } else if (check2.kind === "includes") {
            if (!input.data.includes(check2.value, check2.position)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.invalid_string,
                validation: { includes: check2.value, position: check2.position },
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "toLowerCase") {
            input.data = input.data.toLowerCase();
          } else if (check2.kind === "toUpperCase") {
            input.data = input.data.toUpperCase();
          } else if (check2.kind === "startsWith") {
            if (!input.data.startsWith(check2.value)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.invalid_string,
                validation: { startsWith: check2.value },
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "endsWith") {
            if (!input.data.endsWith(check2.value)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.invalid_string,
                validation: { endsWith: check2.value },
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "datetime") {
            const regex = datetimeRegex(check2);
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.invalid_string,
                validation: "datetime",
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "date") {
            const regex = dateRegex;
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.invalid_string,
                validation: "date",
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "time") {
            const regex = timeRegex(check2);
            if (!regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.invalid_string,
                validation: "time",
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "duration") {
            if (!durationRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "duration",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "ip") {
            if (!isValidIP(input.data, check2.version)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "ip",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "jwt") {
            if (!isValidJWT(input.data, check2.alg)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "jwt",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "cidr") {
            if (!isValidCidr(input.data, check2.version)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "cidr",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "base64") {
            if (!base64Regex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "base64",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "base64url") {
            if (!base64urlRegex.test(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                validation: "base64url",
                code: ZodIssueCode.invalid_string,
                message: check2.message
              });
              status.dirty();
            }
          } else {
            util.assertNever(check2);
          }
        }
        return { status: status.value, value: input.data };
      }
      _regex(regex, validation, message) {
        return this.refinement((data) => regex.test(data), {
          validation,
          code: ZodIssueCode.invalid_string,
          ...errorUtil.errToObj(message)
        });
      }
      _addCheck(check2) {
        return new _ZodString({
          ...this._def,
          checks: [...this._def.checks, check2]
        });
      }
      email(message) {
        return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
      }
      url(message) {
        return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
      }
      emoji(message) {
        return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
      }
      uuid(message) {
        return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
      }
      nanoid(message) {
        return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
      }
      cuid(message) {
        return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
      }
      cuid2(message) {
        return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
      }
      ulid(message) {
        return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
      }
      base64(message) {
        return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
      }
      base64url(message) {
        return this._addCheck({
          kind: "base64url",
          ...errorUtil.errToObj(message)
        });
      }
      jwt(options) {
        return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) });
      }
      ip(options) {
        return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
      }
      cidr(options) {
        return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
      }
      datetime(options) {
        if (typeof options === "string") {
          return this._addCheck({
            kind: "datetime",
            precision: null,
            offset: false,
            local: false,
            message: options
          });
        }
        return this._addCheck({
          kind: "datetime",
          precision: typeof options?.precision === "undefined" ? null : options?.precision,
          offset: options?.offset ?? false,
          local: options?.local ?? false,
          ...errorUtil.errToObj(options?.message)
        });
      }
      date(message) {
        return this._addCheck({ kind: "date", message });
      }
      time(options) {
        if (typeof options === "string") {
          return this._addCheck({
            kind: "time",
            precision: null,
            message: options
          });
        }
        return this._addCheck({
          kind: "time",
          precision: typeof options?.precision === "undefined" ? null : options?.precision,
          ...errorUtil.errToObj(options?.message)
        });
      }
      duration(message) {
        return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
      }
      regex(regex, message) {
        return this._addCheck({
          kind: "regex",
          regex,
          ...errorUtil.errToObj(message)
        });
      }
      includes(value, options) {
        return this._addCheck({
          kind: "includes",
          value,
          position: options?.position,
          ...errorUtil.errToObj(options?.message)
        });
      }
      startsWith(value, message) {
        return this._addCheck({
          kind: "startsWith",
          value,
          ...errorUtil.errToObj(message)
        });
      }
      endsWith(value, message) {
        return this._addCheck({
          kind: "endsWith",
          value,
          ...errorUtil.errToObj(message)
        });
      }
      min(minLength, message) {
        return this._addCheck({
          kind: "min",
          value: minLength,
          ...errorUtil.errToObj(message)
        });
      }
      max(maxLength, message) {
        return this._addCheck({
          kind: "max",
          value: maxLength,
          ...errorUtil.errToObj(message)
        });
      }
      length(len, message) {
        return this._addCheck({
          kind: "length",
          value: len,
          ...errorUtil.errToObj(message)
        });
      }
      /**
       * Equivalent to `.min(1)`
       */
      nonempty(message) {
        return this.min(1, errorUtil.errToObj(message));
      }
      trim() {
        return new _ZodString({
          ...this._def,
          checks: [...this._def.checks, { kind: "trim" }]
        });
      }
      toLowerCase() {
        return new _ZodString({
          ...this._def,
          checks: [...this._def.checks, { kind: "toLowerCase" }]
        });
      }
      toUpperCase() {
        return new _ZodString({
          ...this._def,
          checks: [...this._def.checks, { kind: "toUpperCase" }]
        });
      }
      get isDatetime() {
        return !!this._def.checks.find((ch) => ch.kind === "datetime");
      }
      get isDate() {
        return !!this._def.checks.find((ch) => ch.kind === "date");
      }
      get isTime() {
        return !!this._def.checks.find((ch) => ch.kind === "time");
      }
      get isDuration() {
        return !!this._def.checks.find((ch) => ch.kind === "duration");
      }
      get isEmail() {
        return !!this._def.checks.find((ch) => ch.kind === "email");
      }
      get isURL() {
        return !!this._def.checks.find((ch) => ch.kind === "url");
      }
      get isEmoji() {
        return !!this._def.checks.find((ch) => ch.kind === "emoji");
      }
      get isUUID() {
        return !!this._def.checks.find((ch) => ch.kind === "uuid");
      }
      get isNANOID() {
        return !!this._def.checks.find((ch) => ch.kind === "nanoid");
      }
      get isCUID() {
        return !!this._def.checks.find((ch) => ch.kind === "cuid");
      }
      get isCUID2() {
        return !!this._def.checks.find((ch) => ch.kind === "cuid2");
      }
      get isULID() {
        return !!this._def.checks.find((ch) => ch.kind === "ulid");
      }
      get isIP() {
        return !!this._def.checks.find((ch) => ch.kind === "ip");
      }
      get isCIDR() {
        return !!this._def.checks.find((ch) => ch.kind === "cidr");
      }
      get isBase64() {
        return !!this._def.checks.find((ch) => ch.kind === "base64");
      }
      get isBase64url() {
        return !!this._def.checks.find((ch) => ch.kind === "base64url");
      }
      get minLength() {
        let min2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min2 === null || ch.value > min2)
              min2 = ch.value;
          }
        }
        return min2;
      }
      get maxLength() {
        let max2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max2 === null || ch.value < max2)
              max2 = ch.value;
          }
        }
        return max2;
      }
    };
    ZodString.create = (params) => {
      return new ZodString({
        checks: [],
        typeName: ZodFirstPartyTypeKind.ZodString,
        coerce: params?.coerce ?? false,
        ...processCreateParams(params)
      });
    };
    ZodNumber = class _ZodNumber extends ZodType {
      constructor() {
        super(...arguments);
        this.min = this.gte;
        this.max = this.lte;
        this.step = this.multipleOf;
      }
      _parse(input) {
        if (this._def.coerce) {
          input.data = Number(input.data);
        }
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.number) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.number,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        let ctx = void 0;
        const status = new ParseStatus();
        for (const check2 of this._def.checks) {
          if (check2.kind === "int") {
            if (!util.isInteger(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.invalid_type,
                expected: "integer",
                received: "float",
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "min") {
            const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
            if (tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_small,
                minimum: check2.value,
                type: "number",
                inclusive: check2.inclusive,
                exact: false,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "max") {
            const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
            if (tooBig) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_big,
                maximum: check2.value,
                type: "number",
                inclusive: check2.inclusive,
                exact: false,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "multipleOf") {
            if (floatSafeRemainder(input.data, check2.value) !== 0) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.not_multiple_of,
                multipleOf: check2.value,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "finite") {
            if (!Number.isFinite(input.data)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.not_finite,
                message: check2.message
              });
              status.dirty();
            }
          } else {
            util.assertNever(check2);
          }
        }
        return { status: status.value, value: input.data };
      }
      gte(value, message) {
        return this.setLimit("min", value, true, errorUtil.toString(message));
      }
      gt(value, message) {
        return this.setLimit("min", value, false, errorUtil.toString(message));
      }
      lte(value, message) {
        return this.setLimit("max", value, true, errorUtil.toString(message));
      }
      lt(value, message) {
        return this.setLimit("max", value, false, errorUtil.toString(message));
      }
      setLimit(kind, value, inclusive, message) {
        return new _ZodNumber({
          ...this._def,
          checks: [
            ...this._def.checks,
            {
              kind,
              value,
              inclusive,
              message: errorUtil.toString(message)
            }
          ]
        });
      }
      _addCheck(check2) {
        return new _ZodNumber({
          ...this._def,
          checks: [...this._def.checks, check2]
        });
      }
      int(message) {
        return this._addCheck({
          kind: "int",
          message: errorUtil.toString(message)
        });
      }
      positive(message) {
        return this._addCheck({
          kind: "min",
          value: 0,
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      negative(message) {
        return this._addCheck({
          kind: "max",
          value: 0,
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      nonpositive(message) {
        return this._addCheck({
          kind: "max",
          value: 0,
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      nonnegative(message) {
        return this._addCheck({
          kind: "min",
          value: 0,
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      multipleOf(value, message) {
        return this._addCheck({
          kind: "multipleOf",
          value,
          message: errorUtil.toString(message)
        });
      }
      finite(message) {
        return this._addCheck({
          kind: "finite",
          message: errorUtil.toString(message)
        });
      }
      safe(message) {
        return this._addCheck({
          kind: "min",
          inclusive: true,
          value: Number.MIN_SAFE_INTEGER,
          message: errorUtil.toString(message)
        })._addCheck({
          kind: "max",
          inclusive: true,
          value: Number.MAX_SAFE_INTEGER,
          message: errorUtil.toString(message)
        });
      }
      get minValue() {
        let min2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min2 === null || ch.value > min2)
              min2 = ch.value;
          }
        }
        return min2;
      }
      get maxValue() {
        let max2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max2 === null || ch.value < max2)
              max2 = ch.value;
          }
        }
        return max2;
      }
      get isInt() {
        return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
      }
      get isFinite() {
        let max2 = null;
        let min2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
            return true;
          } else if (ch.kind === "min") {
            if (min2 === null || ch.value > min2)
              min2 = ch.value;
          } else if (ch.kind === "max") {
            if (max2 === null || ch.value < max2)
              max2 = ch.value;
          }
        }
        return Number.isFinite(min2) && Number.isFinite(max2);
      }
    };
    ZodNumber.create = (params) => {
      return new ZodNumber({
        checks: [],
        typeName: ZodFirstPartyTypeKind.ZodNumber,
        coerce: params?.coerce || false,
        ...processCreateParams(params)
      });
    };
    ZodBigInt = class _ZodBigInt extends ZodType {
      constructor() {
        super(...arguments);
        this.min = this.gte;
        this.max = this.lte;
      }
      _parse(input) {
        if (this._def.coerce) {
          try {
            input.data = BigInt(input.data);
          } catch {
            return this._getInvalidInput(input);
          }
        }
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.bigint) {
          return this._getInvalidInput(input);
        }
        let ctx = void 0;
        const status = new ParseStatus();
        for (const check2 of this._def.checks) {
          if (check2.kind === "min") {
            const tooSmall = check2.inclusive ? input.data < check2.value : input.data <= check2.value;
            if (tooSmall) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_small,
                type: "bigint",
                minimum: check2.value,
                inclusive: check2.inclusive,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "max") {
            const tooBig = check2.inclusive ? input.data > check2.value : input.data >= check2.value;
            if (tooBig) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_big,
                type: "bigint",
                maximum: check2.value,
                inclusive: check2.inclusive,
                message: check2.message
              });
              status.dirty();
            }
          } else if (check2.kind === "multipleOf") {
            if (input.data % check2.value !== BigInt(0)) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.not_multiple_of,
                multipleOf: check2.value,
                message: check2.message
              });
              status.dirty();
            }
          } else {
            util.assertNever(check2);
          }
        }
        return { status: status.value, value: input.data };
      }
      _getInvalidInput(input) {
        const ctx = this._getOrReturnCtx(input);
        addIssueToContext(ctx, {
          code: ZodIssueCode.invalid_type,
          expected: ZodParsedType.bigint,
          received: ctx.parsedType
        });
        return INVALID;
      }
      gte(value, message) {
        return this.setLimit("min", value, true, errorUtil.toString(message));
      }
      gt(value, message) {
        return this.setLimit("min", value, false, errorUtil.toString(message));
      }
      lte(value, message) {
        return this.setLimit("max", value, true, errorUtil.toString(message));
      }
      lt(value, message) {
        return this.setLimit("max", value, false, errorUtil.toString(message));
      }
      setLimit(kind, value, inclusive, message) {
        return new _ZodBigInt({
          ...this._def,
          checks: [
            ...this._def.checks,
            {
              kind,
              value,
              inclusive,
              message: errorUtil.toString(message)
            }
          ]
        });
      }
      _addCheck(check2) {
        return new _ZodBigInt({
          ...this._def,
          checks: [...this._def.checks, check2]
        });
      }
      positive(message) {
        return this._addCheck({
          kind: "min",
          value: BigInt(0),
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      negative(message) {
        return this._addCheck({
          kind: "max",
          value: BigInt(0),
          inclusive: false,
          message: errorUtil.toString(message)
        });
      }
      nonpositive(message) {
        return this._addCheck({
          kind: "max",
          value: BigInt(0),
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      nonnegative(message) {
        return this._addCheck({
          kind: "min",
          value: BigInt(0),
          inclusive: true,
          message: errorUtil.toString(message)
        });
      }
      multipleOf(value, message) {
        return this._addCheck({
          kind: "multipleOf",
          value,
          message: errorUtil.toString(message)
        });
      }
      get minValue() {
        let min2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min2 === null || ch.value > min2)
              min2 = ch.value;
          }
        }
        return min2;
      }
      get maxValue() {
        let max2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max2 === null || ch.value < max2)
              max2 = ch.value;
          }
        }
        return max2;
      }
    };
    ZodBigInt.create = (params) => {
      return new ZodBigInt({
        checks: [],
        typeName: ZodFirstPartyTypeKind.ZodBigInt,
        coerce: params?.coerce ?? false,
        ...processCreateParams(params)
      });
    };
    ZodBoolean = class extends ZodType {
      _parse(input) {
        if (this._def.coerce) {
          input.data = Boolean(input.data);
        }
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.boolean) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.boolean,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodBoolean.create = (params) => {
      return new ZodBoolean({
        typeName: ZodFirstPartyTypeKind.ZodBoolean,
        coerce: params?.coerce || false,
        ...processCreateParams(params)
      });
    };
    ZodDate = class _ZodDate extends ZodType {
      _parse(input) {
        if (this._def.coerce) {
          input.data = new Date(input.data);
        }
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.date) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.date,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        if (Number.isNaN(input.data.getTime())) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode.invalid_date
          });
          return INVALID;
        }
        const status = new ParseStatus();
        let ctx = void 0;
        for (const check2 of this._def.checks) {
          if (check2.kind === "min") {
            if (input.data.getTime() < check2.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_small,
                message: check2.message,
                inclusive: true,
                exact: false,
                minimum: check2.value,
                type: "date"
              });
              status.dirty();
            }
          } else if (check2.kind === "max") {
            if (input.data.getTime() > check2.value) {
              ctx = this._getOrReturnCtx(input, ctx);
              addIssueToContext(ctx, {
                code: ZodIssueCode.too_big,
                message: check2.message,
                inclusive: true,
                exact: false,
                maximum: check2.value,
                type: "date"
              });
              status.dirty();
            }
          } else {
            util.assertNever(check2);
          }
        }
        return {
          status: status.value,
          value: new Date(input.data.getTime())
        };
      }
      _addCheck(check2) {
        return new _ZodDate({
          ...this._def,
          checks: [...this._def.checks, check2]
        });
      }
      min(minDate, message) {
        return this._addCheck({
          kind: "min",
          value: minDate.getTime(),
          message: errorUtil.toString(message)
        });
      }
      max(maxDate, message) {
        return this._addCheck({
          kind: "max",
          value: maxDate.getTime(),
          message: errorUtil.toString(message)
        });
      }
      get minDate() {
        let min2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "min") {
            if (min2 === null || ch.value > min2)
              min2 = ch.value;
          }
        }
        return min2 != null ? new Date(min2) : null;
      }
      get maxDate() {
        let max2 = null;
        for (const ch of this._def.checks) {
          if (ch.kind === "max") {
            if (max2 === null || ch.value < max2)
              max2 = ch.value;
          }
        }
        return max2 != null ? new Date(max2) : null;
      }
    };
    ZodDate.create = (params) => {
      return new ZodDate({
        checks: [],
        coerce: params?.coerce || false,
        typeName: ZodFirstPartyTypeKind.ZodDate,
        ...processCreateParams(params)
      });
    };
    ZodSymbol = class extends ZodType {
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.symbol) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.symbol,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodSymbol.create = (params) => {
      return new ZodSymbol({
        typeName: ZodFirstPartyTypeKind.ZodSymbol,
        ...processCreateParams(params)
      });
    };
    ZodUndefined = class extends ZodType {
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.undefined) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.undefined,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodUndefined.create = (params) => {
      return new ZodUndefined({
        typeName: ZodFirstPartyTypeKind.ZodUndefined,
        ...processCreateParams(params)
      });
    };
    ZodNull = class extends ZodType {
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.null) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.null,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodNull.create = (params) => {
      return new ZodNull({
        typeName: ZodFirstPartyTypeKind.ZodNull,
        ...processCreateParams(params)
      });
    };
    ZodAny = class extends ZodType {
      constructor() {
        super(...arguments);
        this._any = true;
      }
      _parse(input) {
        return OK(input.data);
      }
    };
    ZodAny.create = (params) => {
      return new ZodAny({
        typeName: ZodFirstPartyTypeKind.ZodAny,
        ...processCreateParams(params)
      });
    };
    ZodUnknown = class extends ZodType {
      constructor() {
        super(...arguments);
        this._unknown = true;
      }
      _parse(input) {
        return OK(input.data);
      }
    };
    ZodUnknown.create = (params) => {
      return new ZodUnknown({
        typeName: ZodFirstPartyTypeKind.ZodUnknown,
        ...processCreateParams(params)
      });
    };
    ZodNever = class extends ZodType {
      _parse(input) {
        const ctx = this._getOrReturnCtx(input);
        addIssueToContext(ctx, {
          code: ZodIssueCode.invalid_type,
          expected: ZodParsedType.never,
          received: ctx.parsedType
        });
        return INVALID;
      }
    };
    ZodNever.create = (params) => {
      return new ZodNever({
        typeName: ZodFirstPartyTypeKind.ZodNever,
        ...processCreateParams(params)
      });
    };
    ZodVoid = class extends ZodType {
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.undefined) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.void,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return OK(input.data);
      }
    };
    ZodVoid.create = (params) => {
      return new ZodVoid({
        typeName: ZodFirstPartyTypeKind.ZodVoid,
        ...processCreateParams(params)
      });
    };
    ZodArray = class _ZodArray extends ZodType {
      _parse(input) {
        const { ctx, status } = this._processInputParams(input);
        const def = this._def;
        if (ctx.parsedType !== ZodParsedType.array) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.array,
            received: ctx.parsedType
          });
          return INVALID;
        }
        if (def.exactLength !== null) {
          const tooBig = ctx.data.length > def.exactLength.value;
          const tooSmall = ctx.data.length < def.exactLength.value;
          if (tooBig || tooSmall) {
            addIssueToContext(ctx, {
              code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
              minimum: tooSmall ? def.exactLength.value : void 0,
              maximum: tooBig ? def.exactLength.value : void 0,
              type: "array",
              inclusive: true,
              exact: true,
              message: def.exactLength.message
            });
            status.dirty();
          }
        }
        if (def.minLength !== null) {
          if (ctx.data.length < def.minLength.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode.too_small,
              minimum: def.minLength.value,
              type: "array",
              inclusive: true,
              exact: false,
              message: def.minLength.message
            });
            status.dirty();
          }
        }
        if (def.maxLength !== null) {
          if (ctx.data.length > def.maxLength.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode.too_big,
              maximum: def.maxLength.value,
              type: "array",
              inclusive: true,
              exact: false,
              message: def.maxLength.message
            });
            status.dirty();
          }
        }
        if (ctx.common.async) {
          return Promise.all([...ctx.data].map((item, i8) => {
            return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i8));
          })).then((result2) => {
            return ParseStatus.mergeArray(status, result2);
          });
        }
        const result = [...ctx.data].map((item, i8) => {
          return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i8));
        });
        return ParseStatus.mergeArray(status, result);
      }
      get element() {
        return this._def.type;
      }
      min(minLength, message) {
        return new _ZodArray({
          ...this._def,
          minLength: { value: minLength, message: errorUtil.toString(message) }
        });
      }
      max(maxLength, message) {
        return new _ZodArray({
          ...this._def,
          maxLength: { value: maxLength, message: errorUtil.toString(message) }
        });
      }
      length(len, message) {
        return new _ZodArray({
          ...this._def,
          exactLength: { value: len, message: errorUtil.toString(message) }
        });
      }
      nonempty(message) {
        return this.min(1, message);
      }
    };
    ZodArray.create = (schema6, params) => {
      return new ZodArray({
        type: schema6,
        minLength: null,
        maxLength: null,
        exactLength: null,
        typeName: ZodFirstPartyTypeKind.ZodArray,
        ...processCreateParams(params)
      });
    };
    ZodObject = class _ZodObject extends ZodType {
      constructor() {
        super(...arguments);
        this._cached = null;
        this.nonstrict = this.passthrough;
        this.augment = this.extend;
      }
      _getCached() {
        if (this._cached !== null)
          return this._cached;
        const shape = this._def.shape();
        const keys = util.objectKeys(shape);
        this._cached = { shape, keys };
        return this._cached;
      }
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.object) {
          const ctx2 = this._getOrReturnCtx(input);
          addIssueToContext(ctx2, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.object,
            received: ctx2.parsedType
          });
          return INVALID;
        }
        const { status, ctx } = this._processInputParams(input);
        const { shape, keys: shapeKeys } = this._getCached();
        const extraKeys = [];
        if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
          for (const key in ctx.data) {
            if (!shapeKeys.includes(key)) {
              extraKeys.push(key);
            }
          }
        }
        const pairs = [];
        for (const key of shapeKeys) {
          const keyValidator = shape[key];
          const value = ctx.data[key];
          pairs.push({
            key: { status: "valid", value: key },
            value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
            alwaysSet: key in ctx.data
          });
        }
        if (this._def.catchall instanceof ZodNever) {
          const unknownKeys = this._def.unknownKeys;
          if (unknownKeys === "passthrough") {
            for (const key of extraKeys) {
              pairs.push({
                key: { status: "valid", value: key },
                value: { status: "valid", value: ctx.data[key] }
              });
            }
          } else if (unknownKeys === "strict") {
            if (extraKeys.length > 0) {
              addIssueToContext(ctx, {
                code: ZodIssueCode.unrecognized_keys,
                keys: extraKeys
              });
              status.dirty();
            }
          } else if (unknownKeys === "strip") {
          } else {
            throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
          }
        } else {
          const catchall = this._def.catchall;
          for (const key of extraKeys) {
            const value = ctx.data[key];
            pairs.push({
              key: { status: "valid", value: key },
              value: catchall._parse(
                new ParseInputLazyPath(ctx, value, ctx.path, key)
                //, ctx.child(key), value, getParsedType(value)
              ),
              alwaysSet: key in ctx.data
            });
          }
        }
        if (ctx.common.async) {
          return Promise.resolve().then(async () => {
            const syncPairs = [];
            for (const pair of pairs) {
              const key = await pair.key;
              const value = await pair.value;
              syncPairs.push({
                key,
                value,
                alwaysSet: pair.alwaysSet
              });
            }
            return syncPairs;
          }).then((syncPairs) => {
            return ParseStatus.mergeObjectSync(status, syncPairs);
          });
        } else {
          return ParseStatus.mergeObjectSync(status, pairs);
        }
      }
      get shape() {
        return this._def.shape();
      }
      strict(message) {
        errorUtil.errToObj;
        return new _ZodObject({
          ...this._def,
          unknownKeys: "strict",
          ...message !== void 0 ? {
            errorMap: (issue, ctx) => {
              const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
              if (issue.code === "unrecognized_keys")
                return {
                  message: errorUtil.errToObj(message).message ?? defaultError
                };
              return {
                message: defaultError
              };
            }
          } : {}
        });
      }
      strip() {
        return new _ZodObject({
          ...this._def,
          unknownKeys: "strip"
        });
      }
      passthrough() {
        return new _ZodObject({
          ...this._def,
          unknownKeys: "passthrough"
        });
      }
      // const AugmentFactory =
      //   <Def extends ZodObjectDef>(def: Def) =>
      //   <Augmentation extends ZodRawShape>(
      //     augmentation: Augmentation
      //   ): ZodObject<
      //     extendShape<ReturnType<Def["shape"]>, Augmentation>,
      //     Def["unknownKeys"],
      //     Def["catchall"]
      //   > => {
      //     return new ZodObject({
      //       ...def,
      //       shape: () => ({
      //         ...def.shape(),
      //         ...augmentation,
      //       }),
      //     }) as any;
      //   };
      extend(augmentation) {
        return new _ZodObject({
          ...this._def,
          shape: () => ({
            ...this._def.shape(),
            ...augmentation
          })
        });
      }
      /**
       * Prior to zod@1.0.12 there was a bug in the
       * inferred type of merged objects. Please
       * upgrade if you are experiencing issues.
       */
      merge(merging) {
        const merged = new _ZodObject({
          unknownKeys: merging._def.unknownKeys,
          catchall: merging._def.catchall,
          shape: () => ({
            ...this._def.shape(),
            ...merging._def.shape()
          }),
          typeName: ZodFirstPartyTypeKind.ZodObject
        });
        return merged;
      }
      // merge<
      //   Incoming extends AnyZodObject,
      //   Augmentation extends Incoming["shape"],
      //   NewOutput extends {
      //     [k in keyof Augmentation | keyof Output]: k extends keyof Augmentation
      //       ? Augmentation[k]["_output"]
      //       : k extends keyof Output
      //       ? Output[k]
      //       : never;
      //   },
      //   NewInput extends {
      //     [k in keyof Augmentation | keyof Input]: k extends keyof Augmentation
      //       ? Augmentation[k]["_input"]
      //       : k extends keyof Input
      //       ? Input[k]
      //       : never;
      //   }
      // >(
      //   merging: Incoming
      // ): ZodObject<
      //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
      //   Incoming["_def"]["unknownKeys"],
      //   Incoming["_def"]["catchall"],
      //   NewOutput,
      //   NewInput
      // > {
      //   const merged: any = new ZodObject({
      //     unknownKeys: merging._def.unknownKeys,
      //     catchall: merging._def.catchall,
      //     shape: () =>
      //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
      //     typeName: ZodFirstPartyTypeKind.ZodObject,
      //   }) as any;
      //   return merged;
      // }
      setKey(key, schema6) {
        return this.augment({ [key]: schema6 });
      }
      // merge<Incoming extends AnyZodObject>(
      //   merging: Incoming
      // ): //ZodObject<T & Incoming["_shape"], UnknownKeys, Catchall> = (merging) => {
      // ZodObject<
      //   extendShape<T, ReturnType<Incoming["_def"]["shape"]>>,
      //   Incoming["_def"]["unknownKeys"],
      //   Incoming["_def"]["catchall"]
      // > {
      //   // const mergedShape = objectUtil.mergeShapes(
      //   //   this._def.shape(),
      //   //   merging._def.shape()
      //   // );
      //   const merged: any = new ZodObject({
      //     unknownKeys: merging._def.unknownKeys,
      //     catchall: merging._def.catchall,
      //     shape: () =>
      //       objectUtil.mergeShapes(this._def.shape(), merging._def.shape()),
      //     typeName: ZodFirstPartyTypeKind.ZodObject,
      //   }) as any;
      //   return merged;
      // }
      catchall(index7) {
        return new _ZodObject({
          ...this._def,
          catchall: index7
        });
      }
      pick(mask) {
        const shape = {};
        for (const key of util.objectKeys(mask)) {
          if (mask[key] && this.shape[key]) {
            shape[key] = this.shape[key];
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => shape
        });
      }
      omit(mask) {
        const shape = {};
        for (const key of util.objectKeys(this.shape)) {
          if (!mask[key]) {
            shape[key] = this.shape[key];
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => shape
        });
      }
      /**
       * @deprecated
       */
      deepPartial() {
        return deepPartialify(this);
      }
      partial(mask) {
        const newShape = {};
        for (const key of util.objectKeys(this.shape)) {
          const fieldSchema = this.shape[key];
          if (mask && !mask[key]) {
            newShape[key] = fieldSchema;
          } else {
            newShape[key] = fieldSchema.optional();
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => newShape
        });
      }
      required(mask) {
        const newShape = {};
        for (const key of util.objectKeys(this.shape)) {
          if (mask && !mask[key]) {
            newShape[key] = this.shape[key];
          } else {
            const fieldSchema = this.shape[key];
            let newField = fieldSchema;
            while (newField instanceof ZodOptional) {
              newField = newField._def.innerType;
            }
            newShape[key] = newField;
          }
        }
        return new _ZodObject({
          ...this._def,
          shape: () => newShape
        });
      }
      keyof() {
        return createZodEnum(util.objectKeys(this.shape));
      }
    };
    ZodObject.create = (shape, params) => {
      return new ZodObject({
        shape: () => shape,
        unknownKeys: "strip",
        catchall: ZodNever.create(),
        typeName: ZodFirstPartyTypeKind.ZodObject,
        ...processCreateParams(params)
      });
    };
    ZodObject.strictCreate = (shape, params) => {
      return new ZodObject({
        shape: () => shape,
        unknownKeys: "strict",
        catchall: ZodNever.create(),
        typeName: ZodFirstPartyTypeKind.ZodObject,
        ...processCreateParams(params)
      });
    };
    ZodObject.lazycreate = (shape, params) => {
      return new ZodObject({
        shape,
        unknownKeys: "strip",
        catchall: ZodNever.create(),
        typeName: ZodFirstPartyTypeKind.ZodObject,
        ...processCreateParams(params)
      });
    };
    ZodUnion = class extends ZodType {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const options = this._def.options;
        function handleResults(results) {
          for (const result of results) {
            if (result.result.status === "valid") {
              return result.result;
            }
          }
          for (const result of results) {
            if (result.result.status === "dirty") {
              ctx.common.issues.push(...result.ctx.common.issues);
              return result.result;
            }
          }
          const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_union,
            unionErrors
          });
          return INVALID;
        }
        if (ctx.common.async) {
          return Promise.all(options.map(async (option) => {
            const childCtx = {
              ...ctx,
              common: {
                ...ctx.common,
                issues: []
              },
              parent: null
            };
            return {
              result: await option._parseAsync({
                data: ctx.data,
                path: ctx.path,
                parent: childCtx
              }),
              ctx: childCtx
            };
          })).then(handleResults);
        } else {
          let dirty = void 0;
          const issues = [];
          for (const option of options) {
            const childCtx = {
              ...ctx,
              common: {
                ...ctx.common,
                issues: []
              },
              parent: null
            };
            const result = option._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: childCtx
            });
            if (result.status === "valid") {
              return result;
            } else if (result.status === "dirty" && !dirty) {
              dirty = { result, ctx: childCtx };
            }
            if (childCtx.common.issues.length) {
              issues.push(childCtx.common.issues);
            }
          }
          if (dirty) {
            ctx.common.issues.push(...dirty.ctx.common.issues);
            return dirty.result;
          }
          const unionErrors = issues.map((issues2) => new ZodError(issues2));
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_union,
            unionErrors
          });
          return INVALID;
        }
      }
      get options() {
        return this._def.options;
      }
    };
    ZodUnion.create = (types6, params) => {
      return new ZodUnion({
        options: types6,
        typeName: ZodFirstPartyTypeKind.ZodUnion,
        ...processCreateParams(params)
      });
    };
    getDiscriminator = (type) => {
      if (type instanceof ZodLazy) {
        return getDiscriminator(type.schema);
      } else if (type instanceof ZodEffects) {
        return getDiscriminator(type.innerType());
      } else if (type instanceof ZodLiteral) {
        return [type.value];
      } else if (type instanceof ZodEnum) {
        return type.options;
      } else if (type instanceof ZodNativeEnum) {
        return util.objectValues(type.enum);
      } else if (type instanceof ZodDefault) {
        return getDiscriminator(type._def.innerType);
      } else if (type instanceof ZodUndefined) {
        return [void 0];
      } else if (type instanceof ZodNull) {
        return [null];
      } else if (type instanceof ZodOptional) {
        return [void 0, ...getDiscriminator(type.unwrap())];
      } else if (type instanceof ZodNullable) {
        return [null, ...getDiscriminator(type.unwrap())];
      } else if (type instanceof ZodBranded) {
        return getDiscriminator(type.unwrap());
      } else if (type instanceof ZodReadonly) {
        return getDiscriminator(type.unwrap());
      } else if (type instanceof ZodCatch) {
        return getDiscriminator(type._def.innerType);
      } else {
        return [];
      }
    };
    ZodDiscriminatedUnion = class _ZodDiscriminatedUnion extends ZodType {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.object) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.object,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const discriminator = this.discriminator;
        const discriminatorValue = ctx.data[discriminator];
        const option = this.optionsMap.get(discriminatorValue);
        if (!option) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_union_discriminator,
            options: Array.from(this.optionsMap.keys()),
            path: [discriminator]
          });
          return INVALID;
        }
        if (ctx.common.async) {
          return option._parseAsync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
        } else {
          return option._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
        }
      }
      get discriminator() {
        return this._def.discriminator;
      }
      get options() {
        return this._def.options;
      }
      get optionsMap() {
        return this._def.optionsMap;
      }
      /**
       * The constructor of the discriminated union schema. Its behaviour is very similar to that of the normal z.union() constructor.
       * However, it only allows a union of objects, all of which need to share a discriminator property. This property must
       * have a different value for each object in the union.
       * @param discriminator the name of the discriminator property
       * @param types an array of object schemas
       * @param params
       */
      static create(discriminator, options, params) {
        const optionsMap = /* @__PURE__ */ new Map();
        for (const type of options) {
          const discriminatorValues = getDiscriminator(type.shape[discriminator]);
          if (!discriminatorValues.length) {
            throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
          }
          for (const value of discriminatorValues) {
            if (optionsMap.has(value)) {
              throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
            }
            optionsMap.set(value, type);
          }
        }
        return new _ZodDiscriminatedUnion({
          typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
          discriminator,
          options,
          optionsMap,
          ...processCreateParams(params)
        });
      }
    };
    ZodIntersection = class extends ZodType {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        const handleParsed = (parsedLeft, parsedRight) => {
          if (isAborted(parsedLeft) || isAborted(parsedRight)) {
            return INVALID;
          }
          const merged = mergeValues(parsedLeft.value, parsedRight.value);
          if (!merged.valid) {
            addIssueToContext(ctx, {
              code: ZodIssueCode.invalid_intersection_types
            });
            return INVALID;
          }
          if (isDirty(parsedLeft) || isDirty(parsedRight)) {
            status.dirty();
          }
          return { status: status.value, value: merged.data };
        };
        if (ctx.common.async) {
          return Promise.all([
            this._def.left._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            }),
            this._def.right._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            })
          ]).then(([left, right]) => handleParsed(left, right));
        } else {
          return handleParsed(this._def.left._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          }), this._def.right._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          }));
        }
      }
    };
    ZodIntersection.create = (left, right, params) => {
      return new ZodIntersection({
        left,
        right,
        typeName: ZodFirstPartyTypeKind.ZodIntersection,
        ...processCreateParams(params)
      });
    };
    ZodTuple = class _ZodTuple extends ZodType {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.array) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.array,
            received: ctx.parsedType
          });
          return INVALID;
        }
        if (ctx.data.length < this._def.items.length) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_small,
            minimum: this._def.items.length,
            inclusive: true,
            exact: false,
            type: "array"
          });
          return INVALID;
        }
        const rest = this._def.rest;
        if (!rest && ctx.data.length > this._def.items.length) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.too_big,
            maximum: this._def.items.length,
            inclusive: true,
            exact: false,
            type: "array"
          });
          status.dirty();
        }
        const items = [...ctx.data].map((item, itemIndex) => {
          const schema6 = this._def.items[itemIndex] || this._def.rest;
          if (!schema6)
            return null;
          return schema6._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
        }).filter((x11) => !!x11);
        if (ctx.common.async) {
          return Promise.all(items).then((results) => {
            return ParseStatus.mergeArray(status, results);
          });
        } else {
          return ParseStatus.mergeArray(status, items);
        }
      }
      get items() {
        return this._def.items;
      }
      rest(rest) {
        return new _ZodTuple({
          ...this._def,
          rest
        });
      }
    };
    ZodTuple.create = (schemas, params) => {
      if (!Array.isArray(schemas)) {
        throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
      }
      return new ZodTuple({
        items: schemas,
        typeName: ZodFirstPartyTypeKind.ZodTuple,
        rest: null,
        ...processCreateParams(params)
      });
    };
    ZodRecord = class _ZodRecord extends ZodType {
      get keySchema() {
        return this._def.keyType;
      }
      get valueSchema() {
        return this._def.valueType;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.object) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.object,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const pairs = [];
        const keyType = this._def.keyType;
        const valueType = this._def.valueType;
        for (const key in ctx.data) {
          pairs.push({
            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
            value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
            alwaysSet: key in ctx.data
          });
        }
        if (ctx.common.async) {
          return ParseStatus.mergeObjectAsync(status, pairs);
        } else {
          return ParseStatus.mergeObjectSync(status, pairs);
        }
      }
      get element() {
        return this._def.valueType;
      }
      static create(first, second, third) {
        if (second instanceof ZodType) {
          return new _ZodRecord({
            keyType: first,
            valueType: second,
            typeName: ZodFirstPartyTypeKind.ZodRecord,
            ...processCreateParams(third)
          });
        }
        return new _ZodRecord({
          keyType: ZodString.create(),
          valueType: first,
          typeName: ZodFirstPartyTypeKind.ZodRecord,
          ...processCreateParams(second)
        });
      }
    };
    ZodMap = class extends ZodType {
      get keySchema() {
        return this._def.keyType;
      }
      get valueSchema() {
        return this._def.valueType;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.map) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.map,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const keyType = this._def.keyType;
        const valueType = this._def.valueType;
        const pairs = [...ctx.data.entries()].map(([key, value], index7) => {
          return {
            key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index7, "key"])),
            value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index7, "value"]))
          };
        });
        if (ctx.common.async) {
          const finalMap = /* @__PURE__ */ new Map();
          return Promise.resolve().then(async () => {
            for (const pair of pairs) {
              const key = await pair.key;
              const value = await pair.value;
              if (key.status === "aborted" || value.status === "aborted") {
                return INVALID;
              }
              if (key.status === "dirty" || value.status === "dirty") {
                status.dirty();
              }
              finalMap.set(key.value, value.value);
            }
            return { status: status.value, value: finalMap };
          });
        } else {
          const finalMap = /* @__PURE__ */ new Map();
          for (const pair of pairs) {
            const key = pair.key;
            const value = pair.value;
            if (key.status === "aborted" || value.status === "aborted") {
              return INVALID;
            }
            if (key.status === "dirty" || value.status === "dirty") {
              status.dirty();
            }
            finalMap.set(key.value, value.value);
          }
          return { status: status.value, value: finalMap };
        }
      }
    };
    ZodMap.create = (keyType, valueType, params) => {
      return new ZodMap({
        valueType,
        keyType,
        typeName: ZodFirstPartyTypeKind.ZodMap,
        ...processCreateParams(params)
      });
    };
    ZodSet = class _ZodSet extends ZodType {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.set) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.set,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const def = this._def;
        if (def.minSize !== null) {
          if (ctx.data.size < def.minSize.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode.too_small,
              minimum: def.minSize.value,
              type: "set",
              inclusive: true,
              exact: false,
              message: def.minSize.message
            });
            status.dirty();
          }
        }
        if (def.maxSize !== null) {
          if (ctx.data.size > def.maxSize.value) {
            addIssueToContext(ctx, {
              code: ZodIssueCode.too_big,
              maximum: def.maxSize.value,
              type: "set",
              inclusive: true,
              exact: false,
              message: def.maxSize.message
            });
            status.dirty();
          }
        }
        const valueType = this._def.valueType;
        function finalizeSet(elements2) {
          const parsedSet = /* @__PURE__ */ new Set();
          for (const element of elements2) {
            if (element.status === "aborted")
              return INVALID;
            if (element.status === "dirty")
              status.dirty();
            parsedSet.add(element.value);
          }
          return { status: status.value, value: parsedSet };
        }
        const elements = [...ctx.data.values()].map((item, i8) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i8)));
        if (ctx.common.async) {
          return Promise.all(elements).then((elements2) => finalizeSet(elements2));
        } else {
          return finalizeSet(elements);
        }
      }
      min(minSize, message) {
        return new _ZodSet({
          ...this._def,
          minSize: { value: minSize, message: errorUtil.toString(message) }
        });
      }
      max(maxSize, message) {
        return new _ZodSet({
          ...this._def,
          maxSize: { value: maxSize, message: errorUtil.toString(message) }
        });
      }
      size(size2, message) {
        return this.min(size2, message).max(size2, message);
      }
      nonempty(message) {
        return this.min(1, message);
      }
    };
    ZodSet.create = (valueType, params) => {
      return new ZodSet({
        valueType,
        minSize: null,
        maxSize: null,
        typeName: ZodFirstPartyTypeKind.ZodSet,
        ...processCreateParams(params)
      });
    };
    ZodFunction = class _ZodFunction extends ZodType {
      constructor() {
        super(...arguments);
        this.validate = this.implement;
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.function) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.function,
            received: ctx.parsedType
          });
          return INVALID;
        }
        function makeArgsIssue(args2, error2) {
          return makeIssue({
            data: args2,
            path: ctx.path,
            errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x11) => !!x11),
            issueData: {
              code: ZodIssueCode.invalid_arguments,
              argumentsError: error2
            }
          });
        }
        function makeReturnsIssue(returns, error2) {
          return makeIssue({
            data: returns,
            path: ctx.path,
            errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x11) => !!x11),
            issueData: {
              code: ZodIssueCode.invalid_return_type,
              returnTypeError: error2
            }
          });
        }
        const params = { errorMap: ctx.common.contextualErrorMap };
        const fn3 = ctx.data;
        if (this._def.returns instanceof ZodPromise) {
          const me2 = this;
          return OK(async function(...args2) {
            const error2 = new ZodError([]);
            const parsedArgs = await me2._def.args.parseAsync(args2, params).catch((e6) => {
              error2.addIssue(makeArgsIssue(args2, e6));
              throw error2;
            });
            const result = await Reflect.apply(fn3, this, parsedArgs);
            const parsedReturns = await me2._def.returns._def.type.parseAsync(result, params).catch((e6) => {
              error2.addIssue(makeReturnsIssue(result, e6));
              throw error2;
            });
            return parsedReturns;
          });
        } else {
          const me2 = this;
          return OK(function(...args2) {
            const parsedArgs = me2._def.args.safeParse(args2, params);
            if (!parsedArgs.success) {
              throw new ZodError([makeArgsIssue(args2, parsedArgs.error)]);
            }
            const result = Reflect.apply(fn3, this, parsedArgs.data);
            const parsedReturns = me2._def.returns.safeParse(result, params);
            if (!parsedReturns.success) {
              throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
            }
            return parsedReturns.data;
          });
        }
      }
      parameters() {
        return this._def.args;
      }
      returnType() {
        return this._def.returns;
      }
      args(...items) {
        return new _ZodFunction({
          ...this._def,
          args: ZodTuple.create(items).rest(ZodUnknown.create())
        });
      }
      returns(returnType) {
        return new _ZodFunction({
          ...this._def,
          returns: returnType
        });
      }
      implement(func2) {
        const validatedFunc = this.parse(func2);
        return validatedFunc;
      }
      strictImplement(func2) {
        const validatedFunc = this.parse(func2);
        return validatedFunc;
      }
      static create(args2, returns, params) {
        return new _ZodFunction({
          args: args2 ? args2 : ZodTuple.create([]).rest(ZodUnknown.create()),
          returns: returns || ZodUnknown.create(),
          typeName: ZodFirstPartyTypeKind.ZodFunction,
          ...processCreateParams(params)
        });
      }
    };
    ZodLazy = class extends ZodType {
      get schema() {
        return this._def.getter();
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const lazySchema = this._def.getter();
        return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
      }
    };
    ZodLazy.create = (getter, params) => {
      return new ZodLazy({
        getter,
        typeName: ZodFirstPartyTypeKind.ZodLazy,
        ...processCreateParams(params)
      });
    };
    ZodLiteral = class extends ZodType {
      _parse(input) {
        if (input.data !== this._def.value) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            received: ctx.data,
            code: ZodIssueCode.invalid_literal,
            expected: this._def.value
          });
          return INVALID;
        }
        return { status: "valid", value: input.data };
      }
      get value() {
        return this._def.value;
      }
    };
    ZodLiteral.create = (value, params) => {
      return new ZodLiteral({
        value,
        typeName: ZodFirstPartyTypeKind.ZodLiteral,
        ...processCreateParams(params)
      });
    };
    ZodEnum = class _ZodEnum extends ZodType {
      _parse(input) {
        if (typeof input.data !== "string") {
          const ctx = this._getOrReturnCtx(input);
          const expectedValues = this._def.values;
          addIssueToContext(ctx, {
            expected: util.joinValues(expectedValues),
            received: ctx.parsedType,
            code: ZodIssueCode.invalid_type
          });
          return INVALID;
        }
        if (!this._cache) {
          this._cache = new Set(this._def.values);
        }
        if (!this._cache.has(input.data)) {
          const ctx = this._getOrReturnCtx(input);
          const expectedValues = this._def.values;
          addIssueToContext(ctx, {
            received: ctx.data,
            code: ZodIssueCode.invalid_enum_value,
            options: expectedValues
          });
          return INVALID;
        }
        return OK(input.data);
      }
      get options() {
        return this._def.values;
      }
      get enum() {
        const enumValues = {};
        for (const val2 of this._def.values) {
          enumValues[val2] = val2;
        }
        return enumValues;
      }
      get Values() {
        const enumValues = {};
        for (const val2 of this._def.values) {
          enumValues[val2] = val2;
        }
        return enumValues;
      }
      get Enum() {
        const enumValues = {};
        for (const val2 of this._def.values) {
          enumValues[val2] = val2;
        }
        return enumValues;
      }
      extract(values2, newDef = this._def) {
        return _ZodEnum.create(values2, {
          ...this._def,
          ...newDef
        });
      }
      exclude(values2, newDef = this._def) {
        return _ZodEnum.create(this.options.filter((opt) => !values2.includes(opt)), {
          ...this._def,
          ...newDef
        });
      }
    };
    ZodEnum.create = createZodEnum;
    ZodNativeEnum = class extends ZodType {
      _parse(input) {
        const nativeEnumValues = util.getValidEnumValues(this._def.values);
        const ctx = this._getOrReturnCtx(input);
        if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
          const expectedValues = util.objectValues(nativeEnumValues);
          addIssueToContext(ctx, {
            expected: util.joinValues(expectedValues),
            received: ctx.parsedType,
            code: ZodIssueCode.invalid_type
          });
          return INVALID;
        }
        if (!this._cache) {
          this._cache = new Set(util.getValidEnumValues(this._def.values));
        }
        if (!this._cache.has(input.data)) {
          const expectedValues = util.objectValues(nativeEnumValues);
          addIssueToContext(ctx, {
            received: ctx.data,
            code: ZodIssueCode.invalid_enum_value,
            options: expectedValues
          });
          return INVALID;
        }
        return OK(input.data);
      }
      get enum() {
        return this._def.values;
      }
    };
    ZodNativeEnum.create = (values2, params) => {
      return new ZodNativeEnum({
        values: values2,
        typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
        ...processCreateParams(params)
      });
    };
    ZodPromise = class extends ZodType {
      unwrap() {
        return this._def.type;
      }
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.promise,
            received: ctx.parsedType
          });
          return INVALID;
        }
        const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
        return OK(promisified.then((data) => {
          return this._def.type.parseAsync(data, {
            path: ctx.path,
            errorMap: ctx.common.contextualErrorMap
          });
        }));
      }
    };
    ZodPromise.create = (schema6, params) => {
      return new ZodPromise({
        type: schema6,
        typeName: ZodFirstPartyTypeKind.ZodPromise,
        ...processCreateParams(params)
      });
    };
    ZodEffects = class extends ZodType {
      innerType() {
        return this._def.schema;
      }
      sourceType() {
        return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
      }
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        const effect = this._def.effect || null;
        const checkCtx = {
          addIssue: (arg) => {
            addIssueToContext(ctx, arg);
            if (arg.fatal) {
              status.abort();
            } else {
              status.dirty();
            }
          },
          get path() {
            return ctx.path;
          }
        };
        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
        if (effect.type === "preprocess") {
          const processed = effect.transform(ctx.data, checkCtx);
          if (ctx.common.async) {
            return Promise.resolve(processed).then(async (processed2) => {
              if (status.value === "aborted")
                return INVALID;
              const result = await this._def.schema._parseAsync({
                data: processed2,
                path: ctx.path,
                parent: ctx
              });
              if (result.status === "aborted")
                return INVALID;
              if (result.status === "dirty")
                return DIRTY(result.value);
              if (status.value === "dirty")
                return DIRTY(result.value);
              return result;
            });
          } else {
            if (status.value === "aborted")
              return INVALID;
            const result = this._def.schema._parseSync({
              data: processed,
              path: ctx.path,
              parent: ctx
            });
            if (result.status === "aborted")
              return INVALID;
            if (result.status === "dirty")
              return DIRTY(result.value);
            if (status.value === "dirty")
              return DIRTY(result.value);
            return result;
          }
        }
        if (effect.type === "refinement") {
          const executeRefinement = (acc) => {
            const result = effect.refinement(acc, checkCtx);
            if (ctx.common.async) {
              return Promise.resolve(result);
            }
            if (result instanceof Promise) {
              throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
            }
            return acc;
          };
          if (ctx.common.async === false) {
            const inner = this._def.schema._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (inner.status === "aborted")
              return INVALID;
            if (inner.status === "dirty")
              status.dirty();
            executeRefinement(inner.value);
            return { status: status.value, value: inner.value };
          } else {
            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
              if (inner.status === "aborted")
                return INVALID;
              if (inner.status === "dirty")
                status.dirty();
              return executeRefinement(inner.value).then(() => {
                return { status: status.value, value: inner.value };
              });
            });
          }
        }
        if (effect.type === "transform") {
          if (ctx.common.async === false) {
            const base = this._def.schema._parseSync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (!isValid(base))
              return INVALID;
            const result = effect.transform(base.value, checkCtx);
            if (result instanceof Promise) {
              throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
            }
            return { status: status.value, value: result };
          } else {
            return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
              if (!isValid(base))
                return INVALID;
              return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
                status: status.value,
                value: result
              }));
            });
          }
        }
        util.assertNever(effect);
      }
    };
    ZodEffects.create = (schema6, effect, params) => {
      return new ZodEffects({
        schema: schema6,
        typeName: ZodFirstPartyTypeKind.ZodEffects,
        effect,
        ...processCreateParams(params)
      });
    };
    ZodEffects.createWithPreprocess = (preprocess, schema6, params) => {
      return new ZodEffects({
        schema: schema6,
        effect: { type: "preprocess", transform: preprocess },
        typeName: ZodFirstPartyTypeKind.ZodEffects,
        ...processCreateParams(params)
      });
    };
    ZodOptional = class extends ZodType {
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType === ZodParsedType.undefined) {
          return OK(void 0);
        }
        return this._def.innerType._parse(input);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    ZodOptional.create = (type, params) => {
      return new ZodOptional({
        innerType: type,
        typeName: ZodFirstPartyTypeKind.ZodOptional,
        ...processCreateParams(params)
      });
    };
    ZodNullable = class extends ZodType {
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType === ZodParsedType.null) {
          return OK(null);
        }
        return this._def.innerType._parse(input);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    ZodNullable.create = (type, params) => {
      return new ZodNullable({
        innerType: type,
        typeName: ZodFirstPartyTypeKind.ZodNullable,
        ...processCreateParams(params)
      });
    };
    ZodDefault = class extends ZodType {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        let data = ctx.data;
        if (ctx.parsedType === ZodParsedType.undefined) {
          data = this._def.defaultValue();
        }
        return this._def.innerType._parse({
          data,
          path: ctx.path,
          parent: ctx
        });
      }
      removeDefault() {
        return this._def.innerType;
      }
    };
    ZodDefault.create = (type, params) => {
      return new ZodDefault({
        innerType: type,
        typeName: ZodFirstPartyTypeKind.ZodDefault,
        defaultValue: typeof params.default === "function" ? params.default : () => params.default,
        ...processCreateParams(params)
      });
    };
    ZodCatch = class extends ZodType {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const newCtx = {
          ...ctx,
          common: {
            ...ctx.common,
            issues: []
          }
        };
        const result = this._def.innerType._parse({
          data: newCtx.data,
          path: newCtx.path,
          parent: {
            ...newCtx
          }
        });
        if (isAsync(result)) {
          return result.then((result2) => {
            return {
              status: "valid",
              value: result2.status === "valid" ? result2.value : this._def.catchValue({
                get error() {
                  return new ZodError(newCtx.common.issues);
                },
                input: newCtx.data
              })
            };
          });
        } else {
          return {
            status: "valid",
            value: result.status === "valid" ? result.value : this._def.catchValue({
              get error() {
                return new ZodError(newCtx.common.issues);
              },
              input: newCtx.data
            })
          };
        }
      }
      removeCatch() {
        return this._def.innerType;
      }
    };
    ZodCatch.create = (type, params) => {
      return new ZodCatch({
        innerType: type,
        typeName: ZodFirstPartyTypeKind.ZodCatch,
        catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
        ...processCreateParams(params)
      });
    };
    ZodNaN = class extends ZodType {
      _parse(input) {
        const parsedType = this._getType(input);
        if (parsedType !== ZodParsedType.nan) {
          const ctx = this._getOrReturnCtx(input);
          addIssueToContext(ctx, {
            code: ZodIssueCode.invalid_type,
            expected: ZodParsedType.nan,
            received: ctx.parsedType
          });
          return INVALID;
        }
        return { status: "valid", value: input.data };
      }
    };
    ZodNaN.create = (params) => {
      return new ZodNaN({
        typeName: ZodFirstPartyTypeKind.ZodNaN,
        ...processCreateParams(params)
      });
    };
    BRAND = Symbol("zod_brand");
    ZodBranded = class extends ZodType {
      _parse(input) {
        const { ctx } = this._processInputParams(input);
        const data = ctx.data;
        return this._def.type._parse({
          data,
          path: ctx.path,
          parent: ctx
        });
      }
      unwrap() {
        return this._def.type;
      }
    };
    ZodPipeline = class _ZodPipeline extends ZodType {
      _parse(input) {
        const { status, ctx } = this._processInputParams(input);
        if (ctx.common.async) {
          const handleAsync = async () => {
            const inResult = await this._def.in._parseAsync({
              data: ctx.data,
              path: ctx.path,
              parent: ctx
            });
            if (inResult.status === "aborted")
              return INVALID;
            if (inResult.status === "dirty") {
              status.dirty();
              return DIRTY(inResult.value);
            } else {
              return this._def.out._parseAsync({
                data: inResult.value,
                path: ctx.path,
                parent: ctx
              });
            }
          };
          return handleAsync();
        } else {
          const inResult = this._def.in._parseSync({
            data: ctx.data,
            path: ctx.path,
            parent: ctx
          });
          if (inResult.status === "aborted")
            return INVALID;
          if (inResult.status === "dirty") {
            status.dirty();
            return {
              status: "dirty",
              value: inResult.value
            };
          } else {
            return this._def.out._parseSync({
              data: inResult.value,
              path: ctx.path,
              parent: ctx
            });
          }
        }
      }
      static create(a9, b9) {
        return new _ZodPipeline({
          in: a9,
          out: b9,
          typeName: ZodFirstPartyTypeKind.ZodPipeline
        });
      }
    };
    ZodReadonly = class extends ZodType {
      _parse(input) {
        const result = this._def.innerType._parse(input);
        const freeze = (data) => {
          if (isValid(data)) {
            data.value = Object.freeze(data.value);
          }
          return data;
        };
        return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
      }
      unwrap() {
        return this._def.innerType;
      }
    };
    ZodReadonly.create = (type, params) => {
      return new ZodReadonly({
        innerType: type,
        typeName: ZodFirstPartyTypeKind.ZodReadonly,
        ...processCreateParams(params)
      });
    };
    late = {
      object: ZodObject.lazycreate
    };
    (function(ZodFirstPartyTypeKind2) {
      ZodFirstPartyTypeKind2["ZodString"] = "ZodString";
      ZodFirstPartyTypeKind2["ZodNumber"] = "ZodNumber";
      ZodFirstPartyTypeKind2["ZodNaN"] = "ZodNaN";
      ZodFirstPartyTypeKind2["ZodBigInt"] = "ZodBigInt";
      ZodFirstPartyTypeKind2["ZodBoolean"] = "ZodBoolean";
      ZodFirstPartyTypeKind2["ZodDate"] = "ZodDate";
      ZodFirstPartyTypeKind2["ZodSymbol"] = "ZodSymbol";
      ZodFirstPartyTypeKind2["ZodUndefined"] = "ZodUndefined";
      ZodFirstPartyTypeKind2["ZodNull"] = "ZodNull";
      ZodFirstPartyTypeKind2["ZodAny"] = "ZodAny";
      ZodFirstPartyTypeKind2["ZodUnknown"] = "ZodUnknown";
      ZodFirstPartyTypeKind2["ZodNever"] = "ZodNever";
      ZodFirstPartyTypeKind2["ZodVoid"] = "ZodVoid";
      ZodFirstPartyTypeKind2["ZodArray"] = "ZodArray";
      ZodFirstPartyTypeKind2["ZodObject"] = "ZodObject";
      ZodFirstPartyTypeKind2["ZodUnion"] = "ZodUnion";
      ZodFirstPartyTypeKind2["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
      ZodFirstPartyTypeKind2["ZodIntersection"] = "ZodIntersection";
      ZodFirstPartyTypeKind2["ZodTuple"] = "ZodTuple";
      ZodFirstPartyTypeKind2["ZodRecord"] = "ZodRecord";
      ZodFirstPartyTypeKind2["ZodMap"] = "ZodMap";
      ZodFirstPartyTypeKind2["ZodSet"] = "ZodSet";
      ZodFirstPartyTypeKind2["ZodFunction"] = "ZodFunction";
      ZodFirstPartyTypeKind2["ZodLazy"] = "ZodLazy";
      ZodFirstPartyTypeKind2["ZodLiteral"] = "ZodLiteral";
      ZodFirstPartyTypeKind2["ZodEnum"] = "ZodEnum";
      ZodFirstPartyTypeKind2["ZodEffects"] = "ZodEffects";
      ZodFirstPartyTypeKind2["ZodNativeEnum"] = "ZodNativeEnum";
      ZodFirstPartyTypeKind2["ZodOptional"] = "ZodOptional";
      ZodFirstPartyTypeKind2["ZodNullable"] = "ZodNullable";
      ZodFirstPartyTypeKind2["ZodDefault"] = "ZodDefault";
      ZodFirstPartyTypeKind2["ZodCatch"] = "ZodCatch";
      ZodFirstPartyTypeKind2["ZodPromise"] = "ZodPromise";
      ZodFirstPartyTypeKind2["ZodBranded"] = "ZodBranded";
      ZodFirstPartyTypeKind2["ZodPipeline"] = "ZodPipeline";
      ZodFirstPartyTypeKind2["ZodReadonly"] = "ZodReadonly";
    })(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
    instanceOfType = (cls, params = {
      message: `Input not instance of ${cls.name}`
    }) => custom((data) => data instanceof cls, params);
    stringType = ZodString.create;
    numberType = ZodNumber.create;
    nanType = ZodNaN.create;
    bigIntType = ZodBigInt.create;
    booleanType = ZodBoolean.create;
    dateType = ZodDate.create;
    symbolType = ZodSymbol.create;
    undefinedType = ZodUndefined.create;
    nullType = ZodNull.create;
    anyType = ZodAny.create;
    unknownType = ZodUnknown.create;
    neverType = ZodNever.create;
    voidType = ZodVoid.create;
    arrayType = ZodArray.create;
    objectType = ZodObject.create;
    strictObjectType = ZodObject.strictCreate;
    unionType = ZodUnion.create;
    discriminatedUnionType = ZodDiscriminatedUnion.create;
    intersectionType = ZodIntersection.create;
    tupleType = ZodTuple.create;
    recordType = ZodRecord.create;
    mapType = ZodMap.create;
    setType = ZodSet.create;
    functionType = ZodFunction.create;
    lazyType = ZodLazy.create;
    literalType = ZodLiteral.create;
    enumType = ZodEnum.create;
    nativeEnumType = ZodNativeEnum.create;
    promiseType = ZodPromise.create;
    effectsType = ZodEffects.create;
    optionalType = ZodOptional.create;
    nullableType = ZodNullable.create;
    preprocessType = ZodEffects.createWithPreprocess;
    pipelineType = ZodPipeline.create;
    ostring = () => stringType().optional();
    onumber = () => numberType().optional();
    oboolean = () => booleanType().optional();
    coerce = {
      string: (arg) => ZodString.create({ ...arg, coerce: true }),
      number: (arg) => ZodNumber.create({ ...arg, coerce: true }),
      boolean: (arg) => ZodBoolean.create({
        ...arg,
        coerce: true
      }),
      bigint: (arg) => ZodBigInt.create({ ...arg, coerce: true }),
      date: (arg) => ZodDate.create({ ...arg, coerce: true })
    };
    NEVER = INVALID;
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/external.js
var external_exports = {};
__export(external_exports, {
  BRAND: () => BRAND,
  DIRTY: () => DIRTY,
  EMPTY_PATH: () => EMPTY_PATH,
  INVALID: () => INVALID,
  NEVER: () => NEVER,
  OK: () => OK,
  ParseStatus: () => ParseStatus,
  Schema: () => ZodType,
  ZodAny: () => ZodAny,
  ZodArray: () => ZodArray,
  ZodBigInt: () => ZodBigInt,
  ZodBoolean: () => ZodBoolean,
  ZodBranded: () => ZodBranded,
  ZodCatch: () => ZodCatch,
  ZodDate: () => ZodDate,
  ZodDefault: () => ZodDefault,
  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
  ZodEffects: () => ZodEffects,
  ZodEnum: () => ZodEnum,
  ZodError: () => ZodError,
  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
  ZodFunction: () => ZodFunction,
  ZodIntersection: () => ZodIntersection,
  ZodIssueCode: () => ZodIssueCode,
  ZodLazy: () => ZodLazy,
  ZodLiteral: () => ZodLiteral,
  ZodMap: () => ZodMap,
  ZodNaN: () => ZodNaN,
  ZodNativeEnum: () => ZodNativeEnum,
  ZodNever: () => ZodNever,
  ZodNull: () => ZodNull,
  ZodNullable: () => ZodNullable,
  ZodNumber: () => ZodNumber,
  ZodObject: () => ZodObject,
  ZodOptional: () => ZodOptional,
  ZodParsedType: () => ZodParsedType,
  ZodPipeline: () => ZodPipeline,
  ZodPromise: () => ZodPromise,
  ZodReadonly: () => ZodReadonly,
  ZodRecord: () => ZodRecord,
  ZodSchema: () => ZodType,
  ZodSet: () => ZodSet,
  ZodString: () => ZodString,
  ZodSymbol: () => ZodSymbol,
  ZodTransformer: () => ZodEffects,
  ZodTuple: () => ZodTuple,
  ZodType: () => ZodType,
  ZodUndefined: () => ZodUndefined,
  ZodUnion: () => ZodUnion,
  ZodUnknown: () => ZodUnknown,
  ZodVoid: () => ZodVoid,
  addIssueToContext: () => addIssueToContext,
  any: () => anyType,
  array: () => arrayType,
  bigint: () => bigIntType,
  boolean: () => booleanType,
  coerce: () => coerce,
  custom: () => custom,
  date: () => dateType,
  datetimeRegex: () => datetimeRegex,
  defaultErrorMap: () => en_default,
  discriminatedUnion: () => discriminatedUnionType,
  effect: () => effectsType,
  enum: () => enumType,
  function: () => functionType,
  getErrorMap: () => getErrorMap,
  getParsedType: () => getParsedType,
  instanceof: () => instanceOfType,
  intersection: () => intersectionType,
  isAborted: () => isAborted,
  isAsync: () => isAsync,
  isDirty: () => isDirty,
  isValid: () => isValid,
  late: () => late,
  lazy: () => lazyType,
  literal: () => literalType,
  makeIssue: () => makeIssue,
  map: () => mapType,
  nan: () => nanType,
  nativeEnum: () => nativeEnumType,
  never: () => neverType,
  null: () => nullType,
  nullable: () => nullableType,
  number: () => numberType,
  object: () => objectType,
  objectUtil: () => objectUtil,
  oboolean: () => oboolean,
  onumber: () => onumber,
  optional: () => optionalType,
  ostring: () => ostring,
  pipeline: () => pipelineType,
  preprocess: () => preprocessType,
  promise: () => promiseType,
  quotelessJson: () => quotelessJson,
  record: () => recordType,
  set: () => setType,
  setErrorMap: () => setErrorMap,
  strictObject: () => strictObjectType,
  string: () => stringType,
  symbol: () => symbolType,
  transformer: () => effectsType,
  tuple: () => tupleType,
  undefined: () => undefinedType,
  union: () => unionType,
  unknown: () => unknownType,
  util: () => util,
  void: () => voidType
});
var init_external = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/external.js"() {
    "use strict";
    init_errors2();
    init_parseUtil();
    init_typeAliases();
    init_util();
    init_types();
    init_ZodError();
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/index.js
var init_v3 = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/v3/index.js"() {
    "use strict";
    init_external();
    init_external();
  }
});

// ../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/index.js
var init_esm = __esm({
  "../node_modules/.pnpm/zod@3.25.42/node_modules/zod/dist/esm/index.js"() {
    "use strict";
    init_v3();
    init_v3();
  }
});

// src/serializer/gelSchema.ts
var enumSchema, enumSchemaV1, indexColumn, index2, fk, sequenceSchema, roleSchema, sequenceSquashed, column, checkConstraint, columnSquashed, compositePK, uniqueConstraint, policy, policySquashed, viewWithOption, matViewWithOption, mergedViewWithOption, view, table, schemaHash, kitInternals, gelSchemaExternal, gelSchemaInternal, tableSquashed, gelSchemaSquashed, gelSchema, dryGel;
var init_gelSchema = __esm({
  "src/serializer/gelSchema.ts"() {
    "use strict";
    init_global();
    init_esm();
    enumSchema = objectType({
      name: stringType(),
      schema: stringType(),
      values: stringType().array()
    }).strict();
    enumSchemaV1 = objectType({
      name: stringType(),
      values: recordType(stringType(), stringType())
    }).strict();
    indexColumn = objectType({
      expression: stringType(),
      isExpression: booleanType(),
      asc: booleanType(),
      nulls: stringType().optional(),
      opclass: stringType().optional()
    });
    index2 = objectType({
      name: stringType(),
      columns: indexColumn.array(),
      isUnique: booleanType(),
      with: recordType(stringType(), anyType()).optional(),
      method: stringType().default("btree"),
      where: stringType().optional(),
      concurrently: booleanType().default(false)
    }).strict();
    fk = objectType({
      name: stringType(),
      tableFrom: stringType(),
      columnsFrom: stringType().array(),
      tableTo: stringType(),
      schemaTo: stringType().optional(),
      columnsTo: stringType().array(),
      onUpdate: stringType().optional(),
      onDelete: stringType().optional()
    }).strict();
    sequenceSchema = objectType({
      name: stringType(),
      increment: stringType().optional(),
      minValue: stringType().optional(),
      maxValue: stringType().optional(),
      startWith: stringType().optional(),
      cache: stringType().optional(),
      cycle: booleanType().optional(),
      schema: stringType()
    }).strict();
    roleSchema = objectType({
      name: stringType(),
      createDb: booleanType().optional(),
      createRole: booleanType().optional(),
      inherit: booleanType().optional()
    }).strict();
    sequenceSquashed = objectType({
      name: stringType(),
      schema: stringType(),
      values: stringType()
    }).strict();
    column = objectType({
      name: stringType(),
      type: stringType(),
      typeSchema: stringType().optional(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      default: anyType().optional(),
      isUnique: anyType().optional(),
      uniqueName: stringType().optional(),
      nullsNotDistinct: booleanType().optional(),
      generated: objectType({
        type: literalType("stored"),
        as: stringType()
      }).optional(),
      identity: sequenceSchema.merge(objectType({ type: enumType(["always", "byDefault"]) })).optional()
    }).strict();
    checkConstraint = objectType({
      name: stringType(),
      value: stringType()
    }).strict();
    columnSquashed = objectType({
      name: stringType(),
      type: stringType(),
      typeSchema: stringType().optional(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      default: anyType().optional(),
      isUnique: anyType().optional(),
      uniqueName: stringType().optional(),
      nullsNotDistinct: booleanType().optional(),
      generated: objectType({
        type: literalType("stored"),
        as: stringType()
      }).optional(),
      identity: stringType().optional()
    }).strict();
    compositePK = objectType({
      name: stringType(),
      columns: stringType().array()
    }).strict();
    uniqueConstraint = objectType({
      name: stringType(),
      columns: stringType().array(),
      nullsNotDistinct: booleanType()
    }).strict();
    policy = objectType({
      name: stringType(),
      as: enumType(["PERMISSIVE", "RESTRICTIVE"]).optional(),
      for: enumType(["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]).optional(),
      to: stringType().array().optional(),
      using: stringType().optional(),
      withCheck: stringType().optional(),
      on: stringType().optional(),
      schema: stringType().optional()
    }).strict();
    policySquashed = objectType({
      name: stringType(),
      values: stringType()
    }).strict();
    viewWithOption = objectType({
      checkOption: enumType(["local", "cascaded"]).optional(),
      securityBarrier: booleanType().optional(),
      securityInvoker: booleanType().optional()
    }).strict();
    matViewWithOption = objectType({
      fillfactor: numberType().optional(),
      toastTupleTarget: numberType().optional(),
      parallelWorkers: numberType().optional(),
      autovacuumEnabled: booleanType().optional(),
      vacuumIndexCleanup: enumType(["auto", "off", "on"]).optional(),
      vacuumTruncate: booleanType().optional(),
      autovacuumVacuumThreshold: numberType().optional(),
      autovacuumVacuumScaleFactor: numberType().optional(),
      autovacuumVacuumCostDelay: numberType().optional(),
      autovacuumVacuumCostLimit: numberType().optional(),
      autovacuumFreezeMinAge: numberType().optional(),
      autovacuumFreezeMaxAge: numberType().optional(),
      autovacuumFreezeTableAge: numberType().optional(),
      autovacuumMultixactFreezeMinAge: numberType().optional(),
      autovacuumMultixactFreezeMaxAge: numberType().optional(),
      autovacuumMultixactFreezeTableAge: numberType().optional(),
      logAutovacuumMinDuration: numberType().optional(),
      userCatalogTable: booleanType().optional()
    }).strict();
    mergedViewWithOption = viewWithOption.merge(matViewWithOption).strict();
    view = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column),
      definition: stringType().optional(),
      materialized: booleanType(),
      with: mergedViewWithOption.optional(),
      isExisting: booleanType(),
      withNoData: booleanType().optional(),
      using: stringType().optional(),
      tablespace: stringType().optional()
    }).strict();
    table = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column),
      indexes: recordType(stringType(), index2),
      foreignKeys: recordType(stringType(), fk),
      compositePrimaryKeys: recordType(stringType(), compositePK),
      uniqueConstraints: recordType(stringType(), uniqueConstraint).default({}),
      policies: recordType(stringType(), policy).default({}),
      checkConstraints: recordType(stringType(), checkConstraint).default({}),
      isRLSEnabled: booleanType().default(false)
    }).strict();
    schemaHash = objectType({
      id: stringType(),
      prevId: stringType()
    });
    kitInternals = objectType({
      tables: recordType(
        stringType(),
        objectType({
          columns: recordType(
            stringType(),
            objectType({
              isArray: booleanType().optional(),
              dimensions: numberType().optional(),
              rawType: stringType().optional(),
              isDefaultAnExpression: booleanType().optional()
            }).optional()
          )
        }).optional()
      )
    }).optional();
    gelSchemaExternal = objectType({
      version: literalType("1"),
      dialect: literalType("gel"),
      tables: arrayType(table),
      enums: arrayType(enumSchemaV1),
      schemas: arrayType(objectType({ name: stringType() })),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      })
    }).strict();
    gelSchemaInternal = objectType({
      version: literalType("1"),
      dialect: literalType("gel"),
      tables: recordType(stringType(), table),
      enums: recordType(stringType(), enumSchema),
      schemas: recordType(stringType(), stringType()),
      views: recordType(stringType(), view).default({}),
      sequences: recordType(stringType(), sequenceSchema).default({}),
      roles: recordType(stringType(), roleSchema).default({}),
      policies: recordType(stringType(), policy).default({}),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals
    }).strict();
    tableSquashed = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), columnSquashed),
      indexes: recordType(stringType(), stringType()),
      foreignKeys: recordType(stringType(), stringType()),
      compositePrimaryKeys: recordType(stringType(), stringType()),
      uniqueConstraints: recordType(stringType(), stringType()),
      policies: recordType(stringType(), stringType()),
      checkConstraints: recordType(stringType(), stringType()),
      isRLSEnabled: booleanType().default(false)
    }).strict();
    gelSchemaSquashed = objectType({
      version: literalType("1"),
      dialect: literalType("gel"),
      tables: recordType(stringType(), tableSquashed),
      enums: recordType(stringType(), enumSchema),
      schemas: recordType(stringType(), stringType()),
      views: recordType(stringType(), view),
      sequences: recordType(stringType(), sequenceSquashed),
      roles: recordType(stringType(), roleSchema).default({}),
      policies: recordType(stringType(), policySquashed).default({})
    }).strict();
    gelSchema = gelSchemaInternal.merge(schemaHash);
    dryGel = gelSchema.parse({
      version: "1",
      dialect: "gel",
      id: originUUID,
      prevId: "",
      tables: {},
      enums: {},
      schemas: {},
      policies: {},
      roles: {},
      sequences: {},
      _meta: {
        schemas: {},
        tables: {},
        columns: {}
      }
    });
  }
});

// src/serializer/mysqlSchema.ts
var index3, fk2, column2, tableV3, compositePK2, uniqueConstraint2, checkConstraint2, tableV4, table2, viewMeta, view2, kitInternals2, dialect, schemaHash2, schemaInternalV3, schemaInternalV4, schemaInternalV5, schemaInternal, schemaV3, schemaV4, schemaV5, schema, tableSquashedV4, tableSquashed2, viewSquashed, schemaSquashed, schemaSquashedV4, MySqlSquasher, squashMysqlScheme, mysqlSchema, mysqlSchemaV5, mysqlSchemaSquashed, backwardCompatibleMysqlSchema, dryMySql;
var init_mysqlSchema = __esm({
  "src/serializer/mysqlSchema.ts"() {
    "use strict";
    init_esm();
    init_global();
    index3 = objectType({
      name: stringType(),
      columns: stringType().array(),
      isUnique: booleanType(),
      using: enumType(["btree", "hash"]).optional(),
      algorithm: enumType(["default", "inplace", "copy"]).optional(),
      lock: enumType(["default", "none", "shared", "exclusive"]).optional()
    }).strict();
    fk2 = objectType({
      name: stringType(),
      tableFrom: stringType(),
      columnsFrom: stringType().array(),
      tableTo: stringType(),
      columnsTo: stringType().array(),
      onUpdate: stringType().optional(),
      onDelete: stringType().optional()
    }).strict();
    column2 = objectType({
      name: stringType(),
      type: stringType(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      autoincrement: booleanType().optional(),
      default: anyType().optional(),
      onUpdate: anyType().optional(),
      generated: objectType({
        type: enumType(["stored", "virtual"]),
        as: stringType()
      }).optional()
    }).strict();
    tableV3 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column2),
      indexes: recordType(stringType(), index3),
      foreignKeys: recordType(stringType(), fk2)
    }).strict();
    compositePK2 = objectType({
      name: stringType(),
      columns: stringType().array()
    }).strict();
    uniqueConstraint2 = objectType({
      name: stringType(),
      columns: stringType().array()
    }).strict();
    checkConstraint2 = objectType({
      name: stringType(),
      value: stringType()
    }).strict();
    tableV4 = objectType({
      name: stringType(),
      schema: stringType().optional(),
      columns: recordType(stringType(), column2),
      indexes: recordType(stringType(), index3),
      foreignKeys: recordType(stringType(), fk2)
    }).strict();
    table2 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column2),
      indexes: recordType(stringType(), index3),
      foreignKeys: recordType(stringType(), fk2),
      compositePrimaryKeys: recordType(stringType(), compositePK2),
      uniqueConstraints: recordType(stringType(), uniqueConstraint2).default({}),
      checkConstraint: recordType(stringType(), checkConstraint2).default({})
    }).strict();
    viewMeta = objectType({
      algorithm: enumType(["undefined", "merge", "temptable"]),
      sqlSecurity: enumType(["definer", "invoker"]),
      withCheckOption: enumType(["local", "cascaded"]).optional()
    }).strict();
    view2 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column2),
      definition: stringType().optional(),
      isExisting: booleanType()
    }).strict().merge(viewMeta);
    kitInternals2 = objectType({
      tables: recordType(
        stringType(),
        objectType({
          columns: recordType(
            stringType(),
            objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
          )
        }).optional()
      ).optional(),
      indexes: recordType(
        stringType(),
        objectType({
          columns: recordType(
            stringType(),
            objectType({ isExpression: booleanType().optional() }).optional()
          )
        }).optional()
      ).optional()
    }).optional();
    dialect = literalType("mysql");
    schemaHash2 = objectType({
      id: stringType(),
      prevId: stringType()
    });
    schemaInternalV3 = objectType({
      version: literalType("3"),
      dialect,
      tables: recordType(stringType(), tableV3)
    }).strict();
    schemaInternalV4 = objectType({
      version: literalType("4"),
      dialect,
      tables: recordType(stringType(), tableV4),
      schemas: recordType(stringType(), stringType())
    }).strict();
    schemaInternalV5 = objectType({
      version: literalType("5"),
      dialect,
      tables: recordType(stringType(), table2),
      schemas: recordType(stringType(), stringType()),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals2
    }).strict();
    schemaInternal = objectType({
      version: literalType("5"),
      dialect,
      tables: recordType(stringType(), table2),
      views: recordType(stringType(), view2).default({}),
      _meta: objectType({
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals2
    }).strict();
    schemaV3 = schemaInternalV3.merge(schemaHash2);
    schemaV4 = schemaInternalV4.merge(schemaHash2);
    schemaV5 = schemaInternalV5.merge(schemaHash2);
    schema = schemaInternal.merge(schemaHash2);
    tableSquashedV4 = objectType({
      name: stringType(),
      schema: stringType().optional(),
      columns: recordType(stringType(), column2),
      indexes: recordType(stringType(), stringType()),
      foreignKeys: recordType(stringType(), stringType())
    }).strict();
    tableSquashed2 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column2),
      indexes: recordType(stringType(), stringType()),
      foreignKeys: recordType(stringType(), stringType()),
      compositePrimaryKeys: recordType(stringType(), stringType()),
      uniqueConstraints: recordType(stringType(), stringType()).default({}),
      checkConstraints: recordType(stringType(), stringType()).default({})
    }).strict();
    viewSquashed = view2.omit({
      algorithm: true,
      sqlSecurity: true,
      withCheckOption: true
    }).extend({ meta: stringType() });
    schemaSquashed = objectType({
      version: literalType("5"),
      dialect,
      tables: recordType(stringType(), tableSquashed2),
      views: recordType(stringType(), viewSquashed)
    }).strict();
    schemaSquashedV4 = objectType({
      version: literalType("4"),
      dialect,
      tables: recordType(stringType(), tableSquashedV4),
      schemas: recordType(stringType(), stringType())
    }).strict();
    MySqlSquasher = {
      squashIdx: (idx) => {
        index3.parse(idx);
        return `${idx.name};${idx.columns.join(",")};${idx.isUnique};${idx.using ?? ""};${idx.algorithm ?? ""};${idx.lock ?? ""}`;
      },
      unsquashIdx: (input) => {
        const [name3, columnsString, isUnique, using, algorithm, lock] = input.split(";");
        const destructed = {
          name: name3,
          columns: columnsString.split(","),
          isUnique: isUnique === "true",
          using: using ? using : void 0,
          algorithm: algorithm ? algorithm : void 0,
          lock: lock ? lock : void 0
        };
        return index3.parse(destructed);
      },
      squashPK: (pk) => {
        return `${pk.name};${pk.columns.join(",")}`;
      },
      unsquashPK: (pk) => {
        const splitted = pk.split(";");
        return { name: splitted[0], columns: splitted[1].split(",") };
      },
      squashUnique: (unq) => {
        return `${unq.name};${unq.columns.join(",")}`;
      },
      unsquashUnique: (unq) => {
        const [name3, columns] = unq.split(";");
        return { name: name3, columns: columns.split(",") };
      },
      squashFK: (fk5) => {
        return `${fk5.name};${fk5.tableFrom};${fk5.columnsFrom.join(",")};${fk5.tableTo};${fk5.columnsTo.join(",")};${fk5.onUpdate ?? ""};${fk5.onDelete ?? ""}`;
      },
      unsquashFK: (input) => {
        const [
          name3,
          tableFrom,
          columnsFromStr,
          tableTo,
          columnsToStr,
          onUpdate,
          onDelete
        ] = input.split(";");
        const result = fk2.parse({
          name: name3,
          tableFrom,
          columnsFrom: columnsFromStr.split(","),
          tableTo,
          columnsTo: columnsToStr.split(","),
          onUpdate,
          onDelete
        });
        return result;
      },
      squashCheck: (input) => {
        return `${input.name};${input.value}`;
      },
      unsquashCheck: (input) => {
        const [name3, value] = input.split(";");
        return { name: name3, value };
      },
      squashView: (view5) => {
        return `${view5.algorithm};${view5.sqlSecurity};${view5.withCheckOption}`;
      },
      unsquashView: (meta) => {
        const [algorithm, sqlSecurity, withCheckOption] = meta.split(";");
        const toReturn = {
          algorithm,
          sqlSecurity,
          withCheckOption: withCheckOption !== "undefined" ? withCheckOption : void 0
        };
        return viewMeta.parse(toReturn);
      }
    };
    squashMysqlScheme = (json4) => {
      const mappedTables = Object.fromEntries(
        Object.entries(json4.tables).map((it2) => {
          const squashedIndexes = mapValues(it2[1].indexes, (index7) => {
            return MySqlSquasher.squashIdx(index7);
          });
          const squashedFKs = mapValues(it2[1].foreignKeys, (fk5) => {
            return MySqlSquasher.squashFK(fk5);
          });
          const squashedPKs = mapValues(it2[1].compositePrimaryKeys, (pk) => {
            return MySqlSquasher.squashPK(pk);
          });
          const squashedUniqueConstraints = mapValues(
            it2[1].uniqueConstraints,
            (unq) => {
              return MySqlSquasher.squashUnique(unq);
            }
          );
          const squashedCheckConstraints = mapValues(it2[1].checkConstraint, (check2) => {
            return MySqlSquasher.squashCheck(check2);
          });
          return [
            it2[0],
            {
              name: it2[1].name,
              columns: it2[1].columns,
              indexes: squashedIndexes,
              foreignKeys: squashedFKs,
              compositePrimaryKeys: squashedPKs,
              uniqueConstraints: squashedUniqueConstraints,
              checkConstraints: squashedCheckConstraints
            }
          ];
        })
      );
      const mappedViews = Object.fromEntries(
        Object.entries(json4.views).map(([key, value]) => {
          const meta = MySqlSquasher.squashView(value);
          return [key, {
            name: value.name,
            isExisting: value.isExisting,
            columns: value.columns,
            definition: value.definition,
            meta
          }];
        })
      );
      return {
        version: "5",
        dialect: json4.dialect,
        tables: mappedTables,
        views: mappedViews
      };
    };
    mysqlSchema = schema;
    mysqlSchemaV5 = schemaV5;
    mysqlSchemaSquashed = schemaSquashed;
    backwardCompatibleMysqlSchema = unionType([mysqlSchemaV5, schema]);
    dryMySql = mysqlSchema.parse({
      version: "5",
      dialect: "mysql",
      id: originUUID,
      prevId: "",
      tables: {},
      schemas: {},
      views: {},
      _meta: {
        schemas: {},
        tables: {},
        columns: {}
      }
    });
  }
});

// src/serializer/pgSchema.ts
var indexV2, columnV2, tableV2, enumSchemaV12, enumSchema2, pgSchemaV2, references, columnV1, tableV1, pgSchemaV1, indexColumn2, index4, indexV4, indexV5, indexV6, fk3, sequenceSchema2, roleSchema2, sequenceSquashed2, columnV7, column3, checkConstraint3, columnSquashed2, tableV32, compositePK3, uniqueConstraint3, policy2, policySquashed2, viewWithOption2, matViewWithOption2, mergedViewWithOption2, view3, tableV42, tableV5, tableV6, tableV7, table3, schemaHash3, kitInternals3, pgSchemaInternalV3, pgSchemaInternalV4, pgSchemaInternalV5, pgSchemaInternalV6, pgSchemaExternal, pgSchemaInternalV7, pgSchemaInternal, tableSquashed3, tableSquashedV42, pgSchemaSquashedV4, pgSchemaSquashedV6, pgSchemaSquashed, pgSchemaV3, pgSchemaV4, pgSchemaV5, pgSchemaV6, pgSchemaV7, pgSchema2, backwardCompatiblePgSchema, PgSquasher, squashPgScheme, dryPg;
var init_pgSchema = __esm({
  "src/serializer/pgSchema.ts"() {
    "use strict";
    init_global();
    init_esm();
    indexV2 = objectType({
      name: stringType(),
      columns: recordType(
        stringType(),
        objectType({
          name: stringType()
        })
      ),
      isUnique: booleanType()
    }).strict();
    columnV2 = objectType({
      name: stringType(),
      type: stringType(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      default: anyType().optional(),
      references: stringType().optional()
    }).strict();
    tableV2 = objectType({
      name: stringType(),
      columns: recordType(stringType(), columnV2),
      indexes: recordType(stringType(), indexV2)
    }).strict();
    enumSchemaV12 = objectType({
      name: stringType(),
      values: recordType(stringType(), stringType())
    }).strict();
    enumSchema2 = objectType({
      name: stringType(),
      schema: stringType(),
      values: stringType().array()
    }).strict();
    pgSchemaV2 = objectType({
      version: literalType("2"),
      tables: recordType(stringType(), tableV2),
      enums: recordType(stringType(), enumSchemaV12)
    }).strict();
    references = objectType({
      foreignKeyName: stringType(),
      table: stringType(),
      column: stringType(),
      onDelete: stringType().optional(),
      onUpdate: stringType().optional()
    }).strict();
    columnV1 = objectType({
      name: stringType(),
      type: stringType(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      default: anyType().optional(),
      references: references.optional()
    }).strict();
    tableV1 = objectType({
      name: stringType(),
      columns: recordType(stringType(), columnV1),
      indexes: recordType(stringType(), indexV2)
    }).strict();
    pgSchemaV1 = objectType({
      version: literalType("1"),
      tables: recordType(stringType(), tableV1),
      enums: recordType(stringType(), enumSchemaV12)
    }).strict();
    indexColumn2 = objectType({
      expression: stringType(),
      isExpression: booleanType(),
      asc: booleanType(),
      nulls: stringType().optional(),
      opclass: stringType().optional()
    });
    index4 = objectType({
      name: stringType(),
      columns: indexColumn2.array(),
      isUnique: booleanType(),
      with: recordType(stringType(), anyType()).optional(),
      method: stringType().default("btree"),
      where: stringType().optional(),
      concurrently: booleanType().default(false)
    }).strict();
    indexV4 = objectType({
      name: stringType(),
      columns: stringType().array(),
      isUnique: booleanType(),
      with: recordType(stringType(), stringType()).optional(),
      method: stringType().default("btree"),
      where: stringType().optional(),
      concurrently: booleanType().default(false)
    }).strict();
    indexV5 = objectType({
      name: stringType(),
      columns: stringType().array(),
      isUnique: booleanType(),
      with: recordType(stringType(), stringType()).optional(),
      method: stringType().default("btree"),
      where: stringType().optional(),
      concurrently: booleanType().default(false)
    }).strict();
    indexV6 = objectType({
      name: stringType(),
      columns: stringType().array(),
      isUnique: booleanType(),
      with: recordType(stringType(), stringType()).optional(),
      method: stringType().default("btree"),
      where: stringType().optional(),
      concurrently: booleanType().default(false)
    }).strict();
    fk3 = objectType({
      name: stringType(),
      tableFrom: stringType(),
      columnsFrom: stringType().array(),
      tableTo: stringType(),
      schemaTo: stringType().optional(),
      columnsTo: stringType().array(),
      onUpdate: stringType().optional(),
      onDelete: stringType().optional()
    }).strict();
    sequenceSchema2 = objectType({
      name: stringType(),
      increment: stringType().optional(),
      minValue: stringType().optional(),
      maxValue: stringType().optional(),
      startWith: stringType().optional(),
      cache: stringType().optional(),
      cycle: booleanType().optional(),
      schema: stringType()
    }).strict();
    roleSchema2 = objectType({
      name: stringType(),
      createDb: booleanType().optional(),
      createRole: booleanType().optional(),
      inherit: booleanType().optional()
    }).strict();
    sequenceSquashed2 = objectType({
      name: stringType(),
      schema: stringType(),
      values: stringType()
    }).strict();
    columnV7 = objectType({
      name: stringType(),
      type: stringType(),
      typeSchema: stringType().optional(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      default: anyType().optional(),
      isUnique: anyType().optional(),
      uniqueName: stringType().optional(),
      nullsNotDistinct: booleanType().optional()
    }).strict();
    column3 = objectType({
      name: stringType(),
      type: stringType(),
      typeSchema: stringType().optional(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      default: anyType().optional(),
      isUnique: anyType().optional(),
      uniqueName: stringType().optional(),
      nullsNotDistinct: booleanType().optional(),
      generated: objectType({
        type: literalType("stored"),
        as: stringType()
      }).optional(),
      identity: sequenceSchema2.merge(objectType({ type: enumType(["always", "byDefault"]) })).optional()
    }).strict();
    checkConstraint3 = objectType({
      name: stringType(),
      value: stringType()
    }).strict();
    columnSquashed2 = objectType({
      name: stringType(),
      type: stringType(),
      typeSchema: stringType().optional(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      default: anyType().optional(),
      isUnique: anyType().optional(),
      uniqueName: stringType().optional(),
      nullsNotDistinct: booleanType().optional(),
      generated: objectType({
        type: literalType("stored"),
        as: stringType()
      }).optional(),
      identity: stringType().optional()
    }).strict();
    tableV32 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column3),
      indexes: recordType(stringType(), index4),
      foreignKeys: recordType(stringType(), fk3)
    }).strict();
    compositePK3 = objectType({
      name: stringType(),
      columns: stringType().array()
    }).strict();
    uniqueConstraint3 = objectType({
      name: stringType(),
      columns: stringType().array(),
      nullsNotDistinct: booleanType()
    }).strict();
    policy2 = objectType({
      name: stringType(),
      as: enumType(["PERMISSIVE", "RESTRICTIVE"]).optional(),
      for: enumType(["ALL", "SELECT", "INSERT", "UPDATE", "DELETE"]).optional(),
      to: stringType().array().optional(),
      using: stringType().optional(),
      withCheck: stringType().optional(),
      on: stringType().optional(),
      schema: stringType().optional()
    }).strict();
    policySquashed2 = objectType({
      name: stringType(),
      values: stringType()
    }).strict();
    viewWithOption2 = objectType({
      checkOption: enumType(["local", "cascaded"]).optional(),
      securityBarrier: booleanType().optional(),
      securityInvoker: booleanType().optional()
    }).strict();
    matViewWithOption2 = objectType({
      fillfactor: numberType().optional(),
      toastTupleTarget: numberType().optional(),
      parallelWorkers: numberType().optional(),
      autovacuumEnabled: booleanType().optional(),
      vacuumIndexCleanup: enumType(["auto", "off", "on"]).optional(),
      vacuumTruncate: booleanType().optional(),
      autovacuumVacuumThreshold: numberType().optional(),
      autovacuumVacuumScaleFactor: numberType().optional(),
      autovacuumVacuumCostDelay: numberType().optional(),
      autovacuumVacuumCostLimit: numberType().optional(),
      autovacuumFreezeMinAge: numberType().optional(),
      autovacuumFreezeMaxAge: numberType().optional(),
      autovacuumFreezeTableAge: numberType().optional(),
      autovacuumMultixactFreezeMinAge: numberType().optional(),
      autovacuumMultixactFreezeMaxAge: numberType().optional(),
      autovacuumMultixactFreezeTableAge: numberType().optional(),
      logAutovacuumMinDuration: numberType().optional(),
      userCatalogTable: booleanType().optional()
    }).strict();
    mergedViewWithOption2 = viewWithOption2.merge(matViewWithOption2).strict();
    view3 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column3),
      definition: stringType().optional(),
      materialized: booleanType(),
      with: mergedViewWithOption2.optional(),
      isExisting: booleanType(),
      withNoData: booleanType().optional(),
      using: stringType().optional(),
      tablespace: stringType().optional()
    }).strict();
    tableV42 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column3),
      indexes: recordType(stringType(), indexV4),
      foreignKeys: recordType(stringType(), fk3)
    }).strict();
    tableV5 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column3),
      indexes: recordType(stringType(), indexV5),
      foreignKeys: recordType(stringType(), fk3),
      compositePrimaryKeys: recordType(stringType(), compositePK3),
      uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
    }).strict();
    tableV6 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column3),
      indexes: recordType(stringType(), indexV6),
      foreignKeys: recordType(stringType(), fk3),
      compositePrimaryKeys: recordType(stringType(), compositePK3),
      uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
    }).strict();
    tableV7 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), columnV7),
      indexes: recordType(stringType(), index4),
      foreignKeys: recordType(stringType(), fk3),
      compositePrimaryKeys: recordType(stringType(), compositePK3),
      uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({})
    }).strict();
    table3 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column3),
      indexes: recordType(stringType(), index4),
      foreignKeys: recordType(stringType(), fk3),
      compositePrimaryKeys: recordType(stringType(), compositePK3),
      uniqueConstraints: recordType(stringType(), uniqueConstraint3).default({}),
      policies: recordType(stringType(), policy2).default({}),
      checkConstraints: recordType(stringType(), checkConstraint3).default({}),
      isRLSEnabled: booleanType().default(false)
    }).strict();
    schemaHash3 = objectType({
      id: stringType(),
      prevId: stringType()
    });
    kitInternals3 = objectType({
      tables: recordType(
        stringType(),
        objectType({
          columns: recordType(
            stringType(),
            objectType({
              isArray: booleanType().optional(),
              dimensions: numberType().optional(),
              rawType: stringType().optional(),
              isDefaultAnExpression: booleanType().optional()
            }).optional()
          )
        }).optional()
      )
    }).optional();
    pgSchemaInternalV3 = objectType({
      version: literalType("3"),
      dialect: literalType("pg"),
      tables: recordType(stringType(), tableV32),
      enums: recordType(stringType(), enumSchemaV12)
    }).strict();
    pgSchemaInternalV4 = objectType({
      version: literalType("4"),
      dialect: literalType("pg"),
      tables: recordType(stringType(), tableV42),
      enums: recordType(stringType(), enumSchemaV12),
      schemas: recordType(stringType(), stringType())
    }).strict();
    pgSchemaInternalV5 = objectType({
      version: literalType("5"),
      dialect: literalType("pg"),
      tables: recordType(stringType(), tableV5),
      enums: recordType(stringType(), enumSchemaV12),
      schemas: recordType(stringType(), stringType()),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals3
    }).strict();
    pgSchemaInternalV6 = objectType({
      version: literalType("6"),
      dialect: literalType("postgresql"),
      tables: recordType(stringType(), tableV6),
      enums: recordType(stringType(), enumSchema2),
      schemas: recordType(stringType(), stringType()),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals3
    }).strict();
    pgSchemaExternal = objectType({
      version: literalType("5"),
      dialect: literalType("pg"),
      tables: arrayType(table3),
      enums: arrayType(enumSchemaV12),
      schemas: arrayType(objectType({ name: stringType() })),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      })
    }).strict();
    pgSchemaInternalV7 = objectType({
      version: literalType("7"),
      dialect: literalType("postgresql"),
      tables: recordType(stringType(), tableV7),
      enums: recordType(stringType(), enumSchema2),
      schemas: recordType(stringType(), stringType()),
      sequences: recordType(stringType(), sequenceSchema2),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals3
    }).strict();
    pgSchemaInternal = objectType({
      version: literalType("7"),
      dialect: literalType("postgresql"),
      tables: recordType(stringType(), table3),
      enums: recordType(stringType(), enumSchema2),
      schemas: recordType(stringType(), stringType()),
      views: recordType(stringType(), view3).default({}),
      sequences: recordType(stringType(), sequenceSchema2).default({}),
      roles: recordType(stringType(), roleSchema2).default({}),
      policies: recordType(stringType(), policy2).default({}),
      _meta: objectType({
        schemas: recordType(stringType(), stringType()),
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals3
    }).strict();
    tableSquashed3 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), columnSquashed2),
      indexes: recordType(stringType(), stringType()),
      foreignKeys: recordType(stringType(), stringType()),
      compositePrimaryKeys: recordType(stringType(), stringType()),
      uniqueConstraints: recordType(stringType(), stringType()),
      policies: recordType(stringType(), stringType()),
      checkConstraints: recordType(stringType(), stringType()),
      isRLSEnabled: booleanType().default(false)
    }).strict();
    tableSquashedV42 = objectType({
      name: stringType(),
      schema: stringType(),
      columns: recordType(stringType(), column3),
      indexes: recordType(stringType(), stringType()),
      foreignKeys: recordType(stringType(), stringType())
    }).strict();
    pgSchemaSquashedV4 = objectType({
      version: literalType("4"),
      dialect: literalType("pg"),
      tables: recordType(stringType(), tableSquashedV42),
      enums: recordType(stringType(), enumSchemaV12),
      schemas: recordType(stringType(), stringType())
    }).strict();
    pgSchemaSquashedV6 = objectType({
      version: literalType("6"),
      dialect: literalType("postgresql"),
      tables: recordType(stringType(), tableSquashed3),
      enums: recordType(stringType(), enumSchema2),
      schemas: recordType(stringType(), stringType())
    }).strict();
    pgSchemaSquashed = objectType({
      version: literalType("7"),
      dialect: literalType("postgresql"),
      tables: recordType(stringType(), tableSquashed3),
      enums: recordType(stringType(), enumSchema2),
      schemas: recordType(stringType(), stringType()),
      views: recordType(stringType(), view3),
      sequences: recordType(stringType(), sequenceSquashed2),
      roles: recordType(stringType(), roleSchema2).default({}),
      policies: recordType(stringType(), policySquashed2).default({})
    }).strict();
    pgSchemaV3 = pgSchemaInternalV3.merge(schemaHash3);
    pgSchemaV4 = pgSchemaInternalV4.merge(schemaHash3);
    pgSchemaV5 = pgSchemaInternalV5.merge(schemaHash3);
    pgSchemaV6 = pgSchemaInternalV6.merge(schemaHash3);
    pgSchemaV7 = pgSchemaInternalV7.merge(schemaHash3);
    pgSchema2 = pgSchemaInternal.merge(schemaHash3);
    backwardCompatiblePgSchema = unionType([
      pgSchemaV5,
      pgSchemaV6,
      pgSchema2
    ]);
    PgSquasher = {
      squashIdx: (idx) => {
        index4.parse(idx);
        return `${idx.name};${idx.columns.map(
          (c6) => `${c6.expression}--${c6.isExpression}--${c6.asc}--${c6.nulls}--${c6.opclass ? c6.opclass : ""}`
        ).join(",,")};${idx.isUnique};${idx.concurrently};${idx.method};${idx.where};${JSON.stringify(idx.with)}`;
      },
      unsquashIdx: (input) => {
        const [
          name3,
          columnsString,
          isUnique,
          concurrently,
          method,
          where,
          idxWith
        ] = input.split(";");
        const columnString = columnsString.split(",,");
        const columns = [];
        for (const column6 of columnString) {
          const [expression, isExpression, asc2, nulls, opclass] = column6.split("--");
          columns.push({
            nulls,
            isExpression: isExpression === "true",
            asc: asc2 === "true",
            expression,
            opclass: opclass === "undefined" ? void 0 : opclass
          });
        }
        const result = index4.parse({
          name: name3,
          columns,
          isUnique: isUnique === "true",
          concurrently: concurrently === "true",
          method,
          where: where === "undefined" ? void 0 : where,
          with: !idxWith || idxWith === "undefined" ? void 0 : JSON.parse(idxWith)
        });
        return result;
      },
      squashIdxPush: (idx) => {
        index4.parse(idx);
        return `${idx.name};${idx.columns.map((c6) => `${c6.isExpression ? "" : c6.expression}--${c6.asc}--${c6.nulls}`).join(",,")};${idx.isUnique};${idx.method};${JSON.stringify(idx.with)}`;
      },
      unsquashIdxPush: (input) => {
        const [name3, columnsString, isUnique, method, idxWith] = input.split(";");
        const columnString = columnsString.split("--");
        const columns = [];
        for (const column6 of columnString) {
          const [expression, asc2, nulls, opclass] = column6.split(",");
          columns.push({
            nulls,
            isExpression: expression === "",
            asc: asc2 === "true",
            expression
          });
        }
        const result = index4.parse({
          name: name3,
          columns,
          isUnique: isUnique === "true",
          concurrently: false,
          method,
          with: idxWith === "undefined" ? void 0 : JSON.parse(idxWith)
        });
        return result;
      },
      squashFK: (fk5) => {
        return `${fk5.name};${fk5.tableFrom};${fk5.columnsFrom.join(",")};${fk5.tableTo};${fk5.columnsTo.join(",")};${fk5.onUpdate ?? ""};${fk5.onDelete ?? ""};${fk5.schemaTo || "public"}`;
      },
      squashPolicy: (policy5) => {
        return `${policy5.name}--${policy5.as}--${policy5.for}--${policy5.to?.join(",")}--${policy5.using}--${policy5.withCheck}--${policy5.on}`;
      },
      unsquashPolicy: (policy5) => {
        const splitted = policy5.split("--");
        return {
          name: splitted[0],
          as: splitted[1],
          for: splitted[2],
          to: splitted[3].split(","),
          using: splitted[4] !== "undefined" ? splitted[4] : void 0,
          withCheck: splitted[5] !== "undefined" ? splitted[5] : void 0,
          on: splitted[6] !== "undefined" ? splitted[6] : void 0
        };
      },
      squashPolicyPush: (policy5) => {
        return `${policy5.name}--${policy5.as}--${policy5.for}--${policy5.to?.join(",")}--${policy5.on}`;
      },
      unsquashPolicyPush: (policy5) => {
        const splitted = policy5.split("--");
        return {
          name: splitted[0],
          as: splitted[1],
          for: splitted[2],
          to: splitted[3].split(","),
          on: splitted[4] !== "undefined" ? splitted[4] : void 0
        };
      },
      squashPK: (pk) => {
        return `${pk.columns.join(",")};${pk.name}`;
      },
      unsquashPK: (pk) => {
        const splitted = pk.split(";");
        return { name: splitted[1], columns: splitted[0].split(",") };
      },
      squashUnique: (unq) => {
        return `${unq.name};${unq.columns.join(",")};${unq.nullsNotDistinct}`;
      },
      unsquashUnique: (unq) => {
        const [name3, columns, nullsNotDistinct] = unq.split(";");
        return {
          name: name3,
          columns: columns.split(","),
          nullsNotDistinct: nullsNotDistinct === "true"
        };
      },
      unsquashFK: (input) => {
        const [
          name3,
          tableFrom,
          columnsFromStr,
          tableTo,
          columnsToStr,
          onUpdate,
          onDelete,
          schemaTo
        ] = input.split(";");
        const result = fk3.parse({
          name: name3,
          tableFrom,
          columnsFrom: columnsFromStr.split(","),
          schemaTo,
          tableTo,
          columnsTo: columnsToStr.split(","),
          onUpdate,
          onDelete
        });
        return result;
      },
      squashSequence: (seq) => {
        return `${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${seq.cycle ?? ""}`;
      },
      unsquashSequence: (seq) => {
        const splitted = seq.split(";");
        return {
          minValue: splitted[0] !== "undefined" ? splitted[0] : void 0,
          maxValue: splitted[1] !== "undefined" ? splitted[1] : void 0,
          increment: splitted[2] !== "undefined" ? splitted[2] : void 0,
          startWith: splitted[3] !== "undefined" ? splitted[3] : void 0,
          cache: splitted[4] !== "undefined" ? splitted[4] : void 0,
          cycle: splitted[5] === "true"
        };
      },
      squashIdentity: (seq) => {
        return `${seq.name};${seq.type};${seq.minValue};${seq.maxValue};${seq.increment};${seq.startWith};${seq.cache};${seq.cycle ?? ""}`;
      },
      unsquashIdentity: (seq) => {
        const splitted = seq.split(";");
        return {
          name: splitted[0],
          type: splitted[1],
          minValue: splitted[2] !== "undefined" ? splitted[2] : void 0,
          maxValue: splitted[3] !== "undefined" ? splitted[3] : void 0,
          increment: splitted[4] !== "undefined" ? splitted[4] : void 0,
          startWith: splitted[5] !== "undefined" ? splitted[5] : void 0,
          cache: splitted[6] !== "undefined" ? splitted[6] : void 0,
          cycle: splitted[7] === "true"
        };
      },
      squashCheck: (check2) => {
        return `${check2.name};${check2.value}`;
      },
      unsquashCheck: (input) => {
        const [
          name3,
          value
        ] = input.split(";");
        return { name: name3, value };
      }
    };
    squashPgScheme = (json4, action) => {
      const mappedTables = Object.fromEntries(
        Object.entries(json4.tables).map((it2) => {
          const squashedIndexes = mapValues(it2[1].indexes, (index7) => {
            return action === "push" ? PgSquasher.squashIdxPush(index7) : PgSquasher.squashIdx(index7);
          });
          const squashedFKs = mapValues(it2[1].foreignKeys, (fk5) => {
            return PgSquasher.squashFK(fk5);
          });
          const squashedPKs = mapValues(it2[1].compositePrimaryKeys, (pk) => {
            return PgSquasher.squashPK(pk);
          });
          const mappedColumns = Object.fromEntries(
            Object.entries(it2[1].columns).map((it3) => {
              const mappedIdentity = it3[1].identity ? PgSquasher.squashIdentity(it3[1].identity) : void 0;
              return [
                it3[0],
                {
                  ...it3[1],
                  identity: mappedIdentity
                }
              ];
            })
          );
          const squashedUniqueConstraints = mapValues(
            it2[1].uniqueConstraints,
            (unq) => {
              return PgSquasher.squashUnique(unq);
            }
          );
          const squashedPolicies = mapValues(it2[1].policies, (policy5) => {
            return action === "push" ? PgSquasher.squashPolicyPush(policy5) : PgSquasher.squashPolicy(policy5);
          });
          const squashedChecksContraints = mapValues(
            it2[1].checkConstraints,
            (check2) => {
              return PgSquasher.squashCheck(check2);
            }
          );
          return [
            it2[0],
            {
              name: it2[1].name,
              schema: it2[1].schema,
              columns: mappedColumns,
              indexes: squashedIndexes,
              foreignKeys: squashedFKs,
              compositePrimaryKeys: squashedPKs,
              uniqueConstraints: squashedUniqueConstraints,
              policies: squashedPolicies,
              checkConstraints: squashedChecksContraints,
              isRLSEnabled: it2[1].isRLSEnabled ?? false
            }
          ];
        })
      );
      const mappedSequences = Object.fromEntries(
        Object.entries(json4.sequences).map((it2) => {
          return [
            it2[0],
            {
              name: it2[1].name,
              schema: it2[1].schema,
              values: PgSquasher.squashSequence(it2[1])
            }
          ];
        })
      );
      const mappedPolicies = Object.fromEntries(
        Object.entries(json4.policies).map((it2) => {
          return [
            it2[0],
            {
              name: it2[1].name,
              values: action === "push" ? PgSquasher.squashPolicyPush(it2[1]) : PgSquasher.squashPolicy(it2[1])
            }
          ];
        })
      );
      return {
        version: "7",
        dialect: json4.dialect,
        tables: mappedTables,
        enums: json4.enums,
        schemas: json4.schemas,
        views: json4.views,
        policies: mappedPolicies,
        sequences: mappedSequences,
        roles: json4.roles
      };
    };
    dryPg = pgSchema2.parse({
      version: snapshotVersion,
      dialect: "postgresql",
      id: originUUID,
      prevId: "",
      tables: {},
      enums: {},
      schemas: {},
      policies: {},
      roles: {},
      sequences: {},
      _meta: {
        schemas: {},
        tables: {},
        columns: {}
      }
    });
  }
});

// src/serializer/singlestoreSchema.ts
var index5, column4, compositePK4, uniqueConstraint4, table4, viewMeta2, kitInternals4, dialect2, schemaHash4, schemaInternal2, schema2, tableSquashed4, schemaSquashed2, SingleStoreSquasher, squashSingleStoreScheme, singlestoreSchema, singlestoreSchemaSquashed, backwardCompatibleSingleStoreSchema, drySingleStore;
var init_singlestoreSchema = __esm({
  "src/serializer/singlestoreSchema.ts"() {
    "use strict";
    init_esm();
    init_global();
    index5 = objectType({
      name: stringType(),
      columns: stringType().array(),
      isUnique: booleanType(),
      using: enumType(["btree", "hash"]).optional(),
      algorithm: enumType(["default", "inplace", "copy"]).optional(),
      lock: enumType(["default", "none", "shared", "exclusive"]).optional()
    }).strict();
    column4 = objectType({
      name: stringType(),
      type: stringType(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      autoincrement: booleanType().optional(),
      default: anyType().optional(),
      onUpdate: anyType().optional(),
      generated: objectType({
        type: enumType(["stored", "virtual"]),
        as: stringType()
      }).optional()
    }).strict();
    compositePK4 = objectType({
      name: stringType(),
      columns: stringType().array()
    }).strict();
    uniqueConstraint4 = objectType({
      name: stringType(),
      columns: stringType().array()
    }).strict();
    table4 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column4),
      indexes: recordType(stringType(), index5),
      compositePrimaryKeys: recordType(stringType(), compositePK4),
      uniqueConstraints: recordType(stringType(), uniqueConstraint4).default({})
    }).strict();
    viewMeta2 = objectType({
      algorithm: enumType(["undefined", "merge", "temptable"]),
      sqlSecurity: enumType(["definer", "invoker"]),
      withCheckOption: enumType(["local", "cascaded"]).optional()
    }).strict();
    kitInternals4 = objectType({
      tables: recordType(
        stringType(),
        objectType({
          columns: recordType(
            stringType(),
            objectType({ isDefaultAnExpression: booleanType().optional() }).optional()
          )
        }).optional()
      ).optional(),
      indexes: recordType(
        stringType(),
        objectType({
          columns: recordType(
            stringType(),
            objectType({ isExpression: booleanType().optional() }).optional()
          )
        }).optional()
      ).optional()
    }).optional();
    dialect2 = literalType("singlestore");
    schemaHash4 = objectType({
      id: stringType(),
      prevId: stringType()
    });
    schemaInternal2 = objectType({
      version: literalType("1"),
      dialect: dialect2,
      tables: recordType(stringType(), table4),
      /* views: record(string(), view).default({}), */
      _meta: objectType({
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals4
    }).strict();
    schema2 = schemaInternal2.merge(schemaHash4);
    tableSquashed4 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column4),
      indexes: recordType(stringType(), stringType()),
      compositePrimaryKeys: recordType(stringType(), stringType()),
      uniqueConstraints: recordType(stringType(), stringType()).default({})
    }).strict();
    schemaSquashed2 = objectType({
      version: literalType("1"),
      dialect: dialect2,
      tables: recordType(stringType(), tableSquashed4)
      /* views: record(string(), viewSquashed), */
    }).strict();
    SingleStoreSquasher = {
      squashIdx: (idx) => {
        index5.parse(idx);
        return `${idx.name};${idx.columns.join(",")};${idx.isUnique};${idx.using ?? ""};${idx.algorithm ?? ""};${idx.lock ?? ""}`;
      },
      unsquashIdx: (input) => {
        const [name3, columnsString, isUnique, using, algorithm, lock] = input.split(";");
        const destructed = {
          name: name3,
          columns: columnsString.split(","),
          isUnique: isUnique === "true",
          using: using ? using : void 0,
          algorithm: algorithm ? algorithm : void 0,
          lock: lock ? lock : void 0
        };
        return index5.parse(destructed);
      },
      squashPK: (pk) => {
        return `${pk.name};${pk.columns.join(",")}`;
      },
      unsquashPK: (pk) => {
        const splitted = pk.split(";");
        return { name: splitted[0], columns: splitted[1].split(",") };
      },
      squashUnique: (unq) => {
        return `${unq.name};${unq.columns.join(",")}`;
      },
      unsquashUnique: (unq) => {
        const [name3, columns] = unq.split(";");
        return { name: name3, columns: columns.split(",") };
      }
      /* squashView: (view: View): string => {
      		return `${view.algorithm};${view.sqlSecurity};${view.withCheckOption}`;
      	},
      	unsquashView: (meta: string): SquasherViewMeta => {
      		const [algorithm, sqlSecurity, withCheckOption] = meta.split(';');
      		const toReturn = {
      			algorithm: algorithm,
      			sqlSecurity: sqlSecurity,
      			withCheckOption: withCheckOption !== 'undefined' ? withCheckOption : undefined,
      		};
      
      		return viewMeta.parse(toReturn);
      	}, */
    };
    squashSingleStoreScheme = (json4) => {
      const mappedTables = Object.fromEntries(
        Object.entries(json4.tables).map((it2) => {
          const squashedIndexes = mapValues(it2[1].indexes, (index7) => {
            return SingleStoreSquasher.squashIdx(index7);
          });
          const squashedPKs = mapValues(it2[1].compositePrimaryKeys, (pk) => {
            return SingleStoreSquasher.squashPK(pk);
          });
          const squashedUniqueConstraints = mapValues(
            it2[1].uniqueConstraints,
            (unq) => {
              return SingleStoreSquasher.squashUnique(unq);
            }
          );
          return [
            it2[0],
            {
              name: it2[1].name,
              columns: it2[1].columns,
              indexes: squashedIndexes,
              compositePrimaryKeys: squashedPKs,
              uniqueConstraints: squashedUniqueConstraints
            }
          ];
        })
      );
      return {
        version: "1",
        dialect: json4.dialect,
        tables: mappedTables
        /* views: mappedViews, */
      };
    };
    singlestoreSchema = schema2;
    singlestoreSchemaSquashed = schemaSquashed2;
    backwardCompatibleSingleStoreSchema = unionType([singlestoreSchema, schema2]);
    drySingleStore = singlestoreSchema.parse({
      version: "1",
      dialect: "singlestore",
      id: originUUID,
      prevId: "",
      tables: {},
      schemas: {},
      /* views: {}, */
      _meta: {
        schemas: {},
        tables: {},
        columns: {}
      }
    });
  }
});

// src/serializer/sqliteSchema.ts
var index6, fk4, compositePK5, column5, tableV33, uniqueConstraint5, checkConstraint4, table5, view4, dialect3, schemaHash5, schemaInternalV32, schemaInternalV42, schemaInternalV52, kitInternals5, latestVersion, schemaInternal3, schemaV32, schemaV42, schemaV52, schema3, tableSquashed5, schemaSquashed3, SQLiteSquasher, squashSqliteScheme, drySQLite, sqliteSchemaV5, sqliteSchema, SQLiteSchemaSquashed, backwardCompatibleSqliteSchema;
var init_sqliteSchema = __esm({
  "src/serializer/sqliteSchema.ts"() {
    "use strict";
    init_esm();
    init_global();
    index6 = objectType({
      name: stringType(),
      columns: stringType().array(),
      where: stringType().optional(),
      isUnique: booleanType()
    }).strict();
    fk4 = objectType({
      name: stringType(),
      tableFrom: stringType(),
      columnsFrom: stringType().array(),
      tableTo: stringType(),
      columnsTo: stringType().array(),
      onUpdate: stringType().optional(),
      onDelete: stringType().optional()
    }).strict();
    compositePK5 = objectType({
      columns: stringType().array(),
      name: stringType().optional()
    }).strict();
    column5 = objectType({
      name: stringType(),
      type: stringType(),
      primaryKey: booleanType(),
      notNull: booleanType(),
      autoincrement: booleanType().optional(),
      default: anyType().optional(),
      generated: objectType({
        type: enumType(["stored", "virtual"]),
        as: stringType()
      }).optional()
    }).strict();
    tableV33 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column5),
      indexes: recordType(stringType(), index6),
      foreignKeys: recordType(stringType(), fk4)
    }).strict();
    uniqueConstraint5 = objectType({
      name: stringType(),
      columns: stringType().array()
    }).strict();
    checkConstraint4 = objectType({
      name: stringType(),
      value: stringType()
    }).strict();
    table5 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column5),
      indexes: recordType(stringType(), index6),
      foreignKeys: recordType(stringType(), fk4),
      compositePrimaryKeys: recordType(stringType(), compositePK5),
      uniqueConstraints: recordType(stringType(), uniqueConstraint5).default({}),
      checkConstraints: recordType(stringType(), checkConstraint4).default({})
    }).strict();
    view4 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column5),
      definition: stringType().optional(),
      isExisting: booleanType()
    }).strict();
    dialect3 = enumType(["sqlite"]);
    schemaHash5 = objectType({
      id: stringType(),
      prevId: stringType()
    }).strict();
    schemaInternalV32 = objectType({
      version: literalType("3"),
      dialect: dialect3,
      tables: recordType(stringType(), tableV33),
      enums: objectType({})
    }).strict();
    schemaInternalV42 = objectType({
      version: literalType("4"),
      dialect: dialect3,
      tables: recordType(stringType(), table5),
      views: recordType(stringType(), view4).default({}),
      enums: objectType({})
    }).strict();
    schemaInternalV52 = objectType({
      version: literalType("5"),
      dialect: dialect3,
      tables: recordType(stringType(), table5),
      enums: objectType({}),
      _meta: objectType({
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      })
    }).strict();
    kitInternals5 = objectType({
      indexes: recordType(
        stringType(),
        objectType({
          columns: recordType(
            stringType(),
            objectType({ isExpression: booleanType().optional() }).optional()
          )
        }).optional()
      ).optional()
    }).optional();
    latestVersion = literalType("6");
    schemaInternal3 = objectType({
      version: latestVersion,
      dialect: dialect3,
      tables: recordType(stringType(), table5),
      views: recordType(stringType(), view4).default({}),
      enums: objectType({}),
      _meta: objectType({
        tables: recordType(stringType(), stringType()),
        columns: recordType(stringType(), stringType())
      }),
      internal: kitInternals5
    }).strict();
    schemaV32 = schemaInternalV32.merge(schemaHash5).strict();
    schemaV42 = schemaInternalV42.merge(schemaHash5).strict();
    schemaV52 = schemaInternalV52.merge(schemaHash5).strict();
    schema3 = schemaInternal3.merge(schemaHash5).strict();
    tableSquashed5 = objectType({
      name: stringType(),
      columns: recordType(stringType(), column5),
      indexes: recordType(stringType(), stringType()),
      foreignKeys: recordType(stringType(), stringType()),
      compositePrimaryKeys: recordType(stringType(), stringType()),
      uniqueConstraints: recordType(stringType(), stringType()).default({}),
      checkConstraints: recordType(stringType(), stringType()).default({})
    }).strict();
    schemaSquashed3 = objectType({
      version: latestVersion,
      dialect: dialect3,
      tables: recordType(stringType(), tableSquashed5),
      views: recordType(stringType(), view4),
      enums: anyType()
    }).strict();
    SQLiteSquasher = {
      squashIdx: (idx) => {
        index6.parse(idx);
        return `${idx.name};${idx.columns.join(",")};${idx.isUnique};${idx.where ?? ""}`;
      },
      unsquashIdx: (input) => {
        const [name3, columnsString, isUnique, where] = input.split(";");
        const result = index6.parse({
          name: name3,
          columns: columnsString.split(","),
          isUnique: isUnique === "true",
          where: where ?? void 0
        });
        return result;
      },
      squashUnique: (unq) => {
        return `${unq.name};${unq.columns.join(",")}`;
      },
      unsquashUnique: (unq) => {
        const [name3, columns] = unq.split(";");
        return { name: name3, columns: columns.split(",") };
      },
      squashFK: (fk5) => {
        return `${fk5.name};${fk5.tableFrom};${fk5.columnsFrom.join(",")};${fk5.tableTo};${fk5.columnsTo.join(",")};${fk5.onUpdate ?? ""};${fk5.onDelete ?? ""}`;
      },
      unsquashFK: (input) => {
        const [
          name3,
          tableFrom,
          columnsFromStr,
          tableTo,
          columnsToStr,
          onUpdate,
          onDelete
        ] = input.split(";");
        const result = fk4.parse({
          name: name3,
          tableFrom,
          columnsFrom: columnsFromStr.split(","),
          tableTo,
          columnsTo: columnsToStr.split(","),
          onUpdate,
          onDelete
        });
        return result;
      },
      squashPushFK: (fk5) => {
        return `${fk5.tableFrom};${fk5.columnsFrom.join(",")};${fk5.tableTo};${fk5.columnsTo.join(",")};${fk5.onUpdate ?? ""};${fk5.onDelete ?? ""}`;
      },
      unsquashPushFK: (input) => {
        const [
          tableFrom,
          columnsFromStr,
          tableTo,
          columnsToStr,
          onUpdate,
          onDelete
        ] = input.split(";");
        const result = fk4.parse({
          name: "",
          tableFrom,
          columnsFrom: columnsFromStr.split(","),
          tableTo,
          columnsTo: columnsToStr.split(","),
          onUpdate,
          onDelete
        });
        return result;
      },
      squashPK: (pk) => {
        return pk.columns.join(",");
      },
      unsquashPK: (pk) => {
        return pk.split(",");
      },
      squashCheck: (check2) => {
        return `${check2.name};${check2.value}`;
      },
      unsquashCheck: (input) => {
        const [
          name3,
          value
        ] = input.split(";");
        return { name: name3, value };
      }
    };
    squashSqliteScheme = (json4, action) => {
      const mappedTables = Object.fromEntries(
        Object.entries(json4.tables).map((it2) => {
          const squashedIndexes = mapValues(it2[1].indexes, (index7) => {
            return SQLiteSquasher.squashIdx(index7);
          });
          const squashedFKs = customMapEntries(
            it2[1].foreignKeys,
            (key, value) => {
              return action === "push" ? [
                SQLiteSquasher.squashPushFK(value),
                SQLiteSquasher.squashPushFK(value)
              ] : [key, SQLiteSquasher.squashFK(value)];
            }
          );
          const squashedPKs = mapValues(it2[1].compositePrimaryKeys, (pk) => {
            return SQLiteSquasher.squashPK(pk);
          });
          const squashedUniqueConstraints = mapValues(
            it2[1].uniqueConstraints,
            (unq) => {
              return SQLiteSquasher.squashUnique(unq);
            }
          );
          const squashedCheckConstraints = mapValues(
            it2[1].checkConstraints,
            (check2) => {
              return SQLiteSquasher.squashCheck(check2);
            }
          );
          return [
            it2[0],
            {
              name: it2[1].name,
              columns: it2[1].columns,
              indexes: squashedIndexes,
              foreignKeys: squashedFKs,
              compositePrimaryKeys: squashedPKs,
              uniqueConstraints: squashedUniqueConstraints,
              checkConstraints: squashedCheckConstraints
            }
          ];
        })
      );
      return {
        version: "6",
        dialect: json4.dialect,
        tables: mappedTables,
        views: json4.views,
        enums: json4.enums
      };
    };
    drySQLite = schema3.parse({
      version: "6",
      dialect: "sqlite",
      id: originUUID,
      prevId: "",
      tables: {},
      views: {},
      enums: {},
      _meta: {
        tables: {},
        columns: {}
      }
    });
    sqliteSchemaV5 = schemaV52;
    sqliteSchema = schema3;
    SQLiteSchemaSquashed = schemaSquashed3;
    backwardCompatibleSqliteSchema = unionType([sqliteSchemaV5, schema3]);
  }
});

// src/utils.ts
function isPgArrayType(sqlType) {
  return sqlType.match(/.*\[\d*\].*|.*\[\].*/g) !== null;
}
function findAddedAndRemoved(columnNames1, columnNames2) {
  const set1 = new Set(columnNames1);
  const set2 = new Set(columnNames2);
  const addedColumns = columnNames2.filter((it2) => !set1.has(it2));
  const removedColumns = columnNames1.filter((it2) => !set2.has(it2));
  return { addedColumns, removedColumns };
}
function escapeSingleQuotes(str) {
  return str.replace(/'/g, "''");
}
var import_url, copy, prepareMigrationMeta, schemaRenameKey, tableRenameKey, columnRenameKey, normaliseSQLiteUrl, normalisePGliteUrl;
var init_utils8 = __esm({
  "src/utils.ts"() {
    "use strict";
    import_url = require("url");
    init_views();
    init_global();
    init_gelSchema();
    init_mysqlSchema();
    init_pgSchema();
    init_singlestoreSchema();
    init_sqliteSchema();
    copy = (it2) => {
      return JSON.parse(JSON.stringify(it2));
    };
    prepareMigrationMeta = (schemas, tables, columns) => {
      const _meta = {
        schemas: {},
        tables: {},
        columns: {}
      };
      schemas.forEach((it2) => {
        const from = schemaRenameKey(it2.from);
        const to3 = schemaRenameKey(it2.to);
        _meta.schemas[from] = to3;
      });
      tables.forEach((it2) => {
        const from = tableRenameKey(it2.from);
        const to3 = tableRenameKey(it2.to);
        _meta.tables[from] = to3;
      });
      columns.forEach((it2) => {
        const from = columnRenameKey(it2.from.table, it2.from.schema, it2.from.column);
        const to3 = columnRenameKey(it2.to.table, it2.to.schema, it2.to.column);
        _meta.columns[from] = to3;
      });
      return _meta;
    };
    schemaRenameKey = (it2) => {
      return it2;
    };
    tableRenameKey = (it2) => {
      const out2 = it2.schema ? `"${it2.schema}"."${it2.name}"` : `"${it2.name}"`;
      return out2;
    };
    columnRenameKey = (table6, schema6, column6) => {
      const out2 = schema6 ? `"${schema6}"."${table6}"."${column6}"` : `"${table6}"."${column6}"`;
      return out2;
    };
    normaliseSQLiteUrl = (it2, type) => {
      if (type === "libsql") {
        if (it2.startsWith("file:")) {
          return it2;
        }
        try {
          const url = (0, import_url.parse)(it2);
          if (url.protocol === null) {
            return `file:${it2}`;
          }
          return it2;
        } catch (e6) {
          return `file:${it2}`;
        }
      }
      if (type === "better-sqlite") {
        if (it2.startsWith("file:")) {
          return it2.substring(5);
        }
        return it2;
      }
      assertUnreachable(type);
    };
    normalisePGliteUrl = (it2) => {
      if (it2.startsWith("file:")) {
        return it2.substring(5);
      }
      return it2;
    };
  }
});

// src/cli/views.ts
var import_hanji, warning, err2, error, isRenamePromptItem, ResolveColumnSelect, tableKey, ResolveSelectNamed, ResolveSelect, ResolveSchemasSelect, Spinner, ProgressView;
var init_views = __esm({
  "src/cli/views.ts"() {
    "use strict";
    init_source();
    import_hanji = __toESM(require_hanji());
    init_utils8();
    warning = (msg) => {
      (0, import_hanji.render)(`[${source_default.yellow("Warning")}] ${msg}`);
    };
    err2 = (msg) => {
      (0, import_hanji.render)(`${source_default.bold.red("Error")} ${msg}`);
    };
    error = (error2, greyMsg = "") => {
      return `${source_default.bgRed.bold(" Error ")} ${error2} ${greyMsg ? source_default.grey(greyMsg) : ""}`.trim();
    };
    isRenamePromptItem = (item) => {
      return "from" in item && "to" in item;
    };
    ResolveColumnSelect = class extends import_hanji.Prompt {
      constructor(tableName, base, data) {
        super();
        this.tableName = tableName;
        this.base = base;
        this.on("attach", (terminal) => terminal.toggleCursor("hide"));
        this.data = new import_hanji.SelectState(data);
        this.data.bind(this);
      }
      render(status) {
        if (status === "submitted" || status === "aborted") {
          return "\n";
        }
        let text5 = `
Is ${source_default.bold.blue(
          this.base.name
        )} column in ${source_default.bold.blue(
          this.tableName
        )} table created or renamed from another column?
`;
        const isSelectedRenamed = isRenamePromptItem(
          this.data.items[this.data.selectedIdx]
        );
        const selectedPrefix = isSelectedRenamed ? source_default.yellow("\u276F ") : source_default.green("\u276F ");
        const labelLength = this.data.items.filter((it2) => isRenamePromptItem(it2)).map((it2) => {
          return this.base.name.length + 3 + it2["from"].name.length;
        }).reduce((a9, b9) => {
          if (a9 > b9) {
            return a9;
          }
          return b9;
        }, 0);
        this.data.items.forEach((it2, idx) => {
          const isSelected = idx === this.data.selectedIdx;
          const isRenamed = isRenamePromptItem(it2);
          const title = isRenamed ? `${it2.from.name} \u203A ${it2.to.name}`.padEnd(labelLength, " ") : it2.name.padEnd(labelLength, " ");
          const label = isRenamed ? `${source_default.yellow("~")} ${title} ${source_default.gray("rename column")}` : `${source_default.green("+")} ${title} ${source_default.gray("create column")}`;
          text5 += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
          text5 += idx != this.data.items.length - 1 ? "\n" : "";
        });
        return text5;
      }
      result() {
        return this.data.items[this.data.selectedIdx];
      }
    };
    tableKey = (it2) => {
      return it2.schema === "public" || !it2.schema ? it2.name : `${it2.schema}.${it2.name}`;
    };
    ResolveSelectNamed = class extends import_hanji.Prompt {
      constructor(base, data, entityType) {
        super();
        this.base = base;
        this.entityType = entityType;
        this.on("attach", (terminal) => terminal.toggleCursor("hide"));
        this.state = new import_hanji.SelectState(data);
        this.state.bind(this);
        this.base = base;
      }
      render(status) {
        if (status === "submitted" || status === "aborted") {
          return "";
        }
        const key = this.base.name;
        let text5 = `
Is ${source_default.bold.blue(key)} ${this.entityType} created or renamed from another ${this.entityType}?
`;
        const isSelectedRenamed = isRenamePromptItem(
          this.state.items[this.state.selectedIdx]
        );
        const selectedPrefix = isSelectedRenamed ? source_default.yellow("\u276F ") : source_default.green("\u276F ");
        const labelLength = this.state.items.filter((it2) => isRenamePromptItem(it2)).map((_7) => {
          const it2 = _7;
          const keyFrom = it2.from.name;
          return key.length + 3 + keyFrom.length;
        }).reduce((a9, b9) => {
          if (a9 > b9) {
            return a9;
          }
          return b9;
        }, 0);
        const entityType = this.entityType;
        this.state.items.forEach((it2, idx) => {
          const isSelected = idx === this.state.selectedIdx;
          const isRenamed = isRenamePromptItem(it2);
          const title = isRenamed ? `${it2.from.name} \u203A ${it2.to.name}`.padEnd(labelLength, " ") : it2.name.padEnd(labelLength, " ");
          const label = isRenamed ? `${source_default.yellow("~")} ${title} ${source_default.gray(`rename ${entityType}`)}` : `${source_default.green("+")} ${title} ${source_default.gray(`create ${entityType}`)}`;
          text5 += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
          text5 += idx != this.state.items.length - 1 ? "\n" : "";
        });
        return text5;
      }
      result() {
        return this.state.items[this.state.selectedIdx];
      }
    };
    ResolveSelect = class extends import_hanji.Prompt {
      constructor(base, data, entityType) {
        super();
        this.base = base;
        this.entityType = entityType;
        this.on("attach", (terminal) => terminal.toggleCursor("hide"));
        this.state = new import_hanji.SelectState(data);
        this.state.bind(this);
        this.base = base;
      }
      render(status) {
        if (status === "submitted" || status === "aborted") {
          return "";
        }
        const key = tableKey(this.base);
        let text5 = `
Is ${source_default.bold.blue(key)} ${this.entityType} created or renamed from another ${this.entityType}?
`;
        const isSelectedRenamed = isRenamePromptItem(
          this.state.items[this.state.selectedIdx]
        );
        const selectedPrefix = isSelectedRenamed ? source_default.yellow("\u276F ") : source_default.green("\u276F ");
        const labelLength = this.state.items.filter((it2) => isRenamePromptItem(it2)).map((_7) => {
          const it2 = _7;
          const keyFrom = tableKey(it2.from);
          return key.length + 3 + keyFrom.length;
        }).reduce((a9, b9) => {
          if (a9 > b9) {
            return a9;
          }
          return b9;
        }, 0);
        const entityType = this.entityType;
        this.state.items.forEach((it2, idx) => {
          const isSelected = idx === this.state.selectedIdx;
          const isRenamed = isRenamePromptItem(it2);
          const title = isRenamed ? `${tableKey(it2.from)} \u203A ${tableKey(it2.to)}`.padEnd(labelLength, " ") : tableKey(it2).padEnd(labelLength, " ");
          const label = isRenamed ? `${source_default.yellow("~")} ${title} ${source_default.gray(`rename ${entityType}`)}` : `${source_default.green("+")} ${title} ${source_default.gray(`create ${entityType}`)}`;
          text5 += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
          text5 += idx != this.state.items.length - 1 ? "\n" : "";
        });
        return text5;
      }
      result() {
        return this.state.items[this.state.selectedIdx];
      }
    };
    ResolveSchemasSelect = class extends import_hanji.Prompt {
      constructor(base, data) {
        super();
        this.base = base;
        this.on("attach", (terminal) => terminal.toggleCursor("hide"));
        this.state = new import_hanji.SelectState(data);
        this.state.bind(this);
        this.base = base;
      }
      render(status) {
        if (status === "submitted" || status === "aborted") {
          return "";
        }
        let text5 = `
Is ${source_default.bold.blue(
          this.base.name
        )} schema created or renamed from another schema?
`;
        const isSelectedRenamed = isRenamePromptItem(
          this.state.items[this.state.selectedIdx]
        );
        const selectedPrefix = isSelectedRenamed ? source_default.yellow("\u276F ") : source_default.green("\u276F ");
        const labelLength = this.state.items.filter((it2) => isRenamePromptItem(it2)).map((it2) => {
          return this.base.name.length + 3 + it2["from"].name.length;
        }).reduce((a9, b9) => {
          if (a9 > b9) {
            return a9;
          }
          return b9;
        }, 0);
        this.state.items.forEach((it2, idx) => {
          const isSelected = idx === this.state.selectedIdx;
          const isRenamed = isRenamePromptItem(it2);
          const title = isRenamed ? `${it2.from.name} \u203A ${it2.to.name}`.padEnd(labelLength, " ") : it2.name.padEnd(labelLength, " ");
          const label = isRenamed ? `${source_default.yellow("~")} ${title} ${source_default.gray("rename schema")}` : `${source_default.green("+")} ${title} ${source_default.gray("create schema")}`;
          text5 += isSelected ? `${selectedPrefix}${label}` : `  ${label}`;
          text5 += idx != this.state.items.length - 1 ? "\n" : "";
        });
        return text5;
      }
      result() {
        return this.state.items[this.state.selectedIdx];
      }
    };
    Spinner = class {
      constructor(frames) {
        this.frames = frames;
        this.offset = 0;
        this.tick = () => {
          this.iterator();
        };
        this.value = () => {
          return this.frames[this.offset];
        };
        this.iterator = () => {
          this.offset += 1;
          this.offset %= frames.length - 1;
        };
      }
    };
    ProgressView = class extends import_hanji.TaskView {
      constructor(progressText, successText) {
        super();
        this.progressText = progressText;
        this.successText = successText;
        this.spinner = new Spinner("\u28F7\u28EF\u28DF\u287F\u28BF\u28FB\u28FD\u28FE".split(""));
        this.timeout = setInterval(() => {
          this.spinner.tick();
          this.requestLayout();
        }, 128);
        this.on("detach", () => clearInterval(this.timeout));
      }
      render(status) {
        if (status === "pending") {
          const spin = this.spinner.value();
          return `[${spin}] ${this.progressText}
`;
        }
        return `[${source_default.green("\u2713")}] ${this.successText}
`;
      }
    };
  }
});

// src/serializer/index.ts
var import_fs, glob, import_path, prepareFilenames;
var init_serializer = __esm({
  "src/serializer/index.ts"() {
    "use strict";
    import_fs = __toESM(require("fs"));
    glob = __toESM(require_glob());
    import_path = __toESM(require("path"));
    init_views();
    prepareFilenames = (path3) => {
      if (typeof path3 === "string") {
        path3 = [path3];
      }
      const prefix2 = process.env.TEST_CONFIG_PATH_PREFIX || "";
      const result = path3.reduce((result2, cur) => {
        const globbed = glob.sync(`${prefix2}${cur}`);
        globbed.forEach((it2) => {
          const fileName = import_fs.default.lstatSync(it2).isDirectory() ? null : import_path.default.resolve(it2);
          const filenames = fileName ? [fileName] : import_fs.default.readdirSync(it2).map((file) => import_path.default.join(import_path.default.resolve(it2), file));
          filenames.filter((file) => !import_fs.default.lstatSync(file).isDirectory()).forEach((file) => result2.add(file));
        });
        return result2;
      }, /* @__PURE__ */ new Set());
      const res = [...result];
      const errors = res.filter((it2) => {
        return !(it2.endsWith(".ts") || it2.endsWith(".js") || it2.endsWith(".cjs") || it2.endsWith(".mjs") || it2.endsWith(".mts") || it2.endsWith(".cts"));
      });
      if (res.length === 0) {
        console.log(
          error(
            `No schema files found for path config [${path3.map((it2) => `'${it2}'`).join(", ")}]`
          )
        );
        console.log(
          error(
            `If path represents a file - please make sure to use .ts or other extension in the path`
          )
        );
        process.exit(1);
      }
      return res;
    };
  }
});

// src/migrationPreparator.ts
var init_migrationPreparator = __esm({
  "src/migrationPreparator.ts"() {
    "use strict";
    init_serializer();
    init_mysqlSchema();
    init_pgSchema();
    init_singlestoreSchema();
    init_sqliteSchema();
  }
});

// ../node_modules/.pnpm/heap@0.2.7/node_modules/heap/lib/heap.js
var require_heap = __commonJS({
  "../node_modules/.pnpm/heap@0.2.7/node_modules/heap/lib/heap.js"(exports2, module2) {
    "use strict";
    (function() {
      var Heap, defaultCmp, floor, heapify, heappop, heappush, heappushpop, heapreplace, insort, min2, nlargest, nsmallest, updateItem, _siftdown, _siftup;
      floor = Math.floor, min2 = Math.min;
      defaultCmp = function(x11, y7) {
        if (x11 < y7) {
          return -1;
        }
        if (x11 > y7) {
          return 1;
        }
        return 0;
      };
      insort = function(a9, x11, lo, hi3, cmp) {
        var mid;
        if (lo == null) {
          lo = 0;
        }
        if (cmp == null) {
          cmp = defaultCmp;
        }
        if (lo < 0) {
          throw new Error("lo must be non-negative");
        }
        if (hi3 == null) {
          hi3 = a9.length;
        }
        while (lo < hi3) {
          mid = floor((lo + hi3) / 2);
          if (cmp(x11, a9[mid]) < 0) {
            hi3 = mid;
          } else {
            lo = mid + 1;
          }
        }
        return [].splice.apply(a9, [lo, lo - lo].concat(x11)), x11;
      };
      heappush = function(array3, item, cmp) {
        if (cmp == null) {
          cmp = defaultCmp;
        }
        array3.push(item);
        return _siftdown(array3, 0, array3.length - 1, cmp);
      };
      heappop = function(array3, cmp) {
        var lastelt, returnitem;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        lastelt = array3.pop();
        if (array3.length) {
          returnitem = array3[0];
          array3[0] = lastelt;
          _siftup(array3, 0, cmp);
        } else {
          returnitem = lastelt;
        }
        return returnitem;
      };
      heapreplace = function(array3, item, cmp) {
        var returnitem;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        returnitem = array3[0];
        array3[0] = item;
        _siftup(array3, 0, cmp);
        return returnitem;
      };
      heappushpop = function(array3, item, cmp) {
        var _ref;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        if (array3.length && cmp(array3[0], item) < 0) {
          _ref = [array3[0], item], item = _ref[0], array3[0] = _ref[1];
          _siftup(array3, 0, cmp);
        }
        return item;
      };
      heapify = function(array3, cmp) {
        var i8, _i4, _j2, _len, _ref, _ref1, _results, _results1;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        _ref1 = function() {
          _results1 = [];
          for (var _j3 = 0, _ref2 = floor(array3.length / 2); 0 <= _ref2 ? _j3 < _ref2 : _j3 > _ref2; 0 <= _ref2 ? _j3++ : _j3--) {
            _results1.push(_j3);
          }
          return _results1;
        }.apply(this).reverse();
        _results = [];
        for (_i4 = 0, _len = _ref1.length; _i4 < _len; _i4++) {
          i8 = _ref1[_i4];
          _results.push(_siftup(array3, i8, cmp));
        }
        return _results;
      };
      updateItem = function(array3, item, cmp) {
        var pos;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        pos = array3.indexOf(item);
        if (pos === -1) {
          return;
        }
        _siftdown(array3, 0, pos, cmp);
        return _siftup(array3, pos, cmp);
      };
      nlargest = function(array3, n7, cmp) {
        var elem, result, _i4, _len, _ref;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        result = array3.slice(0, n7);
        if (!result.length) {
          return result;
        }
        heapify(result, cmp);
        _ref = array3.slice(n7);
        for (_i4 = 0, _len = _ref.length; _i4 < _len; _i4++) {
          elem = _ref[_i4];
          heappushpop(result, elem, cmp);
        }
        return result.sort(cmp).reverse();
      };
      nsmallest = function(array3, n7, cmp) {
        var elem, i8, los, result, _i4, _j2, _len, _ref, _ref1, _results;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        if (n7 * 10 <= array3.length) {
          result = array3.slice(0, n7).sort(cmp);
          if (!result.length) {
            return result;
          }
          los = result[result.length - 1];
          _ref = array3.slice(n7);
          for (_i4 = 0, _len = _ref.length; _i4 < _len; _i4++) {
            elem = _ref[_i4];
            if (cmp(elem, los) < 0) {
              insort(result, elem, 0, null, cmp);
              result.pop();
              los = result[result.length - 1];
            }
          }
          return result;
        }
        heapify(array3, cmp);
        _results = [];
        for (i8 = _j2 = 0, _ref1 = min2(n7, array3.length); 0 <= _ref1 ? _j2 < _ref1 : _j2 > _ref1; i8 = 0 <= _ref1 ? ++_j2 : --_j2) {
          _results.push(heappop(array3, cmp));
        }
        return _results;
      };
      _siftdown = function(array3, startpos, pos, cmp) {
        var newitem, parent, parentpos;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        newitem = array3[pos];
        while (pos > startpos) {
          parentpos = pos - 1 >> 1;
          parent = array3[parentpos];
          if (cmp(newitem, parent) < 0) {
            array3[pos] = parent;
            pos = parentpos;
            continue;
          }
          break;
        }
        return array3[pos] = newitem;
      };
      _siftup = function(array3, pos, cmp) {
        var childpos, endpos, newitem, rightpos, startpos;
        if (cmp == null) {
          cmp = defaultCmp;
        }
        endpos = array3.length;
        startpos = pos;
        newitem = array3[pos];
        childpos = 2 * pos + 1;
        while (childpos < endpos) {
          rightpos = childpos + 1;
          if (rightpos < endpos && !(cmp(array3[childpos], array3[rightpos]) < 0)) {
            childpos = rightpos;
          }
          array3[pos] = array3[childpos];
          pos = childpos;
          childpos = 2 * pos + 1;
        }
        array3[pos] = newitem;
        return _siftdown(array3, startpos, pos, cmp);
      };
      Heap = function() {
        Heap2.push = heappush;
        Heap2.pop = heappop;
        Heap2.replace = heapreplace;
        Heap2.pushpop = heappushpop;
        Heap2.heapify = heapify;
        Heap2.updateItem = updateItem;
        Heap2.nlargest = nlargest;
        Heap2.nsmallest = nsmallest;
        function Heap2(cmp) {
          this.cmp = cmp != null ? cmp : defaultCmp;
          this.nodes = [];
        }
        Heap2.prototype.push = function(x11) {
          return heappush(this.nodes, x11, this.cmp);
        };
        Heap2.prototype.pop = function() {
          return heappop(this.nodes, this.cmp);
        };
        Heap2.prototype.peek = function() {
          return this.nodes[0];
        };
        Heap2.prototype.contains = function(x11) {
          return this.nodes.indexOf(x11) !== -1;
        };
        Heap2.prototype.replace = function(x11) {
          return heapreplace(this.nodes, x11, this.cmp);
        };
        Heap2.prototype.pushpop = function(x11) {
          return heappushpop(this.nodes, x11, this.cmp);
        };
        Heap2.prototype.heapify = function() {
          return heapify(this.nodes, this.cmp);
        };
        Heap2.prototype.updateItem = function(x11) {
          return updateItem(this.nodes, x11, this.cmp);
        };
        Heap2.prototype.clear = function() {
          return this.nodes = [];
        };
        Heap2.prototype.empty = function() {
          return this.nodes.length === 0;
        };
        Heap2.prototype.size = function() {
          return this.nodes.length;
        };
        Heap2.prototype.clone = function() {
          var heap;
          heap = new Heap2();
          heap.nodes = this.nodes.slice(0);
          return heap;
        };
        Heap2.prototype.toArray = function() {
          return this.nodes.slice(0);
        };
        Heap2.prototype.insert = Heap2.prototype.push;
        Heap2.prototype.top = Heap2.prototype.peek;
        Heap2.prototype.front = Heap2.prototype.peek;
        Heap2.prototype.has = Heap2.prototype.contains;
        Heap2.prototype.copy = Heap2.prototype.clone;
        return Heap2;
      }();
      (function(root, factory) {
        if (typeof define === "function" && define.amd) {
          return define([], factory);
        } else if (typeof exports2 === "object") {
          return module2.exports = factory();
        } else {
          return root.Heap = factory();
        }
      })(this, function() {
        return Heap;
      });
    }).call(exports2);
  }
});

// ../node_modules/.pnpm/heap@0.2.7/node_modules/heap/index.js
var require_heap2 = __commonJS({
  "../node_modules/.pnpm/heap@0.2.7/node_modules/heap/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_heap();
  }
});

// ../node_modules/.pnpm/@ewoudenberg+difflib@0.1.0/node_modules/@ewoudenberg/difflib/lib/difflib.js
var require_difflib = __commonJS({
  "../node_modules/.pnpm/@ewoudenberg+difflib@0.1.0/node_modules/@ewoudenberg/difflib/lib/difflib.js"(exports2) {
    "use strict";
    (function() {
      var Differ, Heap, IS_CHARACTER_JUNK, IS_LINE_JUNK, SequenceMatcher, _any, _arrayCmp, _calculateRatio, _countLeading, _formatRangeContext, _formatRangeUnified, _has, assert2, contextDiff, floor, getCloseMatches, max2, min2, ndiff, restore, unifiedDiff, indexOf = [].indexOf;
      ({ floor, max: max2, min: min2 } = Math);
      Heap = require_heap2();
      assert2 = require("assert");
      _calculateRatio = function(matches, length) {
        if (length) {
          return 2 * matches / length;
        } else {
          return 1;
        }
      };
      _arrayCmp = function(a9, b9) {
        var i8, l7, la, lb, ref;
        [la, lb] = [a9.length, b9.length];
        for (i8 = l7 = 0, ref = min2(la, lb); 0 <= ref ? l7 < ref : l7 > ref; i8 = 0 <= ref ? ++l7 : --l7) {
          if (a9[i8] < b9[i8]) {
            return -1;
          }
          if (a9[i8] > b9[i8]) {
            return 1;
          }
        }
        return la - lb;
      };
      _has = function(obj, key) {
        return Object.prototype.hasOwnProperty.call(obj, key);
      };
      _any = function(items) {
        var item, l7, len;
        for (l7 = 0, len = items.length; l7 < len; l7++) {
          item = items[l7];
          if (item) {
            return true;
          }
        }
        return false;
      };
      SequenceMatcher = class SequenceMatcher {
        /*
            SequenceMatcher is a flexible class for comparing pairs of sequences of
            any type, so long as the sequence elements are hashable.  The basic
            algorithm predates, and is a little fancier than, an algorithm
            published in the late 1980's by Ratcliff and Obershelp under the
            hyperbolic name "gestalt pattern matching".  The basic idea is to find
            the longest contiguous matching subsequence that contains no "junk"
            elements (R-O doesn't address junk).  The same idea is then applied
            recursively to the pieces of the sequences to the left and to the right
            of the matching subsequence.  This does not yield minimal edit
            sequences, but does tend to yield matches that "look right" to people.
        
            SequenceMatcher tries to compute a "human-friendly diff" between two
            sequences.  Unlike e.g. UNIX(tm) diff, the fundamental notion is the
            longest *contiguous* & junk-free matching subsequence.  That's what
            catches peoples' eyes.  The Windows(tm) windiff has another interesting
            notion, pairing up elements that appear uniquely in each sequence.
            That, and the method here, appear to yield more intuitive difference
            reports than does diff.  This method appears to be the least vulnerable
            to synching up on blocks of "junk lines", though (like blank lines in
            ordinary text files, or maybe "<P>" lines in HTML files).  That may be
            because this is the only method of the 3 that has a *concept* of
            "junk" <wink>.
        
            Example, comparing two strings, and considering blanks to be "junk":
        
            >>> isjunk = (c) -> c is ' '
            >>> s = new SequenceMatcher(isjunk,
                                        'private Thread currentThread;',
                                        'private volatile Thread currentThread;')
        
            .ratio() returns a float in [0, 1], measuring the "similarity" of the
            sequences.  As a rule of thumb, a .ratio() value over 0.6 means the
            sequences are close matches:
        
            >>> s.ratio().toPrecision(3)
            '0.866'
        
            If you're only interested in where the sequences match,
            .getMatchingBlocks() is handy:
        
            >>> for [a, b, size] in s.getMatchingBlocks()
            ...   console.log("a[#{a}] and b[#{b}] match for #{size} elements");
            a[0] and b[0] match for 8 elements
            a[8] and b[17] match for 21 elements
            a[29] and b[38] match for 0 elements
        
            Note that the last tuple returned by .get_matching_blocks() is always a
            dummy, (len(a), len(b), 0), and this is the only case in which the last
            tuple element (number of elements matched) is 0.
        
            If you want to know how to change the first sequence into the second,
            use .get_opcodes():
        
            >>> for [op, a1, a2, b1, b2] in s.getOpcodes()
            ...   console.log "#{op} a[#{a1}:#{a2}] b[#{b1}:#{b2}]"
            equal a[0:8] b[0:8]
            insert a[8:8] b[8:17]
            equal a[8:29] b[17:38]
        
            See the Differ class for a fancy human-friendly file differencer, which
            uses SequenceMatcher both to compare sequences of lines, and to compare
            sequences of characters within similar (near-matching) lines.
        
            See also function getCloseMatches() in this module, which shows how
            simple code building on SequenceMatcher can be used to do useful work.
        
            Timing:  Basic R-O is cubic time worst case and quadratic time expected
            case.  SequenceMatcher is quadratic time for the worst case and has
            expected-case behavior dependent in a complicated way on how many
            elements the sequences have in common; best case time is linear.
        
            Methods:
        
            constructor(isjunk=null, a='', b='')
                Construct a SequenceMatcher.
        
            setSeqs(a, b)
                Set the two sequences to be compared.
        
            setSeq1(a)
                Set the first sequence to be compared.
        
            setSeq2(b)
                Set the second sequence to be compared.
        
            findLongestMatch(alo, ahi, blo, bhi)
                Find longest matching block in a[alo:ahi] and b[blo:bhi].
        
            getMatchingBlocks()
                Return list of triples describing matching subsequences.
        
            getOpcodes()
                Return list of 5-tuples describing how to turn a into b.
        
            ratio()
                Return a measure of the sequences' similarity (float in [0,1]).
        
            quickRatio()
                Return an upper bound on .ratio() relatively quickly.
        
            realQuickRatio()
                Return an upper bound on ratio() very quickly.
            */
        constructor(isjunk1, a9 = "", b9 = "", autojunk = true) {
          this.isjunk = isjunk1;
          this.autojunk = autojunk;
          this.a = this.b = null;
          this.setSeqs(a9, b9);
        }
        setSeqs(a9, b9) {
          this.setSeq1(a9);
          return this.setSeq2(b9);
        }
        setSeq1(a9) {
          if (a9 === this.a) {
            return;
          }
          this.a = a9;
          return this.matchingBlocks = this.opcodes = null;
        }
        setSeq2(b9) {
          if (b9 === this.b) {
            return;
          }
          this.b = b9;
          this.matchingBlocks = this.opcodes = null;
          this.fullbcount = null;
          return this._chainB();
        }
        // For each element x in b, set b2j[x] to a list of the indices in
        // b where x appears; the indices are in increasing order; note that
        // the number of times x appears in b is b2j[x].length ...
        // when @isjunk is defined, junk elements don't show up in this
        // map at all, which stops the central findLongestMatch method
        // from starting any matching block at a junk element ...
        // also creates the fast isbjunk function ...
        // b2j also does not contain entries for "popular" elements, meaning
        // elements that account for more than 1 + 1% of the total elements, and
        // when the sequence is reasonably large (>= 200 elements); this can
        // be viewed as an adaptive notion of semi-junk, and yields an enormous
        // speedup when, e.g., comparing program files with hundreds of
        // instances of "return null;" ...
        // note that this is only called when b changes; so for cross-product
        // kinds of matches, it's best to call setSeq2 once, then setSeq1
        // repeatedly
        _chainB() {
          var b9, b2j, elt, i8, indices, isjunk, junk, l7, len, n7, ntest, popular;
          b9 = this.b;
          this.b2j = b2j = /* @__PURE__ */ new Map();
          for (i8 = l7 = 0, len = b9.length; l7 < len; i8 = ++l7) {
            elt = b9[i8];
            if (!b2j.has(elt)) {
              b2j.set(elt, []);
            }
            indices = b2j.get(elt);
            indices.push(i8);
          }
          junk = /* @__PURE__ */ new Map();
          isjunk = this.isjunk;
          if (isjunk) {
            b2j.forEach(function(idxs, elt2) {
              if (isjunk(elt2)) {
                junk.set(elt2, true);
                return b2j.delete(elt2);
              }
            });
          }
          popular = /* @__PURE__ */ new Map();
          n7 = b9.length;
          if (this.autojunk && n7 >= 200) {
            ntest = floor(n7 / 100) + 1;
            b2j.forEach(function(idxs, elt2) {
              if (idxs.length > ntest) {
                popular.set(elt2, true);
                return b2j.delete(elt2);
              }
            });
          }
          this.isbjunk = function(b10) {
            return junk.has(b10);
          };
          return this.isbpopular = function(b10) {
            return popular.has(b10);
          };
        }
        findLongestMatch(alo, ahi, blo, bhi) {
          var a9, b9, b2j, besti, bestj, bestsize, i8, isbjunk, j7, j2len, jlist, k9, l7, len, m12, newj2len, ref, ref1;
          [a9, b9, b2j, isbjunk] = [this.a, this.b, this.b2j, this.isbjunk];
          [besti, bestj, bestsize] = [alo, blo, 0];
          j2len = {};
          for (i8 = l7 = ref = alo, ref1 = ahi; ref <= ref1 ? l7 < ref1 : l7 > ref1; i8 = ref <= ref1 ? ++l7 : --l7) {
            newj2len = {};
            jlist = [];
            if (b2j.has(a9[i8])) {
              jlist = b2j.get(a9[i8]);
            }
            for (m12 = 0, len = jlist.length; m12 < len; m12++) {
              j7 = jlist[m12];
              if (j7 < blo) {
                continue;
              }
              if (j7 >= bhi) {
                break;
              }
              k9 = newj2len[j7] = (j2len[j7 - 1] || 0) + 1;
              if (k9 > bestsize) {
                [besti, bestj, bestsize] = [i8 - k9 + 1, j7 - k9 + 1, k9];
              }
            }
            j2len = newj2len;
          }
          while (besti > alo && bestj > blo && !isbjunk(b9[bestj - 1]) && a9[besti - 1] === b9[bestj - 1]) {
            [besti, bestj, bestsize] = [besti - 1, bestj - 1, bestsize + 1];
          }
          while (besti + bestsize < ahi && bestj + bestsize < bhi && !isbjunk(b9[bestj + bestsize]) && a9[besti + bestsize] === b9[bestj + bestsize]) {
            bestsize++;
          }
          while (besti > alo && bestj > blo && isbjunk(b9[bestj - 1]) && a9[besti - 1] === b9[bestj - 1]) {
            [besti, bestj, bestsize] = [besti - 1, bestj - 1, bestsize + 1];
          }
          while (besti + bestsize < ahi && bestj + bestsize < bhi && isbjunk(b9[bestj + bestsize]) && a9[besti + bestsize] === b9[bestj + bestsize]) {
            bestsize++;
          }
          return [besti, bestj, bestsize];
        }
        getMatchingBlocks() {
          var ahi, alo, bhi, blo, i8, i1, i22, j7, j1, j22, k9, k1, k22, l7, la, lb, len, matchingBlocks, nonAdjacent, queue, x11;
          if (this.matchingBlocks) {
            return this.matchingBlocks;
          }
          [la, lb] = [this.a.length, this.b.length];
          queue = [[0, la, 0, lb]];
          matchingBlocks = [];
          while (queue.length) {
            [alo, ahi, blo, bhi] = queue.pop();
            [i8, j7, k9] = x11 = this.findLongestMatch(alo, ahi, blo, bhi);
            if (k9) {
              matchingBlocks.push(x11);
              if (alo < i8 && blo < j7) {
                queue.push([alo, i8, blo, j7]);
              }
              if (i8 + k9 < ahi && j7 + k9 < bhi) {
                queue.push([i8 + k9, ahi, j7 + k9, bhi]);
              }
            }
          }
          matchingBlocks.sort(_arrayCmp);
          i1 = j1 = k1 = 0;
          nonAdjacent = [];
          for (l7 = 0, len = matchingBlocks.length; l7 < len; l7++) {
            [i22, j22, k22] = matchingBlocks[l7];
            if (i1 + k1 === i22 && j1 + k1 === j22) {
              k1 += k22;
            } else {
              if (k1) {
                nonAdjacent.push([i1, j1, k1]);
              }
              [i1, j1, k1] = [i22, j22, k22];
            }
          }
          if (k1) {
            nonAdjacent.push([i1, j1, k1]);
          }
          nonAdjacent.push([la, lb, 0]);
          return this.matchingBlocks = nonAdjacent;
        }
        getOpcodes() {
          var ai, answer, bj, i8, j7, l7, len, ref, size2, tag;
          if (this.opcodes) {
            return this.opcodes;
          }
          i8 = j7 = 0;
          this.opcodes = answer = [];
          ref = this.getMatchingBlocks();
          for (l7 = 0, len = ref.length; l7 < len; l7++) {
            [ai, bj, size2] = ref[l7];
            tag = "";
            if (i8 < ai && j7 < bj) {
              tag = "replace";
            } else if (i8 < ai) {
              tag = "delete";
            } else if (j7 < bj) {
              tag = "insert";
            }
            if (tag) {
              answer.push([tag, i8, ai, j7, bj]);
            }
            [i8, j7] = [ai + size2, bj + size2];
            if (size2) {
              answer.push(["equal", ai, i8, bj, j7]);
            }
          }
          return answer;
        }
        getGroupedOpcodes(n7 = 3) {
          var codes, group, groups, i1, i22, j1, j22, l7, len, nn2, tag;
          codes = this.getOpcodes();
          if (!codes.length) {
            codes = [["equal", 0, 1, 0, 1]];
          }
          if (codes[0][0] === "equal") {
            [tag, i1, i22, j1, j22] = codes[0];
            codes[0] = [tag, max2(i1, i22 - n7), i22, max2(j1, j22 - n7), j22];
          }
          if (codes[codes.length - 1][0] === "equal") {
            [tag, i1, i22, j1, j22] = codes[codes.length - 1];
            codes[codes.length - 1] = [tag, i1, min2(i22, i1 + n7), j1, min2(j22, j1 + n7)];
          }
          nn2 = n7 + n7;
          groups = [];
          group = [];
          for (l7 = 0, len = codes.length; l7 < len; l7++) {
            [tag, i1, i22, j1, j22] = codes[l7];
            if (tag === "equal" && i22 - i1 > nn2) {
              group.push([tag, i1, min2(i22, i1 + n7), j1, min2(j22, j1 + n7)]);
              groups.push(group);
              group = [];
              [i1, j1] = [max2(i1, i22 - n7), max2(j1, j22 - n7)];
            }
            group.push([tag, i1, i22, j1, j22]);
          }
          if (group.length && !(group.length === 1 && group[0][0] === "equal")) {
            groups.push(group);
          }
          return groups;
        }
        ratio() {
          var l7, len, match2, matches, ref;
          matches = 0;
          ref = this.getMatchingBlocks();
          for (l7 = 0, len = ref.length; l7 < len; l7++) {
            match2 = ref[l7];
            matches += match2[2];
          }
          return _calculateRatio(matches, this.a.length + this.b.length);
        }
        quickRatio() {
          var avail, elt, fullbcount, l7, len, len1, m12, matches, numb, ref, ref1;
          if (!this.fullbcount) {
            this.fullbcount = fullbcount = {};
            ref = this.b;
            for (l7 = 0, len = ref.length; l7 < len; l7++) {
              elt = ref[l7];
              fullbcount[elt] = (fullbcount[elt] || 0) + 1;
            }
          }
          fullbcount = this.fullbcount;
          avail = {};
          matches = 0;
          ref1 = this.a;
          for (m12 = 0, len1 = ref1.length; m12 < len1; m12++) {
            elt = ref1[m12];
            if (_has(avail, elt)) {
              numb = avail[elt];
            } else {
              numb = fullbcount[elt] || 0;
            }
            avail[elt] = numb - 1;
            if (numb > 0) {
              matches++;
            }
          }
          return _calculateRatio(matches, this.a.length + this.b.length);
        }
        realQuickRatio() {
          var la, lb;
          [la, lb] = [this.a.length, this.b.length];
          return _calculateRatio(min2(la, lb), la + lb);
        }
      };
      getCloseMatches = function(word, possibilities, n7 = 3, cutoff = 0.6) {
        var l7, len, len1, m12, result, results, s10, score, x11;
        if (!(n7 > 0)) {
          throw new Error(`n must be > 0: (${n7})`);
        }
        if (!(0 <= cutoff && cutoff <= 1)) {
          throw new Error(`cutoff must be in [0.0, 1.0]: (${cutoff})`);
        }
        result = [];
        s10 = new SequenceMatcher();
        s10.setSeq2(word);
        for (l7 = 0, len = possibilities.length; l7 < len; l7++) {
          x11 = possibilities[l7];
          s10.setSeq1(x11);
          if (s10.realQuickRatio() >= cutoff && s10.quickRatio() >= cutoff && s10.ratio() >= cutoff) {
            result.push([s10.ratio(), x11]);
          }
        }
        result = Heap.nlargest(result, n7, _arrayCmp);
        results = [];
        for (m12 = 0, len1 = result.length; m12 < len1; m12++) {
          [score, x11] = result[m12];
          results.push(x11);
        }
        return results;
      };
      _countLeading = function(line2, ch) {
        var i8, n7;
        [i8, n7] = [0, line2.length];
        while (i8 < n7 && line2[i8] === ch) {
          i8++;
        }
        return i8;
      };
      Differ = class Differ {
        /*
            Differ is a class for comparing sequences of lines of text, and
            producing human-readable differences or deltas.  Differ uses
            SequenceMatcher both to compare sequences of lines, and to compare
            sequences of characters within similar (near-matching) lines.
        
            Each line of a Differ delta begins with a two-letter code:
        
                '- '    line unique to sequence 1
                '+ '    line unique to sequence 2
                '  '    line common to both sequences
                '? '    line not present in either input sequence
        
            Lines beginning with '? ' attempt to guide the eye to intraline
            differences, and were not present in either input sequence.  These lines
            can be confusing if the sequences contain tab characters.
        
            Note that Differ makes no claim to produce a *minimal* diff.  To the
            contrary, minimal diffs are often counter-intuitive, because they synch
            up anywhere possible, sometimes accidental matches 100 pages apart.
            Restricting synch points to contiguous matches preserves some notion of
            locality, at the occasional cost of producing a longer diff.
        
            Example: Comparing two texts.
        
            >>> text1 = ['1. Beautiful is better than ugly.\n',
            ...   '2. Explicit is better than implicit.\n',
            ...   '3. Simple is better than complex.\n',
            ...   '4. Complex is better than complicated.\n']
            >>> text1.length
            4
            >>> text2 = ['1. Beautiful is better than ugly.\n',
            ...   '3.   Simple is better than complex.\n',
            ...   '4. Complicated is better than complex.\n',
            ...   '5. Flat is better than nested.\n']
        
            Next we instantiate a Differ object:
        
            >>> d = new Differ()
        
            Note that when instantiating a Differ object we may pass functions to
            filter out line and character 'junk'.
        
            Finally, we compare the two:
        
            >>> result = d.compare(text1, text2)
            [ '  1. Beautiful is better than ugly.\n',
              '- 2. Explicit is better than implicit.\n',
              '- 3. Simple is better than complex.\n',
              '+ 3.   Simple is better than complex.\n',
              '?   ++\n',
              '- 4. Complex is better than complicated.\n',
              '?          ^                     ---- ^\n',
              '+ 4. Complicated is better than complex.\n',
              '?         ++++ ^                      ^\n',
              '+ 5. Flat is better than nested.\n' ]
        
            Methods:
        
            constructor(linejunk=null, charjunk=null)
                Construct a text differencer, with optional filters.
            compare(a, b)
                Compare two sequences of lines; generate the resulting delta.
            */
        constructor(linejunk1, charjunk1) {
          this.linejunk = linejunk1;
          this.charjunk = charjunk1;
        }
        /*
            Construct a text differencer, with optional filters.
        
            The two optional keyword parameters are for filter functions:
        
            - `linejunk`: A function that should accept a single string argument,
              and return true iff the string is junk. The module-level function
              `IS_LINE_JUNK` may be used to filter out lines without visible
              characters, except for at most one splat ('#').  It is recommended
              to leave linejunk null. 
        
            - `charjunk`: A function that should accept a string of length 1. The
              module-level function `IS_CHARACTER_JUNK` may be used to filter out
              whitespace characters (a blank or tab; **note**: bad idea to include
              newline in this!).  Use of IS_CHARACTER_JUNK is recommended.
            */
        compare(a9, b9) {
          var ahi, alo, bhi, blo, cruncher, g10, l7, len, len1, line2, lines, m12, ref, tag;
          cruncher = new SequenceMatcher(this.linejunk, a9, b9);
          lines = [];
          ref = cruncher.getOpcodes();
          for (l7 = 0, len = ref.length; l7 < len; l7++) {
            [tag, alo, ahi, blo, bhi] = ref[l7];
            switch (tag) {
              case "replace":
                g10 = this._fancyReplace(a9, alo, ahi, b9, blo, bhi);
                break;
              case "delete":
                g10 = this._dump("-", a9, alo, ahi);
                break;
              case "insert":
                g10 = this._dump("+", b9, blo, bhi);
                break;
              case "equal":
                g10 = this._dump(" ", a9, alo, ahi);
                break;
              default:
                throw new Error(`unknow tag (${tag})`);
            }
            for (m12 = 0, len1 = g10.length; m12 < len1; m12++) {
              line2 = g10[m12];
              lines.push(line2);
            }
          }
          return lines;
        }
        _dump(tag, x11, lo, hi3) {
          var i8, l7, ref, ref1, results;
          results = [];
          for (i8 = l7 = ref = lo, ref1 = hi3; ref <= ref1 ? l7 < ref1 : l7 > ref1; i8 = ref <= ref1 ? ++l7 : --l7) {
            results.push(`${tag} ${x11[i8]}`);
          }
          return results;
        }
        _plainReplace(a9, alo, ahi, b9, blo, bhi) {
          var first, g10, l7, len, len1, line2, lines, m12, ref, second;
          assert2(alo < ahi && blo < bhi);
          if (bhi - blo < ahi - alo) {
            first = this._dump("+", b9, blo, bhi);
            second = this._dump("-", a9, alo, ahi);
          } else {
            first = this._dump("-", a9, alo, ahi);
            second = this._dump("+", b9, blo, bhi);
          }
          lines = [];
          ref = [first, second];
          for (l7 = 0, len = ref.length; l7 < len; l7++) {
            g10 = ref[l7];
            for (m12 = 0, len1 = g10.length; m12 < len1; m12++) {
              line2 = g10[m12];
              lines.push(line2);
            }
          }
          return lines;
        }
        _fancyReplace(a9, alo, ahi, b9, blo, bhi) {
          var aelt, ai, ai1, ai2, atags, belt, bestRatio, besti, bestj, bj, bj1, bj2, btags, cruncher, cutoff, eqi, eqj, i8, j7, l7, la, lb, len, len1, len2, len3, len4, line2, lines, m12, o9, p11, q7, r6, ref, ref1, ref2, ref3, ref4, ref5, ref6, ref7, ref8, t6, tag;
          [bestRatio, cutoff] = [0.74, 0.75];
          cruncher = new SequenceMatcher(this.charjunk);
          [eqi, eqj] = [
            null,
            null
            // 1st indices of equal lines (if any)
          ];
          lines = [];
          for (j7 = l7 = ref = blo, ref1 = bhi; ref <= ref1 ? l7 < ref1 : l7 > ref1; j7 = ref <= ref1 ? ++l7 : --l7) {
            bj = b9[j7];
            cruncher.setSeq2(bj);
            for (i8 = m12 = ref2 = alo, ref3 = ahi; ref2 <= ref3 ? m12 < ref3 : m12 > ref3; i8 = ref2 <= ref3 ? ++m12 : --m12) {
              ai = a9[i8];
              if (ai === bj) {
                if (eqi === null) {
                  [eqi, eqj] = [i8, j7];
                }
                continue;
              }
              cruncher.setSeq1(ai);
              if (cruncher.realQuickRatio() > bestRatio && cruncher.quickRatio() > bestRatio && cruncher.ratio() > bestRatio) {
                [bestRatio, besti, bestj] = [cruncher.ratio(), i8, j7];
              }
            }
          }
          if (bestRatio < cutoff) {
            if (eqi === null) {
              ref4 = this._plainReplace(a9, alo, ahi, b9, blo, bhi);
              for (o9 = 0, len = ref4.length; o9 < len; o9++) {
                line2 = ref4[o9];
                lines.push(line2);
              }
              return lines;
            }
            [besti, bestj, bestRatio] = [eqi, eqj, 1];
          } else {
            eqi = null;
          }
          ref5 = this._fancyHelper(a9, alo, besti, b9, blo, bestj);
          for (p11 = 0, len1 = ref5.length; p11 < len1; p11++) {
            line2 = ref5[p11];
            lines.push(line2);
          }
          [aelt, belt] = [a9[besti], b9[bestj]];
          if (eqi === null) {
            atags = btags = "";
            cruncher.setSeqs(aelt, belt);
            ref6 = cruncher.getOpcodes();
            for (q7 = 0, len2 = ref6.length; q7 < len2; q7++) {
              [tag, ai1, ai2, bj1, bj2] = ref6[q7];
              [la, lb] = [ai2 - ai1, bj2 - bj1];
              switch (tag) {
                case "replace":
                  atags += Array(la + 1).join("^");
                  btags += Array(lb + 1).join("^");
                  break;
                case "delete":
                  atags += Array(la + 1).join("-");
                  break;
                case "insert":
                  btags += Array(lb + 1).join("+");
                  break;
                case "equal":
                  atags += Array(la + 1).join(" ");
                  btags += Array(lb + 1).join(" ");
                  break;
                default:
                  throw new Error(`unknow tag (${tag})`);
              }
            }
            ref7 = this._qformat(aelt, belt, atags, btags);
            for (r6 = 0, len3 = ref7.length; r6 < len3; r6++) {
              line2 = ref7[r6];
              lines.push(line2);
            }
          } else {
            lines.push("  " + aelt);
          }
          ref8 = this._fancyHelper(a9, besti + 1, ahi, b9, bestj + 1, bhi);
          for (t6 = 0, len4 = ref8.length; t6 < len4; t6++) {
            line2 = ref8[t6];
            lines.push(line2);
          }
          return lines;
        }
        _fancyHelper(a9, alo, ahi, b9, blo, bhi) {
          var g10;
          g10 = [];
          if (alo < ahi) {
            if (blo < bhi) {
              g10 = this._fancyReplace(a9, alo, ahi, b9, blo, bhi);
            } else {
              g10 = this._dump("-", a9, alo, ahi);
            }
          } else if (blo < bhi) {
            g10 = this._dump("+", b9, blo, bhi);
          }
          return g10;
        }
        _qformat(aline, bline, atags, btags) {
          var common, lines;
          lines = [];
          common = min2(_countLeading(aline, "	"), _countLeading(bline, "	"));
          common = min2(common, _countLeading(atags.slice(0, common), " "));
          common = min2(common, _countLeading(btags.slice(0, common), " "));
          atags = atags.slice(common).replace(/\s+$/, "");
          btags = btags.slice(common).replace(/\s+$/, "");
          lines.push("- " + aline);
          if (atags.length) {
            lines.push(`? ${Array(common + 1).join("	")}${atags}
`);
          }
          lines.push("+ " + bline);
          if (btags.length) {
            lines.push(`? ${Array(common + 1).join("	")}${btags}
`);
          }
          return lines;
        }
      };
      IS_LINE_JUNK = function(line2, pat = /^\s*#?\s*$/) {
        return pat.test(line2);
      };
      IS_CHARACTER_JUNK = function(ch, ws4 = " 	") {
        return indexOf.call(ws4, ch) >= 0;
      };
      _formatRangeUnified = function(start2, stop2) {
        var beginning, length;
        beginning = start2 + 1;
        length = stop2 - start2;
        if (length === 1) {
          return `${beginning}`;
        }
        if (!length) {
          beginning--;
        }
        return `${beginning},${length}`;
      };
      unifiedDiff = function(a9, b9, { fromfile, tofile, fromfiledate, tofiledate, n: n7, lineterm } = {}) {
        var file1Range, file2Range, first, fromdate, group, i1, i22, j1, j22, l7, last, len, len1, len2, len3, len4, line2, lines, m12, o9, p11, q7, ref, ref1, ref2, ref3, started, tag, todate;
        if (fromfile == null) {
          fromfile = "";
        }
        if (tofile == null) {
          tofile = "";
        }
        if (fromfiledate == null) {
          fromfiledate = "";
        }
        if (tofiledate == null) {
          tofiledate = "";
        }
        if (n7 == null) {
          n7 = 3;
        }
        if (lineterm == null) {
          lineterm = "\n";
        }
        lines = [];
        started = false;
        ref = new SequenceMatcher(null, a9, b9).getGroupedOpcodes();
        for (l7 = 0, len = ref.length; l7 < len; l7++) {
          group = ref[l7];
          if (!started) {
            started = true;
            fromdate = fromfiledate ? `	${fromfiledate}` : "";
            todate = tofiledate ? `	${tofiledate}` : "";
            lines.push(`--- ${fromfile}${fromdate}${lineterm}`);
            lines.push(`+++ ${tofile}${todate}${lineterm}`);
          }
          [first, last] = [group[0], group[group.length - 1]];
          file1Range = _formatRangeUnified(first[1], last[2]);
          file2Range = _formatRangeUnified(first[3], last[4]);
          lines.push(`@@ -${file1Range} +${file2Range} @@${lineterm}`);
          for (m12 = 0, len1 = group.length; m12 < len1; m12++) {
            [tag, i1, i22, j1, j22] = group[m12];
            if (tag === "equal") {
              ref1 = a9.slice(i1, i22);
              for (o9 = 0, len2 = ref1.length; o9 < len2; o9++) {
                line2 = ref1[o9];
                lines.push(" " + line2);
              }
              continue;
            }
            if (tag === "replace" || tag === "delete") {
              ref2 = a9.slice(i1, i22);
              for (p11 = 0, len3 = ref2.length; p11 < len3; p11++) {
                line2 = ref2[p11];
                lines.push("-" + line2);
              }
            }
            if (tag === "replace" || tag === "insert") {
              ref3 = b9.slice(j1, j22);
              for (q7 = 0, len4 = ref3.length; q7 < len4; q7++) {
                line2 = ref3[q7];
                lines.push("+" + line2);
              }
            }
          }
        }
        return lines;
      };
      _formatRangeContext = function(start2, stop2) {
        var beginning, length;
        beginning = start2 + 1;
        length = stop2 - start2;
        if (!length) {
          beginning--;
        }
        if (length <= 1) {
          return `${beginning}`;
        }
        return `${beginning},${beginning + length - 1}`;
      };
      contextDiff = function(a9, b9, { fromfile, tofile, fromfiledate, tofiledate, n: n7, lineterm } = {}) {
        var _7, file1Range, file2Range, first, fromdate, group, i1, i22, j1, j22, l7, last, len, len1, len2, len3, len4, line2, lines, m12, o9, p11, prefix2, q7, ref, ref1, ref2, started, tag, todate;
        if (fromfile == null) {
          fromfile = "";
        }
        if (tofile == null) {
          tofile = "";
        }
        if (fromfiledate == null) {
          fromfiledate = "";
        }
        if (tofiledate == null) {
          tofiledate = "";
        }
        if (n7 == null) {
          n7 = 3;
        }
        if (lineterm == null) {
          lineterm = "\n";
        }
        prefix2 = {
          insert: "+ ",
          delete: "- ",
          replace: "! ",
          equal: "  "
        };
        started = false;
        lines = [];
        ref = new SequenceMatcher(null, a9, b9).getGroupedOpcodes();
        for (l7 = 0, len = ref.length; l7 < len; l7++) {
          group = ref[l7];
          if (!started) {
            started = true;
            fromdate = fromfiledate ? `	${fromfiledate}` : "";
            todate = tofiledate ? `	${tofiledate}` : "";
            lines.push(`*** ${fromfile}${fromdate}${lineterm}`);
            lines.push(`--- ${tofile}${todate}${lineterm}`);
            [first, last] = [group[0], group[group.length - 1]];
            lines.push("***************" + lineterm);
            file1Range = _formatRangeContext(first[1], last[2]);
            lines.push(`*** ${file1Range} ****${lineterm}`);
            if (_any(function() {
              var len12, m13, results;
              results = [];
              for (m13 = 0, len12 = group.length; m13 < len12; m13++) {
                [tag, _7, _7, _7, _7] = group[m13];
                results.push(tag === "replace" || tag === "delete");
              }
              return results;
            }())) {
              for (m12 = 0, len1 = group.length; m12 < len1; m12++) {
                [tag, i1, i22, _7, _7] = group[m12];
                if (tag !== "insert") {
                  ref1 = a9.slice(i1, i22);
                  for (o9 = 0, len2 = ref1.length; o9 < len2; o9++) {
                    line2 = ref1[o9];
                    lines.push(prefix2[tag] + line2);
                  }
                }
              }
            }
            file2Range = _formatRangeContext(first[3], last[4]);
            lines.push(`--- ${file2Range} ----${lineterm}`);
            if (_any(function() {
              var len32, p12, results;
              results = [];
              for (p12 = 0, len32 = group.length; p12 < len32; p12++) {
                [tag, _7, _7, _7, _7] = group[p12];
                results.push(tag === "replace" || tag === "insert");
              }
              return results;
            }())) {
              for (p11 = 0, len3 = group.length; p11 < len3; p11++) {
                [tag, _7, _7, j1, j22] = group[p11];
                if (tag !== "delete") {
                  ref2 = b9.slice(j1, j22);
                  for (q7 = 0, len4 = ref2.length; q7 < len4; q7++) {
                    line2 = ref2[q7];
                    lines.push(prefix2[tag] + line2);
                  }
                }
              }
            }
          }
        }
        return lines;
      };
      ndiff = function(a9, b9, linejunk, charjunk = IS_CHARACTER_JUNK) {
        return new Differ(linejunk, charjunk).compare(a9, b9);
      };
      restore = function(delta, which) {
        var l7, len, line2, lines, prefixes2, ref, tag;
        tag = {
          1: "- ",
          2: "+ "
        }[which];
        if (!tag) {
          throw new Error(`unknow delta choice (must be 1 or 2): ${which}`);
        }
        prefixes2 = ["  ", tag];
        lines = [];
        for (l7 = 0, len = delta.length; l7 < len; l7++) {
          line2 = delta[l7];
          if (ref = line2.slice(0, 2), indexOf.call(prefixes2, ref) >= 0) {
            lines.push(line2.slice(2));
          }
        }
        return lines;
      };
      exports2._arrayCmp = _arrayCmp;
      exports2.SequenceMatcher = SequenceMatcher;
      exports2.getCloseMatches = getCloseMatches;
      exports2._countLeading = _countLeading;
      exports2.Differ = Differ;
      exports2.IS_LINE_JUNK = IS_LINE_JUNK;
      exports2.IS_CHARACTER_JUNK = IS_CHARACTER_JUNK;
      exports2._formatRangeUnified = _formatRangeUnified;
      exports2.unifiedDiff = unifiedDiff;
      exports2._formatRangeContext = _formatRangeContext;
      exports2.contextDiff = contextDiff;
      exports2.ndiff = ndiff;
      exports2.restore = restore;
    }).call(exports2);
  }
});

// ../node_modules/.pnpm/@ewoudenberg+difflib@0.1.0/node_modules/@ewoudenberg/difflib/index.js
var require_difflib2 = __commonJS({
  "../node_modules/.pnpm/@ewoudenberg+difflib@0.1.0/node_modules/@ewoudenberg/difflib/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_difflib();
  }
});

// ../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/util.js
var require_util = __commonJS({
  "../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/util.js"(exports2, module2) {
    "use strict";
    var extendedTypeOf = function(obj) {
      const result = typeof obj;
      if (obj == null) {
        return "null";
      } else if (result === "object" && obj.constructor === Array) {
        return "array";
      } else if (result === "object" && obj instanceof Date) {
        return "date";
      } else {
        return result;
      }
    };
    var roundObj = function(data, precision) {
      const type = typeof data;
      if (type === "array") {
        return data.map((x11) => roundObj(x11, precision));
      } else if (type === "object") {
        for (const key in data) {
          data[key] = roundObj(data[key], precision);
        }
        return data;
      } else if (type === "number" && Number.isFinite(data) && !Number.isInteger(data)) {
        return +data.toFixed(precision);
      } else {
        return data;
      }
    };
    module2.exports = { extendedTypeOf, roundObj };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/styles.js
var require_styles = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/styles.js"(exports2, module2) {
    "use strict";
    var styles3 = {};
    module2["exports"] = styles3;
    var codes = {
      reset: [0, 0],
      bold: [1, 22],
      dim: [2, 22],
      italic: [3, 23],
      underline: [4, 24],
      inverse: [7, 27],
      hidden: [8, 28],
      strikethrough: [9, 29],
      black: [30, 39],
      red: [31, 39],
      green: [32, 39],
      yellow: [33, 39],
      blue: [34, 39],
      magenta: [35, 39],
      cyan: [36, 39],
      white: [37, 39],
      gray: [90, 39],
      grey: [90, 39],
      brightRed: [91, 39],
      brightGreen: [92, 39],
      brightYellow: [93, 39],
      brightBlue: [94, 39],
      brightMagenta: [95, 39],
      brightCyan: [96, 39],
      brightWhite: [97, 39],
      bgBlack: [40, 49],
      bgRed: [41, 49],
      bgGreen: [42, 49],
      bgYellow: [43, 49],
      bgBlue: [44, 49],
      bgMagenta: [45, 49],
      bgCyan: [46, 49],
      bgWhite: [47, 49],
      bgGray: [100, 49],
      bgGrey: [100, 49],
      bgBrightRed: [101, 49],
      bgBrightGreen: [102, 49],
      bgBrightYellow: [103, 49],
      bgBrightBlue: [104, 49],
      bgBrightMagenta: [105, 49],
      bgBrightCyan: [106, 49],
      bgBrightWhite: [107, 49],
      // legacy styles for colors pre v1.0.0
      blackBG: [40, 49],
      redBG: [41, 49],
      greenBG: [42, 49],
      yellowBG: [43, 49],
      blueBG: [44, 49],
      magentaBG: [45, 49],
      cyanBG: [46, 49],
      whiteBG: [47, 49]
    };
    Object.keys(codes).forEach(function(key) {
      var val2 = codes[key];
      var style = styles3[key] = [];
      style.open = "\x1B[" + val2[0] + "m";
      style.close = "\x1B[" + val2[1] + "m";
    });
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/system/has-flag.js
var require_has_flag = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/system/has-flag.js"(exports2, module2) {
    "use strict";
    module2.exports = function(flag, argv) {
      argv = argv || process.argv;
      var terminatorPos = argv.indexOf("--");
      var prefix2 = /^-{1,2}/.test(flag) ? "" : "--";
      var pos = argv.indexOf(prefix2 + flag);
      return pos !== -1 && (terminatorPos === -1 ? true : pos < terminatorPos);
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/system/supports-colors.js
var require_supports_colors = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/system/supports-colors.js"(exports2, module2) {
    "use strict";
    var os4 = require("os");
    var hasFlag2 = require_has_flag();
    var env4 = process.env;
    var forceColor = void 0;
    if (hasFlag2("no-color") || hasFlag2("no-colors") || hasFlag2("color=false")) {
      forceColor = false;
    } else if (hasFlag2("color") || hasFlag2("colors") || hasFlag2("color=true") || hasFlag2("color=always")) {
      forceColor = true;
    }
    if ("FORCE_COLOR" in env4) {
      forceColor = env4.FORCE_COLOR.length === 0 || parseInt(env4.FORCE_COLOR, 10) !== 0;
    }
    function translateLevel2(level) {
      if (level === 0) {
        return false;
      }
      return {
        level,
        hasBasic: true,
        has256: level >= 2,
        has16m: level >= 3
      };
    }
    function supportsColor2(stream) {
      if (forceColor === false) {
        return 0;
      }
      if (hasFlag2("color=16m") || hasFlag2("color=full") || hasFlag2("color=truecolor")) {
        return 3;
      }
      if (hasFlag2("color=256")) {
        return 2;
      }
      if (stream && !stream.isTTY && forceColor !== true) {
        return 0;
      }
      var min2 = forceColor ? 1 : 0;
      if (process.platform === "win32") {
        var osRelease = os4.release().split(".");
        if (Number(process.versions.node.split(".")[0]) >= 8 && Number(osRelease[0]) >= 10 && Number(osRelease[2]) >= 10586) {
          return Number(osRelease[2]) >= 14931 ? 3 : 2;
        }
        return 1;
      }
      if ("CI" in env4) {
        if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI"].some(function(sign) {
          return sign in env4;
        }) || env4.CI_NAME === "codeship") {
          return 1;
        }
        return min2;
      }
      if ("TEAMCITY_VERSION" in env4) {
        return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env4.TEAMCITY_VERSION) ? 1 : 0;
      }
      if ("TERM_PROGRAM" in env4) {
        var version3 = parseInt((env4.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
        switch (env4.TERM_PROGRAM) {
          case "iTerm.app":
            return version3 >= 3 ? 3 : 2;
          case "Hyper":
            return 3;
          case "Apple_Terminal":
            return 2;
        }
      }
      if (/-256(color)?$/i.test(env4.TERM)) {
        return 2;
      }
      if (/^screen|^xterm|^vt100|^rxvt|color|ansi|cygwin|linux/i.test(env4.TERM)) {
        return 1;
      }
      if ("COLORTERM" in env4) {
        return 1;
      }
      if (env4.TERM === "dumb") {
        return min2;
      }
      return min2;
    }
    function getSupportLevel(stream) {
      var level = supportsColor2(stream);
      return translateLevel2(level);
    }
    module2.exports = {
      supportsColor: getSupportLevel,
      stdout: getSupportLevel(process.stdout),
      stderr: getSupportLevel(process.stderr)
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/custom/trap.js
var require_trap = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/custom/trap.js"(exports2, module2) {
    "use strict";
    module2["exports"] = function runTheTrap(text5, options) {
      var result = "";
      text5 = text5 || "Run the trap, drop the bass";
      text5 = text5.split("");
      var trap = {
        a: ["@", "\u0104", "\u023A", "\u0245", "\u0394", "\u039B", "\u0414"],
        b: ["\xDF", "\u0181", "\u0243", "\u026E", "\u03B2", "\u0E3F"],
        c: ["\xA9", "\u023B", "\u03FE"],
        d: ["\xD0", "\u018A", "\u0500", "\u0501", "\u0502", "\u0503"],
        e: [
          "\xCB",
          "\u0115",
          "\u018E",
          "\u0258",
          "\u03A3",
          "\u03BE",
          "\u04BC",
          "\u0A6C"
        ],
        f: ["\u04FA"],
        g: ["\u0262"],
        h: ["\u0126", "\u0195", "\u04A2", "\u04BA", "\u04C7", "\u050A"],
        i: ["\u0F0F"],
        j: ["\u0134"],
        k: ["\u0138", "\u04A0", "\u04C3", "\u051E"],
        l: ["\u0139"],
        m: ["\u028D", "\u04CD", "\u04CE", "\u0520", "\u0521", "\u0D69"],
        n: ["\xD1", "\u014B", "\u019D", "\u0376", "\u03A0", "\u048A"],
        o: [
          "\xD8",
          "\xF5",
          "\xF8",
          "\u01FE",
          "\u0298",
          "\u047A",
          "\u05DD",
          "\u06DD",
          "\u0E4F"
        ],
        p: ["\u01F7", "\u048E"],
        q: ["\u09CD"],
        r: ["\xAE", "\u01A6", "\u0210", "\u024C", "\u0280", "\u042F"],
        s: ["\xA7", "\u03DE", "\u03DF", "\u03E8"],
        t: ["\u0141", "\u0166", "\u0373"],
        u: ["\u01B1", "\u054D"],
        v: ["\u05D8"],
        w: ["\u0428", "\u0460", "\u047C", "\u0D70"],
        x: ["\u04B2", "\u04FE", "\u04FC", "\u04FD"],
        y: ["\xA5", "\u04B0", "\u04CB"],
        z: ["\u01B5", "\u0240"]
      };
      text5.forEach(function(c6) {
        c6 = c6.toLowerCase();
        var chars = trap[c6] || [" "];
        var rand = Math.floor(Math.random() * chars.length);
        if (typeof trap[c6] !== "undefined") {
          result += trap[c6][rand];
        } else {
          result += c6;
        }
      });
      return result;
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/custom/zalgo.js
var require_zalgo = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/custom/zalgo.js"(exports2, module2) {
    "use strict";
    module2["exports"] = function zalgo(text5, options) {
      text5 = text5 || "   he is here   ";
      var soul = {
        "up": [
          "\u030D",
          "\u030E",
          "\u0304",
          "\u0305",
          "\u033F",
          "\u0311",
          "\u0306",
          "\u0310",
          "\u0352",
          "\u0357",
          "\u0351",
          "\u0307",
          "\u0308",
          "\u030A",
          "\u0342",
          "\u0313",
          "\u0308",
          "\u034A",
          "\u034B",
          "\u034C",
          "\u0303",
          "\u0302",
          "\u030C",
          "\u0350",
          "\u0300",
          "\u0301",
          "\u030B",
          "\u030F",
          "\u0312",
          "\u0313",
          "\u0314",
          "\u033D",
          "\u0309",
          "\u0363",
          "\u0364",
          "\u0365",
          "\u0366",
          "\u0367",
          "\u0368",
          "\u0369",
          "\u036A",
          "\u036B",
          "\u036C",
          "\u036D",
          "\u036E",
          "\u036F",
          "\u033E",
          "\u035B",
          "\u0346",
          "\u031A"
        ],
        "down": [
          "\u0316",
          "\u0317",
          "\u0318",
          "\u0319",
          "\u031C",
          "\u031D",
          "\u031E",
          "\u031F",
          "\u0320",
          "\u0324",
          "\u0325",
          "\u0326",
          "\u0329",
          "\u032A",
          "\u032B",
          "\u032C",
          "\u032D",
          "\u032E",
          "\u032F",
          "\u0330",
          "\u0331",
          "\u0332",
          "\u0333",
          "\u0339",
          "\u033A",
          "\u033B",
          "\u033C",
          "\u0345",
          "\u0347",
          "\u0348",
          "\u0349",
          "\u034D",
          "\u034E",
          "\u0353",
          "\u0354",
          "\u0355",
          "\u0356",
          "\u0359",
          "\u035A",
          "\u0323"
        ],
        "mid": [
          "\u0315",
          "\u031B",
          "\u0300",
          "\u0301",
          "\u0358",
          "\u0321",
          "\u0322",
          "\u0327",
          "\u0328",
          "\u0334",
          "\u0335",
          "\u0336",
          "\u035C",
          "\u035D",
          "\u035E",
          "\u035F",
          "\u0360",
          "\u0362",
          "\u0338",
          "\u0337",
          "\u0361",
          " \u0489"
        ]
      };
      var all = [].concat(soul.up, soul.down, soul.mid);
      function randomNumber(range) {
        var r6 = Math.floor(Math.random() * range);
        return r6;
      }
      function isChar(character) {
        var bool = false;
        all.filter(function(i8) {
          bool = i8 === character;
        });
        return bool;
      }
      function heComes(text6, options2) {
        var result = "";
        var counts;
        var l7;
        options2 = options2 || {};
        options2["up"] = typeof options2["up"] !== "undefined" ? options2["up"] : true;
        options2["mid"] = typeof options2["mid"] !== "undefined" ? options2["mid"] : true;
        options2["down"] = typeof options2["down"] !== "undefined" ? options2["down"] : true;
        options2["size"] = typeof options2["size"] !== "undefined" ? options2["size"] : "maxi";
        text6 = text6.split("");
        for (l7 in text6) {
          if (isChar(l7)) {
            continue;
          }
          result = result + text6[l7];
          counts = { "up": 0, "down": 0, "mid": 0 };
          switch (options2.size) {
            case "mini":
              counts.up = randomNumber(8);
              counts.mid = randomNumber(2);
              counts.down = randomNumber(8);
              break;
            case "maxi":
              counts.up = randomNumber(16) + 3;
              counts.mid = randomNumber(4) + 1;
              counts.down = randomNumber(64) + 3;
              break;
            default:
              counts.up = randomNumber(8) + 1;
              counts.mid = randomNumber(6) / 2;
              counts.down = randomNumber(8) + 1;
              break;
          }
          var arr = ["up", "mid", "down"];
          for (var d7 in arr) {
            var index7 = arr[d7];
            for (var i8 = 0; i8 <= counts[index7]; i8++) {
              if (options2[index7]) {
                result = result + soul[index7][randomNumber(soul[index7].length)];
              }
            }
          }
        }
        return result;
      }
      return heComes(text5, options);
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/america.js
var require_america = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/america.js"(exports2, module2) {
    "use strict";
    module2["exports"] = function(colors) {
      return function(letter, i8, exploded) {
        if (letter === " ") return letter;
        switch (i8 % 3) {
          case 0:
            return colors.red(letter);
          case 1:
            return colors.white(letter);
          case 2:
            return colors.blue(letter);
        }
      };
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/zebra.js
var require_zebra = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/zebra.js"(exports2, module2) {
    "use strict";
    module2["exports"] = function(colors) {
      return function(letter, i8, exploded) {
        return i8 % 2 === 0 ? letter : colors.inverse(letter);
      };
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/rainbow.js
var require_rainbow = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/rainbow.js"(exports2, module2) {
    "use strict";
    module2["exports"] = function(colors) {
      var rainbowColors = ["red", "yellow", "green", "blue", "magenta"];
      return function(letter, i8, exploded) {
        if (letter === " ") {
          return letter;
        } else {
          return colors[rainbowColors[i8++ % rainbowColors.length]](letter);
        }
      };
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/random.js
var require_random = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/maps/random.js"(exports2, module2) {
    "use strict";
    module2["exports"] = function(colors) {
      var available = [
        "underline",
        "inverse",
        "grey",
        "yellow",
        "red",
        "green",
        "blue",
        "white",
        "cyan",
        "magenta",
        "brightYellow",
        "brightRed",
        "brightGreen",
        "brightBlue",
        "brightWhite",
        "brightCyan",
        "brightMagenta"
      ];
      return function(letter, i8, exploded) {
        return letter === " " ? letter : colors[available[Math.round(Math.random() * (available.length - 2))]](letter);
      };
    };
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/colors.js
var require_colors = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/lib/colors.js"(exports2, module2) {
    "use strict";
    var colors = {};
    module2["exports"] = colors;
    colors.themes = {};
    var util2 = require("util");
    var ansiStyles2 = colors.styles = require_styles();
    var defineProps = Object.defineProperties;
    var newLineRegex = new RegExp(/[\r\n]+/g);
    colors.supportsColor = require_supports_colors().supportsColor;
    if (typeof colors.enabled === "undefined") {
      colors.enabled = colors.supportsColor() !== false;
    }
    colors.enable = function() {
      colors.enabled = true;
    };
    colors.disable = function() {
      colors.enabled = false;
    };
    colors.stripColors = colors.strip = function(str) {
      return ("" + str).replace(/\x1B\[\d+m/g, "");
    };
    var stylize = colors.stylize = function stylize2(str, style) {
      if (!colors.enabled) {
        return str + "";
      }
      var styleMap = ansiStyles2[style];
      if (!styleMap && style in colors) {
        return colors[style](str);
      }
      return styleMap.open + str + styleMap.close;
    };
    var matchOperatorsRe = /[|\\{}()[\]^$+*?.]/g;
    var escapeStringRegexp = function(str) {
      if (typeof str !== "string") {
        throw new TypeError("Expected a string");
      }
      return str.replace(matchOperatorsRe, "\\$&");
    };
    function build(_styles) {
      var builder = function builder2() {
        return applyStyle2.apply(builder2, arguments);
      };
      builder._styles = _styles;
      builder.__proto__ = proto2;
      return builder;
    }
    var styles3 = function() {
      var ret = {};
      ansiStyles2.grey = ansiStyles2.gray;
      Object.keys(ansiStyles2).forEach(function(key) {
        ansiStyles2[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles2[key].close), "g");
        ret[key] = {
          get: function() {
            return build(this._styles.concat(key));
          }
        };
      });
      return ret;
    }();
    var proto2 = defineProps(function colors2() {
    }, styles3);
    function applyStyle2() {
      var args2 = Array.prototype.slice.call(arguments);
      var str = args2.map(function(arg) {
        if (arg != null && arg.constructor === String) {
          return arg;
        } else {
          return util2.inspect(arg);
        }
      }).join(" ");
      if (!colors.enabled || !str) {
        return str;
      }
      var newLinesPresent = str.indexOf("\n") != -1;
      var nestedStyles = this._styles;
      var i8 = nestedStyles.length;
      while (i8--) {
        var code = ansiStyles2[nestedStyles[i8]];
        str = code.open + str.replace(code.closeRe, code.open) + code.close;
        if (newLinesPresent) {
          str = str.replace(newLineRegex, function(match2) {
            return code.close + match2 + code.open;
          });
        }
      }
      return str;
    }
    colors.setTheme = function(theme) {
      if (typeof theme === "string") {
        console.log("colors.setTheme now only accepts an object, not a string.  If you are trying to set a theme from a file, it is now your (the caller's) responsibility to require the file.  The old syntax looked like colors.setTheme(__dirname + '/../themes/generic-logging.js'); The new syntax looks like colors.setTheme(require(__dirname + '/../themes/generic-logging.js'));");
        return;
      }
      for (var style in theme) {
        (function(style2) {
          colors[style2] = function(str) {
            if (typeof theme[style2] === "object") {
              var out2 = str;
              for (var i8 in theme[style2]) {
                out2 = colors[theme[style2][i8]](out2);
              }
              return out2;
            }
            return colors[theme[style2]](str);
          };
        })(style);
      }
    };
    function init3() {
      var ret = {};
      Object.keys(styles3).forEach(function(name3) {
        ret[name3] = {
          get: function() {
            return build([name3]);
          }
        };
      });
      return ret;
    }
    var sequencer = function sequencer2(map3, str) {
      var exploded = str.split("");
      exploded = exploded.map(map3);
      return exploded.join("");
    };
    colors.trap = require_trap();
    colors.zalgo = require_zalgo();
    colors.maps = {};
    colors.maps.america = require_america()(colors);
    colors.maps.zebra = require_zebra()(colors);
    colors.maps.rainbow = require_rainbow()(colors);
    colors.maps.random = require_random()(colors);
    for (map2 in colors.maps) {
      (function(map3) {
        colors[map3] = function(str) {
          return sequencer(colors.maps[map3], str);
        };
      })(map2);
    }
    var map2;
    defineProps(colors, init3());
  }
});

// ../node_modules/.pnpm/colors@1.4.0/node_modules/colors/safe.js
var require_safe = __commonJS({
  "../node_modules/.pnpm/colors@1.4.0/node_modules/colors/safe.js"(exports2, module2) {
    "use strict";
    var colors = require_colors();
    module2["exports"] = colors;
  }
});

// ../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/colorize.js
var require_colorize = __commonJS({
  "../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/colorize.js"(exports2, module2) {
    "use strict";
    var color = require_safe();
    var { extendedTypeOf } = require_util();
    var Theme = {
      " "(s10) {
        return s10;
      },
      "+": color.green,
      "-": color.red
    };
    var subcolorizeToCallback = function(options, key, diff2, output, color2, indent) {
      let subvalue;
      const prefix2 = key ? `${key}: ` : "";
      const subindent = indent + "  ";
      const outputElisions = (n7) => {
        const maxElisions = options.maxElisions === void 0 ? Infinity : options.maxElisions;
        if (n7 < maxElisions) {
          for (let i8 = 0; i8 < n7; i8++) {
            output(" ", subindent + "...");
          }
        } else {
          output(" ", subindent + `... (${n7} entries)`);
        }
      };
      switch (extendedTypeOf(diff2)) {
        case "object":
          if ("__old" in diff2 && "__new" in diff2 && Object.keys(diff2).length === 2) {
            subcolorizeToCallback(options, key, diff2.__old, output, "-", indent);
            return subcolorizeToCallback(options, key, diff2.__new, output, "+", indent);
          } else {
            output(color2, `${indent}${prefix2}{`);
            for (const subkey of Object.keys(diff2)) {
              let m12;
              subvalue = diff2[subkey];
              if (m12 = subkey.match(/^(.*)__deleted$/)) {
                subcolorizeToCallback(options, m12[1], subvalue, output, "-", subindent);
              } else if (m12 = subkey.match(/^(.*)__added$/)) {
                subcolorizeToCallback(options, m12[1], subvalue, output, "+", subindent);
              } else {
                subcolorizeToCallback(options, subkey, subvalue, output, color2, subindent);
              }
            }
            return output(color2, `${indent}}`);
          }
        case "array": {
          output(color2, `${indent}${prefix2}[`);
          let looksLikeDiff = true;
          for (const item of diff2) {
            if (extendedTypeOf(item) !== "array" || !(item.length === 2 || item.length === 1 && item[0] === " ") || !(typeof item[0] === "string") || item[0].length !== 1 || ![" ", "-", "+", "~"].includes(item[0])) {
              looksLikeDiff = false;
            }
          }
          if (looksLikeDiff) {
            let op;
            let elisionCount = 0;
            for ([op, subvalue] of diff2) {
              if (op === " " && subvalue == null) {
                elisionCount++;
              } else {
                if (elisionCount > 0) {
                  outputElisions(elisionCount);
                }
                elisionCount = 0;
                if (![" ", "~", "+", "-"].includes(op)) {
                  throw new Error(`Unexpected op '${op}' in ${JSON.stringify(diff2, null, 2)}`);
                }
                if (op === "~") {
                  op = " ";
                }
                subcolorizeToCallback(options, "", subvalue, output, op, subindent);
              }
            }
            if (elisionCount > 0) {
              outputElisions(elisionCount);
            }
          } else {
            for (subvalue of diff2) {
              subcolorizeToCallback(options, "", subvalue, output, color2, subindent);
            }
          }
          return output(color2, `${indent}]`);
        }
        default:
          if (diff2 === 0 || diff2 === null || diff2 === false || diff2 === "" || diff2) {
            return output(color2, indent + prefix2 + JSON.stringify(diff2));
          }
      }
    };
    var colorizeToCallback = (diff2, options, output) => subcolorizeToCallback(options, "", diff2, output, " ", "");
    var colorizeToArray = function(diff2, options = {}) {
      const output = [];
      colorizeToCallback(diff2, options, (color2, line2) => output.push(`${color2}${line2}`));
      return output;
    };
    var colorize = function(diff2, options = {}) {
      const output = [];
      colorizeToCallback(diff2, options, function(color2, line2) {
        if (options.color != null ? options.color : true) {
          return output.push(((options.theme != null ? options.theme[color2] : void 0) != null ? options.theme != null ? options.theme[color2] : void 0 : Theme[color2])(`${color2}${line2}`) + "\n");
        } else {
          return output.push(`${color2}${line2}
`);
        }
      });
      return output.join("");
    };
    module2.exports = { colorize, colorizeToArray, colorizeToCallback };
  }
});

// ../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/index.js
var require_lib = __commonJS({
  "../node_modules/.pnpm/json-diff@1.0.6/node_modules/json-diff/lib/index.js"(exports2, module2) {
    "use strict";
    var { SequenceMatcher } = require_difflib2();
    var { extendedTypeOf, roundObj } = require_util();
    var { colorize, colorizeToCallback } = require_colorize();
    var JsonDiff = class {
      constructor(options) {
        options.outputKeys = options.outputKeys || [];
        options.excludeKeys = options.excludeKeys || [];
        this.options = options;
      }
      isScalar(obj) {
        return typeof obj !== "object" || obj === null;
      }
      objectDiff(obj1, obj2) {
        let result = {};
        let score = 0;
        let equal = true;
        for (const [key, value] of Object.entries(obj1)) {
          if (!this.options.outputNewOnly) {
            const postfix = "__deleted";
            if (!(key in obj2) && !this.options.excludeKeys.includes(key)) {
              result[`${key}${postfix}`] = value;
              score -= 30;
              equal = false;
            }
          }
        }
        for (const [key, value] of Object.entries(obj2)) {
          const postfix = !this.options.outputNewOnly ? "__added" : "";
          if (!(key in obj1) && !this.options.excludeKeys.includes(key)) {
            result[`${key}${postfix}`] = value;
            score -= 30;
            equal = false;
          }
        }
        for (const [key, value1] of Object.entries(obj1)) {
          if (key in obj2) {
            if (this.options.excludeKeys.includes(key)) {
              continue;
            }
            score += 20;
            const value2 = obj2[key];
            const change = this.diff(value1, value2);
            if (!change.equal) {
              result[key] = change.result;
              equal = false;
            } else if (this.options.full || this.options.outputKeys.includes(key)) {
              result[key] = value1;
            }
            score += Math.min(20, Math.max(-10, change.score / 5));
          }
        }
        if (equal) {
          score = 100 * Math.max(Object.keys(obj1).length, 0.5);
          if (!this.options.full) {
            result = void 0;
          }
        } else {
          score = Math.max(0, score);
        }
        return { score, result, equal };
      }
      findMatchingObject(item, index7, fuzzyOriginals) {
        let bestMatch = null;
        for (const [key, { item: candidate, index: matchIndex }] of Object.entries(fuzzyOriginals)) {
          if (key !== "__next") {
            const indexDistance = Math.abs(matchIndex - index7);
            if (extendedTypeOf(item) === extendedTypeOf(candidate)) {
              const { score } = this.diff(item, candidate);
              if (!bestMatch || score > bestMatch.score || score === bestMatch.score && indexDistance < bestMatch.indexDistance) {
                bestMatch = { score, key, indexDistance };
              }
            }
          }
        }
        return bestMatch;
      }
      scalarize(array3, originals, fuzzyOriginals) {
        const fuzzyMatches = [];
        if (fuzzyOriginals) {
          const keyScores = {};
          for (let index7 = 0; index7 < array3.length; index7++) {
            const item = array3[index7];
            if (this.isScalar(item)) {
              continue;
            }
            const bestMatch = this.findMatchingObject(item, index7, fuzzyOriginals);
            if (bestMatch && (!keyScores[bestMatch.key] || bestMatch.score > keyScores[bestMatch.key].score)) {
              keyScores[bestMatch.key] = { score: bestMatch.score, index: index7 };
            }
          }
          for (const [key, match2] of Object.entries(keyScores)) {
            fuzzyMatches[match2.index] = key;
          }
        }
        const result = [];
        for (let index7 = 0; index7 < array3.length; index7++) {
          const item = array3[index7];
          if (this.isScalar(item)) {
            result.push(item);
          } else {
            const key = fuzzyMatches[index7] || "__$!SCALAR" + originals.__next++;
            originals[key] = { item, index: index7 };
            result.push(key);
          }
        }
        return result;
      }
      isScalarized(item, originals) {
        return typeof item === "string" && item in originals;
      }
      descalarize(item, originals) {
        if (this.isScalarized(item, originals)) {
          return originals[item].item;
        } else {
          return item;
        }
      }
      arrayDiff(obj1, obj2) {
        const originals1 = { __next: 1 };
        const seq1 = this.scalarize(obj1, originals1);
        const originals2 = { __next: originals1.__next };
        const seq2 = this.scalarize(obj2, originals2, originals1);
        if (this.options.sort) {
          seq1.sort();
          seq2.sort();
        }
        const opcodes = new SequenceMatcher(null, seq1, seq2).getOpcodes();
        let result = [];
        let score = 0;
        let equal = true;
        for (const [op, i1, i22, j1, j22] of opcodes) {
          let i8, j7;
          let asc2, end;
          let asc1, end1;
          let asc22, end2;
          if (!(op === "equal" || this.options.keysOnly && op === "replace")) {
            equal = false;
          }
          switch (op) {
            case "equal":
              for (i8 = i1, end = i22, asc2 = i1 <= end; asc2 ? i8 < end : i8 > end; asc2 ? i8++ : i8--) {
                const item = seq1[i8];
                if (this.isScalarized(item, originals1)) {
                  if (!this.isScalarized(item, originals2)) {
                    throw new Error(
                      `internal bug: isScalarized(item, originals1) != isScalarized(item, originals2) for item ${JSON.stringify(
                        item
                      )}`
                    );
                  }
                  const item1 = this.descalarize(item, originals1);
                  const item2 = this.descalarize(item, originals2);
                  const change = this.diff(item1, item2);
                  if (!change.equal) {
                    result.push(["~", change.result]);
                    equal = false;
                  } else {
                    if (this.options.full || this.options.keepUnchangedValues) {
                      result.push([" ", item1]);
                    } else {
                      result.push([" "]);
                    }
                  }
                } else {
                  if (this.options.full || this.options.keepUnchangedValues) {
                    result.push([" ", item]);
                  } else {
                    result.push([" "]);
                  }
                }
                score += 10;
              }
              break;
            case "delete":
              for (i8 = i1, end1 = i22, asc1 = i1 <= end1; asc1 ? i8 < end1 : i8 > end1; asc1 ? i8++ : i8--) {
                result.push(["-", this.descalarize(seq1[i8], originals1)]);
                score -= 5;
              }
              break;
            case "insert":
              for (j7 = j1, end2 = j22, asc22 = j1 <= end2; asc22 ? j7 < end2 : j7 > end2; asc22 ? j7++ : j7--) {
                result.push(["+", this.descalarize(seq2[j7], originals2)]);
                score -= 5;
              }
              break;
            case "replace":
              if (!this.options.keysOnly) {
                let asc3, end3;
                let asc4, end4;
                for (i8 = i1, end3 = i22, asc3 = i1 <= end3; asc3 ? i8 < end3 : i8 > end3; asc3 ? i8++ : i8--) {
                  result.push(["-", this.descalarize(seq1[i8], originals1)]);
                  score -= 5;
                }
                for (j7 = j1, end4 = j22, asc4 = j1 <= end4; asc4 ? j7 < end4 : j7 > end4; asc4 ? j7++ : j7--) {
                  result.push(["+", this.descalarize(seq2[j7], originals2)]);
                  score -= 5;
                }
              } else {
                let asc5, end5;
                for (i8 = i1, end5 = i22, asc5 = i1 <= end5; asc5 ? i8 < end5 : i8 > end5; asc5 ? i8++ : i8--) {
                  const change = this.diff(
                    this.descalarize(seq1[i8], originals1),
                    this.descalarize(seq2[i8 - i1 + j1], originals2)
                  );
                  if (!change.equal) {
                    result.push(["~", change.result]);
                    equal = false;
                  } else {
                    result.push([" "]);
                  }
                }
              }
              break;
          }
        }
        if (equal || opcodes.length === 0) {
          if (!this.options.full) {
            result = void 0;
          } else {
            result = obj1;
          }
          score = 100;
        } else {
          score = Math.max(0, score);
        }
        return { score, result, equal };
      }
      diff(obj1, obj2) {
        const type1 = extendedTypeOf(obj1);
        const type2 = extendedTypeOf(obj2);
        if (type1 === type2) {
          switch (type1) {
            case "object":
              return this.objectDiff(obj1, obj2);
            case "array":
              return this.arrayDiff(obj1, obj2);
          }
        }
        let score = 100;
        let result = obj1;
        let equal;
        if (!this.options.keysOnly) {
          if (type1 === "date" && type2 === "date") {
            equal = obj1.getTime() === obj2.getTime();
          } else {
            equal = obj1 === obj2;
          }
          if (!equal) {
            score = 0;
            if (this.options.outputNewOnly) {
              result = obj2;
            } else {
              result = { __old: obj1, __new: obj2 };
            }
          } else if (!this.options.full) {
            result = void 0;
          }
        } else {
          equal = true;
          result = void 0;
        }
        return { score, result, equal };
      }
    };
    function diff2(obj1, obj2, options = {}) {
      if (options.precision !== void 0) {
        obj1 = roundObj(obj1, options.precision);
        obj2 = roundObj(obj2, options.precision);
      }
      return new JsonDiff(options).diff(obj1, obj2).result;
    }
    function diffString(obj1, obj2, options = {}) {
      return colorize(diff2(obj1, obj2, options), options);
    }
    module2.exports = { diff: diff2, diffString, colorize, colorizeToCallback };
  }
});

// src/jsonDiffer.js
function diffSchemasOrTables(left, right) {
  left = JSON.parse(JSON.stringify(left));
  right = JSON.parse(JSON.stringify(right));
  const result = Object.entries((0, import_json_diff.diff)(left, right) ?? {});
  const added = result.filter((it2) => it2[0].endsWith("__added")).map((it2) => it2[1]);
  const deleted = result.filter((it2) => it2[0].endsWith("__deleted")).map((it2) => it2[1]);
  return { added, deleted };
}
function diffIndPolicies(left, right) {
  left = JSON.parse(JSON.stringify(left));
  right = JSON.parse(JSON.stringify(right));
  const result = Object.entries((0, import_json_diff.diff)(left, right) ?? {});
  const added = result.filter((it2) => it2[0].endsWith("__added")).map((it2) => it2[1]);
  const deleted = result.filter((it2) => it2[0].endsWith("__deleted")).map((it2) => it2[1]);
  return { added, deleted };
}
function diffColumns(left, right) {
  left = JSON.parse(JSON.stringify(left));
  right = JSON.parse(JSON.stringify(right));
  const result = (0, import_json_diff.diff)(left, right) ?? {};
  const alteredTables = Object.fromEntries(
    Object.entries(result).filter((it2) => {
      return !(it2[0].includes("__added") || it2[0].includes("__deleted"));
    }).map((tableEntry) => {
      const deletedColumns = Object.entries(tableEntry[1].columns ?? {}).filter((it2) => {
        return it2[0].endsWith("__deleted");
      }).map((it2) => {
        return it2[1];
      });
      const addedColumns = Object.entries(tableEntry[1].columns ?? {}).filter((it2) => {
        return it2[0].endsWith("__added");
      }).map((it2) => {
        return it2[1];
      });
      tableEntry[1].columns = {
        added: addedColumns,
        deleted: deletedColumns
      };
      const table6 = left[tableEntry[0]];
      return [
        tableEntry[0],
        { name: table6.name, schema: table6.schema, ...tableEntry[1] }
      ];
    })
  );
  return alteredTables;
}
function diffPolicies(left, right) {
  left = JSON.parse(JSON.stringify(left));
  right = JSON.parse(JSON.stringify(right));
  const result = (0, import_json_diff.diff)(left, right) ?? {};
  const alteredTables = Object.fromEntries(
    Object.entries(result).filter((it2) => {
      return !(it2[0].includes("__added") || it2[0].includes("__deleted"));
    }).map((tableEntry) => {
      const deletedPolicies = Object.entries(tableEntry[1].policies ?? {}).filter((it2) => {
        return it2[0].endsWith("__deleted");
      }).map((it2) => {
        return it2[1];
      });
      const addedPolicies = Object.entries(tableEntry[1].policies ?? {}).filter((it2) => {
        return it2[0].endsWith("__added");
      }).map((it2) => {
        return it2[1];
      });
      tableEntry[1].policies = {
        added: addedPolicies,
        deleted: deletedPolicies
      };
      const table6 = left[tableEntry[0]];
      return [
        tableEntry[0],
        { name: table6.name, schema: table6.schema, ...tableEntry[1] }
      ];
    })
  );
  return alteredTables;
}
function applyJsonDiff(json1, json22) {
  json1 = JSON.parse(JSON.stringify(json1));
  json22 = JSON.parse(JSON.stringify(json22));
  const rawDiff = (0, import_json_diff.diff)(json1, json22);
  const difference = JSON.parse(JSON.stringify(rawDiff || {}));
  difference.schemas = difference.schemas || {};
  difference.tables = difference.tables || {};
  difference.enums = difference.enums || {};
  difference.sequences = difference.sequences || {};
  difference.roles = difference.roles || {};
  difference.policies = difference.policies || {};
  difference.views = difference.views || {};
  const schemaKeys = Object.keys(difference.schemas);
  for (let key of schemaKeys) {
    if (key.endsWith("__added") || key.endsWith("__deleted")) {
      delete difference.schemas[key];
      continue;
    }
  }
  const tableKeys = Object.keys(difference.tables);
  for (let key of tableKeys) {
    if (key.endsWith("__added") || key.endsWith("__deleted")) {
      delete difference.tables[key];
      continue;
    }
    const table6 = json1.tables[key];
    difference.tables[key] = {
      name: table6.name,
      schema: table6.schema,
      ...difference.tables[key]
    };
  }
  for (let [tableKey2, tableValue] of Object.entries(difference.tables)) {
    const table6 = difference.tables[tableKey2];
    const columns = tableValue.columns || {};
    const columnKeys = Object.keys(columns);
    for (let key of columnKeys) {
      if (key.endsWith("__added") || key.endsWith("__deleted")) {
        delete table6.columns[key];
        continue;
      }
    }
    if (Object.keys(columns).length === 0) {
      delete table6["columns"];
    }
    if ("name" in table6 && "schema" in table6 && Object.keys(table6).length === 2) {
      delete difference.tables[tableKey2];
    }
  }
  const enumsEntries = Object.entries(difference.enums);
  const alteredEnums = enumsEntries.filter((it2) => !(it2[0].includes("__added") || it2[0].includes("__deleted"))).map((it2) => {
    const enumEntry = json1.enums[it2[0]];
    const { name: name3, schema: schema6, values: values2 } = enumEntry;
    const sequence = mapArraysDiff(values2, it2[1].values);
    const addedValues = sequence.filter((it3) => it3.type === "added").map((it3) => {
      return {
        before: it3.before,
        value: it3.value
      };
    });
    const deletedValues = sequence.filter((it3) => it3.type === "removed").map((it3) => it3.value);
    return { name: name3, schema: schema6, addedValues, deletedValues };
  });
  const sequencesEntries = Object.entries(difference.sequences);
  const alteredSequences = sequencesEntries.filter((it2) => !(it2[0].includes("__added") || it2[0].includes("__deleted")) && "values" in it2[1]).map((it2) => {
    return json22.sequences[it2[0]];
  });
  const rolesEntries = Object.entries(difference.roles);
  const alteredRoles = rolesEntries.filter((it2) => !(it2[0].includes("__added") || it2[0].includes("__deleted"))).map((it2) => {
    return json22.roles[it2[0]];
  });
  const policiesEntries = Object.entries(difference.policies);
  const alteredPolicies = policiesEntries.filter((it2) => !(it2[0].includes("__added") || it2[0].includes("__deleted"))).map((it2) => {
    return json22.policies[it2[0]];
  });
  const viewsEntries = Object.entries(difference.views);
  const alteredViews = viewsEntries.filter((it2) => !(it2[0].includes("__added") || it2[0].includes("__deleted"))).map(
    ([nameWithSchema, view5]) => {
      const deletedWithOption = view5.with__deleted;
      const addedWithOption = view5.with__added;
      const deletedWith = Object.fromEntries(
        Object.entries(view5.with || {}).filter((it2) => it2[0].endsWith("__deleted")).map(([key, value]) => {
          return [key.replace("__deleted", ""), value];
        })
      );
      const addedWith = Object.fromEntries(
        Object.entries(view5.with || {}).filter((it2) => it2[0].endsWith("__added")).map(([key, value]) => {
          return [key.replace("__added", ""), value];
        })
      );
      const alterWith = Object.fromEntries(
        Object.entries(view5.with || {}).filter(
          (it2) => typeof it2[1].__old !== "undefined" && typeof it2[1].__new !== "undefined"
        ).map(
          (it2) => {
            return [it2[0], it2[1].__new];
          }
        )
      );
      const alteredSchema = view5.schema;
      const alteredDefinition = view5.definition;
      const alteredExisting = view5.isExisting;
      const addedTablespace = view5.tablespace__added;
      const droppedTablespace = view5.tablespace__deleted;
      const alterTablespaceTo = view5.tablespace;
      let alteredTablespace;
      if (addedTablespace) alteredTablespace = { __new: addedTablespace, __old: "pg_default" };
      if (droppedTablespace) alteredTablespace = { __new: "pg_default", __old: droppedTablespace };
      if (alterTablespaceTo) alteredTablespace = alterTablespaceTo;
      const addedUsing = view5.using__added;
      const droppedUsing = view5.using__deleted;
      const alterUsingTo = view5.using;
      let alteredUsing;
      if (addedUsing) alteredUsing = { __new: addedUsing, __old: "heap" };
      if (droppedUsing) alteredUsing = { __new: "heap", __old: droppedUsing };
      if (alterUsingTo) alteredUsing = alterUsingTo;
      const alteredMeta = view5.meta;
      return Object.fromEntries(
        Object.entries({
          name: json22.views[nameWithSchema].name,
          schema: json22.views[nameWithSchema].schema,
          // pg
          deletedWithOption,
          addedWithOption,
          deletedWith: Object.keys(deletedWith).length ? deletedWith : void 0,
          addedWith: Object.keys(addedWith).length ? addedWith : void 0,
          alteredWith: Object.keys(alterWith).length ? alterWith : void 0,
          alteredSchema,
          alteredTablespace,
          alteredUsing,
          // mysql
          alteredMeta,
          // common
          alteredDefinition,
          alteredExisting
        }).filter(([_7, value]) => value !== void 0)
      );
    }
  );
  const alteredTablesWithColumns = Object.values(difference.tables).map(
    (table6) => {
      return findAlternationsInTable(table6);
    }
  );
  return {
    alteredTablesWithColumns,
    alteredEnums,
    alteredSequences,
    alteredRoles,
    alteredViews,
    alteredPolicies
  };
}
var import_json_diff, mapArraysDiff, findAlternationsInTable, alternationsInColumn;
var init_jsonDiffer = __esm({
  "src/jsonDiffer.js"() {
    "use strict";
    "use-strict";
    import_json_diff = __toESM(require_lib());
    mapArraysDiff = (source, diff2) => {
      const sequence = [];
      let sourceIndex = 0;
      for (let i8 = 0; i8 < diff2.length; i8++) {
        const it2 = diff2[i8];
        if (it2.length === 1) {
          sequence.push({ type: "same", value: source[sourceIndex] });
          sourceIndex += 1;
        } else {
          if (it2[0] === "-") {
            sequence.push({ type: "removed", value: it2[1] });
          } else {
            sequence.push({ type: "added", value: it2[1], before: "" });
          }
        }
      }
      const result = sequence.reverse().reduce(
        (acc, it2) => {
          if (it2.type === "same") {
            acc.prev = it2.value;
          }
          if (it2.type === "added" && acc.prev) {
            it2.before = acc.prev;
          }
          acc.result.push(it2);
          return acc;
        },
        { result: [] }
      );
      return result.result.reverse();
    };
    findAlternationsInTable = (table6) => {
      const columns = table6.columns ?? {};
      const altered = Object.keys(columns).filter((it2) => !(it2.includes("__deleted") || it2.includes("__added"))).map((it2) => {
        return { name: it2, ...columns[it2] };
      });
      const deletedIndexes = Object.fromEntries(
        Object.entries(table6.indexes__deleted || {}).concat(
          Object.entries(table6.indexes || {}).filter((it2) => it2[0].includes("__deleted"))
        ).map((entry) => [entry[0].replace("__deleted", ""), entry[1]])
      );
      const addedIndexes = Object.fromEntries(
        Object.entries(table6.indexes__added || {}).concat(
          Object.entries(table6.indexes || {}).filter((it2) => it2[0].includes("__added"))
        ).map((entry) => [entry[0].replace("__added", ""), entry[1]])
      );
      const alteredIndexes = Object.fromEntries(
        Object.entries(table6.indexes || {}).filter((it2) => {
          return !it2[0].endsWith("__deleted") && !it2[0].endsWith("__added");
        })
      );
      const deletedPolicies = Object.fromEntries(
        Object.entries(table6.policies__deleted || {}).concat(
          Object.entries(table6.policies || {}).filter((it2) => it2[0].includes("__deleted"))
        ).map((entry) => [entry[0].replace("__deleted", ""), entry[1]])
      );
      const addedPolicies = Object.fromEntries(
        Object.entries(table6.policies__added || {}).concat(
          Object.entries(table6.policies || {}).filter((it2) => it2[0].includes("__added"))
        ).map((entry) => [entry[0].replace("__added", ""), entry[1]])
      );
      const alteredPolicies = Object.fromEntries(
        Object.entries(table6.policies || {}).filter((it2) => {
          return !it2[0].endsWith("__deleted") && !it2[0].endsWith("__added");
        })
      );
      const deletedForeignKeys = Object.fromEntries(
        Object.entries(table6.foreignKeys__deleted || {}).concat(
          Object.entries(table6.foreignKeys || {}).filter((it2) => it2[0].includes("__deleted"))
        ).map((entry) => [entry[0].replace("__deleted", ""), entry[1]])
      );
      const addedForeignKeys = Object.fromEntries(
        Object.entries(table6.foreignKeys__added || {}).concat(
          Object.entries(table6.foreignKeys || {}).filter((it2) => it2[0].includes("__added"))
        ).map((entry) => [entry[0].replace("__added", ""), entry[1]])
      );
      const alteredForeignKeys = Object.fromEntries(
        Object.entries(table6.foreignKeys || {}).filter(
          (it2) => !it2[0].endsWith("__added") && !it2[0].endsWith("__deleted")
        ).map((entry) => [entry[0], entry[1]])
      );
      const addedCompositePKs = Object.fromEntries(
        Object.entries(table6.compositePrimaryKeys || {}).filter((it2) => {
          return it2[0].endsWith("__added");
        })
      );
      const deletedCompositePKs = Object.fromEntries(
        Object.entries(table6.compositePrimaryKeys || {}).filter((it2) => {
          return it2[0].endsWith("__deleted");
        })
      );
      const alteredCompositePKs = Object.fromEntries(
        Object.entries(table6.compositePrimaryKeys || {}).filter((it2) => {
          return !it2[0].endsWith("__deleted") && !it2[0].endsWith("__added");
        })
      );
      const addedUniqueConstraints = Object.fromEntries(
        Object.entries(table6.uniqueConstraints || {}).filter((it2) => {
          return it2[0].endsWith("__added");
        })
      );
      const deletedUniqueConstraints = Object.fromEntries(
        Object.entries(table6.uniqueConstraints || {}).filter((it2) => {
          return it2[0].endsWith("__deleted");
        })
      );
      const alteredUniqueConstraints = Object.fromEntries(
        Object.entries(table6.uniqueConstraints || {}).filter((it2) => {
          return !it2[0].endsWith("__deleted") && !it2[0].endsWith("__added");
        })
      );
      const addedCheckConstraints = Object.fromEntries(
        Object.entries(table6.checkConstraints || {}).filter((it2) => {
          return it2[0].endsWith("__added");
        })
      );
      const deletedCheckConstraints = Object.fromEntries(
        Object.entries(table6.checkConstraints || {}).filter((it2) => {
          return it2[0].endsWith("__deleted");
        })
      );
      const alteredCheckConstraints = Object.fromEntries(
        Object.entries(table6.checkConstraints || {}).filter((it2) => {
          return !it2[0].endsWith("__deleted") && !it2[0].endsWith("__added");
        })
      );
      const mappedAltered = altered.map((it2) => alternationsInColumn(it2)).filter(Boolean);
      return {
        name: table6.name,
        schema: table6.schema || "",
        altered: mappedAltered,
        addedIndexes,
        deletedIndexes,
        alteredIndexes,
        addedForeignKeys,
        deletedForeignKeys,
        alteredForeignKeys,
        addedCompositePKs,
        deletedCompositePKs,
        alteredCompositePKs,
        addedUniqueConstraints,
        deletedUniqueConstraints,
        alteredUniqueConstraints,
        deletedPolicies,
        addedPolicies,
        alteredPolicies,
        addedCheckConstraints,
        deletedCheckConstraints,
        alteredCheckConstraints
      };
    };
    alternationsInColumn = (column6) => {
      const altered = [column6];
      const result = altered.filter((it2) => {
        if ("type" in it2 && it2.type.__old.replace(" (", "(") === it2.type.__new.replace(" (", "(")) {
          return false;
        }
        return true;
      }).map((it2) => {
        if (typeof it2.name !== "string" && "__old" in it2.name) {
          return {
            ...it2,
            name: { type: "changed", old: it2.name.__old, new: it2.name.__new }
          };
        }
        return it2;
      }).map((it2) => {
        if ("type" in it2) {
          return {
            ...it2,
            type: { type: "changed", old: it2.type.__old, new: it2.type.__new }
          };
        }
        return it2;
      }).map((it2) => {
        if ("default" in it2) {
          return {
            ...it2,
            default: {
              type: "changed",
              old: it2.default.__old,
              new: it2.default.__new
            }
          };
        }
        if ("default__added" in it2) {
          const { default__added, ...others } = it2;
          return {
            ...others,
            default: { type: "added", value: it2.default__added }
          };
        }
        if ("default__deleted" in it2) {
          const { default__deleted, ...others } = it2;
          return {
            ...others,
            default: { type: "deleted", value: it2.default__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("generated" in it2) {
          if ("as" in it2.generated && "type" in it2.generated) {
            return {
              ...it2,
              generated: {
                type: "changed",
                old: { as: it2.generated.as.__old, type: it2.generated.type.__old },
                new: { as: it2.generated.as.__new, type: it2.generated.type.__new }
              }
            };
          } else if ("as" in it2.generated) {
            return {
              ...it2,
              generated: {
                type: "changed",
                old: { as: it2.generated.as.__old },
                new: { as: it2.generated.as.__new }
              }
            };
          } else {
            return {
              ...it2,
              generated: {
                type: "changed",
                old: { as: it2.generated.type.__old },
                new: { as: it2.generated.type.__new }
              }
            };
          }
        }
        if ("generated__added" in it2) {
          const { generated__added, ...others } = it2;
          return {
            ...others,
            generated: { type: "added", value: it2.generated__added }
          };
        }
        if ("generated__deleted" in it2) {
          const { generated__deleted, ...others } = it2;
          return {
            ...others,
            generated: { type: "deleted", value: it2.generated__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("identity" in it2) {
          return {
            ...it2,
            identity: {
              type: "changed",
              old: it2.identity.__old,
              new: it2.identity.__new
            }
          };
        }
        if ("identity__added" in it2) {
          const { identity__added, ...others } = it2;
          return {
            ...others,
            identity: { type: "added", value: it2.identity__added }
          };
        }
        if ("identity__deleted" in it2) {
          const { identity__deleted, ...others } = it2;
          return {
            ...others,
            identity: { type: "deleted", value: it2.identity__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("notNull" in it2) {
          return {
            ...it2,
            notNull: {
              type: "changed",
              old: it2.notNull.__old,
              new: it2.notNull.__new
            }
          };
        }
        if ("notNull__added" in it2) {
          const { notNull__added, ...others } = it2;
          return {
            ...others,
            notNull: { type: "added", value: it2.notNull__added }
          };
        }
        if ("notNull__deleted" in it2) {
          const { notNull__deleted, ...others } = it2;
          return {
            ...others,
            notNull: { type: "deleted", value: it2.notNull__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("primaryKey" in it2) {
          return {
            ...it2,
            primaryKey: {
              type: "changed",
              old: it2.primaryKey.__old,
              new: it2.primaryKey.__new
            }
          };
        }
        if ("primaryKey__added" in it2) {
          const { notNull__added, ...others } = it2;
          return {
            ...others,
            primaryKey: { type: "added", value: it2.primaryKey__added }
          };
        }
        if ("primaryKey__deleted" in it2) {
          const { notNull__deleted, ...others } = it2;
          return {
            ...others,
            primaryKey: { type: "deleted", value: it2.primaryKey__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("typeSchema" in it2) {
          return {
            ...it2,
            typeSchema: {
              type: "changed",
              old: it2.typeSchema.__old,
              new: it2.typeSchema.__new
            }
          };
        }
        if ("typeSchema__added" in it2) {
          const { typeSchema__added, ...others } = it2;
          return {
            ...others,
            typeSchema: { type: "added", value: it2.typeSchema__added }
          };
        }
        if ("typeSchema__deleted" in it2) {
          const { typeSchema__deleted, ...others } = it2;
          return {
            ...others,
            typeSchema: { type: "deleted", value: it2.typeSchema__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("onUpdate" in it2) {
          return {
            ...it2,
            onUpdate: {
              type: "changed",
              old: it2.onUpdate.__old,
              new: it2.onUpdate.__new
            }
          };
        }
        if ("onUpdate__added" in it2) {
          const { onUpdate__added, ...others } = it2;
          return {
            ...others,
            onUpdate: { type: "added", value: it2.onUpdate__added }
          };
        }
        if ("onUpdate__deleted" in it2) {
          const { onUpdate__deleted, ...others } = it2;
          return {
            ...others,
            onUpdate: { type: "deleted", value: it2.onUpdate__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("autoincrement" in it2) {
          return {
            ...it2,
            autoincrement: {
              type: "changed",
              old: it2.autoincrement.__old,
              new: it2.autoincrement.__new
            }
          };
        }
        if ("autoincrement__added" in it2) {
          const { autoincrement__added, ...others } = it2;
          return {
            ...others,
            autoincrement: { type: "added", value: it2.autoincrement__added }
          };
        }
        if ("autoincrement__deleted" in it2) {
          const { autoincrement__deleted, ...others } = it2;
          return {
            ...others,
            autoincrement: { type: "deleted", value: it2.autoincrement__deleted }
          };
        }
        return it2;
      }).map((it2) => {
        if ("" in it2) {
          return {
            ...it2,
            autoincrement: {
              type: "changed",
              old: it2.autoincrement.__old,
              new: it2.autoincrement.__new
            }
          };
        }
        if ("autoincrement__added" in it2) {
          const { autoincrement__added, ...others } = it2;
          return {
            ...others,
            autoincrement: { type: "added", value: it2.autoincrement__added }
          };
        }
        if ("autoincrement__deleted" in it2) {
          const { autoincrement__deleted, ...others } = it2;
          return {
            ...others,
            autoincrement: { type: "deleted", value: it2.autoincrement__deleted }
          };
        }
        return it2;
      }).filter(Boolean);
      return result[0];
    };
  }
});

// src/sqlgenerator.ts
function fromJson(statements, dialect6, action, json22) {
  const result = statements.flatMap((statement) => {
    const filtered = convertors.filter((it2) => {
      return it2.can(statement, dialect6);
    });
    const convertor = filtered.length === 1 ? filtered[0] : void 0;
    if (!convertor) {
      return "";
    }
    return convertor.convert(statement, json22, action);
  }).filter((it2) => it2 !== "");
  return result;
}
var parseType, Convertor, PgCreateRoleConvertor, PgDropRoleConvertor, PgRenameRoleConvertor, PgAlterRoleConvertor, PgCreatePolicyConvertor, PgDropPolicyConvertor, PgRenamePolicyConvertor, PgAlterPolicyConvertor, PgCreateIndPolicyConvertor, PgDropIndPolicyConvertor, PgRenameIndPolicyConvertor, PgAlterIndPolicyConvertor, PgEnableRlsConvertor, PgDisableRlsConvertor, PgCreateTableConvertor, MySqlCreateTableConvertor, SingleStoreCreateTableConvertor, SQLiteCreateTableConvertor, PgCreateViewConvertor, MySqlCreateViewConvertor, SqliteCreateViewConvertor, PgDropViewConvertor, MySqlDropViewConvertor, SqliteDropViewConvertor, MySqlAlterViewConvertor, PgRenameViewConvertor, MySqlRenameViewConvertor, PgAlterViewSchemaConvertor, PgAlterViewAddWithOptionConvertor, PgAlterViewDropWithOptionConvertor, PgAlterViewAlterTablespaceConvertor, PgAlterViewAlterUsingConvertor, PgAlterTableAlterColumnSetGenerated, PgAlterTableAlterColumnDropGenerated, PgAlterTableAlterColumnAlterGenerated, PgAlterTableAddUniqueConstraintConvertor, PgAlterTableDropUniqueConstraintConvertor, PgAlterTableAddCheckConstraintConvertor, PgAlterTableDeleteCheckConstraintConvertor, MySQLAlterTableAddUniqueConstraintConvertor, MySQLAlterTableDropUniqueConstraintConvertor, MySqlAlterTableAddCheckConstraintConvertor, SingleStoreAlterTableAddUniqueConstraintConvertor, SingleStoreAlterTableDropUniqueConstraintConvertor, MySqlAlterTableDeleteCheckConstraintConvertor, CreatePgSequenceConvertor, DropPgSequenceConvertor, RenamePgSequenceConvertor, MovePgSequenceConvertor, AlterPgSequenceConvertor, CreateTypeEnumConvertor, DropTypeEnumConvertor, AlterTypeAddValueConvertor, AlterTypeSetSchemaConvertor, AlterRenameTypeConvertor, AlterTypeDropValueConvertor, PgDropTableConvertor, MySQLDropTableConvertor, SingleStoreDropTableConvertor, SQLiteDropTableConvertor, PgRenameTableConvertor, SqliteRenameTableConvertor, MySqlRenameTableConvertor, SingleStoreRenameTableConvertor, PgAlterTableRenameColumnConvertor, MySqlAlterTableRenameColumnConvertor, SingleStoreAlterTableRenameColumnConvertor, SQLiteAlterTableRenameColumnConvertor, PgAlterTableDropColumnConvertor, MySqlAlterTableDropColumnConvertor, SingleStoreAlterTableDropColumnConvertor, SQLiteAlterTableDropColumnConvertor, PgAlterTableAddColumnConvertor, MySqlAlterTableAddColumnConvertor, SingleStoreAlterTableAddColumnConvertor, SQLiteAlterTableAddColumnConvertor, PgAlterTableAlterColumnSetTypeConvertor, PgAlterTableAlterColumnSetDefaultConvertor, PgAlterTableAlterColumnDropDefaultConvertor, PgAlterTableAlterColumnDropGeneratedConvertor, PgAlterTableAlterColumnSetExpressionConvertor, PgAlterTableAlterColumnAlterrGeneratedConvertor, SqliteAlterTableAlterColumnDropGeneratedConvertor, SqliteAlterTableAlterColumnSetExpressionConvertor, SqliteAlterTableAlterColumnAlterGeneratedConvertor, MySqlAlterTableAlterColumnAlterrGeneratedConvertor, MySqlAlterTableAddPk, MySqlAlterTableDropPk, LibSQLModifyColumn, MySqlModifyColumn, SingleStoreAlterTableAlterColumnAlterrGeneratedConvertor, SingleStoreAlterTableAddPk, SingleStoreAlterTableDropPk, SingleStoreModifyColumn, PgAlterTableCreateCompositePrimaryKeyConvertor, PgAlterTableDeleteCompositePrimaryKeyConvertor, PgAlterTableAlterCompositePrimaryKeyConvertor, MySqlAlterTableCreateCompositePrimaryKeyConvertor, MySqlAlterTableDeleteCompositePrimaryKeyConvertor, MySqlAlterTableAlterCompositePrimaryKeyConvertor, PgAlterTableAlterColumnSetPrimaryKeyConvertor, PgAlterTableAlterColumnDropPrimaryKeyConvertor, PgAlterTableAlterColumnSetNotNullConvertor, PgAlterTableAlterColumnDropNotNullConvertor, PgCreateForeignKeyConvertor, LibSQLCreateForeignKeyConvertor, MySqlCreateForeignKeyConvertor, PgAlterForeignKeyConvertor, PgDeleteForeignKeyConvertor, MySqlDeleteForeignKeyConvertor, CreatePgIndexConvertor, CreateMySqlIndexConvertor, CreateSingleStoreIndexConvertor, CreateSqliteIndexConvertor, PgDropIndexConvertor, PgCreateSchemaConvertor, PgRenameSchemaConvertor, PgDropSchemaConvertor, PgAlterTableSetSchemaConvertor, PgAlterTableSetNewSchemaConvertor, PgAlterTableRemoveFromSchemaConvertor, SqliteDropIndexConvertor, MySqlDropIndexConvertor, SingleStoreDropIndexConvertor, SQLiteRecreateTableConvertor, LibSQLRecreateTableConvertor, SingleStoreRecreateTableConvertor, convertors;
var init_sqlgenerator = __esm({
  "src/sqlgenerator.ts"() {
    "use strict";
    init_migrate();
    init_mysqlSchema();
    init_pgSchema();
    init_singlestoreSchema();
    init_sqliteSchema();
    init_utils8();
    parseType = (schemaPrefix, type) => {
      const pgNativeTypes = [
        "uuid",
        "smallint",
        "integer",
        "bigint",
        "boolean",
        "text",
        "varchar",
        "serial",
        "bigserial",
        "decimal",
        "numeric",
        "real",
        "json",
        "jsonb",
        "time",
        "time with time zone",
        "time without time zone",
        "time",
        "timestamp",
        "timestamp with time zone",
        "timestamp without time zone",
        "date",
        "interval",
        "bigint",
        "bigserial",
        "double precision",
        "interval year",
        "interval month",
        "interval day",
        "interval hour",
        "interval minute",
        "interval second",
        "interval year to month",
        "interval day to hour",
        "interval day to minute",
        "interval day to second",
        "interval hour to minute",
        "interval hour to second",
        "interval minute to second",
        "char",
        "vector",
        "geometry",
        "halfvec",
        "sparsevec",
        "bit"
      ];
      const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
      const arrayDefinition = (type.match(arrayDefinitionRegex) ?? []).join("");
      const withoutArrayDefinition = type.replace(arrayDefinitionRegex, "");
      return pgNativeTypes.some((it2) => type.startsWith(it2)) ? `${withoutArrayDefinition}${arrayDefinition}` : `${schemaPrefix}"${withoutArrayDefinition}"${arrayDefinition}`;
    };
    Convertor = class {
    };
    PgCreateRoleConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_role" && dialect6 === "postgresql";
      }
      convert(statement) {
        return `CREATE ROLE "${statement.name}"${statement.values.createDb || statement.values.createRole || !statement.values.inherit ? ` WITH${statement.values.createDb ? " CREATEDB" : ""}${statement.values.createRole ? " CREATEROLE" : ""}${statement.values.inherit ? "" : " NOINHERIT"}` : ""};`;
      }
    };
    PgDropRoleConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_role" && dialect6 === "postgresql";
      }
      convert(statement) {
        return `DROP ROLE "${statement.name}";`;
      }
    };
    PgRenameRoleConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_role" && dialect6 === "postgresql";
      }
      convert(statement) {
        return `ALTER ROLE "${statement.nameFrom}" RENAME TO "${statement.nameTo}";`;
      }
    };
    PgAlterRoleConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_role" && dialect6 === "postgresql";
      }
      convert(statement) {
        return `ALTER ROLE "${statement.name}"${` WITH${statement.values.createDb ? " CREATEDB" : " NOCREATEDB"}${statement.values.createRole ? " CREATEROLE" : " NOCREATEROLE"}${statement.values.inherit ? " INHERIT" : " NOINHERIT"}`};`;
      }
    };
    PgCreatePolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_policy" && dialect6 === "postgresql";
      }
      convert(statement) {
        const policy5 = statement.data;
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        const usingPart = policy5.using ? ` USING (${policy5.using})` : "";
        const withCheckPart = policy5.withCheck ? ` WITH CHECK (${policy5.withCheck})` : "";
        const policyToPart = policy5.to?.map(
          (v11) => ["current_user", "current_role", "session_user", "public"].includes(v11) ? v11 : `"${v11}"`
        ).join(", ");
        return `CREATE POLICY "${policy5.name}" ON ${tableNameWithSchema} AS ${policy5.as?.toUpperCase()} FOR ${policy5.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
      }
    };
    PgDropPolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_policy" && dialect6 === "postgresql";
      }
      convert(statement) {
        const policy5 = statement.data;
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `DROP POLICY "${policy5.name}" ON ${tableNameWithSchema} CASCADE;`;
      }
    };
    PgRenamePolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_policy" && dialect6 === "postgresql";
      }
      convert(statement) {
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER POLICY "${statement.oldName}" ON ${tableNameWithSchema} RENAME TO "${statement.newName}";`;
      }
    };
    PgAlterPolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_policy" && dialect6 === "postgresql";
      }
      convert(statement, _dialect, action) {
        const newPolicy = action === "push" ? PgSquasher.unsquashPolicyPush(statement.newData) : PgSquasher.unsquashPolicy(statement.newData);
        const oldPolicy = action === "push" ? PgSquasher.unsquashPolicyPush(statement.oldData) : PgSquasher.unsquashPolicy(statement.oldData);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        const usingPart = newPolicy.using ? ` USING (${newPolicy.using})` : oldPolicy.using ? ` USING (${oldPolicy.using})` : "";
        const withCheckPart = newPolicy.withCheck ? ` WITH CHECK (${newPolicy.withCheck})` : oldPolicy.withCheck ? ` WITH CHECK  (${oldPolicy.withCheck})` : "";
        return `ALTER POLICY "${oldPolicy.name}" ON ${tableNameWithSchema} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
      }
    };
    PgCreateIndPolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_ind_policy" && dialect6 === "postgresql";
      }
      convert(statement) {
        const policy5 = statement.data;
        const usingPart = policy5.using ? ` USING (${policy5.using})` : "";
        const withCheckPart = policy5.withCheck ? ` WITH CHECK (${policy5.withCheck})` : "";
        const policyToPart = policy5.to?.map(
          (v11) => ["current_user", "current_role", "session_user", "public"].includes(v11) ? v11 : `"${v11}"`
        ).join(", ");
        return `CREATE POLICY "${policy5.name}" ON ${policy5.on} AS ${policy5.as?.toUpperCase()} FOR ${policy5.for?.toUpperCase()} TO ${policyToPart}${usingPart}${withCheckPart};`;
      }
    };
    PgDropIndPolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_ind_policy" && dialect6 === "postgresql";
      }
      convert(statement) {
        const policy5 = statement.data;
        return `DROP POLICY "${policy5.name}" ON ${policy5.on} CASCADE;`;
      }
    };
    PgRenameIndPolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_ind_policy" && dialect6 === "postgresql";
      }
      convert(statement) {
        return `ALTER POLICY "${statement.oldName}" ON ${statement.tableKey} RENAME TO "${statement.newName}";`;
      }
    };
    PgAlterIndPolicyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_ind_policy" && dialect6 === "postgresql";
      }
      convert(statement) {
        const newPolicy = statement.newData;
        const oldPolicy = statement.oldData;
        const usingPart = newPolicy.using ? ` USING (${newPolicy.using})` : oldPolicy.using ? ` USING (${oldPolicy.using})` : "";
        const withCheckPart = newPolicy.withCheck ? ` WITH CHECK (${newPolicy.withCheck})` : oldPolicy.withCheck ? ` WITH CHECK  (${oldPolicy.withCheck})` : "";
        return `ALTER POLICY "${oldPolicy.name}" ON ${oldPolicy.on} TO ${newPolicy.to}${usingPart}${withCheckPart};`;
      }
    };
    PgEnableRlsConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "enable_rls" && dialect6 === "postgresql";
      }
      convert(statement) {
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ENABLE ROW LEVEL SECURITY;`;
      }
    };
    PgDisableRlsConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "disable_rls" && dialect6 === "postgresql";
      }
      convert(statement) {
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} DISABLE ROW LEVEL SECURITY;`;
      }
    };
    PgCreateTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_table" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { tableName, schema: schema6, columns, compositePKs, uniqueConstraints, checkConstraints, policies, isRLSEnabled } = st2;
        let statement = "";
        const name3 = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        statement += `CREATE TABLE ${name3} (
`;
        for (let i8 = 0; i8 < columns.length; i8++) {
          const column6 = columns[i8];
          const primaryKeyStatement = column6.primaryKey ? " PRIMARY KEY" : "";
          const notNullStatement = column6.notNull && !column6.identity ? " NOT NULL" : "";
          const defaultStatement = column6.default !== void 0 ? ` DEFAULT ${column6.default}` : "";
          const uniqueConstraint6 = column6.isUnique ? ` CONSTRAINT "${column6.uniqueName}" UNIQUE${column6.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""}` : "";
          const schemaPrefix = column6.typeSchema && column6.typeSchema !== "public" ? `"${column6.typeSchema}".` : "";
          const type = parseType(schemaPrefix, column6.type);
          const generated = column6.generated;
          const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : "";
          const unsquashedIdentity = column6.identity ? PgSquasher.unsquashIdentity(column6.identity) : void 0;
          const identityWithSchema = schema6 ? `"${schema6}"."${unsquashedIdentity?.name}"` : `"${unsquashedIdentity?.name}"`;
          const identity = unsquashedIdentity ? ` GENERATED ${unsquashedIdentity.type === "always" ? "ALWAYS" : "BY DEFAULT"} AS IDENTITY (sequence name ${identityWithSchema}${unsquashedIdentity.increment ? ` INCREMENT BY ${unsquashedIdentity.increment}` : ""}${unsquashedIdentity.minValue ? ` MINVALUE ${unsquashedIdentity.minValue}` : ""}${unsquashedIdentity.maxValue ? ` MAXVALUE ${unsquashedIdentity.maxValue}` : ""}${unsquashedIdentity.startWith ? ` START WITH ${unsquashedIdentity.startWith}` : ""}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ""}${unsquashedIdentity.cycle ? ` CYCLE` : ""})` : "";
          statement += `	"${column6.name}" ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${uniqueConstraint6}${identity}`;
          statement += i8 === columns.length - 1 ? "" : ",\n";
        }
        if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
          statement += ",\n";
          const compositePK6 = PgSquasher.unsquashPK(compositePKs[0]);
          statement += `	CONSTRAINT "${st2.compositePkName}" PRIMARY KEY("${compositePK6.columns.join(`","`)}")`;
        }
        if (typeof uniqueConstraints !== "undefined" && uniqueConstraints.length > 0) {
          for (const uniqueConstraint6 of uniqueConstraints) {
            statement += ",\n";
            const unsquashedUnique = PgSquasher.unsquashUnique(uniqueConstraint6);
            statement += `	CONSTRAINT "${unsquashedUnique.name}" UNIQUE${unsquashedUnique.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""}("${unsquashedUnique.columns.join(`","`)}")`;
          }
        }
        if (typeof checkConstraints !== "undefined" && checkConstraints.length > 0) {
          for (const checkConstraint5 of checkConstraints) {
            statement += ",\n";
            const unsquashedCheck = PgSquasher.unsquashCheck(checkConstraint5);
            statement += `	CONSTRAINT "${unsquashedCheck.name}" CHECK (${unsquashedCheck.value})`;
          }
        }
        statement += `
);`;
        statement += `
`;
        const enableRls = new PgEnableRlsConvertor().convert({
          type: "enable_rls",
          tableName,
          schema: schema6
        });
        return [statement, ...policies && policies.length > 0 || isRLSEnabled ? [enableRls] : []];
      }
    };
    MySqlCreateTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_table" && dialect6 === "mysql";
      }
      convert(st2) {
        const {
          tableName,
          columns,
          schema: schema6,
          checkConstraints,
          compositePKs,
          uniqueConstraints,
          internals
        } = st2;
        let statement = "";
        statement += `CREATE TABLE \`${tableName}\` (
`;
        for (let i8 = 0; i8 < columns.length; i8++) {
          const column6 = columns[i8];
          const primaryKeyStatement = column6.primaryKey ? " PRIMARY KEY" : "";
          const notNullStatement = column6.notNull ? " NOT NULL" : "";
          const defaultStatement = column6.default !== void 0 ? ` DEFAULT ${column6.default}` : "";
          const onUpdateStatement = column6.onUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          const autoincrementStatement = column6.autoincrement ? " AUTO_INCREMENT" : "";
          const generatedStatement = column6.generated ? ` GENERATED ALWAYS AS (${column6.generated?.as}) ${column6.generated?.type.toUpperCase()}` : "";
          statement += `	\`${column6.name}\` ${column6.type}${autoincrementStatement}${primaryKeyStatement}${generatedStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}`;
          statement += i8 === columns.length - 1 ? "" : ",\n";
        }
        if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
          statement += ",\n";
          const compositePK6 = MySqlSquasher.unsquashPK(compositePKs[0]);
          statement += `	CONSTRAINT \`${st2.compositePkName}\` PRIMARY KEY(\`${compositePK6.columns.join(`\`,\``)}\`)`;
        }
        if (typeof uniqueConstraints !== "undefined" && uniqueConstraints.length > 0) {
          for (const uniqueConstraint6 of uniqueConstraints) {
            statement += ",\n";
            const unsquashedUnique = MySqlSquasher.unsquashUnique(uniqueConstraint6);
            const uniqueString = unsquashedUnique.columns.map((it2) => {
              return internals?.indexes ? internals?.indexes[unsquashedUnique.name]?.columns[it2]?.isExpression ? it2 : `\`${it2}\`` : `\`${it2}\``;
            }).join(",");
            statement += `	CONSTRAINT \`${unsquashedUnique.name}\` UNIQUE(${uniqueString})`;
          }
        }
        if (typeof checkConstraints !== "undefined" && checkConstraints.length > 0) {
          for (const checkConstraint5 of checkConstraints) {
            statement += ",\n";
            const unsquashedCheck = MySqlSquasher.unsquashCheck(checkConstraint5);
            statement += `	CONSTRAINT \`${unsquashedCheck.name}\` CHECK(${unsquashedCheck.value})`;
          }
        }
        statement += `
);`;
        statement += `
`;
        return statement;
      }
    };
    SingleStoreCreateTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_table" && dialect6 === "singlestore";
      }
      convert(st2) {
        const {
          tableName,
          columns,
          schema: schema6,
          compositePKs,
          uniqueConstraints,
          internals
        } = st2;
        let statement = "";
        statement += `CREATE TABLE \`${tableName}\` (
`;
        for (let i8 = 0; i8 < columns.length; i8++) {
          const column6 = columns[i8];
          const primaryKeyStatement = column6.primaryKey ? " PRIMARY KEY" : "";
          const notNullStatement = column6.notNull ? " NOT NULL" : "";
          const defaultStatement = column6.default !== void 0 ? ` DEFAULT ${column6.default}` : "";
          const onUpdateStatement = column6.onUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          const autoincrementStatement = column6.autoincrement ? " AUTO_INCREMENT" : "";
          const generatedStatement = column6.generated ? ` GENERATED ALWAYS AS (${column6.generated?.as}) ${column6.generated?.type.toUpperCase()}` : "";
          statement += `	\`${column6.name}\` ${column6.type}${autoincrementStatement}${primaryKeyStatement}${notNullStatement}${defaultStatement}${onUpdateStatement}${generatedStatement}`;
          statement += i8 === columns.length - 1 ? "" : ",\n";
        }
        if (typeof compositePKs !== "undefined" && compositePKs.length > 0) {
          statement += ",\n";
          const compositePK6 = SingleStoreSquasher.unsquashPK(compositePKs[0]);
          statement += `	CONSTRAINT \`${compositePK6.name}\` PRIMARY KEY(\`${compositePK6.columns.join(`\`,\``)}\`)`;
        }
        if (typeof uniqueConstraints !== "undefined" && uniqueConstraints.length > 0) {
          for (const uniqueConstraint6 of uniqueConstraints) {
            statement += ",\n";
            const unsquashedUnique = SingleStoreSquasher.unsquashUnique(uniqueConstraint6);
            const uniqueString = unsquashedUnique.columns.map((it2) => {
              return internals?.indexes ? internals?.indexes[unsquashedUnique.name]?.columns[it2]?.isExpression ? it2 : `\`${it2}\`` : `\`${it2}\``;
            }).join(",");
            statement += `	CONSTRAINT \`${unsquashedUnique.name}\` UNIQUE(${uniqueString})`;
          }
        }
        statement += `
);`;
        statement += `
`;
        return statement;
      }
    };
    SQLiteCreateTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "sqlite_create_table" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(st2) {
        const {
          tableName,
          columns,
          referenceData,
          compositePKs,
          uniqueConstraints,
          checkConstraints
        } = st2;
        let statement = "";
        statement += `CREATE TABLE \`${tableName}\` (
`;
        for (let i8 = 0; i8 < columns.length; i8++) {
          const column6 = columns[i8];
          const primaryKeyStatement = column6.primaryKey ? " PRIMARY KEY" : "";
          const notNullStatement = column6.notNull ? " NOT NULL" : "";
          const defaultStatement = column6.default !== void 0 ? ` DEFAULT ${column6.default}` : "";
          const autoincrementStatement = column6.autoincrement ? " AUTOINCREMENT" : "";
          const generatedStatement = column6.generated ? ` GENERATED ALWAYS AS ${column6.generated.as} ${column6.generated.type.toUpperCase()}` : "";
          statement += "	";
          statement += `\`${column6.name}\` ${column6.type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}`;
          statement += i8 === columns.length - 1 ? "" : ",\n";
        }
        compositePKs.forEach((it2) => {
          statement += ",\n	";
          statement += `PRIMARY KEY(${it2.map((it3) => `\`${it3}\``).join(", ")})`;
        });
        for (let i8 = 0; i8 < referenceData.length; i8++) {
          const {
            name: name3,
            tableFrom,
            tableTo,
            columnsFrom,
            columnsTo,
            onDelete,
            onUpdate
          } = referenceData[i8];
          const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : "";
          const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : "";
          const fromColumnsString = columnsFrom.map((it2) => `\`${it2}\``).join(",");
          const toColumnsString = columnsTo.map((it2) => `\`${it2}\``).join(",");
          statement += ",";
          statement += "\n	";
          statement += `FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onUpdateStatement}${onDeleteStatement}`;
        }
        if (typeof uniqueConstraints !== "undefined" && uniqueConstraints.length > 0) {
          for (const uniqueConstraint6 of uniqueConstraints) {
            statement += ",\n";
            const unsquashedUnique = SQLiteSquasher.unsquashUnique(uniqueConstraint6);
            statement += `	CONSTRAINT ${unsquashedUnique.name} UNIQUE(\`${unsquashedUnique.columns.join(`\`,\``)}\`)`;
          }
        }
        if (typeof checkConstraints !== "undefined" && checkConstraints.length > 0) {
          for (const check2 of checkConstraints) {
            statement += ",\n";
            const { value, name: name3 } = SQLiteSquasher.unsquashCheck(check2);
            statement += `	CONSTRAINT "${name3}" CHECK(${value})`;
          }
        }
        statement += `
`;
        statement += `);`;
        statement += `
`;
        return statement;
      }
    };
    PgCreateViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_view" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { definition, name: viewName, schema: schema6, with: withOption, materialized, withNoData, tablespace, using } = st2;
        const name3 = schema6 ? `"${schema6}"."${viewName}"` : `"${viewName}"`;
        let statement = materialized ? `CREATE MATERIALIZED VIEW ${name3}` : `CREATE VIEW ${name3}`;
        if (using) statement += ` USING "${using}"`;
        const options = [];
        if (withOption) {
          statement += ` WITH (`;
          Object.entries(withOption).forEach(([key, value]) => {
            if (typeof value === "undefined") return;
            options.push(`${key.snake_case()} = ${value}`);
          });
          statement += options.join(", ");
          statement += `)`;
        }
        if (tablespace) statement += ` TABLESPACE ${tablespace}`;
        statement += ` AS (${definition})`;
        if (withNoData) statement += ` WITH NO DATA`;
        statement += `;`;
        return statement;
      }
    };
    MySqlCreateViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "mysql_create_view" && dialect6 === "mysql";
      }
      convert(st2) {
        const { definition, name: name3, algorithm, sqlSecurity, withCheckOption, replace } = st2;
        let statement = `CREATE `;
        statement += replace ? `OR REPLACE ` : "";
        statement += algorithm ? `ALGORITHM = ${algorithm}
` : "";
        statement += sqlSecurity ? `SQL SECURITY ${sqlSecurity}
` : "";
        statement += `VIEW \`${name3}\` AS (${definition})`;
        statement += withCheckOption ? `
WITH ${withCheckOption} CHECK OPTION` : "";
        statement += ";";
        return statement;
      }
    };
    SqliteCreateViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "sqlite_create_view" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(st2) {
        const { definition, name: name3 } = st2;
        return `CREATE VIEW \`${name3}\` AS ${definition};`;
      }
    };
    PgDropViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_view" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { name: viewName, schema: schema6, materialized } = st2;
        const name3 = schema6 ? `"${schema6}"."${viewName}"` : `"${viewName}"`;
        return `DROP${materialized ? " MATERIALIZED" : ""} VIEW ${name3};`;
      }
    };
    MySqlDropViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_view" && dialect6 === "mysql";
      }
      convert(st2) {
        const { name: name3 } = st2;
        return `DROP VIEW \`${name3}\`;`;
      }
    };
    SqliteDropViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_view" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(st2) {
        const { name: name3 } = st2;
        return `DROP VIEW \`${name3}\`;`;
      }
    };
    MySqlAlterViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_mysql_view" && dialect6 === "mysql";
      }
      convert(st2) {
        const { name: name3, algorithm, definition, sqlSecurity, withCheckOption } = st2;
        let statement = `ALTER `;
        statement += algorithm ? `ALGORITHM = ${algorithm}
` : "";
        statement += sqlSecurity ? `SQL SECURITY ${sqlSecurity}
` : "";
        statement += `VIEW \`${name3}\` AS ${definition}`;
        statement += withCheckOption ? `
WITH ${withCheckOption} CHECK OPTION` : "";
        statement += ";";
        return statement;
      }
    };
    PgRenameViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_view" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { nameFrom: from, nameTo: to3, schema: schema6, materialized } = st2;
        const nameFrom = `"${schema6}"."${from}"`;
        return `ALTER${materialized ? " MATERIALIZED" : ""} VIEW ${nameFrom} RENAME TO "${to3}";`;
      }
    };
    MySqlRenameViewConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_view" && dialect6 === "mysql";
      }
      convert(st2) {
        const { nameFrom: from, nameTo: to3 } = st2;
        return `RENAME TABLE \`${from}\` TO \`${to3}\`;`;
      }
    };
    PgAlterViewSchemaConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_view_alter_schema" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { fromSchema, toSchema, name: name3, materialized } = st2;
        const statement = `ALTER${materialized ? " MATERIALIZED" : ""} VIEW "${fromSchema}"."${name3}" SET SCHEMA "${toSchema}";`;
        return statement;
      }
    };
    PgAlterViewAddWithOptionConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_view_add_with_option" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { schema: schema6, with: withOption, name: name3, materialized } = st2;
        let statement = `ALTER${materialized ? " MATERIALIZED" : ""} VIEW "${schema6}"."${name3}" SET (`;
        const options = [];
        Object.entries(withOption).forEach(([key, value]) => {
          options.push(`${key.snake_case()} = ${value}`);
        });
        statement += options.join(", ");
        statement += `);`;
        return statement;
      }
    };
    PgAlterViewDropWithOptionConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_view_drop_with_option" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { schema: schema6, name: name3, materialized, with: withOptions } = st2;
        let statement = `ALTER${materialized ? " MATERIALIZED" : ""} VIEW "${schema6}"."${name3}" RESET (`;
        const options = [];
        Object.entries(withOptions).forEach(([key, value]) => {
          options.push(`${key.snake_case()}`);
        });
        statement += options.join(", ");
        statement += ");";
        return statement;
      }
    };
    PgAlterViewAlterTablespaceConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_view_alter_tablespace" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { schema: schema6, name: name3, toTablespace } = st2;
        const statement = `ALTER MATERIALIZED VIEW "${schema6}"."${name3}" SET TABLESPACE ${toTablespace};`;
        return statement;
      }
    };
    PgAlterViewAlterUsingConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_view_alter_using" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { schema: schema6, name: name3, toUsing } = st2;
        const statement = `ALTER MATERIALIZED VIEW "${schema6}"."${name3}" SET ACCESS METHOD "${toUsing}";`;
        return statement;
      }
    };
    PgAlterTableAlterColumnSetGenerated = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_identity" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { identity, tableName, columnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
        const identityWithSchema = schema6 ? `"${schema6}"."${unsquashedIdentity?.name}"` : `"${unsquashedIdentity?.name}"`;
        const identityStatement = unsquashedIdentity ? ` GENERATED ${unsquashedIdentity.type === "always" ? "ALWAYS" : "BY DEFAULT"} AS IDENTITY (sequence name ${identityWithSchema}${unsquashedIdentity.increment ? ` INCREMENT BY ${unsquashedIdentity.increment}` : ""}${unsquashedIdentity.minValue ? ` MINVALUE ${unsquashedIdentity.minValue}` : ""}${unsquashedIdentity.maxValue ? ` MAXVALUE ${unsquashedIdentity.maxValue}` : ""}${unsquashedIdentity.startWith ? ` START WITH ${unsquashedIdentity.startWith}` : ""}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ""}${unsquashedIdentity.cycle ? ` CYCLE` : ""})` : "";
        return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" ADD${identityStatement};`;
      }
    };
    PgAlterTableAlterColumnDropGenerated = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_identity" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP IDENTITY;`;
      }
    };
    PgAlterTableAlterColumnAlterGenerated = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_change_identity" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { identity, oldIdentity, tableName, columnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        const unsquashedIdentity = PgSquasher.unsquashIdentity(identity);
        const unsquashedOldIdentity = PgSquasher.unsquashIdentity(oldIdentity);
        const statementsToReturn = [];
        if (unsquashedOldIdentity.type !== unsquashedIdentity.type) {
          statementsToReturn.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET GENERATED ${unsquashedIdentity.type === "always" ? "ALWAYS" : "BY DEFAULT"};`
          );
        }
        if (unsquashedOldIdentity.minValue !== unsquashedIdentity.minValue) {
          statementsToReturn.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MINVALUE ${unsquashedIdentity.minValue};`
          );
        }
        if (unsquashedOldIdentity.maxValue !== unsquashedIdentity.maxValue) {
          statementsToReturn.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET MAXVALUE ${unsquashedIdentity.maxValue};`
          );
        }
        if (unsquashedOldIdentity.increment !== unsquashedIdentity.increment) {
          statementsToReturn.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET INCREMENT BY ${unsquashedIdentity.increment};`
          );
        }
        if (unsquashedOldIdentity.startWith !== unsquashedIdentity.startWith) {
          statementsToReturn.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET START WITH ${unsquashedIdentity.startWith};`
          );
        }
        if (unsquashedOldIdentity.cache !== unsquashedIdentity.cache) {
          statementsToReturn.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET CACHE ${unsquashedIdentity.cache};`
          );
        }
        if (unsquashedOldIdentity.cycle !== unsquashedIdentity.cycle) {
          statementsToReturn.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET ${unsquashedIdentity.cycle ? `CYCLE` : "NO CYCLE"};`
          );
        }
        return statementsToReturn;
      }
    };
    PgAlterTableAddUniqueConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_unique_constraint" && dialect6 === "postgresql";
      }
      convert(statement) {
        const unsquashed = PgSquasher.unsquashUnique(statement.data);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" UNIQUE${unsquashed.nullsNotDistinct ? " NULLS NOT DISTINCT" : ""}("${unsquashed.columns.join('","')}");`;
      }
    };
    PgAlterTableDropUniqueConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_unique_constraint" && dialect6 === "postgresql";
      }
      convert(statement) {
        const unsquashed = PgSquasher.unsquashUnique(statement.data);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${unsquashed.name}";`;
      }
    };
    PgAlterTableAddCheckConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_check_constraint" && dialect6 === "postgresql";
      }
      convert(statement) {
        const unsquashed = PgSquasher.unsquashCheck(statement.data);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${unsquashed.name}" CHECK (${unsquashed.value});`;
      }
    };
    PgAlterTableDeleteCheckConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_check_constraint" && dialect6 === "postgresql";
      }
      convert(statement) {
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
      }
    };
    MySQLAlterTableAddUniqueConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_unique_constraint" && dialect6 === "mysql";
      }
      convert(statement) {
        const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
        return `ALTER TABLE \`${statement.tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` UNIQUE(\`${unsquashed.columns.join("`,`")}\`);`;
      }
    };
    MySQLAlterTableDropUniqueConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_unique_constraint" && dialect6 === "mysql";
      }
      convert(statement) {
        const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
        return `ALTER TABLE \`${statement.tableName}\` DROP INDEX \`${unsquashed.name}\`;`;
      }
    };
    MySqlAlterTableAddCheckConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_check_constraint" && dialect6 === "mysql";
      }
      convert(statement) {
        const unsquashed = MySqlSquasher.unsquashCheck(statement.data);
        const { tableName } = statement;
        return `ALTER TABLE \`${tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` CHECK (${unsquashed.value});`;
      }
    };
    SingleStoreAlterTableAddUniqueConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_unique_constraint" && dialect6 === "singlestore";
      }
      convert(statement) {
        const unsquashed = SingleStoreSquasher.unsquashUnique(statement.data);
        return `ALTER TABLE \`${statement.tableName}\` ADD CONSTRAINT \`${unsquashed.name}\` UNIQUE(\`${unsquashed.columns.join("`,`")}\`);`;
      }
    };
    SingleStoreAlterTableDropUniqueConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_unique_constraint" && dialect6 === "singlestore";
      }
      convert(statement) {
        const unsquashed = SingleStoreSquasher.unsquashUnique(statement.data);
        return `ALTER TABLE \`${statement.tableName}\` DROP INDEX \`${unsquashed.name}\`;`;
      }
    };
    MySqlAlterTableDeleteCheckConstraintConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_check_constraint" && dialect6 === "mysql";
      }
      convert(statement) {
        const { tableName } = statement;
        return `ALTER TABLE \`${tableName}\` DROP CONSTRAINT \`${statement.constraintName}\`;`;
      }
    };
    CreatePgSequenceConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_sequence" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { name: name3, values: values2, schema: schema6 } = st2;
        const sequenceWithSchema = schema6 ? `"${schema6}"."${name3}"` : `"${name3}"`;
        return `CREATE SEQUENCE ${sequenceWithSchema}${values2.increment ? ` INCREMENT BY ${values2.increment}` : ""}${values2.minValue ? ` MINVALUE ${values2.minValue}` : ""}${values2.maxValue ? ` MAXVALUE ${values2.maxValue}` : ""}${values2.startWith ? ` START WITH ${values2.startWith}` : ""}${values2.cache ? ` CACHE ${values2.cache}` : ""}${values2.cycle ? ` CYCLE` : ""};`;
      }
    };
    DropPgSequenceConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_sequence" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { name: name3, schema: schema6 } = st2;
        const sequenceWithSchema = schema6 ? `"${schema6}"."${name3}"` : `"${name3}"`;
        return `DROP SEQUENCE ${sequenceWithSchema};`;
      }
    };
    RenamePgSequenceConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_sequence" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { nameFrom, nameTo, schema: schema6 } = st2;
        const sequenceWithSchemaFrom = schema6 ? `"${schema6}"."${nameFrom}"` : `"${nameFrom}"`;
        const sequenceWithSchemaTo = schema6 ? `"${schema6}"."${nameTo}"` : `"${nameTo}"`;
        return `ALTER SEQUENCE ${sequenceWithSchemaFrom} RENAME TO "${nameTo}";`;
      }
    };
    MovePgSequenceConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "move_sequence" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { schemaFrom, schemaTo, name: name3 } = st2;
        const sequenceWithSchema = schemaFrom ? `"${schemaFrom}"."${name3}"` : `"${name3}"`;
        const seqSchemaTo = schemaTo ? `"${schemaTo}"` : `public`;
        return `ALTER SEQUENCE ${sequenceWithSchema} SET SCHEMA ${seqSchemaTo};`;
      }
    };
    AlterPgSequenceConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_sequence" && dialect6 === "postgresql";
      }
      convert(st2) {
        const { name: name3, schema: schema6, values: values2 } = st2;
        const { increment, minValue, maxValue, startWith, cache: cache5, cycle } = values2;
        const sequenceWithSchema = schema6 ? `"${schema6}"."${name3}"` : `"${name3}"`;
        return `ALTER SEQUENCE ${sequenceWithSchema}${increment ? ` INCREMENT BY ${increment}` : ""}${minValue ? ` MINVALUE ${minValue}` : ""}${maxValue ? ` MAXVALUE ${maxValue}` : ""}${startWith ? ` START WITH ${startWith}` : ""}${cache5 ? ` CACHE ${cache5}` : ""}${cycle ? ` CYCLE` : ""};`;
      }
    };
    CreateTypeEnumConvertor = class extends Convertor {
      can(statement) {
        return statement.type === "create_type_enum";
      }
      convert(st2) {
        const { name: name3, values: values2, schema: schema6 } = st2;
        const enumNameWithSchema = schema6 ? `"${schema6}"."${name3}"` : `"${name3}"`;
        let valuesStatement = "(";
        valuesStatement += values2.map((it2) => `'${escapeSingleQuotes(it2)}'`).join(", ");
        valuesStatement += ")";
        let statement = `CREATE TYPE ${enumNameWithSchema} AS ENUM${valuesStatement};`;
        return statement;
      }
    };
    DropTypeEnumConvertor = class extends Convertor {
      can(statement) {
        return statement.type === "drop_type_enum";
      }
      convert(st2) {
        const { name: name3, schema: schema6 } = st2;
        const enumNameWithSchema = schema6 ? `"${schema6}"."${name3}"` : `"${name3}"`;
        let statement = `DROP TYPE ${enumNameWithSchema};`;
        return statement;
      }
    };
    AlterTypeAddValueConvertor = class extends Convertor {
      can(statement) {
        return statement.type === "alter_type_add_value";
      }
      convert(st2) {
        const { name: name3, schema: schema6, value, before } = st2;
        const enumNameWithSchema = schema6 ? `"${schema6}"."${name3}"` : `"${name3}"`;
        return `ALTER TYPE ${enumNameWithSchema} ADD VALUE '${value}'${before.length ? ` BEFORE '${before}'` : ""};`;
      }
    };
    AlterTypeSetSchemaConvertor = class extends Convertor {
      can(statement) {
        return statement.type === "move_type_enum";
      }
      convert(st2) {
        const { name: name3, schemaFrom, schemaTo } = st2;
        const enumNameWithSchema = schemaFrom ? `"${schemaFrom}"."${name3}"` : `"${name3}"`;
        return `ALTER TYPE ${enumNameWithSchema} SET SCHEMA "${schemaTo}";`;
      }
    };
    AlterRenameTypeConvertor = class extends Convertor {
      can(statement) {
        return statement.type === "rename_type_enum";
      }
      convert(st2) {
        const { nameTo, nameFrom, schema: schema6 } = st2;
        const enumNameWithSchema = schema6 ? `"${schema6}"."${nameFrom}"` : `"${nameFrom}"`;
        return `ALTER TYPE ${enumNameWithSchema} RENAME TO "${nameTo}";`;
      }
    };
    AlterTypeDropValueConvertor = class extends Convertor {
      can(statement) {
        return statement.type === "alter_type_drop_value";
      }
      convert(st2) {
        const { columnsWithEnum, name: name3, newValues, enumSchema: enumSchema4 } = st2;
        const statements = [];
        for (const withEnum of columnsWithEnum) {
          const tableNameWithSchema = withEnum.tableSchema ? `"${withEnum.tableSchema}"."${withEnum.table}"` : `"${withEnum.table}"`;
          statements.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE text;`
          );
          if (withEnum.default) {
            statements.push(
              `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::text;`
            );
          }
        }
        statements.push(new DropTypeEnumConvertor().convert({ name: name3, schema: enumSchema4, type: "drop_type_enum" }));
        statements.push(new CreateTypeEnumConvertor().convert({
          name: name3,
          schema: enumSchema4,
          values: newValues,
          type: "create_type_enum"
        }));
        for (const withEnum of columnsWithEnum) {
          const tableNameWithSchema = withEnum.tableSchema ? `"${withEnum.tableSchema}"."${withEnum.table}"` : `"${withEnum.table}"`;
          const parsedType = parseType(`"${enumSchema4}".`, withEnum.columnType);
          if (withEnum.default) {
            statements.push(
              `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DEFAULT ${withEnum.default}::${parsedType};`
            );
          }
          statements.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${withEnum.column}" SET DATA TYPE ${parsedType} USING "${withEnum.column}"::${parsedType};`
          );
        }
        return statements;
      }
    };
    PgDropTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_table" && dialect6 === "postgresql";
      }
      convert(statement, _d7, action) {
        const { tableName, schema: schema6, policies } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        const dropPolicyConvertor = new PgDropPolicyConvertor();
        const droppedPolicies = policies?.map((p11) => {
          return dropPolicyConvertor.convert({
            type: "drop_policy",
            tableName,
            data: action === "push" ? PgSquasher.unsquashPolicyPush(p11) : PgSquasher.unsquashPolicy(p11),
            schema: schema6
          });
        }) ?? [];
        return [
          ...droppedPolicies,
          `DROP TABLE ${tableNameWithSchema} CASCADE;`
        ];
      }
    };
    MySQLDropTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_table" && dialect6 === "mysql";
      }
      convert(statement) {
        const { tableName } = statement;
        return `DROP TABLE \`${tableName}\`;`;
      }
    };
    SingleStoreDropTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_table" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { tableName } = statement;
        return `DROP TABLE \`${tableName}\`;`;
      }
    };
    SQLiteDropTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_table" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const { tableName } = statement;
        return `DROP TABLE \`${tableName}\`;`;
      }
    };
    PgRenameTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_table" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableNameFrom, tableNameTo, toSchema, fromSchema } = statement;
        const from = fromSchema ? `"${fromSchema}"."${tableNameFrom}"` : `"${tableNameFrom}"`;
        const to3 = `"${tableNameTo}"`;
        return `ALTER TABLE ${from} RENAME TO ${to3};`;
      }
    };
    SqliteRenameTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_table" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const { tableNameFrom, tableNameTo } = statement;
        return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
      }
    };
    MySqlRenameTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_table" && dialect6 === "mysql";
      }
      convert(statement) {
        const { tableNameFrom, tableNameTo } = statement;
        return `RENAME TABLE \`${tableNameFrom}\` TO \`${tableNameTo}\`;`;
      }
    };
    SingleStoreRenameTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_table" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { tableNameFrom, tableNameTo } = statement;
        return `ALTER TABLE \`${tableNameFrom}\` RENAME TO \`${tableNameTo}\`;`;
      }
    };
    PgAlterTableRenameColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_rename_column" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, oldColumnName, newColumnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
      }
    };
    MySqlAlterTableRenameColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_rename_column" && dialect6 === "mysql";
      }
      convert(statement) {
        const { tableName, oldColumnName, newColumnName } = statement;
        return `ALTER TABLE \`${tableName}\` RENAME COLUMN \`${oldColumnName}\` TO \`${newColumnName}\`;`;
      }
    };
    SingleStoreAlterTableRenameColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_rename_column" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { tableName, oldColumnName, newColumnName } = statement;
        return `ALTER TABLE \`${tableName}\` CHANGE \`${oldColumnName}\` \`${newColumnName}\`;`;
      }
    };
    SQLiteAlterTableRenameColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_rename_column" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const { tableName, oldColumnName, newColumnName } = statement;
        return `ALTER TABLE \`${tableName}\` RENAME COLUMN "${oldColumnName}" TO "${newColumnName}";`;
      }
    };
    PgAlterTableDropColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_drop_column" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} DROP COLUMN "${columnName}";`;
      }
    };
    MySqlAlterTableDropColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_drop_column" && dialect6 === "mysql";
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
      }
    };
    SingleStoreAlterTableDropColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_drop_column" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
      }
    };
    SQLiteAlterTableDropColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_drop_column" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        return `ALTER TABLE \`${tableName}\` DROP COLUMN \`${columnName}\`;`;
      }
    };
    PgAlterTableAddColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_add_column" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, column: column6, schema: schema6 } = statement;
        const { name: name3, type, notNull, generated, primaryKey: primaryKey2, identity } = column6;
        const primaryKeyStatement = primaryKey2 ? " PRIMARY KEY" : "";
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        const defaultStatement = `${column6.default !== void 0 ? ` DEFAULT ${column6.default}` : ""}`;
        const schemaPrefix = column6.typeSchema && column6.typeSchema !== "public" ? `"${column6.typeSchema}".` : "";
        const fixedType = parseType(schemaPrefix, column6.type);
        const notNullStatement = `${notNull ? " NOT NULL" : ""}`;
        const unsquashedIdentity = identity ? PgSquasher.unsquashIdentity(identity) : void 0;
        const identityWithSchema = schema6 ? `"${schema6}"."${unsquashedIdentity?.name}"` : `"${unsquashedIdentity?.name}"`;
        const identityStatement = unsquashedIdentity ? ` GENERATED ${unsquashedIdentity.type === "always" ? "ALWAYS" : "BY DEFAULT"} AS IDENTITY (sequence name ${identityWithSchema}${unsquashedIdentity.increment ? ` INCREMENT BY ${unsquashedIdentity.increment}` : ""}${unsquashedIdentity.minValue ? ` MINVALUE ${unsquashedIdentity.minValue}` : ""}${unsquashedIdentity.maxValue ? ` MAXVALUE ${unsquashedIdentity.maxValue}` : ""}${unsquashedIdentity.startWith ? ` START WITH ${unsquashedIdentity.startWith}` : ""}${unsquashedIdentity.cache ? ` CACHE ${unsquashedIdentity.cache}` : ""}${unsquashedIdentity.cycle ? ` CYCLE` : ""})` : "";
        const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) STORED` : "";
        return `ALTER TABLE ${tableNameWithSchema} ADD COLUMN "${name3}" ${fixedType}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${identityStatement};`;
      }
    };
    MySqlAlterTableAddColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_add_column" && dialect6 === "mysql";
      }
      convert(statement) {
        const { tableName, column: column6 } = statement;
        const {
          name: name3,
          type,
          notNull,
          primaryKey: primaryKey2,
          autoincrement,
          onUpdate,
          generated
        } = column6;
        const defaultStatement = `${column6.default !== void 0 ? ` DEFAULT ${column6.default}` : ""}`;
        const notNullStatement = `${notNull ? " NOT NULL" : ""}`;
        const primaryKeyStatement = `${primaryKey2 ? " PRIMARY KEY" : ""}`;
        const autoincrementStatement = `${autoincrement ? " AUTO_INCREMENT" : ""}`;
        const onUpdateStatement = `${onUpdate ? " ON UPDATE CURRENT_TIMESTAMP" : ""}`;
        const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}` : "";
        return `ALTER TABLE \`${tableName}\` ADD \`${name3}\` ${type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${generatedStatement}${notNullStatement}${onUpdateStatement};`;
      }
    };
    SingleStoreAlterTableAddColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_add_column" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { tableName, column: column6 } = statement;
        const {
          name: name3,
          type,
          notNull,
          primaryKey: primaryKey2,
          autoincrement,
          onUpdate,
          generated
        } = column6;
        const defaultStatement = `${column6.default !== void 0 ? ` DEFAULT ${column6.default}` : ""}`;
        const notNullStatement = `${notNull ? " NOT NULL" : ""}`;
        const primaryKeyStatement = `${primaryKey2 ? " PRIMARY KEY" : ""}`;
        const autoincrementStatement = `${autoincrement ? " AUTO_INCREMENT" : ""}`;
        const onUpdateStatement = `${onUpdate ? " ON UPDATE CURRENT_TIMESTAMP" : ""}`;
        const generatedStatement = generated ? ` GENERATED ALWAYS AS (${generated?.as}) ${generated?.type.toUpperCase()}` : "";
        return `ALTER TABLE \`${tableName}\` ADD \`${name3}\` ${type}${primaryKeyStatement}${autoincrementStatement}${defaultStatement}${notNullStatement}${onUpdateStatement}${generatedStatement};`;
      }
    };
    SQLiteAlterTableAddColumnConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "sqlite_alter_table_add_column" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const { tableName, column: column6, referenceData } = statement;
        const { name: name3, type, notNull, primaryKey: primaryKey2, generated } = column6;
        const defaultStatement = `${column6.default !== void 0 ? ` DEFAULT ${column6.default}` : ""}`;
        const notNullStatement = `${notNull ? " NOT NULL" : ""}`;
        const primaryKeyStatement = `${primaryKey2 ? " PRIMARY KEY" : ""}`;
        const referenceAsObject = referenceData ? SQLiteSquasher.unsquashFK(referenceData) : void 0;
        const referenceStatement = `${referenceAsObject ? ` REFERENCES ${referenceAsObject.tableTo}(${referenceAsObject.columnsTo})` : ""}`;
        const generatedStatement = generated ? ` GENERATED ALWAYS AS ${generated.as} ${generated.type.toUpperCase()}` : "";
        return `ALTER TABLE \`${tableName}\` ADD \`${name3}\` ${type}${primaryKeyStatement}${defaultStatement}${generatedStatement}${notNullStatement}${referenceStatement};`;
      }
    };
    PgAlterTableAlterColumnSetTypeConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "pg_alter_table_alter_column_set_type" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName, newDataType, schema: schema6, oldDataType, columnDefault, typeSchema } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        const statements = [];
        const type = parseType(`"${typeSchema}".`, newDataType.name);
        if (!oldDataType.isEnum && !newDataType.isEnum) {
          statements.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`
          );
          if (columnDefault) {
            statements.push(
              `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`
            );
          }
        }
        if (oldDataType.isEnum && !newDataType.isEnum) {
          statements.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type};`
          );
          if (columnDefault) {
            statements.push(
              `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`
            );
          }
        }
        if (!oldDataType.isEnum && newDataType.isEnum) {
          if (columnDefault) {
            statements.push(
              `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault}::${type};`
            );
          }
          statements.push(
            `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::${type};`
          );
        }
        if (oldDataType.isEnum && newDataType.isEnum) {
          const alterType = `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DATA TYPE ${type} USING "${columnName}"::text::${type};`;
          if (newDataType.name !== oldDataType.name && columnDefault) {
            statements.push(
              `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`,
              alterType,
              `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${columnDefault};`
            );
          } else {
            statements.push(alterType);
          }
        }
        return statements;
      }
    };
    PgAlterTableAlterColumnSetDefaultConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_default" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET DEFAULT ${statement.newDefaultValue};`;
      }
    };
    PgAlterTableAlterColumnDropDefaultConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_default" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP DEFAULT;`;
      }
    };
    PgAlterTableAlterColumnDropGeneratedConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_generated" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP EXPRESSION;`;
      }
    };
    PgAlterTableAlterColumnSetExpressionConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_generated" && dialect6 === "postgresql";
      }
      convert(statement) {
        const {
          tableName,
          columnName,
          schema: schema6,
          columnNotNull: notNull,
          columnDefault,
          columnOnUpdate,
          columnAutoIncrement,
          columnPk,
          columnGenerated
        } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
          schema: schema6,
          tableName,
          column: {
            name: columnName,
            type: statement.newDataType,
            notNull,
            default: columnDefault,
            onUpdate: columnOnUpdate,
            autoincrement: columnAutoIncrement,
            primaryKey: columnPk,
            generated: columnGenerated
          },
          type: "alter_table_add_column"
        });
        return [
          `ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
          addColumnStatement
        ];
      }
    };
    PgAlterTableAlterColumnAlterrGeneratedConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_alter_generated" && dialect6 === "postgresql";
      }
      convert(statement) {
        const {
          tableName,
          columnName,
          schema: schema6,
          columnNotNull: notNull,
          columnDefault,
          columnOnUpdate,
          columnAutoIncrement,
          columnPk,
          columnGenerated
        } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        const addColumnStatement = new PgAlterTableAddColumnConvertor().convert({
          schema: schema6,
          tableName,
          column: {
            name: columnName,
            type: statement.newDataType,
            notNull,
            default: columnDefault,
            onUpdate: columnOnUpdate,
            autoincrement: columnAutoIncrement,
            primaryKey: columnPk,
            generated: columnGenerated
          },
          type: "alter_table_add_column"
        });
        return [
          `ALTER TABLE ${tableNameWithSchema} drop column "${columnName}";`,
          addColumnStatement
        ];
      }
    };
    SqliteAlterTableAlterColumnDropGeneratedConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_generated" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const {
          tableName,
          columnName,
          schema: schema6,
          columnDefault,
          columnOnUpdate,
          columnAutoIncrement,
          columnPk,
          columnGenerated,
          columnNotNull
        } = statement;
        const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
          {
            tableName,
            column: {
              name: columnName,
              type: statement.newDataType,
              notNull: columnNotNull,
              default: columnDefault,
              onUpdate: columnOnUpdate,
              autoincrement: columnAutoIncrement,
              primaryKey: columnPk,
              generated: columnGenerated
            },
            type: "sqlite_alter_table_add_column"
          }
        );
        const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
          tableName,
          columnName,
          schema: schema6,
          type: "alter_table_drop_column"
        });
        return [dropColumnStatement, addColumnStatement];
      }
    };
    SqliteAlterTableAlterColumnSetExpressionConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_generated" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const {
          tableName,
          columnName,
          schema: schema6,
          columnNotNull: notNull,
          columnDefault,
          columnOnUpdate,
          columnAutoIncrement,
          columnPk,
          columnGenerated
        } = statement;
        const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
          {
            tableName,
            column: {
              name: columnName,
              type: statement.newDataType,
              notNull,
              default: columnDefault,
              onUpdate: columnOnUpdate,
              autoincrement: columnAutoIncrement,
              primaryKey: columnPk,
              generated: columnGenerated
            },
            type: "sqlite_alter_table_add_column"
          }
        );
        const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
          tableName,
          columnName,
          schema: schema6,
          type: "alter_table_drop_column"
        });
        return [dropColumnStatement, addColumnStatement];
      }
    };
    SqliteAlterTableAlterColumnAlterGeneratedConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_alter_generated" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const {
          tableName,
          columnName,
          schema: schema6,
          columnNotNull,
          columnDefault,
          columnOnUpdate,
          columnAutoIncrement,
          columnPk,
          columnGenerated
        } = statement;
        const addColumnStatement = new SQLiteAlterTableAddColumnConvertor().convert(
          {
            tableName,
            column: {
              name: columnName,
              type: statement.newDataType,
              notNull: columnNotNull,
              default: columnDefault,
              onUpdate: columnOnUpdate,
              autoincrement: columnAutoIncrement,
              primaryKey: columnPk,
              generated: columnGenerated
            },
            type: "sqlite_alter_table_add_column"
          }
        );
        const dropColumnStatement = new SQLiteAlterTableDropColumnConvertor().convert({
          tableName,
          columnName,
          schema: schema6,
          type: "alter_table_drop_column"
        });
        return [dropColumnStatement, addColumnStatement];
      }
    };
    MySqlAlterTableAlterColumnAlterrGeneratedConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_alter_generated" && dialect6 === "mysql";
      }
      convert(statement) {
        const {
          tableName,
          columnName,
          schema: schema6,
          columnNotNull: notNull,
          columnDefault,
          columnOnUpdate,
          columnAutoIncrement,
          columnPk,
          columnGenerated
        } = statement;
        const tableNameWithSchema = schema6 ? `\`${schema6}\`.\`${tableName}\`` : `\`${tableName}\``;
        const addColumnStatement = new MySqlAlterTableAddColumnConvertor().convert({
          schema: schema6,
          tableName,
          column: {
            name: columnName,
            type: statement.newDataType,
            notNull,
            default: columnDefault,
            onUpdate: columnOnUpdate,
            autoincrement: columnAutoIncrement,
            primaryKey: columnPk,
            generated: columnGenerated
          },
          type: "alter_table_add_column"
        });
        return [
          `ALTER TABLE ${tableNameWithSchema} drop column \`${columnName}\`;`,
          addColumnStatement
        ];
      }
    };
    MySqlAlterTableAddPk = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_pk" && dialect6 === "mysql";
      }
      convert(statement) {
        return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY (\`${statement.columnName}\`);`;
      }
    };
    MySqlAlterTableDropPk = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_pk" && dialect6 === "mysql";
      }
      convert(statement) {
        return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY`;
      }
    };
    LibSQLModifyColumn = class extends Convertor {
      can(statement, dialect6) {
        return (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_set_default" || statement.type === "alter_table_alter_column_drop_default" || statement.type === "create_check_constraint" || statement.type === "delete_check_constraint") && dialect6 === "turso";
      }
      convert(statement, json22) {
        const { tableName, columnName } = statement;
        let columnType = ``;
        let columnDefault = "";
        let columnNotNull = "";
        const sqlStatements = [];
        const indexes = [];
        for (const table6 of Object.values(json22.tables)) {
          for (const index7 of Object.values(table6.indexes)) {
            const unsquashed = SQLiteSquasher.unsquashIdx(index7);
            sqlStatements.push(`DROP INDEX "${unsquashed.name}";`);
            indexes.push({ ...unsquashed, tableName: table6.name });
          }
        }
        switch (statement.type) {
          case "alter_table_alter_column_set_type":
            columnType = ` ${statement.newDataType}`;
            columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
            columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
            break;
          case "alter_table_alter_column_drop_notnull":
            columnType = ` ${statement.newDataType}`;
            columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
            columnNotNull = "";
            break;
          case "alter_table_alter_column_set_notnull":
            columnType = ` ${statement.newDataType}`;
            columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
            columnNotNull = ` NOT NULL`;
            break;
          case "alter_table_alter_column_set_default":
            columnType = ` ${statement.newDataType}`;
            columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
            columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
            break;
          case "alter_table_alter_column_drop_default":
            columnType = ` ${statement.newDataType}`;
            columnDefault = "";
            columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
            break;
        }
        columnDefault = columnDefault instanceof Date ? columnDefault.toISOString() : columnDefault;
        sqlStatements.push(
          `ALTER TABLE \`${tableName}\` ALTER COLUMN "${columnName}" TO "${columnName}"${columnType}${columnNotNull}${columnDefault};`
        );
        for (const index7 of indexes) {
          const indexPart = index7.isUnique ? "UNIQUE INDEX" : "INDEX";
          const whereStatement = index7.where ? ` WHERE ${index7.where}` : "";
          const uniqueString = index7.columns.map((it2) => `\`${it2}\``).join(",");
          const tableName2 = index7.tableName;
          sqlStatements.push(
            `CREATE ${indexPart} \`${index7.name}\` ON \`${tableName2}\` (${uniqueString})${whereStatement};`
          );
        }
        return sqlStatements;
      }
    };
    MySqlModifyColumn = class extends Convertor {
      can(statement, dialect6) {
        return (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_drop_on_update" || statement.type === "alter_table_alter_column_set_on_update" || statement.type === "alter_table_alter_column_set_autoincrement" || statement.type === "alter_table_alter_column_drop_autoincrement" || statement.type === "alter_table_alter_column_set_default" || statement.type === "alter_table_alter_column_drop_default" || statement.type === "alter_table_alter_column_set_generated" || statement.type === "alter_table_alter_column_drop_generated") && dialect6 === "mysql";
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        let columnType = ``;
        let columnDefault = "";
        let columnNotNull = "";
        let columnOnUpdate = "";
        let columnAutoincrement = "";
        let primaryKey2 = statement.columnPk ? " PRIMARY KEY" : "";
        let columnGenerated = "";
        if (statement.type === "alter_table_alter_column_drop_notnull") {
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_notnull") {
          columnNotNull = ` NOT NULL`;
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_drop_on_update") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnOnUpdate = "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_on_update") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = ` ON UPDATE CURRENT_TIMESTAMP`;
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_autoincrement") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = " AUTO_INCREMENT";
        } else if (statement.type === "alter_table_alter_column_drop_autoincrement") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = "";
        } else if (statement.type === "alter_table_alter_column_set_default") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_drop_default") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_generated") {
          columnType = ` ${statement.newDataType}`;
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
          if (statement.columnGenerated?.type === "virtual") {
            return [
              new MySqlAlterTableDropColumnConvertor().convert({
                type: "alter_table_drop_column",
                tableName: statement.tableName,
                columnName: statement.columnName,
                schema: statement.schema
              }),
              new MySqlAlterTableAddColumnConvertor().convert({
                tableName,
                column: {
                  name: columnName,
                  type: statement.newDataType,
                  notNull: statement.columnNotNull,
                  default: statement.columnDefault,
                  onUpdate: statement.columnOnUpdate,
                  autoincrement: statement.columnAutoIncrement,
                  primaryKey: statement.columnPk,
                  generated: statement.columnGenerated
                },
                schema: statement.schema,
                type: "alter_table_add_column"
              })
            ];
          } else {
            columnGenerated = statement.columnGenerated ? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}` : "";
          }
        } else if (statement.type === "alter_table_alter_column_drop_generated") {
          columnType = ` ${statement.newDataType}`;
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
          if (statement.oldColumn?.generated?.type === "virtual") {
            return [
              new MySqlAlterTableDropColumnConvertor().convert({
                type: "alter_table_drop_column",
                tableName: statement.tableName,
                columnName: statement.columnName,
                schema: statement.schema
              }),
              new MySqlAlterTableAddColumnConvertor().convert({
                tableName,
                column: {
                  name: columnName,
                  type: statement.newDataType,
                  notNull: statement.columnNotNull,
                  default: statement.columnDefault,
                  onUpdate: statement.columnOnUpdate,
                  autoincrement: statement.columnAutoIncrement,
                  primaryKey: statement.columnPk,
                  generated: statement.columnGenerated
                },
                schema: statement.schema,
                type: "alter_table_add_column"
              })
            ];
          }
        } else {
          columnType = ` ${statement.newDataType}`;
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
          columnGenerated = statement.columnGenerated ? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}` : "";
        }
        columnDefault = columnDefault instanceof Date ? columnDefault.toISOString() : columnDefault;
        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${columnName}\`${columnType}${columnAutoincrement}${columnGenerated}${columnNotNull}${columnDefault}${columnOnUpdate};`;
      }
    };
    SingleStoreAlterTableAlterColumnAlterrGeneratedConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_alter_generated" && dialect6 === "singlestore";
      }
      convert(statement) {
        const {
          tableName,
          columnName,
          schema: schema6,
          columnNotNull: notNull,
          columnDefault,
          columnOnUpdate,
          columnAutoIncrement,
          columnPk,
          columnGenerated
        } = statement;
        const tableNameWithSchema = schema6 ? `\`${schema6}\`.\`${tableName}\`` : `\`${tableName}\``;
        const addColumnStatement = new SingleStoreAlterTableAddColumnConvertor().convert({
          schema: schema6,
          tableName,
          column: {
            name: columnName,
            type: statement.newDataType,
            notNull,
            default: columnDefault,
            onUpdate: columnOnUpdate,
            autoincrement: columnAutoIncrement,
            primaryKey: columnPk,
            generated: columnGenerated
          },
          type: "alter_table_add_column"
        });
        return [
          `ALTER TABLE ${tableNameWithSchema} drop column \`${columnName}\`;`,
          addColumnStatement
        ];
      }
    };
    SingleStoreAlterTableAddPk = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_pk" && dialect6 === "singlestore";
      }
      convert(statement) {
        return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY (\`${statement.columnName}\`);`;
      }
    };
    SingleStoreAlterTableDropPk = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_pk" && dialect6 === "singlestore";
      }
      convert(statement) {
        return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY`;
      }
    };
    SingleStoreModifyColumn = class extends Convertor {
      can(statement, dialect6) {
        return (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_drop_on_update" || statement.type === "alter_table_alter_column_set_on_update" || statement.type === "alter_table_alter_column_set_autoincrement" || statement.type === "alter_table_alter_column_drop_autoincrement" || statement.type === "alter_table_alter_column_set_default" || statement.type === "alter_table_alter_column_drop_default" || statement.type === "alter_table_alter_column_set_generated" || statement.type === "alter_table_alter_column_drop_generated") && dialect6 === "singlestore";
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        let columnType = ``;
        let columnDefault = "";
        let columnNotNull = "";
        let columnOnUpdate = "";
        let columnAutoincrement = "";
        let primaryKey2 = statement.columnPk ? " PRIMARY KEY" : "";
        let columnGenerated = "";
        if (statement.type === "alter_table_alter_column_drop_notnull") {
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_notnull") {
          columnNotNull = ` NOT NULL`;
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_drop_on_update") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnOnUpdate = "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_on_update") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = ` ON UPDATE CURRENT_TIMESTAMP`;
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_autoincrement") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = " AUTO_INCREMENT";
        } else if (statement.type === "alter_table_alter_column_drop_autoincrement") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = "";
        } else if (statement.type === "alter_table_alter_column_set_default") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = ` DEFAULT ${statement.newDefaultValue}`;
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_drop_default") {
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnType = ` ${statement.newDataType}`;
          columnDefault = "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
        } else if (statement.type === "alter_table_alter_column_set_generated") {
          columnType = ` ${statement.newDataType}`;
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
          if (statement.columnGenerated?.type === "virtual") {
            return [
              new SingleStoreAlterTableDropColumnConvertor().convert({
                type: "alter_table_drop_column",
                tableName: statement.tableName,
                columnName: statement.columnName,
                schema: statement.schema
              }),
              new SingleStoreAlterTableAddColumnConvertor().convert({
                tableName,
                column: {
                  name: columnName,
                  type: statement.newDataType,
                  notNull: statement.columnNotNull,
                  default: statement.columnDefault,
                  onUpdate: statement.columnOnUpdate,
                  autoincrement: statement.columnAutoIncrement,
                  primaryKey: statement.columnPk,
                  generated: statement.columnGenerated
                },
                schema: statement.schema,
                type: "alter_table_add_column"
              })
            ];
          } else {
            columnGenerated = statement.columnGenerated ? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}` : "";
          }
        } else if (statement.type === "alter_table_alter_column_drop_generated") {
          columnType = ` ${statement.newDataType}`;
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
          if (statement.oldColumn?.generated?.type === "virtual") {
            return [
              new SingleStoreAlterTableDropColumnConvertor().convert({
                type: "alter_table_drop_column",
                tableName: statement.tableName,
                columnName: statement.columnName,
                schema: statement.schema
              }),
              new SingleStoreAlterTableAddColumnConvertor().convert({
                tableName,
                column: {
                  name: columnName,
                  type: statement.newDataType,
                  notNull: statement.columnNotNull,
                  default: statement.columnDefault,
                  onUpdate: statement.columnOnUpdate,
                  autoincrement: statement.columnAutoIncrement,
                  primaryKey: statement.columnPk,
                  generated: statement.columnGenerated
                },
                schema: statement.schema,
                type: "alter_table_add_column"
              })
            ];
          }
        } else {
          columnType = ` ${statement.newDataType}`;
          columnNotNull = statement.columnNotNull ? ` NOT NULL` : "";
          columnOnUpdate = columnOnUpdate = statement.columnOnUpdate ? ` ON UPDATE CURRENT_TIMESTAMP` : "";
          columnDefault = statement.columnDefault ? ` DEFAULT ${statement.columnDefault}` : "";
          columnAutoincrement = statement.columnAutoIncrement ? " AUTO_INCREMENT" : "";
          columnGenerated = statement.columnGenerated ? ` GENERATED ALWAYS AS (${statement.columnGenerated?.as}) ${statement.columnGenerated?.type.toUpperCase()}` : "";
        }
        columnDefault = columnDefault instanceof Date ? columnDefault.toISOString() : columnDefault;
        return `ALTER TABLE \`${tableName}\` MODIFY COLUMN \`${columnName}\`${columnType}${columnAutoincrement}${columnNotNull}${columnDefault}${columnOnUpdate}${columnGenerated};`;
      }
    };
    PgAlterTableCreateCompositePrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_composite_pk" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { name: name3, columns } = PgSquasher.unsquashPK(statement.data);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.constraintName}" PRIMARY KEY("${columns.join('","')}");`;
      }
    };
    PgAlterTableDeleteCompositePrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_composite_pk" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { name: name3, columns } = PgSquasher.unsquashPK(statement.data);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.constraintName}";`;
      }
    };
    PgAlterTableAlterCompositePrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_composite_pk" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { name: name3, columns } = PgSquasher.unsquashPK(statement.old);
        const { name: newName, columns: newColumns } = PgSquasher.unsquashPK(
          statement.new
        );
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${statement.oldConstraintName}";
${BREAKPOINT}ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${statement.newConstraintName}" PRIMARY KEY("${newColumns.join('","')}");`;
      }
    };
    MySqlAlterTableCreateCompositePrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_composite_pk" && dialect6 === "mysql";
      }
      convert(statement) {
        const { name: name3, columns } = MySqlSquasher.unsquashPK(statement.data);
        return `ALTER TABLE \`${statement.tableName}\` ADD PRIMARY KEY(\`${columns.join("`,`")}\`);`;
      }
    };
    MySqlAlterTableDeleteCompositePrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_composite_pk" && dialect6 === "mysql";
      }
      convert(statement) {
        const { name: name3, columns } = MySqlSquasher.unsquashPK(statement.data);
        return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY;`;
      }
    };
    MySqlAlterTableAlterCompositePrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_composite_pk" && dialect6 === "mysql";
      }
      convert(statement) {
        const { name: name3, columns } = MySqlSquasher.unsquashPK(statement.old);
        const { name: newName, columns: newColumns } = MySqlSquasher.unsquashPK(
          statement.new
        );
        return `ALTER TABLE \`${statement.tableName}\` DROP PRIMARY KEY, ADD PRIMARY KEY(\`${newColumns.join("`,`")}\`);`;
      }
    };
    PgAlterTableAlterColumnSetPrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_pk" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ADD PRIMARY KEY ("${columnName}");`;
      }
    };
    PgAlterTableAlterColumnDropPrimaryKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_pk" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName, schema: schema6 } = statement;
        return `/* 
    Unfortunately in current drizzle-kit version we can't automatically get name for primary key.
    We are working on making it available!

    Meanwhile you can:
        1. Check pk name in your database, by running
            SELECT constraint_name FROM information_schema.table_constraints
            WHERE table_schema = '${typeof schema6 === "undefined" || schema6 === "" ? "public" : schema6}'
                AND table_name = '${tableName}'
                AND constraint_type = 'PRIMARY KEY';
        2. Uncomment code below and paste pk name manually
        
    Hope to release this update as soon as possible
*/

-- ALTER TABLE "${tableName}" DROP CONSTRAINT "<constraint_name>";`;
      }
    };
    PgAlterTableAlterColumnSetNotNullConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_set_notnull" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" SET NOT NULL;`;
      }
    };
    PgAlterTableAlterColumnDropNotNullConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_alter_column_drop_notnull" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, columnName } = statement;
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} ALTER COLUMN "${columnName}" DROP NOT NULL;`;
      }
    };
    PgCreateForeignKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_reference" && dialect6 === "postgresql";
      }
      convert(statement) {
        const {
          name: name3,
          tableFrom,
          tableTo,
          columnsFrom,
          columnsTo,
          onDelete,
          onUpdate,
          schemaTo
        } = PgSquasher.unsquashFK(statement.data);
        const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : "";
        const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : "";
        const fromColumnsString = columnsFrom.map((it2) => `"${it2}"`).join(",");
        const toColumnsString = columnsTo.map((it2) => `"${it2}"`).join(",");
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${tableFrom}"` : `"${tableFrom}"`;
        const tableToNameWithSchema = schemaTo ? `"${schemaTo}"."${tableTo}"` : `"${tableTo}"`;
        const alterStatement = `ALTER TABLE ${tableNameWithSchema} ADD CONSTRAINT "${name3}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
        return alterStatement;
      }
    };
    LibSQLCreateForeignKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_reference" && dialect6 === "turso";
      }
      convert(statement, json22, action) {
        const { columnsFrom, columnsTo, tableFrom, onDelete, onUpdate, tableTo } = action === "push" ? SQLiteSquasher.unsquashPushFK(statement.data) : SQLiteSquasher.unsquashFK(statement.data);
        const { columnDefault, columnNotNull, columnType } = statement;
        const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : "";
        const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : "";
        const columnsDefaultValue = columnDefault ? ` DEFAULT ${columnDefault}` : "";
        const columnNotNullValue = columnNotNull ? ` NOT NULL` : "";
        const columnTypeValue = columnType ? ` ${columnType}` : "";
        const columnFrom = columnsFrom[0];
        const columnTo = columnsTo[0];
        return `ALTER TABLE \`${tableFrom}\` ALTER COLUMN "${columnFrom}" TO "${columnFrom}"${columnTypeValue}${columnNotNullValue}${columnsDefaultValue} REFERENCES ${tableTo}(${columnTo})${onDeleteStatement}${onUpdateStatement};`;
      }
    };
    MySqlCreateForeignKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_reference" && dialect6 === "mysql";
      }
      convert(statement) {
        const {
          name: name3,
          tableFrom,
          tableTo,
          columnsFrom,
          columnsTo,
          onDelete,
          onUpdate
        } = MySqlSquasher.unsquashFK(statement.data);
        const onDeleteStatement = onDelete ? ` ON DELETE ${onDelete}` : "";
        const onUpdateStatement = onUpdate ? ` ON UPDATE ${onUpdate}` : "";
        const fromColumnsString = columnsFrom.map((it2) => `\`${it2}\``).join(",");
        const toColumnsString = columnsTo.map((it2) => `\`${it2}\``).join(",");
        return `ALTER TABLE \`${tableFrom}\` ADD CONSTRAINT \`${name3}\` FOREIGN KEY (${fromColumnsString}) REFERENCES \`${tableTo}\`(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
      }
    };
    PgAlterForeignKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_reference" && dialect6 === "postgresql";
      }
      convert(statement) {
        const newFk = PgSquasher.unsquashFK(statement.data);
        const oldFk = PgSquasher.unsquashFK(statement.oldFkey);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${oldFk.tableFrom}"` : `"${oldFk.tableFrom}"`;
        let sql3 = `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${oldFk.name}";
`;
        const onDeleteStatement = newFk.onDelete ? ` ON DELETE ${newFk.onDelete}` : "";
        const onUpdateStatement = newFk.onUpdate ? ` ON UPDATE ${newFk.onUpdate}` : "";
        const fromColumnsString = newFk.columnsFrom.map((it2) => `"${it2}"`).join(",");
        const toColumnsString = newFk.columnsTo.map((it2) => `"${it2}"`).join(",");
        const tableFromNameWithSchema = oldFk.schemaTo ? `"${oldFk.schemaTo}"."${oldFk.tableFrom}"` : `"${oldFk.tableFrom}"`;
        const tableToNameWithSchema = newFk.schemaTo ? `"${newFk.schemaTo}"."${newFk.tableFrom}"` : `"${newFk.tableFrom}"`;
        const alterStatement = `ALTER TABLE ${tableFromNameWithSchema} ADD CONSTRAINT "${newFk.name}" FOREIGN KEY (${fromColumnsString}) REFERENCES ${tableToNameWithSchema}(${toColumnsString})${onDeleteStatement}${onUpdateStatement};`;
        sql3 += alterStatement;
        return sql3;
      }
    };
    PgDeleteForeignKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_reference" && dialect6 === "postgresql";
      }
      convert(statement) {
        const tableFrom = statement.tableName;
        const { name: name3 } = PgSquasher.unsquashFK(statement.data);
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${tableFrom}"` : `"${tableFrom}"`;
        return `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${name3}";
`;
      }
    };
    MySqlDeleteForeignKeyConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "delete_reference" && dialect6 === "mysql";
      }
      convert(statement) {
        const tableFrom = statement.tableName;
        const { name: name3 } = MySqlSquasher.unsquashFK(statement.data);
        return `ALTER TABLE \`${tableFrom}\` DROP FOREIGN KEY \`${name3}\`;
`;
      }
    };
    CreatePgIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_index_pg" && dialect6 === "postgresql";
      }
      convert(statement) {
        const {
          name: name3,
          columns,
          isUnique,
          concurrently,
          with: withMap,
          method,
          where
        } = statement.data;
        const indexPart = isUnique ? "UNIQUE INDEX" : "INDEX";
        const value = columns.map(
          (it2) => `${it2.isExpression ? it2.expression : `"${it2.expression}"`}${it2.opclass ? ` ${it2.opclass}` : it2.asc ? "" : " DESC"}${it2.asc && it2.nulls && it2.nulls === "last" || it2.opclass ? "" : ` NULLS ${it2.nulls.toUpperCase()}`}`
        ).join(",");
        const tableNameWithSchema = statement.schema ? `"${statement.schema}"."${statement.tableName}"` : `"${statement.tableName}"`;
        function reverseLogic(mappedWith) {
          let reversedString = "";
          for (const key in mappedWith) {
            if (mappedWith.hasOwnProperty(key)) {
              reversedString += `${key}=${mappedWith[key]},`;
            }
          }
          reversedString = reversedString.slice(0, -1);
          return reversedString;
        }
        return `CREATE ${indexPart}${concurrently ? " CONCURRENTLY" : ""} "${name3}" ON ${tableNameWithSchema} USING ${method} (${value})${Object.keys(withMap).length !== 0 ? ` WITH (${reverseLogic(withMap)})` : ""}${where ? ` WHERE ${where}` : ""};`;
      }
    };
    CreateMySqlIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_index" && dialect6 === "mysql";
      }
      convert(statement) {
        const { name: name3, columns, isUnique } = MySqlSquasher.unsquashIdx(
          statement.data
        );
        const indexPart = isUnique ? "UNIQUE INDEX" : "INDEX";
        const uniqueString = columns.map((it2) => {
          return statement.internal?.indexes ? statement.internal?.indexes[name3]?.columns[it2]?.isExpression ? it2 : `\`${it2}\`` : `\`${it2}\``;
        }).join(",");
        return `CREATE ${indexPart} \`${name3}\` ON \`${statement.tableName}\` (${uniqueString});`;
      }
    };
    CreateSingleStoreIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_index" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { name: name3, columns, isUnique } = SingleStoreSquasher.unsquashIdx(
          statement.data
        );
        const indexPart = isUnique ? "UNIQUE INDEX" : "INDEX";
        const uniqueString = columns.map((it2) => {
          return statement.internal?.indexes ? statement.internal?.indexes[name3]?.columns[it2]?.isExpression ? it2 : `\`${it2}\`` : `\`${it2}\``;
        }).join(",");
        return `CREATE ${indexPart} \`${name3}\` ON \`${statement.tableName}\` (${uniqueString});`;
      }
    };
    CreateSqliteIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_index" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const { name: name3, columns, isUnique, where } = SQLiteSquasher.unsquashIdx(
          statement.data
        );
        const indexPart = isUnique ? "UNIQUE INDEX" : "INDEX";
        const whereStatement = where ? ` WHERE ${where}` : "";
        const uniqueString = columns.map((it2) => {
          return statement.internal?.indexes ? statement.internal?.indexes[name3]?.columns[it2]?.isExpression ? it2 : `\`${it2}\`` : `\`${it2}\``;
        }).join(",");
        return `CREATE ${indexPart} \`${name3}\` ON \`${statement.tableName}\` (${uniqueString})${whereStatement};`;
      }
    };
    PgDropIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_index" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { schema: schema6 } = statement;
        const { name: name3 } = PgSquasher.unsquashIdx(statement.data);
        const indexNameWithSchema = schema6 ? `"${schema6}"."${name3}"` : `"${name3}"`;
        return `DROP INDEX ${indexNameWithSchema};`;
      }
    };
    PgCreateSchemaConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "create_schema" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { name: name3 } = statement;
        return `CREATE SCHEMA "${name3}";
`;
      }
    };
    PgRenameSchemaConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "rename_schema" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { from, to: to3 } = statement;
        return `ALTER SCHEMA "${from}" RENAME TO "${to3}";
`;
      }
    };
    PgDropSchemaConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_schema" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { name: name3 } = statement;
        return `DROP SCHEMA "${name3}";
`;
      }
    };
    PgAlterTableSetSchemaConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_set_schema" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, schemaFrom, schemaTo } = statement;
        return `ALTER TABLE "${schemaFrom}"."${tableName}" SET SCHEMA "${schemaTo}";
`;
      }
    };
    PgAlterTableSetNewSchemaConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_set_new_schema" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, to: to3, from } = statement;
        const tableNameWithSchema = from ? `"${from}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA "${to3}";
`;
      }
    };
    PgAlterTableRemoveFromSchemaConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "alter_table_remove_from_schema" && dialect6 === "postgresql";
      }
      convert(statement) {
        const { tableName, schema: schema6 } = statement;
        const tableNameWithSchema = schema6 ? `"${schema6}"."${tableName}"` : `"${tableName}"`;
        return `ALTER TABLE ${tableNameWithSchema} SET SCHEMA public;
`;
      }
    };
    SqliteDropIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_index" && (dialect6 === "sqlite" || dialect6 === "turso");
      }
      convert(statement) {
        const { name: name3 } = PgSquasher.unsquashIdx(statement.data);
        return `DROP INDEX \`${name3}\`;`;
      }
    };
    MySqlDropIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_index" && dialect6 === "mysql";
      }
      convert(statement) {
        const { name: name3 } = MySqlSquasher.unsquashIdx(statement.data);
        return `DROP INDEX \`${name3}\` ON \`${statement.tableName}\`;`;
      }
    };
    SingleStoreDropIndexConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "drop_index" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { name: name3 } = SingleStoreSquasher.unsquashIdx(statement.data);
        return `DROP INDEX \`${name3}\` ON \`${statement.tableName}\`;`;
      }
    };
    SQLiteRecreateTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "recreate_table" && dialect6 === "sqlite";
      }
      convert(statement) {
        const { tableName, columns, compositePKs, referenceData, checkConstraints } = statement;
        const columnNames = columns.map((it2) => `"${it2.name}"`).join(", ");
        const newTableName = `__new_${tableName}`;
        const sqlStatements = [];
        sqlStatements.push(`PRAGMA foreign_keys=OFF;`);
        const mappedCheckConstraints = checkConstraints.map(
          (it2) => it2.replaceAll(`"${tableName}".`, `"${newTableName}".`).replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`).replaceAll(`${tableName}.`, `${newTableName}.`).replaceAll(`'${tableName}'.`, `'${newTableName}'.`)
        );
        sqlStatements.push(
          new SQLiteCreateTableConvertor().convert({
            type: "sqlite_create_table",
            tableName: newTableName,
            columns,
            referenceData,
            compositePKs,
            checkConstraints: mappedCheckConstraints
          })
        );
        sqlStatements.push(
          `INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${tableName}\`;`
        );
        sqlStatements.push(
          new SQLiteDropTableConvertor().convert({
            type: "drop_table",
            tableName,
            schema: ""
          })
        );
        sqlStatements.push(
          new SqliteRenameTableConvertor().convert({
            fromSchema: "",
            tableNameFrom: newTableName,
            tableNameTo: tableName,
            toSchema: "",
            type: "rename_table"
          })
        );
        sqlStatements.push(`PRAGMA foreign_keys=ON;`);
        return sqlStatements;
      }
    };
    LibSQLRecreateTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "recreate_table" && dialect6 === "turso";
      }
      convert(statement) {
        const { tableName, columns, compositePKs, referenceData, checkConstraints } = statement;
        const columnNames = columns.map((it2) => `"${it2.name}"`).join(", ");
        const newTableName = `__new_${tableName}`;
        const sqlStatements = [];
        const mappedCheckConstraints = checkConstraints.map(
          (it2) => it2.replaceAll(`"${tableName}".`, `"${newTableName}".`).replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`).replaceAll(`${tableName}.`, `${newTableName}.`).replaceAll(`'${tableName}'.`, `\`${newTableName}\`.`)
        );
        sqlStatements.push(`PRAGMA foreign_keys=OFF;`);
        sqlStatements.push(
          new SQLiteCreateTableConvertor().convert({
            type: "sqlite_create_table",
            tableName: newTableName,
            columns,
            referenceData,
            compositePKs,
            checkConstraints: mappedCheckConstraints
          })
        );
        sqlStatements.push(
          `INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${tableName}\`;`
        );
        sqlStatements.push(
          new SQLiteDropTableConvertor().convert({
            type: "drop_table",
            tableName,
            schema: ""
          })
        );
        sqlStatements.push(
          new SqliteRenameTableConvertor().convert({
            fromSchema: "",
            tableNameFrom: newTableName,
            tableNameTo: tableName,
            toSchema: "",
            type: "rename_table"
          })
        );
        sqlStatements.push(`PRAGMA foreign_keys=ON;`);
        return sqlStatements;
      }
    };
    SingleStoreRecreateTableConvertor = class extends Convertor {
      can(statement, dialect6) {
        return statement.type === "singlestore_recreate_table" && dialect6 === "singlestore";
      }
      convert(statement) {
        const { tableName, columns, compositePKs, uniqueConstraints } = statement;
        const columnNames = columns.map((it2) => `\`${it2.name}\``).join(", ");
        const newTableName = `__new_${tableName}`;
        const sqlStatements = [];
        sqlStatements.push(
          new SingleStoreCreateTableConvertor().convert({
            type: "create_table",
            tableName: newTableName,
            columns,
            compositePKs,
            uniqueConstraints,
            schema: ""
          })
        );
        sqlStatements.push(
          `INSERT INTO \`${newTableName}\`(${columnNames}) SELECT ${columnNames} FROM \`${tableName}\`;`
        );
        sqlStatements.push(
          new SingleStoreDropTableConvertor().convert({
            type: "drop_table",
            tableName,
            schema: ""
          })
        );
        sqlStatements.push(
          new SingleStoreRenameTableConvertor().convert({
            fromSchema: "",
            tableNameFrom: newTableName,
            tableNameTo: tableName,
            toSchema: "",
            type: "rename_table"
          })
        );
        return sqlStatements;
      }
    };
    convertors = [];
    convertors.push(new PgCreateTableConvertor());
    convertors.push(new MySqlCreateTableConvertor());
    convertors.push(new SingleStoreCreateTableConvertor());
    convertors.push(new SingleStoreRecreateTableConvertor());
    convertors.push(new SQLiteCreateTableConvertor());
    convertors.push(new SQLiteRecreateTableConvertor());
    convertors.push(new LibSQLRecreateTableConvertor());
    convertors.push(new PgCreateViewConvertor());
    convertors.push(new PgDropViewConvertor());
    convertors.push(new PgRenameViewConvertor());
    convertors.push(new PgAlterViewSchemaConvertor());
    convertors.push(new PgAlterViewAddWithOptionConvertor());
    convertors.push(new PgAlterViewDropWithOptionConvertor());
    convertors.push(new PgAlterViewAlterTablespaceConvertor());
    convertors.push(new PgAlterViewAlterUsingConvertor());
    convertors.push(new MySqlCreateViewConvertor());
    convertors.push(new MySqlDropViewConvertor());
    convertors.push(new MySqlRenameViewConvertor());
    convertors.push(new MySqlAlterViewConvertor());
    convertors.push(new SqliteCreateViewConvertor());
    convertors.push(new SqliteDropViewConvertor());
    convertors.push(new CreateTypeEnumConvertor());
    convertors.push(new DropTypeEnumConvertor());
    convertors.push(new AlterTypeAddValueConvertor());
    convertors.push(new AlterTypeSetSchemaConvertor());
    convertors.push(new AlterRenameTypeConvertor());
    convertors.push(new AlterTypeDropValueConvertor());
    convertors.push(new CreatePgSequenceConvertor());
    convertors.push(new DropPgSequenceConvertor());
    convertors.push(new RenamePgSequenceConvertor());
    convertors.push(new MovePgSequenceConvertor());
    convertors.push(new AlterPgSequenceConvertor());
    convertors.push(new PgDropTableConvertor());
    convertors.push(new MySQLDropTableConvertor());
    convertors.push(new SingleStoreDropTableConvertor());
    convertors.push(new SQLiteDropTableConvertor());
    convertors.push(new PgRenameTableConvertor());
    convertors.push(new MySqlRenameTableConvertor());
    convertors.push(new SingleStoreRenameTableConvertor());
    convertors.push(new SqliteRenameTableConvertor());
    convertors.push(new PgAlterTableRenameColumnConvertor());
    convertors.push(new MySqlAlterTableRenameColumnConvertor());
    convertors.push(new SingleStoreAlterTableRenameColumnConvertor());
    convertors.push(new SQLiteAlterTableRenameColumnConvertor());
    convertors.push(new PgAlterTableDropColumnConvertor());
    convertors.push(new MySqlAlterTableDropColumnConvertor());
    convertors.push(new SingleStoreAlterTableDropColumnConvertor());
    convertors.push(new SQLiteAlterTableDropColumnConvertor());
    convertors.push(new PgAlterTableAddColumnConvertor());
    convertors.push(new MySqlAlterTableAddColumnConvertor());
    convertors.push(new SingleStoreAlterTableAddColumnConvertor());
    convertors.push(new SQLiteAlterTableAddColumnConvertor());
    convertors.push(new PgAlterTableAlterColumnSetTypeConvertor());
    convertors.push(new PgAlterTableAddUniqueConstraintConvertor());
    convertors.push(new PgAlterTableDropUniqueConstraintConvertor());
    convertors.push(new PgAlterTableAddCheckConstraintConvertor());
    convertors.push(new PgAlterTableDeleteCheckConstraintConvertor());
    convertors.push(new MySqlAlterTableAddCheckConstraintConvertor());
    convertors.push(new MySqlAlterTableDeleteCheckConstraintConvertor());
    convertors.push(new MySQLAlterTableAddUniqueConstraintConvertor());
    convertors.push(new MySQLAlterTableDropUniqueConstraintConvertor());
    convertors.push(new SingleStoreAlterTableAddUniqueConstraintConvertor());
    convertors.push(new SingleStoreAlterTableDropUniqueConstraintConvertor());
    convertors.push(new CreatePgIndexConvertor());
    convertors.push(new CreateMySqlIndexConvertor());
    convertors.push(new CreateSingleStoreIndexConvertor());
    convertors.push(new CreateSqliteIndexConvertor());
    convertors.push(new PgDropIndexConvertor());
    convertors.push(new SqliteDropIndexConvertor());
    convertors.push(new MySqlDropIndexConvertor());
    convertors.push(new SingleStoreDropIndexConvertor());
    convertors.push(new PgAlterTableAlterColumnSetPrimaryKeyConvertor());
    convertors.push(new PgAlterTableAlterColumnDropPrimaryKeyConvertor());
    convertors.push(new PgAlterTableAlterColumnSetNotNullConvertor());
    convertors.push(new PgAlterTableAlterColumnDropNotNullConvertor());
    convertors.push(new PgAlterTableAlterColumnSetDefaultConvertor());
    convertors.push(new PgAlterTableAlterColumnDropDefaultConvertor());
    convertors.push(new PgAlterPolicyConvertor());
    convertors.push(new PgCreatePolicyConvertor());
    convertors.push(new PgDropPolicyConvertor());
    convertors.push(new PgRenamePolicyConvertor());
    convertors.push(new PgAlterIndPolicyConvertor());
    convertors.push(new PgCreateIndPolicyConvertor());
    convertors.push(new PgDropIndPolicyConvertor());
    convertors.push(new PgRenameIndPolicyConvertor());
    convertors.push(new PgEnableRlsConvertor());
    convertors.push(new PgDisableRlsConvertor());
    convertors.push(new PgDropRoleConvertor());
    convertors.push(new PgAlterRoleConvertor());
    convertors.push(new PgCreateRoleConvertor());
    convertors.push(new PgRenameRoleConvertor());
    convertors.push(new PgAlterTableAlterColumnSetExpressionConvertor());
    convertors.push(new PgAlterTableAlterColumnDropGeneratedConvertor());
    convertors.push(new PgAlterTableAlterColumnAlterrGeneratedConvertor());
    convertors.push(new MySqlAlterTableAlterColumnAlterrGeneratedConvertor());
    convertors.push(new SingleStoreAlterTableAlterColumnAlterrGeneratedConvertor());
    convertors.push(new SqliteAlterTableAlterColumnDropGeneratedConvertor());
    convertors.push(new SqliteAlterTableAlterColumnAlterGeneratedConvertor());
    convertors.push(new SqliteAlterTableAlterColumnSetExpressionConvertor());
    convertors.push(new MySqlModifyColumn());
    convertors.push(new LibSQLModifyColumn());
    convertors.push(new SingleStoreModifyColumn());
    convertors.push(new PgCreateForeignKeyConvertor());
    convertors.push(new MySqlCreateForeignKeyConvertor());
    convertors.push(new PgAlterForeignKeyConvertor());
    convertors.push(new PgDeleteForeignKeyConvertor());
    convertors.push(new MySqlDeleteForeignKeyConvertor());
    convertors.push(new PgCreateSchemaConvertor());
    convertors.push(new PgRenameSchemaConvertor());
    convertors.push(new PgDropSchemaConvertor());
    convertors.push(new PgAlterTableSetSchemaConvertor());
    convertors.push(new PgAlterTableSetNewSchemaConvertor());
    convertors.push(new PgAlterTableRemoveFromSchemaConvertor());
    convertors.push(new LibSQLCreateForeignKeyConvertor());
    convertors.push(new PgAlterTableAlterColumnDropGenerated());
    convertors.push(new PgAlterTableAlterColumnSetGenerated());
    convertors.push(new PgAlterTableAlterColumnAlterGenerated());
    convertors.push(new PgAlterTableCreateCompositePrimaryKeyConvertor());
    convertors.push(new PgAlterTableDeleteCompositePrimaryKeyConvertor());
    convertors.push(new PgAlterTableAlterCompositePrimaryKeyConvertor());
    convertors.push(new MySqlAlterTableDeleteCompositePrimaryKeyConvertor());
    convertors.push(new MySqlAlterTableDropPk());
    convertors.push(new MySqlAlterTableCreateCompositePrimaryKeyConvertor());
    convertors.push(new MySqlAlterTableAddPk());
    convertors.push(new MySqlAlterTableAlterCompositePrimaryKeyConvertor());
    convertors.push(new SingleStoreAlterTableDropPk());
    convertors.push(new SingleStoreAlterTableAddPk());
    https: `
create table users (
	id int,
    name character varying(128)
);

create type venum as enum('one', 'two', 'three');
alter table users add column typed venum;

insert into users(id, name, typed) values (1, 'name1', 'one');
insert into users(id, name, typed) values (2, 'name2', 'two');
insert into users(id, name, typed) values (3, 'name3', 'three');

alter type venum rename to __venum;
create type venum as enum ('one', 'two', 'three', 'four', 'five');

ALTER TABLE users ALTER COLUMN typed TYPE venum USING typed::text::venum;

insert into users(id, name, typed) values (4, 'name4', 'four');
insert into users(id, name, typed) values (5, 'name5', 'five');

drop type __venum;
`;
  }
});

// src/cli/commands/sqlitePushUtils.ts
var _moveDataStatements, getOldTableName, getNewTableName, logSuggestionsAndReturn;
var init_sqlitePushUtils = __esm({
  "src/cli/commands/sqlitePushUtils.ts"() {
    "use strict";
    init_source();
    init_sqliteSchema();
    init_sqlgenerator();
    init_utils8();
    _moveDataStatements = (tableName, json4, dataLoss = false) => {
      const statements = [];
      const newTableName = `__new_${tableName}`;
      const tableColumns = Object.values(json4.tables[tableName].columns);
      const referenceData = Object.values(json4.tables[tableName].foreignKeys);
      const compositePKs = Object.values(
        json4.tables[tableName].compositePrimaryKeys
      ).map((it2) => SQLiteSquasher.unsquashPK(it2));
      const checkConstraints = Object.values(json4.tables[tableName].checkConstraints);
      const mappedCheckConstraints = checkConstraints.map(
        (it2) => it2.replaceAll(`"${tableName}".`, `"${newTableName}".`).replaceAll(`\`${tableName}\`.`, `\`${newTableName}\`.`).replaceAll(`${tableName}.`, `${newTableName}.`).replaceAll(`'${tableName}'.`, `\`${newTableName}\`.`)
      );
      const fks = referenceData.map((it2) => SQLiteSquasher.unsquashPushFK(it2));
      statements.push(
        new SQLiteCreateTableConvertor().convert({
          type: "sqlite_create_table",
          tableName: newTableName,
          columns: tableColumns,
          referenceData: fks,
          compositePKs,
          checkConstraints: mappedCheckConstraints
        })
      );
      if (!dataLoss) {
        const columns = Object.keys(json4.tables[tableName].columns).map(
          (c6) => `"${c6}"`
        );
        statements.push(
          `INSERT INTO \`${newTableName}\`(${columns.join(
            ", "
          )}) SELECT ${columns.join(", ")} FROM \`${tableName}\`;`
        );
      }
      statements.push(
        new SQLiteDropTableConvertor().convert({
          type: "drop_table",
          tableName,
          schema: ""
        })
      );
      statements.push(
        new SqliteRenameTableConvertor().convert({
          fromSchema: "",
          tableNameFrom: newTableName,
          tableNameTo: tableName,
          toSchema: "",
          type: "rename_table"
        })
      );
      for (const idx of Object.values(json4.tables[tableName].indexes)) {
        statements.push(
          new CreateSqliteIndexConvertor().convert({
            type: "create_index",
            tableName,
            schema: "",
            data: idx
          })
        );
      }
      return statements;
    };
    getOldTableName = (tableName, meta) => {
      for (const key of Object.keys(meta.tables)) {
        const value = meta.tables[key];
        if (`"${tableName}"` === value) {
          return key.substring(1, key.length - 1);
        }
      }
      return tableName;
    };
    getNewTableName = (tableName, meta) => {
      if (typeof meta.tables[`"${tableName}"`] !== "undefined") {
        return meta.tables[`"${tableName}"`].substring(
          1,
          meta.tables[`"${tableName}"`].length - 1
        );
      }
      return tableName;
    };
    logSuggestionsAndReturn = async (connection2, statements, json1, json22, meta) => {
      let shouldAskForApprove = false;
      const statementsToExecute = [];
      const infoToPrint = [];
      const tablesToRemove = [];
      const columnsToRemove = [];
      const schemasToRemove = [];
      const tablesToTruncate = [];
      for (const statement of statements) {
        if (statement.type === "drop_table") {
          const res = await connection2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                statement.tableName
              )} table with ${count2} items`
            );
            tablesToRemove.push(statement.tableName);
            shouldAskForApprove = true;
          }
          const fromJsonStatement = fromJson([statement], "sqlite", "push");
          statementsToExecute.push(
            ...Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]
          );
        } else if (statement.type === "alter_table_drop_column") {
          const tableName = statement.tableName;
          const columnName = statement.columnName;
          const res = await connection2.query(
            `select count(\`${tableName}\`.\`${columnName}\`) as count from \`${tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                columnName
              )} column in ${tableName} table with ${count2} items`
            );
            columnsToRemove.push(`${tableName}_${statement.columnName}`);
            shouldAskForApprove = true;
          }
          const fromJsonStatement = fromJson([statement], "sqlite", "push");
          statementsToExecute.push(
            ...Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]
          );
        } else if (statement.type === "sqlite_alter_table_add_column" && (statement.column.notNull && !statement.column.default)) {
          const tableName = statement.tableName;
          const columnName = statement.column.name;
          const res = await connection2.query(
            `select count(*) as count from \`${tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to add not-null ${source_default.underline(
                columnName
              )} column without default value, which contains ${count2} items`
            );
            tablesToTruncate.push(tableName);
            statementsToExecute.push(`delete from ${tableName};`);
            shouldAskForApprove = true;
          }
          const fromJsonStatement = fromJson([statement], "sqlite", "push");
          statementsToExecute.push(
            ...Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]
          );
        } else if (statement.type === "recreate_table") {
          const tableName = statement.tableName;
          const oldTableName = getOldTableName(tableName, meta);
          let dataLoss = false;
          const prevColumnNames = Object.keys(json1.tables[oldTableName].columns);
          const currentColumnNames = Object.keys(json22.tables[tableName].columns);
          const { removedColumns, addedColumns } = findAddedAndRemoved(
            prevColumnNames,
            currentColumnNames
          );
          if (removedColumns.length) {
            for (const removedColumn of removedColumns) {
              const res = await connection2.query(
                `select count(\`${tableName}\`.\`${removedColumn}\`) as count from \`${tableName}\``
              );
              const count2 = Number(res[0].count);
              if (count2 > 0) {
                infoToPrint.push(
                  `\xB7 You're about to delete ${source_default.underline(
                    removedColumn
                  )} column in ${tableName} table with ${count2} items`
                );
                columnsToRemove.push(removedColumn);
                shouldAskForApprove = true;
              }
            }
          }
          if (addedColumns.length) {
            for (const addedColumn of addedColumns) {
              const [res] = await connection2.query(
                `select count(*) as count from \`${tableName}\``
              );
              const columnConf = json22.tables[tableName].columns[addedColumn];
              const count2 = Number(res.count);
              if (count2 > 0 && columnConf.notNull && !columnConf.default) {
                dataLoss = true;
                infoToPrint.push(
                  `\xB7 You're about to add not-null ${source_default.underline(
                    addedColumn
                  )} column without default value to table, which contains ${count2} items`
                );
                shouldAskForApprove = true;
                tablesToTruncate.push(tableName);
                statementsToExecute.push(`DELETE FROM \`${tableName}\`;`);
              }
            }
          }
          const tablesReferencingCurrent = [];
          for (const table6 of Object.values(json22.tables)) {
            const tablesRefs = Object.values(json22.tables[table6.name].foreignKeys).filter((t6) => SQLiteSquasher.unsquashPushFK(t6).tableTo === tableName).map((it2) => SQLiteSquasher.unsquashPushFK(it2).tableFrom);
            tablesReferencingCurrent.push(...tablesRefs);
          }
          if (!tablesReferencingCurrent.length) {
            statementsToExecute.push(..._moveDataStatements(tableName, json22, dataLoss));
            continue;
          }
          const [{ foreign_keys: pragmaState }] = await connection2.query(`PRAGMA foreign_keys;`);
          if (pragmaState) {
            statementsToExecute.push(`PRAGMA foreign_keys=OFF;`);
          }
          statementsToExecute.push(..._moveDataStatements(tableName, json22, dataLoss));
          if (pragmaState) {
            statementsToExecute.push(`PRAGMA foreign_keys=ON;`);
          }
        } else {
          const fromJsonStatement = fromJson([statement], "sqlite", "push");
          statementsToExecute.push(
            ...Array.isArray(fromJsonStatement) ? fromJsonStatement : [fromJsonStatement]
          );
        }
      }
      return {
        statementsToExecute,
        shouldAskForApprove,
        infoToPrint,
        columnsToRemove: [...new Set(columnsToRemove)],
        schemasToRemove: [...new Set(schemasToRemove)],
        tablesToTruncate: [...new Set(tablesToTruncate)],
        tablesToRemove: [...new Set(tablesToRemove)]
      };
    };
  }
});

// src/jsonStatements.ts
var preparePgCreateTableJson, prepareMySqlCreateTableJson, prepareSingleStoreCreateTableJson, prepareSQLiteCreateTable, prepareDropTableJson, prepareRenameTableJson, prepareCreateEnumJson, prepareAddValuesToEnumJson, prepareDropEnumValues, prepareDropEnumJson, prepareMoveEnumJson, prepareRenameEnumJson, prepareCreateSequenceJson, prepareAlterSequenceJson, prepareDropSequenceJson, prepareMoveSequenceJson, prepareRenameSequenceJson, prepareCreateRoleJson, prepareAlterRoleJson, prepareDropRoleJson, prepareRenameRoleJson, prepareCreateSchemasJson, prepareRenameSchemasJson, prepareDeleteSchemasJson, prepareRenameColumns, _prepareDropColumns, _prepareAddColumns, _prepareSqliteAddColumns, prepareAlterColumnsMysql, preparePgAlterColumns, prepareSqliteAlterColumns, prepareRenamePolicyJsons, prepareRenameIndPolicyJsons, prepareCreatePolicyJsons, prepareCreateIndPolicyJsons, prepareDropPolicyJsons, prepareDropIndPolicyJsons, prepareAlterPolicyJson, prepareAlterIndPolicyJson, preparePgCreateIndexesJson, prepareCreateIndexesJson, prepareCreateReferencesJson, prepareLibSQLCreateReferencesJson, prepareDropReferencesJson, prepareLibSQLDropReferencesJson, prepareAlterReferencesJson, prepareDropIndexesJson, prepareAddCompositePrimaryKeySqlite, prepareDeleteCompositePrimaryKeySqlite, prepareAlterCompositePrimaryKeySqlite, prepareAddCompositePrimaryKeyPg, prepareDeleteCompositePrimaryKeyPg, prepareAlterCompositePrimaryKeyPg, prepareAddUniqueConstraintPg, prepareDeleteUniqueConstraintPg, prepareAddCheckConstraint, prepareDeleteCheckConstraint, prepareAddCompositePrimaryKeyMySql, prepareDeleteCompositePrimaryKeyMySql, prepareAlterCompositePrimaryKeyMySql, preparePgCreateViewJson, prepareMySqlCreateViewJson, prepareSqliteCreateViewJson, prepareDropViewJson, prepareRenameViewJson, preparePgAlterViewAlterSchemaJson, preparePgAlterViewAddWithOptionJson, preparePgAlterViewDropWithOptionJson, preparePgAlterViewAlterTablespaceJson, preparePgAlterViewAlterUsingJson, prepareMySqlAlterView;
var init_jsonStatements = __esm({
  "src/jsonStatements.ts"() {
    "use strict";
    init_source();
    init_sqlitePushUtils();
    init_views();
    init_mysqlSchema();
    init_pgSchema();
    init_singlestoreSchema();
    init_sqliteSchema();
    preparePgCreateTableJson = (table6, json22) => {
      const { name: name3, schema: schema6, columns, compositePrimaryKeys, uniqueConstraints, checkConstraints, policies, isRLSEnabled } = table6;
      const tableKey2 = `${schema6 || "public"}.${name3}`;
      const compositePkName = Object.values(compositePrimaryKeys).length > 0 ? json22.tables[tableKey2].compositePrimaryKeys[`${PgSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name}`].name : "";
      return {
        type: "create_table",
        tableName: name3,
        schema: schema6,
        columns: Object.values(columns),
        compositePKs: Object.values(compositePrimaryKeys),
        compositePkName,
        uniqueConstraints: Object.values(uniqueConstraints),
        policies: Object.values(policies),
        checkConstraints: Object.values(checkConstraints),
        isRLSEnabled: isRLSEnabled ?? false
      };
    };
    prepareMySqlCreateTableJson = (table6, json22, internals) => {
      const { name: name3, schema: schema6, columns, compositePrimaryKeys, uniqueConstraints, checkConstraints } = table6;
      return {
        type: "create_table",
        tableName: name3,
        schema: schema6,
        columns: Object.values(columns),
        compositePKs: Object.values(compositePrimaryKeys),
        compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json22.tables[name3].compositePrimaryKeys[MySqlSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name].name : "",
        uniqueConstraints: Object.values(uniqueConstraints),
        internals,
        checkConstraints: Object.values(checkConstraints)
      };
    };
    prepareSingleStoreCreateTableJson = (table6, json22, internals) => {
      const { name: name3, schema: schema6, columns, compositePrimaryKeys, uniqueConstraints } = table6;
      return {
        type: "create_table",
        tableName: name3,
        schema: schema6,
        columns: Object.values(columns),
        compositePKs: Object.values(compositePrimaryKeys),
        compositePkName: Object.values(compositePrimaryKeys).length > 0 ? json22.tables[name3].compositePrimaryKeys[SingleStoreSquasher.unsquashPK(Object.values(compositePrimaryKeys)[0]).name].name : "",
        uniqueConstraints: Object.values(uniqueConstraints),
        internals
      };
    };
    prepareSQLiteCreateTable = (table6, action) => {
      const { name: name3, columns, uniqueConstraints, checkConstraints } = table6;
      const references2 = Object.values(table6.foreignKeys);
      const composites = Object.values(table6.compositePrimaryKeys).map(
        (it2) => SQLiteSquasher.unsquashPK(it2)
      );
      const fks = references2.map(
        (it2) => action === "push" ? SQLiteSquasher.unsquashPushFK(it2) : SQLiteSquasher.unsquashFK(it2)
      );
      return {
        type: "sqlite_create_table",
        tableName: name3,
        columns: Object.values(columns),
        referenceData: fks,
        compositePKs: composites,
        uniqueConstraints: Object.values(uniqueConstraints),
        checkConstraints: Object.values(checkConstraints)
      };
    };
    prepareDropTableJson = (table6) => {
      return {
        type: "drop_table",
        tableName: table6.name,
        schema: table6.schema,
        policies: table6.policies ? Object.values(table6.policies) : []
      };
    };
    prepareRenameTableJson = (tableFrom, tableTo) => {
      return {
        type: "rename_table",
        fromSchema: tableTo.schema,
        toSchema: tableTo.schema,
        tableNameFrom: tableFrom.name,
        tableNameTo: tableTo.name
      };
    };
    prepareCreateEnumJson = (name3, schema6, values2) => {
      return {
        type: "create_type_enum",
        name: name3,
        schema: schema6,
        values: values2
      };
    };
    prepareAddValuesToEnumJson = (name3, schema6, values2) => {
      return values2.map((it2) => {
        return {
          type: "alter_type_add_value",
          name: name3,
          schema: schema6,
          value: it2.value,
          before: it2.before
        };
      });
    };
    prepareDropEnumValues = (name3, schema6, removedValues, json22) => {
      if (!removedValues.length) return [];
      const affectedColumns = [];
      for (const tableKey2 in json22.tables) {
        const table6 = json22.tables[tableKey2];
        for (const columnKey in table6.columns) {
          const column6 = table6.columns[columnKey];
          const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
          const parsedColumnType = column6.type.replace(arrayDefinitionRegex, "");
          if (parsedColumnType === name3 && column6.typeSchema === schema6) {
            affectedColumns.push({
              tableSchema: table6.schema,
              table: table6.name,
              column: column6.name,
              columnType: column6.type,
              default: column6.default
            });
          }
        }
      }
      return [{
        type: "alter_type_drop_value",
        name: name3,
        enumSchema: schema6,
        deletedValues: removedValues,
        newValues: json22.enums[`${schema6}.${name3}`].values,
        columnsWithEnum: affectedColumns
      }];
    };
    prepareDropEnumJson = (name3, schema6) => {
      return {
        type: "drop_type_enum",
        name: name3,
        schema: schema6
      };
    };
    prepareMoveEnumJson = (name3, schemaFrom, schemaTo) => {
      return {
        type: "move_type_enum",
        name: name3,
        schemaFrom,
        schemaTo
      };
    };
    prepareRenameEnumJson = (nameFrom, nameTo, schema6) => {
      return {
        type: "rename_type_enum",
        nameFrom,
        nameTo,
        schema: schema6
      };
    };
    prepareCreateSequenceJson = (seq) => {
      const values2 = PgSquasher.unsquashSequence(seq.values);
      return {
        type: "create_sequence",
        name: seq.name,
        schema: seq.schema,
        values: values2
      };
    };
    prepareAlterSequenceJson = (seq) => {
      const values2 = PgSquasher.unsquashSequence(seq.values);
      return [
        {
          type: "alter_sequence",
          schema: seq.schema,
          name: seq.name,
          values: values2
        }
      ];
    };
    prepareDropSequenceJson = (name3, schema6) => {
      return {
        type: "drop_sequence",
        name: name3,
        schema: schema6
      };
    };
    prepareMoveSequenceJson = (name3, schemaFrom, schemaTo) => {
      return {
        type: "move_sequence",
        name: name3,
        schemaFrom,
        schemaTo
      };
    };
    prepareRenameSequenceJson = (nameFrom, nameTo, schema6) => {
      return {
        type: "rename_sequence",
        nameFrom,
        nameTo,
        schema: schema6
      };
    };
    prepareCreateRoleJson = (role) => {
      return {
        type: "create_role",
        name: role.name,
        values: {
          createDb: role.createDb,
          createRole: role.createRole,
          inherit: role.inherit
        }
      };
    };
    prepareAlterRoleJson = (role) => {
      return {
        type: "alter_role",
        name: role.name,
        values: {
          createDb: role.createDb,
          createRole: role.createRole,
          inherit: role.inherit
        }
      };
    };
    prepareDropRoleJson = (name3) => {
      return {
        type: "drop_role",
        name: name3
      };
    };
    prepareRenameRoleJson = (nameFrom, nameTo) => {
      return {
        type: "rename_role",
        nameFrom,
        nameTo
      };
    };
    prepareCreateSchemasJson = (values2) => {
      return values2.map((it2) => {
        return {
          type: "create_schema",
          name: it2
        };
      });
    };
    prepareRenameSchemasJson = (values2) => {
      return values2.map((it2) => {
        return {
          type: "rename_schema",
          from: it2.from,
          to: it2.to
        };
      });
    };
    prepareDeleteSchemasJson = (values2) => {
      return values2.map((it2) => {
        return {
          type: "drop_schema",
          name: it2
        };
      });
    };
    prepareRenameColumns = (tableName, schema6, pairs) => {
      return pairs.map((it2) => {
        return {
          type: "alter_table_rename_column",
          tableName,
          oldColumnName: it2.from.name,
          newColumnName: it2.to.name,
          schema: schema6
        };
      });
    };
    _prepareDropColumns = (taleName, schema6, columns) => {
      return columns.map((it2) => {
        return {
          type: "alter_table_drop_column",
          tableName: taleName,
          columnName: it2.name,
          schema: schema6
        };
      });
    };
    _prepareAddColumns = (tableName, schema6, columns) => {
      return columns.map((it2) => {
        return {
          type: "alter_table_add_column",
          tableName,
          column: it2,
          schema: schema6
        };
      });
    };
    _prepareSqliteAddColumns = (tableName, columns, referenceData) => {
      const unsquashed = referenceData.map((addedFkValue) => SQLiteSquasher.unsquashFK(addedFkValue));
      return columns.map((it2) => {
        const columnsWithReference = unsquashed.find((t6) => t6.columnsFrom.includes(it2.name));
        if (it2.generated?.type === "stored") {
          warning(
            `As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`
          );
          return void 0;
        }
        return {
          type: "sqlite_alter_table_add_column",
          tableName,
          column: it2,
          referenceData: columnsWithReference ? SQLiteSquasher.squashFK(columnsWithReference) : void 0
        };
      }).filter(Boolean);
    };
    prepareAlterColumnsMysql = (tableName, schema6, columns, json1, json22, action) => {
      let statements = [];
      let dropPkStatements = [];
      let setPkStatements = [];
      for (const column6 of columns) {
        const columnName = typeof column6.name !== "string" ? column6.name.new : column6.name;
        const table6 = json22.tables[tableName];
        const snapshotColumn = table6.columns[columnName];
        const columnType = snapshotColumn.type;
        const columnDefault = snapshotColumn.default;
        const columnOnUpdate = "onUpdate" in snapshotColumn ? snapshotColumn.onUpdate : void 0;
        const columnNotNull = table6.columns[columnName].notNull;
        const columnAutoIncrement = "autoincrement" in snapshotColumn ? snapshotColumn.autoincrement ?? false : false;
        const columnPk = table6.columns[columnName].primaryKey;
        if (column6.autoincrement?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_autoincrement",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.autoincrement?.type === "changed") {
          const type = column6.autoincrement.new ? "alter_table_alter_column_set_autoincrement" : "alter_table_alter_column_drop_autoincrement";
          statements.push({
            type,
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.autoincrement?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_autoincrement",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
      }
      for (const column6 of columns) {
        const columnName = typeof column6.name !== "string" ? column6.name.new : column6.name;
        const columnType = json22.tables[tableName].columns[columnName].type;
        const columnDefault = json22.tables[tableName].columns[columnName].default;
        const columnGenerated = json22.tables[tableName].columns[columnName].generated;
        const columnOnUpdate = json22.tables[tableName].columns[columnName].onUpdate;
        const columnNotNull = json22.tables[tableName].columns[columnName].notNull;
        const columnAutoIncrement = json22.tables[tableName].columns[columnName].autoincrement;
        const columnPk = json22.tables[tableName].columns[columnName].primaryKey;
        const compositePk = json22.tables[tableName].compositePrimaryKeys[`${tableName}_${columnName}`];
        if (typeof column6.name !== "string") {
          statements.push({
            type: "alter_table_rename_column",
            tableName,
            oldColumnName: column6.name.old,
            newColumnName: column6.name.new,
            schema: schema6
          });
        }
        if (column6.type?.type === "changed") {
          statements.push({
            type: "alter_table_alter_column_set_type",
            tableName,
            columnName,
            newDataType: column6.type.new,
            oldDataType: column6.type.old,
            schema: schema6,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated
          });
        }
        if (column6.primaryKey?.type === "deleted" || column6.primaryKey?.type === "changed" && !column6.primaryKey.new && typeof compositePk === "undefined") {
          dropPkStatements.push({
            ////
            type: "alter_table_alter_column_drop_pk",
            tableName,
            columnName,
            schema: schema6
          });
        }
        if (column6.default?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_default",
            tableName,
            columnName,
            newDefaultValue: column6.default.value,
            schema: schema6,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.default?.type === "changed") {
          statements.push({
            type: "alter_table_alter_column_set_default",
            tableName,
            columnName,
            newDefaultValue: column6.default.new,
            oldDefaultValue: column6.default.old,
            schema: schema6,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.default?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_default",
            tableName,
            columnName,
            schema: schema6,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.notNull?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_notnull",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.notNull?.type === "changed") {
          const type = column6.notNull.new ? "alter_table_alter_column_set_notnull" : "alter_table_alter_column_drop_notnull";
          statements.push({
            type,
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.notNull?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_notnull",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.generated?.type === "added") {
          if (columnGenerated?.type === "virtual") {
            warning(
              `You are trying to add virtual generated constraint to ${source_default.blue(
                columnName
              )} column. As MySQL docs mention: "Nongenerated columns can be altered to stored but not virtual generated columns". We will drop an existing column and add it with a virtual generated statement. This means that the data previously stored in this column will be wiped, and new data will be generated on each read for this column
`
            );
          }
          statements.push({
            type: "alter_table_alter_column_set_generated",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated
          });
        }
        if (column6.generated?.type === "changed" && action !== "push") {
          statements.push({
            type: "alter_table_alter_column_alter_generated",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated
          });
        }
        if (column6.generated?.type === "deleted") {
          if (columnGenerated?.type === "virtual") {
            warning(
              `You are trying to remove virtual generated constraint from ${source_default.blue(
                columnName
              )} column. As MySQL docs mention: "Stored but not virtual generated columns can be altered to nongenerated columns. The stored generated values become the values of the nongenerated column". We will drop an existing column and add it without a virtual generated statement. This means that this column will have no data after migration
`
            );
          }
          statements.push({
            type: "alter_table_alter_column_drop_generated",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated,
            oldColumn: json1.tables[tableName].columns[columnName]
          });
        }
        if (column6.primaryKey?.type === "added" || column6.primaryKey?.type === "changed" && column6.primaryKey.new) {
          const wasAutoincrement = statements.filter(
            (it2) => it2.type === "alter_table_alter_column_set_autoincrement"
          );
          if (wasAutoincrement.length === 0) {
            setPkStatements.push({
              type: "alter_table_alter_column_set_pk",
              tableName,
              schema: schema6,
              columnName
            });
          }
        }
        if (column6.onUpdate?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_on_update",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.onUpdate?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_on_update",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
      }
      return [...dropPkStatements, ...setPkStatements, ...statements];
    };
    preparePgAlterColumns = (_tableName, schema6, columns, json22, json1, action) => {
      const tableKey2 = `${schema6 || "public"}.${_tableName}`;
      let statements = [];
      let dropPkStatements = [];
      let setPkStatements = [];
      for (const column6 of columns) {
        const columnName = typeof column6.name !== "string" ? column6.name.new : column6.name;
        const tableName = json22.tables[tableKey2].name;
        const columnType = json22.tables[tableKey2].columns[columnName].type;
        const columnDefault = json22.tables[tableKey2].columns[columnName].default;
        const columnGenerated = json22.tables[tableKey2].columns[columnName].generated;
        const columnOnUpdate = json22.tables[tableKey2].columns[columnName].onUpdate;
        const columnNotNull = json22.tables[tableKey2].columns[columnName].notNull;
        const columnAutoIncrement = json22.tables[tableKey2].columns[columnName].autoincrement;
        const columnPk = json22.tables[tableKey2].columns[columnName].primaryKey;
        const typeSchema = json22.tables[tableKey2].columns[columnName].typeSchema;
        const json1ColumnTypeSchema = json1.tables[tableKey2].columns[columnName].typeSchema;
        const compositePk = json22.tables[tableKey2].compositePrimaryKeys[`${tableName}_${columnName}`];
        if (typeof column6.name !== "string") {
          statements.push({
            type: "alter_table_rename_column",
            tableName,
            oldColumnName: column6.name.old,
            newColumnName: column6.name.new,
            schema: schema6
          });
        }
        if (column6.type?.type === "changed") {
          const arrayDefinitionRegex = /\[\d*(?:\[\d*\])*\]/g;
          const parsedNewColumnType = column6.type.new.replace(arrayDefinitionRegex, "");
          const parsedOldColumnType = column6.type.old.replace(arrayDefinitionRegex, "");
          const isNewTypeIsEnum = json22.enums[`${typeSchema}.${parsedNewColumnType}`];
          const isOldTypeIsEnum = json1.enums[`${json1ColumnTypeSchema}.${parsedOldColumnType}`];
          statements.push({
            type: "pg_alter_table_alter_column_set_type",
            tableName,
            columnName,
            typeSchema,
            newDataType: {
              name: column6.type.new,
              isEnum: isNewTypeIsEnum ? true : false
            },
            oldDataType: {
              name: column6.type.old,
              isEnum: isOldTypeIsEnum ? true : false
            },
            schema: schema6,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.primaryKey?.type === "deleted" || column6.primaryKey?.type === "changed" && !column6.primaryKey.new && typeof compositePk === "undefined") {
          dropPkStatements.push({
            ////
            type: "alter_table_alter_column_drop_pk",
            tableName,
            columnName,
            schema: schema6
          });
        }
        if (column6.default?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_default",
            tableName,
            columnName,
            newDefaultValue: column6.default.value,
            schema: schema6,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.default?.type === "changed") {
          statements.push({
            type: "alter_table_alter_column_set_default",
            tableName,
            columnName,
            newDefaultValue: column6.default.new,
            oldDefaultValue: column6.default.old,
            schema: schema6,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.default?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_default",
            tableName,
            columnName,
            schema: schema6,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.notNull?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_notnull",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.notNull?.type === "changed") {
          const type = column6.notNull.new ? "alter_table_alter_column_set_notnull" : "alter_table_alter_column_drop_notnull";
          statements.push({
            type,
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.notNull?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_notnull",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.identity?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_identity",
            tableName,
            columnName,
            schema: schema6,
            identity: column6.identity.value
          });
        }
        if (column6.identity?.type === "changed") {
          statements.push({
            type: "alter_table_alter_column_change_identity",
            tableName,
            columnName,
            schema: schema6,
            identity: column6.identity.new,
            oldIdentity: column6.identity.old
          });
        }
        if (column6.identity?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_identity",
            tableName,
            columnName,
            schema: schema6
          });
        }
        if (column6.generated?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_generated",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated
          });
        }
        if (column6.generated?.type === "changed" && action !== "push") {
          statements.push({
            type: "alter_table_alter_column_alter_generated",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated
          });
        }
        if (column6.generated?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_generated",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated
          });
        }
        if (column6.primaryKey?.type === "added" || column6.primaryKey?.type === "changed" && column6.primaryKey.new) {
          const wasAutoincrement = statements.filter(
            (it2) => it2.type === "alter_table_alter_column_set_autoincrement"
          );
          if (wasAutoincrement.length === 0) {
            setPkStatements.push({
              type: "alter_table_alter_column_set_pk",
              tableName,
              schema: schema6,
              columnName
            });
          }
        }
        if (column6.onUpdate?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_on_update",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.onUpdate?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_on_update",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
      }
      return [...dropPkStatements, ...setPkStatements, ...statements];
    };
    prepareSqliteAlterColumns = (tableName, schema6, columns, json22) => {
      let statements = [];
      let dropPkStatements = [];
      let setPkStatements = [];
      for (const column6 of columns) {
        const columnName = typeof column6.name !== "string" ? column6.name.new : column6.name;
        const columnType = json22.tables[tableName].columns[columnName].type;
        const columnDefault = json22.tables[tableName].columns[columnName].default;
        const columnOnUpdate = json22.tables[tableName].columns[columnName].onUpdate;
        const columnNotNull = json22.tables[tableName].columns[columnName].notNull;
        const columnAutoIncrement = json22.tables[tableName].columns[columnName].autoincrement;
        const columnPk = json22.tables[tableName].columns[columnName].primaryKey;
        const columnGenerated = json22.tables[tableName].columns[columnName].generated;
        const compositePk = json22.tables[tableName].compositePrimaryKeys[`${tableName}_${columnName}`];
        if (column6.autoincrement?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_autoincrement",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.autoincrement?.type === "changed") {
          const type = column6.autoincrement.new ? "alter_table_alter_column_set_autoincrement" : "alter_table_alter_column_drop_autoincrement";
          statements.push({
            type,
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.autoincrement?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_autoincrement",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (typeof column6.name !== "string") {
          statements.push({
            type: "alter_table_rename_column",
            tableName,
            oldColumnName: column6.name.old,
            newColumnName: column6.name.new,
            schema: schema6
          });
        }
        if (column6.type?.type === "changed") {
          statements.push({
            type: "alter_table_alter_column_set_type",
            tableName,
            columnName,
            newDataType: column6.type.new,
            oldDataType: column6.type.old,
            schema: schema6,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.primaryKey?.type === "deleted" || column6.primaryKey?.type === "changed" && !column6.primaryKey.new && typeof compositePk === "undefined") {
          dropPkStatements.push({
            ////
            type: "alter_table_alter_column_drop_pk",
            tableName,
            columnName,
            schema: schema6
          });
        }
        if (column6.default?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_default",
            tableName,
            columnName,
            newDefaultValue: column6.default.value,
            schema: schema6,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.default?.type === "changed") {
          statements.push({
            type: "alter_table_alter_column_set_default",
            tableName,
            columnName,
            newDefaultValue: column6.default.new,
            oldDefaultValue: column6.default.old,
            schema: schema6,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.default?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_default",
            tableName,
            columnName,
            schema: schema6,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            newDataType: columnType,
            columnPk
          });
        }
        if (column6.notNull?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_notnull",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.notNull?.type === "changed") {
          const type = column6.notNull.new ? "alter_table_alter_column_set_notnull" : "alter_table_alter_column_drop_notnull";
          statements.push({
            type,
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.notNull?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_notnull",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.generated?.type === "added") {
          if (columnGenerated?.type === "virtual") {
            statements.push({
              type: "alter_table_alter_column_set_generated",
              tableName,
              columnName,
              schema: schema6,
              newDataType: columnType,
              columnDefault,
              columnOnUpdate,
              columnNotNull,
              columnAutoIncrement,
              columnPk,
              columnGenerated
            });
          } else {
            warning(
              `As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`
            );
          }
        }
        if (column6.generated?.type === "changed") {
          if (columnGenerated?.type === "virtual") {
            statements.push({
              type: "alter_table_alter_column_alter_generated",
              tableName,
              columnName,
              schema: schema6,
              newDataType: columnType,
              columnDefault,
              columnOnUpdate,
              columnNotNull,
              columnAutoIncrement,
              columnPk,
              columnGenerated
            });
          } else {
            warning(
              `As SQLite docs mention: "It is not possible to ALTER TABLE ADD COLUMN a STORED column. One can add a VIRTUAL column, however", source: "https://www.sqlite.org/gencol.html"`
            );
          }
        }
        if (column6.generated?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_generated",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk,
            columnGenerated
          });
        }
        if (column6.primaryKey?.type === "added" || column6.primaryKey?.type === "changed" && column6.primaryKey.new) {
          const wasAutoincrement = statements.filter(
            (it2) => it2.type === "alter_table_alter_column_set_autoincrement"
          );
          if (wasAutoincrement.length === 0) {
            setPkStatements.push({
              type: "alter_table_alter_column_set_pk",
              tableName,
              schema: schema6,
              columnName
            });
          }
        }
        if (column6.onUpdate?.type === "added") {
          statements.push({
            type: "alter_table_alter_column_set_on_update",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
        if (column6.onUpdate?.type === "deleted") {
          statements.push({
            type: "alter_table_alter_column_drop_on_update",
            tableName,
            columnName,
            schema: schema6,
            newDataType: columnType,
            columnDefault,
            columnOnUpdate,
            columnNotNull,
            columnAutoIncrement,
            columnPk
          });
        }
      }
      return [...dropPkStatements, ...setPkStatements, ...statements];
    };
    prepareRenamePolicyJsons = (tableName, schema6, renames) => {
      return renames.map((it2) => {
        return {
          type: "rename_policy",
          tableName,
          oldName: it2.from.name,
          newName: it2.to.name,
          schema: schema6
        };
      });
    };
    prepareRenameIndPolicyJsons = (renames) => {
      return renames.map((it2) => {
        return {
          type: "rename_ind_policy",
          tableKey: it2.from.on,
          oldName: it2.from.name,
          newName: it2.to.name
        };
      });
    };
    prepareCreatePolicyJsons = (tableName, schema6, policies) => {
      return policies.map((it2) => {
        return {
          type: "create_policy",
          tableName,
          data: it2,
          schema: schema6
        };
      });
    };
    prepareCreateIndPolicyJsons = (policies) => {
      return policies.map((it2) => {
        return {
          type: "create_ind_policy",
          tableName: it2.on,
          data: it2
        };
      });
    };
    prepareDropPolicyJsons = (tableName, schema6, policies) => {
      return policies.map((it2) => {
        return {
          type: "drop_policy",
          tableName,
          data: it2,
          schema: schema6
        };
      });
    };
    prepareDropIndPolicyJsons = (policies) => {
      return policies.map((it2) => {
        return {
          type: "drop_ind_policy",
          tableName: it2.on,
          data: it2
        };
      });
    };
    prepareAlterPolicyJson = (tableName, schema6, oldPolicy, newPolicy) => {
      return {
        type: "alter_policy",
        tableName,
        oldData: oldPolicy,
        newData: newPolicy,
        schema: schema6
      };
    };
    prepareAlterIndPolicyJson = (oldPolicy, newPolicy) => {
      return {
        type: "alter_ind_policy",
        oldData: oldPolicy,
        newData: newPolicy
      };
    };
    preparePgCreateIndexesJson = (tableName, schema6, indexes, fullSchema, action) => {
      if (action === "push") {
        return Object.values(indexes).map((indexData) => {
          const unsquashedIndex = PgSquasher.unsquashIdxPush(indexData);
          const data = fullSchema.tables[`${schema6 === "" ? "public" : schema6}.${tableName}`].indexes[unsquashedIndex.name];
          return {
            type: "create_index_pg",
            tableName,
            data,
            schema: schema6
          };
        });
      }
      return Object.values(indexes).map((indexData) => {
        return {
          type: "create_index_pg",
          tableName,
          data: PgSquasher.unsquashIdx(indexData),
          schema: schema6
        };
      });
    };
    prepareCreateIndexesJson = (tableName, schema6, indexes, internal) => {
      return Object.values(indexes).map((indexData) => {
        return {
          type: "create_index",
          tableName,
          data: indexData,
          schema: schema6,
          internal
        };
      });
    };
    prepareCreateReferencesJson = (tableName, schema6, foreignKeys) => {
      return Object.values(foreignKeys).map((fkData) => {
        return {
          type: "create_reference",
          tableName,
          data: fkData,
          schema: schema6
        };
      });
    };
    prepareLibSQLCreateReferencesJson = (tableName, schema6, foreignKeys, json22, action) => {
      return Object.values(foreignKeys).map((fkData) => {
        const { columnsFrom, tableFrom, columnsTo } = action === "push" ? SQLiteSquasher.unsquashPushFK(fkData) : SQLiteSquasher.unsquashFK(fkData);
        let isMulticolumn = false;
        if (columnsFrom.length > 1 || columnsTo.length > 1) {
          isMulticolumn = true;
          return {
            type: "create_reference",
            tableName,
            data: fkData,
            schema: schema6,
            isMulticolumn
          };
        }
        const columnFrom = columnsFrom[0];
        const {
          notNull: columnNotNull,
          default: columnDefault,
          type: columnType
        } = json22.tables[tableFrom].columns[columnFrom];
        return {
          type: "create_reference",
          tableName,
          data: fkData,
          schema: schema6,
          columnNotNull,
          columnDefault,
          columnType
        };
      });
    };
    prepareDropReferencesJson = (tableName, schema6, foreignKeys) => {
      return Object.values(foreignKeys).map((fkData) => {
        return {
          type: "delete_reference",
          tableName,
          data: fkData,
          schema: schema6
        };
      });
    };
    prepareLibSQLDropReferencesJson = (tableName, schema6, foreignKeys, json22, meta, action) => {
      const statements = Object.values(foreignKeys).map((fkData) => {
        const { columnsFrom, tableFrom, columnsTo, name: name3, tableTo, onDelete, onUpdate } = action === "push" ? SQLiteSquasher.unsquashPushFK(fkData) : SQLiteSquasher.unsquashFK(fkData);
        const keys = Object.keys(json22.tables[tableName].columns);
        const filtered = columnsFrom.filter((it2) => keys.includes(it2));
        const fullDrop = filtered.length === 0;
        if (fullDrop) return;
        let isMulticolumn = false;
        if (columnsFrom.length > 1 || columnsTo.length > 1) {
          isMulticolumn = true;
          return {
            type: "delete_reference",
            tableName,
            data: fkData,
            schema: schema6,
            isMulticolumn
          };
        }
        const columnFrom = columnsFrom[0];
        const newTableName = getNewTableName(tableFrom, meta);
        const {
          notNull: columnNotNull,
          default: columnDefault,
          type: columnType
        } = json22.tables[newTableName].columns[columnFrom];
        const fkToSquash = {
          columnsFrom,
          columnsTo,
          name: name3,
          tableFrom: newTableName,
          tableTo,
          onDelete,
          onUpdate
        };
        const foreignKey2 = action === "push" ? SQLiteSquasher.squashPushFK(fkToSquash) : SQLiteSquasher.squashFK(fkToSquash);
        return {
          type: "delete_reference",
          tableName,
          data: foreignKey2,
          schema: schema6,
          columnNotNull,
          columnDefault,
          columnType
        };
      });
      return statements.filter((it2) => it2);
    };
    prepareAlterReferencesJson = (tableName, schema6, foreignKeys) => {
      const stmts = [];
      Object.values(foreignKeys).map((val2) => {
        stmts.push({
          type: "delete_reference",
          tableName,
          schema: schema6,
          data: val2.__old
        });
        stmts.push({
          type: "create_reference",
          tableName,
          schema: schema6,
          data: val2.__new
        });
      });
      return stmts;
    };
    prepareDropIndexesJson = (tableName, schema6, indexes) => {
      return Object.values(indexes).map((indexData) => {
        return {
          type: "drop_index",
          tableName,
          data: indexData,
          schema: schema6
        };
      });
    };
    prepareAddCompositePrimaryKeySqlite = (tableName, pks) => {
      return Object.values(pks).map((it2) => {
        return {
          type: "create_composite_pk",
          tableName,
          data: it2
        };
      });
    };
    prepareDeleteCompositePrimaryKeySqlite = (tableName, pks) => {
      return Object.values(pks).map((it2) => {
        return {
          type: "delete_composite_pk",
          tableName,
          data: it2
        };
      });
    };
    prepareAlterCompositePrimaryKeySqlite = (tableName, pks) => {
      return Object.values(pks).map((it2) => {
        return {
          type: "alter_composite_pk",
          tableName,
          old: it2.__old,
          new: it2.__new
        };
      });
    };
    prepareAddCompositePrimaryKeyPg = (tableName, schema6, pks, json22) => {
      return Object.values(pks).map((it2) => {
        const unsquashed = PgSquasher.unsquashPK(it2);
        return {
          type: "create_composite_pk",
          tableName,
          data: it2,
          schema: schema6,
          constraintName: PgSquasher.unsquashPK(it2).name
        };
      });
    };
    prepareDeleteCompositePrimaryKeyPg = (tableName, schema6, pks, json1) => {
      return Object.values(pks).map((it2) => {
        return {
          type: "delete_composite_pk",
          tableName,
          data: it2,
          schema: schema6,
          constraintName: PgSquasher.unsquashPK(it2).name
        };
      });
    };
    prepareAlterCompositePrimaryKeyPg = (tableName, schema6, pks, json1, json22) => {
      return Object.values(pks).map((it2) => {
        return {
          type: "alter_composite_pk",
          tableName,
          old: it2.__old,
          new: it2.__new,
          schema: schema6,
          oldConstraintName: PgSquasher.unsquashPK(it2.__old).name,
          newConstraintName: PgSquasher.unsquashPK(it2.__new).name
        };
      });
    };
    prepareAddUniqueConstraintPg = (tableName, schema6, unqs) => {
      return Object.values(unqs).map((it2) => {
        return {
          type: "create_unique_constraint",
          tableName,
          data: it2,
          schema: schema6
        };
      });
    };
    prepareDeleteUniqueConstraintPg = (tableName, schema6, unqs) => {
      return Object.values(unqs).map((it2) => {
        return {
          type: "delete_unique_constraint",
          tableName,
          data: it2,
          schema: schema6
        };
      });
    };
    prepareAddCheckConstraint = (tableName, schema6, check2) => {
      return Object.values(check2).map((it2) => {
        return {
          type: "create_check_constraint",
          tableName,
          data: it2,
          schema: schema6
        };
      });
    };
    prepareDeleteCheckConstraint = (tableName, schema6, check2) => {
      return Object.values(check2).map((it2) => {
        return {
          type: "delete_check_constraint",
          tableName,
          constraintName: PgSquasher.unsquashCheck(it2).name,
          schema: schema6
        };
      });
    };
    prepareAddCompositePrimaryKeyMySql = (tableName, pks, json1, json22) => {
      const res = [];
      for (const it2 of Object.values(pks)) {
        const unsquashed = MySqlSquasher.unsquashPK(it2);
        if (unsquashed.columns.length === 1 && json1.tables[tableName]?.columns[unsquashed.columns[0]]?.primaryKey) {
          continue;
        }
        res.push({
          type: "create_composite_pk",
          tableName,
          data: it2,
          constraintName: unsquashed.name
        });
      }
      return res;
    };
    prepareDeleteCompositePrimaryKeyMySql = (tableName, pks, json1) => {
      return Object.values(pks).map((it2) => {
        const unsquashed = MySqlSquasher.unsquashPK(it2);
        return {
          type: "delete_composite_pk",
          tableName,
          data: it2
        };
      });
    };
    prepareAlterCompositePrimaryKeyMySql = (tableName, pks, json1, json22) => {
      return Object.values(pks).map((it2) => {
        return {
          type: "alter_composite_pk",
          tableName,
          old: it2.__old,
          new: it2.__new,
          oldConstraintName: json1.tables[tableName].compositePrimaryKeys[MySqlSquasher.unsquashPK(it2.__old).name].name,
          newConstraintName: json22.tables[tableName].compositePrimaryKeys[MySqlSquasher.unsquashPK(it2.__new).name].name
        };
      });
    };
    preparePgCreateViewJson = (name3, schema6, definition, materialized, withNoData = false, withOption, using, tablespace) => {
      return {
        type: "create_view",
        name: name3,
        schema: schema6,
        definition,
        with: withOption,
        materialized,
        withNoData,
        using,
        tablespace
      };
    };
    prepareMySqlCreateViewJson = (name3, definition, meta, replace = false) => {
      const { algorithm, sqlSecurity, withCheckOption } = MySqlSquasher.unsquashView(meta);
      return {
        type: "mysql_create_view",
        name: name3,
        definition,
        algorithm,
        sqlSecurity,
        withCheckOption,
        replace
      };
    };
    prepareSqliteCreateViewJson = (name3, definition) => {
      return {
        type: "sqlite_create_view",
        name: name3,
        definition
      };
    };
    prepareDropViewJson = (name3, schema6, materialized) => {
      const resObject = { name: name3, type: "drop_view" };
      if (schema6) resObject["schema"] = schema6;
      if (materialized) resObject["materialized"] = materialized;
      return resObject;
    };
    prepareRenameViewJson = (to3, from, schema6, materialized) => {
      const resObject = {
        type: "rename_view",
        nameTo: to3,
        nameFrom: from
      };
      if (schema6) resObject["schema"] = schema6;
      if (materialized) resObject["materialized"] = materialized;
      return resObject;
    };
    preparePgAlterViewAlterSchemaJson = (to3, from, name3, materialized) => {
      const returnObject = {
        type: "alter_view_alter_schema",
        fromSchema: from,
        toSchema: to3,
        name: name3
      };
      if (materialized) returnObject["materialized"] = materialized;
      return returnObject;
    };
    preparePgAlterViewAddWithOptionJson = (name3, schema6, materialized, withOption) => {
      return {
        type: "alter_view_add_with_option",
        name: name3,
        schema: schema6,
        materialized,
        with: withOption
      };
    };
    preparePgAlterViewDropWithOptionJson = (name3, schema6, materialized, withOption) => {
      return {
        type: "alter_view_drop_with_option",
        name: name3,
        schema: schema6,
        materialized,
        with: withOption
      };
    };
    preparePgAlterViewAlterTablespaceJson = (name3, schema6, materialized, to3) => {
      return {
        type: "alter_view_alter_tablespace",
        name: name3,
        schema: schema6,
        materialized,
        toTablespace: to3
      };
    };
    preparePgAlterViewAlterUsingJson = (name3, schema6, materialized, to3) => {
      return {
        type: "alter_view_alter_using",
        name: name3,
        schema: schema6,
        materialized,
        toUsing: to3
      };
    };
    prepareMySqlAlterView = (view5) => {
      return { type: "alter_mysql_view", ...view5 };
    };
  }
});

// src/statementCombiner.ts
var prepareLibSQLRecreateTable, prepareSQLiteRecreateTable, libSQLCombineStatements, sqliteCombineStatements, prepareSingleStoreRecreateTable, singleStoreCombineStatements;
var init_statementCombiner = __esm({
  "src/statementCombiner.ts"() {
    "use strict";
    init_jsonStatements();
    init_sqliteSchema();
    prepareLibSQLRecreateTable = (table6, action) => {
      const { name: name3, columns, uniqueConstraints, indexes, checkConstraints } = table6;
      const composites = Object.values(table6.compositePrimaryKeys).map(
        (it2) => SQLiteSquasher.unsquashPK(it2)
      );
      const references2 = Object.values(table6.foreignKeys);
      const fks = references2.map(
        (it2) => action === "push" ? SQLiteSquasher.unsquashPushFK(it2) : SQLiteSquasher.unsquashFK(it2)
      );
      const statements = [
        {
          type: "recreate_table",
          tableName: name3,
          columns: Object.values(columns),
          compositePKs: composites,
          referenceData: fks,
          uniqueConstraints: Object.values(uniqueConstraints),
          checkConstraints: Object.values(checkConstraints)
        }
      ];
      if (Object.keys(indexes).length) {
        statements.push(...prepareCreateIndexesJson(name3, "", indexes));
      }
      return statements;
    };
    prepareSQLiteRecreateTable = (table6, action) => {
      const { name: name3, columns, uniqueConstraints, indexes, checkConstraints } = table6;
      const composites = Object.values(table6.compositePrimaryKeys).map(
        (it2) => SQLiteSquasher.unsquashPK(it2)
      );
      const references2 = Object.values(table6.foreignKeys);
      const fks = references2.map(
        (it2) => action === "push" ? SQLiteSquasher.unsquashPushFK(it2) : SQLiteSquasher.unsquashFK(it2)
      );
      const statements = [
        {
          type: "recreate_table",
          tableName: name3,
          columns: Object.values(columns),
          compositePKs: composites,
          referenceData: fks,
          uniqueConstraints: Object.values(uniqueConstraints),
          checkConstraints: Object.values(checkConstraints)
        }
      ];
      if (Object.keys(indexes).length) {
        statements.push(...prepareCreateIndexesJson(name3, "", indexes));
      }
      return statements;
    };
    libSQLCombineStatements = (statements, json22, action) => {
      const newStatements = {};
      for (const statement of statements) {
        if (statement.type === "alter_table_alter_column_drop_autoincrement" || statement.type === "alter_table_alter_column_set_autoincrement" || statement.type === "alter_table_alter_column_drop_pk" || statement.type === "alter_table_alter_column_set_pk" || statement.type === "create_composite_pk" || statement.type === "alter_composite_pk" || statement.type === "delete_composite_pk" || statement.type === "create_check_constraint" || statement.type === "delete_check_constraint") {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        if (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_set_default" || statement.type === "alter_table_alter_column_drop_default") {
          const { tableName: tableName2, columnName, columnPk } = statement;
          const columnIsPartOfForeignKey = Object.values(
            json22.tables[tableName2].foreignKeys
          ).some((it2) => {
            const unsquashFk = action === "push" ? SQLiteSquasher.unsquashPushFK(it2) : SQLiteSquasher.unsquashFK(it2);
            return unsquashFk.columnsFrom.includes(columnName);
          });
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2 && (columnIsPartOfForeignKey || columnPk)) {
            newStatements[tableName2] = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
            continue;
          }
          if (statementsForTable2 && (columnIsPartOfForeignKey || columnPk)) {
            if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
              const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
              const preparedStatements = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
              if (wasRename) {
                newStatements[tableName2].push(...preparedStatements);
              } else {
                newStatements[tableName2] = preparedStatements;
              }
            }
            continue;
          }
          if (statementsForTable2 && !(columnIsPartOfForeignKey || columnPk)) {
            if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
              newStatements[tableName2].push(statement);
            }
            continue;
          }
          newStatements[tableName2] = [statement];
          continue;
        }
        if (statement.type === "create_reference") {
          const tableName2 = statement.tableName;
          const data = action === "push" ? SQLiteSquasher.unsquashPushFK(statement.data) : SQLiteSquasher.unsquashFK(statement.data);
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = statement.isMulticolumn ? prepareLibSQLRecreateTable(json22.tables[tableName2], action) : [statement];
            continue;
          }
          if (!statement.isMulticolumn && statementsForTable2.some(
            (st2) => st2.type === "sqlite_alter_table_add_column" && st2.column.name === data.columnsFrom[0]
          )) {
            continue;
          }
          if (statement.isMulticolumn) {
            if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
              const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
              const preparedStatements = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
              if (wasRename) {
                newStatements[tableName2].push(...preparedStatements);
              } else {
                newStatements[tableName2] = preparedStatements;
              }
              continue;
            }
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            newStatements[tableName2].push(statement);
          }
          continue;
        }
        if (statement.type === "delete_reference") {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        if (statement.type === "sqlite_alter_table_add_column" && statement.column.primaryKey) {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareLibSQLRecreateTable(json22.tables[tableName2], action);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        const tableName = statement.type === "rename_table" ? statement.tableNameTo : statement.tableName;
        const statementsForTable = newStatements[tableName];
        if (!statementsForTable) {
          newStatements[tableName] = [statement];
          continue;
        }
        if (!statementsForTable.some(({ type }) => type === "recreate_table")) {
          newStatements[tableName].push(statement);
        }
      }
      const combinedStatements = Object.values(newStatements).flat();
      const renamedTables = combinedStatements.filter((it2) => it2.type === "rename_table");
      const renamedColumns = combinedStatements.filter((it2) => it2.type === "alter_table_rename_column");
      const rest = combinedStatements.filter((it2) => it2.type !== "rename_table" && it2.type !== "alter_table_rename_column");
      return [...renamedTables, ...renamedColumns, ...rest];
    };
    sqliteCombineStatements = (statements, json22, action) => {
      const newStatements = {};
      for (const statement of statements) {
        if (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_set_default" || statement.type === "alter_table_alter_column_drop_default" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_drop_autoincrement" || statement.type === "alter_table_alter_column_set_autoincrement" || statement.type === "alter_table_alter_column_drop_pk" || statement.type === "alter_table_alter_column_set_pk" || statement.type === "delete_reference" || statement.type === "alter_reference" || statement.type === "create_composite_pk" || statement.type === "alter_composite_pk" || statement.type === "delete_composite_pk" || statement.type === "create_unique_constraint" || statement.type === "delete_unique_constraint" || statement.type === "create_check_constraint" || statement.type === "delete_check_constraint") {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareSQLiteRecreateTable(json22.tables[tableName2], action);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareSQLiteRecreateTable(json22.tables[tableName2], action);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        if (statement.type === "sqlite_alter_table_add_column" && statement.column.primaryKey) {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareSQLiteRecreateTable(json22.tables[tableName2], action);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareSQLiteRecreateTable(json22.tables[tableName2], action);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        if (statement.type === "create_reference") {
          const tableName2 = statement.tableName;
          const data = action === "push" ? SQLiteSquasher.unsquashPushFK(statement.data) : SQLiteSquasher.unsquashFK(statement.data);
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareSQLiteRecreateTable(json22.tables[tableName2], action);
            continue;
          }
          if (data.columnsFrom.length === 1 && statementsForTable2.some(
            (st2) => st2.type === "sqlite_alter_table_add_column" && st2.column.name === data.columnsFrom[0]
          )) {
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareSQLiteRecreateTable(json22.tables[tableName2], action);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        const tableName = statement.type === "rename_table" ? statement.tableNameTo : statement.tableName;
        const statementsForTable = newStatements[tableName];
        if (!statementsForTable) {
          newStatements[tableName] = [statement];
          continue;
        }
        if (!statementsForTable.some(({ type }) => type === "recreate_table")) {
          newStatements[tableName].push(statement);
        }
      }
      const combinedStatements = Object.values(newStatements).flat();
      const renamedTables = combinedStatements.filter((it2) => it2.type === "rename_table");
      const renamedColumns = combinedStatements.filter((it2) => it2.type === "alter_table_rename_column");
      const rest = combinedStatements.filter((it2) => it2.type !== "rename_table" && it2.type !== "alter_table_rename_column");
      return [...renamedTables, ...renamedColumns, ...rest];
    };
    prepareSingleStoreRecreateTable = (table6) => {
      const { name: name3, columns, uniqueConstraints, indexes, compositePrimaryKeys } = table6;
      const composites = Object.values(compositePrimaryKeys);
      const statements = [
        {
          type: "singlestore_recreate_table",
          tableName: name3,
          columns: Object.values(columns),
          compositePKs: composites,
          uniqueConstraints: Object.values(uniqueConstraints)
        }
      ];
      if (Object.keys(indexes).length) {
        statements.push(...prepareCreateIndexesJson(name3, "", indexes));
      }
      return statements;
    };
    singleStoreCombineStatements = (statements, json22) => {
      const newStatements = {};
      for (const statement of statements) {
        if (statement.type === "alter_table_alter_column_set_type" || statement.type === "alter_table_alter_column_set_notnull" || statement.type === "alter_table_alter_column_drop_notnull" || statement.type === "alter_table_alter_column_drop_autoincrement" || statement.type === "alter_table_alter_column_set_autoincrement" || statement.type === "alter_table_alter_column_drop_pk" || statement.type === "alter_table_alter_column_set_pk" || statement.type === "create_composite_pk" || statement.type === "alter_composite_pk" || statement.type === "delete_composite_pk") {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareSingleStoreRecreateTable(json22.tables[tableName2]);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(
              ({ type }) => type === "rename_table" || type === "alter_table_rename_column"
            );
            const preparedStatements = prepareSingleStoreRecreateTable(json22.tables[tableName2]);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        if ((statement.type === "alter_table_alter_column_drop_default" || statement.type === "alter_table_alter_column_set_default") && statement.columnNotNull) {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareSingleStoreRecreateTable(json22.tables[tableName2]);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareSingleStoreRecreateTable(json22.tables[tableName2]);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        if (statement.type === "alter_table_add_column" && statement.column.primaryKey) {
          const tableName2 = statement.tableName;
          const statementsForTable2 = newStatements[tableName2];
          if (!statementsForTable2) {
            newStatements[tableName2] = prepareSingleStoreRecreateTable(json22.tables[tableName2]);
            continue;
          }
          if (!statementsForTable2.some(({ type }) => type === "recreate_table")) {
            const wasRename = statementsForTable2.some(({ type }) => type === "rename_table");
            const preparedStatements = prepareSingleStoreRecreateTable(json22.tables[tableName2]);
            if (wasRename) {
              newStatements[tableName2].push(...preparedStatements);
            } else {
              newStatements[tableName2] = preparedStatements;
            }
            continue;
          }
          continue;
        }
        const tableName = statement.type === "rename_table" ? statement.tableNameTo : statement.tableName;
        const statementsForTable = newStatements[tableName];
        if (!statementsForTable) {
          newStatements[tableName] = [statement];
          continue;
        }
        if (!statementsForTable.some(({ type }) => type === "singlestore_recreate_table")) {
          newStatements[tableName].push(statement);
        }
      }
      const combinedStatements = Object.values(newStatements).flat();
      const renamedTables = combinedStatements.filter((it2) => it2.type === "rename_table");
      const renamedColumns = combinedStatements.filter((it2) => it2.type === "alter_table_rename_column");
      const rest = combinedStatements.filter((it2) => it2.type !== "rename_table" && it2.type !== "alter_table_rename_column");
      return [...renamedTables, ...renamedColumns, ...rest];
    };
  }
});

// src/snapshotsDiffer.ts
var snapshotsDiffer_exports = {};
__export(snapshotsDiffer_exports, {
  alteredPgViewSchema: () => alteredPgViewSchema,
  alteredTableScheme: () => alteredTableScheme,
  applyLibSQLSnapshotsDiff: () => applyLibSQLSnapshotsDiff,
  applyMysqlSnapshotsDiff: () => applyMysqlSnapshotsDiff,
  applyPgSnapshotsDiff: () => applyPgSnapshotsDiff,
  applySingleStoreSnapshotsDiff: () => applySingleStoreSnapshotsDiff,
  applySqliteSnapshotsDiff: () => applySqliteSnapshotsDiff,
  diffResultScheme: () => diffResultScheme,
  diffResultSchemeMysql: () => diffResultSchemeMysql,
  diffResultSchemeSQLite: () => diffResultSchemeSQLite,
  diffResultSchemeSingleStore: () => diffResultSchemeSingleStore,
  makePatched: () => makePatched,
  makeSelfOrPatched: () => makeSelfOrPatched
});
var makeChanged, makeSelfOrChanged, makePatched, makeSelfOrPatched, columnSchema, alteredColumnSchema, enumSchema3, changedEnumSchema, tableScheme, alteredTableScheme, alteredViewCommon, alteredPgViewSchema, alteredMySqlViewSchema, diffResultScheme, diffResultSchemeMysql, diffResultSchemeSingleStore, diffResultSchemeSQLite, schemaChangeFor, nameChangeFor, nameSchemaChangeFor, columnChangeFor, applyPgSnapshotsDiff, applyMysqlSnapshotsDiff, applySingleStoreSnapshotsDiff, applySqliteSnapshotsDiff, applyLibSQLSnapshotsDiff;
var init_snapshotsDiffer = __esm({
  "src/snapshotsDiffer.ts"() {
    "use strict";
    init_esm();
    init_jsonDiffer();
    init_sqlgenerator();
    init_jsonStatements();
    init_global();
    init_mysqlSchema();
    init_pgSchema();
    init_singlestoreSchema();
    init_sqliteSchema();
    init_statementCombiner();
    init_utils8();
    makeChanged = (schema6) => {
      return objectType({
        type: enumType(["changed"]),
        old: schema6,
        new: schema6
      });
    };
    makeSelfOrChanged = (schema6) => {
      return unionType([
        schema6,
        objectType({
          type: enumType(["changed"]),
          old: schema6,
          new: schema6
        })
      ]);
    };
    makePatched = (schema6) => {
      return unionType([
        objectType({
          type: literalType("added"),
          value: schema6
        }),
        objectType({
          type: literalType("deleted"),
          value: schema6
        }),
        objectType({
          type: literalType("changed"),
          old: schema6,
          new: schema6
        })
      ]);
    };
    makeSelfOrPatched = (schema6) => {
      return unionType([
        objectType({
          type: literalType("none"),
          value: schema6
        }),
        objectType({
          type: literalType("added"),
          value: schema6
        }),
        objectType({
          type: literalType("deleted"),
          value: schema6
        }),
        objectType({
          type: literalType("changed"),
          old: schema6,
          new: schema6
        })
      ]);
    };
    columnSchema = objectType({
      name: stringType(),
      type: stringType(),
      typeSchema: stringType().optional(),
      primaryKey: booleanType().optional(),
      default: anyType().optional(),
      notNull: booleanType().optional(),
      // should it be optional? should if be here?
      autoincrement: booleanType().optional(),
      onUpdate: booleanType().optional(),
      isUnique: anyType().optional(),
      uniqueName: stringType().optional(),
      nullsNotDistinct: booleanType().optional(),
      generated: objectType({
        as: stringType(),
        type: enumType(["stored", "virtual"]).default("stored")
      }).optional(),
      identity: stringType().optional()
    }).strict();
    alteredColumnSchema = objectType({
      name: makeSelfOrChanged(stringType()),
      type: makeChanged(stringType()).optional(),
      default: makePatched(anyType()).optional(),
      primaryKey: makePatched(booleanType()).optional(),
      notNull: makePatched(booleanType()).optional(),
      typeSchema: makePatched(stringType()).optional(),
      onUpdate: makePatched(booleanType()).optional(),
      autoincrement: makePatched(booleanType()).optional(),
      generated: makePatched(
        objectType({
          as: stringType(),
          type: enumType(["stored", "virtual"]).default("stored")
        })
      ).optional(),
      identity: makePatched(stringType()).optional()
    }).strict();
    enumSchema3 = objectType({
      name: stringType(),
      schema: stringType(),
      values: arrayType(stringType())
    }).strict();
    changedEnumSchema = objectType({
      name: stringType(),
      schema: stringType(),
      addedValues: objectType({
        before: stringType(),
        value: stringType()
      }).array(),
      deletedValues: arrayType(stringType())
    }).strict();
    tableScheme = objectType({
      name: stringType(),
      schema: stringType().default(""),
      columns: recordType(stringType(), columnSchema),
      indexes: recordType(stringType(), stringType()),
      foreignKeys: recordType(stringType(), stringType()),
      compositePrimaryKeys: recordType(stringType(), stringType()).default({}),
      uniqueConstraints: recordType(stringType(), stringType()).default({}),
      policies: recordType(stringType(), stringType()).default({}),
      checkConstraints: recordType(stringType(), stringType()).default({}),
      isRLSEnabled: booleanType().default(false)
    }).strict();
    alteredTableScheme = objectType({
      name: stringType(),
      schema: stringType(),
      altered: alteredColumnSchema.array(),
      addedIndexes: recordType(stringType(), stringType()),
      deletedIndexes: recordType(stringType(), stringType()),
      alteredIndexes: recordType(
        stringType(),
        objectType({
          __new: stringType(),
          __old: stringType()
        }).strict()
      ),
      addedForeignKeys: recordType(stringType(), stringType()),
      deletedForeignKeys: recordType(stringType(), stringType()),
      alteredForeignKeys: recordType(
        stringType(),
        objectType({
          __new: stringType(),
          __old: stringType()
        }).strict()
      ),
      addedCompositePKs: recordType(stringType(), stringType()),
      deletedCompositePKs: recordType(stringType(), stringType()),
      alteredCompositePKs: recordType(
        stringType(),
        objectType({
          __new: stringType(),
          __old: stringType()
        })
      ),
      addedUniqueConstraints: recordType(stringType(), stringType()),
      deletedUniqueConstraints: recordType(stringType(), stringType()),
      alteredUniqueConstraints: recordType(
        stringType(),
        objectType({
          __new: stringType(),
          __old: stringType()
        })
      ),
      addedPolicies: recordType(stringType(), stringType()),
      deletedPolicies: recordType(stringType(), stringType()),
      alteredPolicies: recordType(
        stringType(),
        objectType({
          __new: stringType(),
          __old: stringType()
        })
      ),
      addedCheckConstraints: recordType(
        stringType(),
        stringType()
      ),
      deletedCheckConstraints: recordType(
        stringType(),
        stringType()
      ),
      alteredCheckConstraints: recordType(
        stringType(),
        objectType({
          __new: stringType(),
          __old: stringType()
        })
      )
    }).strict();
    alteredViewCommon = objectType({
      name: stringType(),
      alteredDefinition: objectType({
        __old: stringType(),
        __new: stringType()
      }).strict().optional(),
      alteredExisting: objectType({
        __old: booleanType(),
        __new: booleanType()
      }).strict().optional()
    });
    alteredPgViewSchema = alteredViewCommon.merge(
      objectType({
        schema: stringType(),
        deletedWithOption: mergedViewWithOption2.optional(),
        addedWithOption: mergedViewWithOption2.optional(),
        addedWith: mergedViewWithOption2.optional(),
        deletedWith: mergedViewWithOption2.optional(),
        alteredWith: mergedViewWithOption2.optional(),
        alteredSchema: objectType({
          __old: stringType(),
          __new: stringType()
        }).strict().optional(),
        alteredTablespace: objectType({
          __old: stringType(),
          __new: stringType()
        }).strict().optional(),
        alteredUsing: objectType({
          __old: stringType(),
          __new: stringType()
        }).strict().optional()
      }).strict()
    );
    alteredMySqlViewSchema = alteredViewCommon.merge(
      objectType({
        alteredMeta: objectType({
          __old: stringType(),
          __new: stringType()
        }).strict().optional()
      }).strict()
    );
    diffResultScheme = objectType({
      alteredTablesWithColumns: alteredTableScheme.array(),
      alteredEnums: changedEnumSchema.array(),
      alteredSequences: sequenceSquashed2.array(),
      alteredRoles: roleSchema2.array(),
      alteredPolicies: policySquashed2.array(),
      alteredViews: alteredPgViewSchema.array()
    }).strict();
    diffResultSchemeMysql = objectType({
      alteredTablesWithColumns: alteredTableScheme.array(),
      alteredEnums: neverType().array(),
      alteredViews: alteredMySqlViewSchema.array()
    });
    diffResultSchemeSingleStore = objectType({
      alteredTablesWithColumns: alteredTableScheme.array(),
      alteredEnums: neverType().array()
    });
    diffResultSchemeSQLite = objectType({
      alteredTablesWithColumns: alteredTableScheme.array(),
      alteredEnums: neverType().array(),
      alteredViews: alteredViewCommon.array()
    });
    schemaChangeFor = (table6, renamedSchemas) => {
      for (let ren of renamedSchemas) {
        if (table6.schema === ren.from.name) {
          return { key: `${ren.to.name}.${table6.name}`, schema: ren.to.name };
        }
      }
      return {
        key: `${table6.schema || "public"}.${table6.name}`,
        schema: table6.schema
      };
    };
    nameChangeFor = (table6, renamed) => {
      for (let ren of renamed) {
        if (table6.name === ren.from.name) {
          return { name: ren.to.name };
        }
      }
      return {
        name: table6.name
      };
    };
    nameSchemaChangeFor = (table6, renamedTables) => {
      for (let ren of renamedTables) {
        if (table6.name === ren.from.name && table6.schema === ren.from.schema) {
          return {
            key: `${ren.to.schema || "public"}.${ren.to.name}`,
            name: ren.to.name,
            schema: ren.to.schema
          };
        }
      }
      return {
        key: `${table6.schema || "public"}.${table6.name}`,
        name: table6.name,
        schema: table6.schema
      };
    };
    columnChangeFor = (column6, renamedColumns) => {
      for (let ren of renamedColumns) {
        if (column6 === ren.from.name) {
          return ren.to.name;
        }
      }
      return column6;
    };
    applyPgSnapshotsDiff = async (json1, json22, schemasResolver2, enumsResolver2, sequencesResolver2, policyResolver2, indPolicyResolver2, roleResolver2, tablesResolver2, columnsResolver2, viewsResolver2, prevFull, curFull, action) => {
      const schemasDiff = diffSchemasOrTables(json1.schemas, json22.schemas);
      const {
        created: createdSchemas,
        deleted: deletedSchemas,
        renamed: renamedSchemas
      } = await schemasResolver2({
        created: schemasDiff.added.map((it2) => ({ name: it2 })),
        deleted: schemasDiff.deleted.map((it2) => ({ name: it2 }))
      });
      const schemasPatchedSnap1 = copy(json1);
      schemasPatchedSnap1.tables = mapEntries(
        schemasPatchedSnap1.tables,
        (_7, it2) => {
          const { key, schema: schema6 } = schemaChangeFor(it2, renamedSchemas);
          it2.schema = schema6;
          return [key, it2];
        }
      );
      schemasPatchedSnap1.enums = mapEntries(schemasPatchedSnap1.enums, (_7, it2) => {
        const { key, schema: schema6 } = schemaChangeFor(it2, renamedSchemas);
        it2.schema = schema6;
        return [key, it2];
      });
      const enumsDiff = diffSchemasOrTables(schemasPatchedSnap1.enums, json22.enums);
      const {
        created: createdEnums,
        deleted: deletedEnums,
        renamed: renamedEnums,
        moved: movedEnums
      } = await enumsResolver2({
        created: enumsDiff.added,
        deleted: enumsDiff.deleted
      });
      schemasPatchedSnap1.enums = mapEntries(schemasPatchedSnap1.enums, (_7, it2) => {
        const { key, name: name3, schema: schema6 } = nameSchemaChangeFor(it2, renamedEnums);
        it2.name = name3;
        it2.schema = schema6;
        return [key, it2];
      });
      const columnTypesChangeMap = renamedEnums.reduce(
        (acc, it2) => {
          acc[`${it2.from.schema}.${it2.from.name}`] = {
            nameFrom: it2.from.name,
            nameTo: it2.to.name,
            schemaFrom: it2.from.schema,
            schemaTo: it2.to.schema
          };
          return acc;
        },
        {}
      );
      const columnTypesMovesMap = movedEnums.reduce(
        (acc, it2) => {
          acc[`${it2.schemaFrom}.${it2.name}`] = {
            nameFrom: it2.name,
            nameTo: it2.name,
            schemaFrom: it2.schemaFrom,
            schemaTo: it2.schemaTo
          };
          return acc;
        },
        {}
      );
      schemasPatchedSnap1.tables = mapEntries(
        schemasPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedColumns = mapValues(tableValue.columns, (column6) => {
            const key = `${column6.typeSchema || "public"}.${column6.type}`;
            const change = columnTypesChangeMap[key] || columnTypesMovesMap[key];
            if (change) {
              column6.type = change.nameTo;
              column6.typeSchema = change.schemaTo;
            }
            return column6;
          });
          tableValue.columns = patchedColumns;
          return [tableKey2, tableValue];
        }
      );
      schemasPatchedSnap1.sequences = mapEntries(
        schemasPatchedSnap1.sequences,
        (_7, it2) => {
          const { key, schema: schema6 } = schemaChangeFor(it2, renamedSchemas);
          it2.schema = schema6;
          return [key, it2];
        }
      );
      const sequencesDiff = diffSchemasOrTables(
        schemasPatchedSnap1.sequences,
        json22.sequences
      );
      const {
        created: createdSequences,
        deleted: deletedSequences,
        renamed: renamedSequences,
        moved: movedSequences
      } = await sequencesResolver2({
        created: sequencesDiff.added,
        deleted: sequencesDiff.deleted
      });
      schemasPatchedSnap1.sequences = mapEntries(
        schemasPatchedSnap1.sequences,
        (_7, it2) => {
          const { key, name: name3, schema: schema6 } = nameSchemaChangeFor(it2, renamedSequences);
          it2.name = name3;
          it2.schema = schema6;
          return [key, it2];
        }
      );
      const sequencesChangeMap = renamedSequences.reduce(
        (acc, it2) => {
          acc[`${it2.from.schema}.${it2.from.name}`] = {
            nameFrom: it2.from.name,
            nameTo: it2.to.name,
            schemaFrom: it2.from.schema,
            schemaTo: it2.to.schema
          };
          return acc;
        },
        {}
      );
      const sequencesMovesMap = movedSequences.reduce(
        (acc, it2) => {
          acc[`${it2.schemaFrom}.${it2.name}`] = {
            nameFrom: it2.name,
            nameTo: it2.name,
            schemaFrom: it2.schemaFrom,
            schemaTo: it2.schemaTo
          };
          return acc;
        },
        {}
      );
      schemasPatchedSnap1.tables = mapEntries(
        schemasPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedColumns = mapValues(tableValue.columns, (column6) => {
            const key = `${column6.typeSchema || "public"}.${column6.type}`;
            const change = sequencesChangeMap[key] || sequencesMovesMap[key];
            if (change) {
              column6.type = change.nameTo;
              column6.typeSchema = change.schemaTo;
            }
            return column6;
          });
          tableValue.columns = patchedColumns;
          return [tableKey2, tableValue];
        }
      );
      const rolesDiff = diffSchemasOrTables(
        schemasPatchedSnap1.roles,
        json22.roles
      );
      const {
        created: createdRoles,
        deleted: deletedRoles,
        renamed: renamedRoles
      } = await roleResolver2({
        created: rolesDiff.added,
        deleted: rolesDiff.deleted
      });
      schemasPatchedSnap1.roles = mapEntries(
        schemasPatchedSnap1.roles,
        (_7, it2) => {
          const { name: name3 } = nameChangeFor(it2, renamedRoles);
          it2.name = name3;
          return [name3, it2];
        }
      );
      const rolesChangeMap = renamedRoles.reduce(
        (acc, it2) => {
          acc[it2.from.name] = {
            nameFrom: it2.from.name,
            nameTo: it2.to.name
          };
          return acc;
        },
        {}
      );
      schemasPatchedSnap1.roles = mapEntries(
        schemasPatchedSnap1.roles,
        (roleKey, roleValue) => {
          const key = roleKey;
          const change = rolesChangeMap[key];
          if (change) {
            roleValue.name = change.nameTo;
          }
          return [roleKey, roleValue];
        }
      );
      const tablesDiff = diffSchemasOrTables(
        schemasPatchedSnap1.tables,
        json22.tables
      );
      const {
        created: createdTables,
        deleted: deletedTables,
        moved: movedTables,
        renamed: renamedTables
        // renamed or moved
      } = await tablesResolver2({
        created: tablesDiff.added,
        deleted: tablesDiff.deleted
      });
      const tablesPatchedSnap1 = copy(schemasPatchedSnap1);
      tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_7, it2) => {
        const { key, name: name3, schema: schema6 } = nameSchemaChangeFor(it2, renamedTables);
        it2.name = name3;
        it2.schema = schema6;
        return [key, it2];
      });
      const res = diffColumns(tablesPatchedSnap1.tables, json22.tables);
      const columnRenames = [];
      const columnCreates = [];
      const columnDeletes = [];
      for (let entry of Object.values(res)) {
        const { renamed, created: created2, deleted: deleted2 } = await columnsResolver2({
          tableName: entry.name,
          schema: entry.schema,
          deleted: entry.columns.deleted,
          created: entry.columns.added
        });
        if (created2.length > 0) {
          columnCreates.push({
            table: entry.name,
            schema: entry.schema,
            columns: created2
          });
        }
        if (deleted2.length > 0) {
          columnDeletes.push({
            table: entry.name,
            schema: entry.schema,
            columns: deleted2
          });
        }
        if (renamed.length > 0) {
          columnRenames.push({
            table: entry.name,
            schema: entry.schema,
            renames: renamed
          });
        }
      }
      const columnRenamesDict = columnRenames.reduce(
        (acc, it2) => {
          acc[`${it2.schema || "public"}.${it2.table}`] = it2.renames;
          return acc;
        },
        {}
      );
      const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
      columnsPatchedSnap1.tables = mapEntries(
        columnsPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedColumns = mapKeys(
            tableValue.columns,
            (columnKey, column6) => {
              const rens = columnRenamesDict[`${tableValue.schema || "public"}.${tableValue.name}`] || [];
              const newName = columnChangeFor(columnKey, rens);
              column6.name = newName;
              return newName;
            }
          );
          tableValue.columns = patchedColumns;
          return [tableKey2, tableValue];
        }
      );
      const policyRes = diffPolicies(tablesPatchedSnap1.tables, json22.tables);
      const policyRenames = [];
      const policyCreates = [];
      const policyDeletes = [];
      for (let entry of Object.values(policyRes)) {
        const { renamed, created: created2, deleted: deleted2 } = await policyResolver2({
          tableName: entry.name,
          schema: entry.schema,
          deleted: entry.policies.deleted.map(
            action === "push" ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy
          ),
          created: entry.policies.added.map(action === "push" ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy)
        });
        if (created2.length > 0) {
          policyCreates.push({
            table: entry.name,
            schema: entry.schema,
            columns: created2
          });
        }
        if (deleted2.length > 0) {
          policyDeletes.push({
            table: entry.name,
            schema: entry.schema,
            columns: deleted2
          });
        }
        if (renamed.length > 0) {
          policyRenames.push({
            table: entry.name,
            schema: entry.schema,
            renames: renamed
          });
        }
      }
      const policyRenamesDict = columnRenames.reduce(
        (acc, it2) => {
          acc[`${it2.schema || "public"}.${it2.table}`] = it2.renames;
          return acc;
        },
        {}
      );
      const policyPatchedSnap1 = copy(tablesPatchedSnap1);
      policyPatchedSnap1.tables = mapEntries(
        policyPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedPolicies = mapKeys(
            tableValue.policies,
            (policyKey, policy5) => {
              const rens = policyRenamesDict[`${tableValue.schema || "public"}.${tableValue.name}`] || [];
              const newName = columnChangeFor(policyKey, rens);
              const unsquashedPolicy = action === "push" ? PgSquasher.unsquashPolicyPush(policy5) : PgSquasher.unsquashPolicy(policy5);
              unsquashedPolicy.name = newName;
              policy5 = PgSquasher.squashPolicy(unsquashedPolicy);
              return newName;
            }
          );
          tableValue.policies = patchedPolicies;
          return [tableKey2, tableValue];
        }
      );
      const indPolicyRes = diffIndPolicies(policyPatchedSnap1.policies, json22.policies);
      const indPolicyCreates = [];
      const indPolicyDeletes = [];
      const { renamed: indPolicyRenames, created, deleted } = await indPolicyResolver2({
        deleted: indPolicyRes.deleted.map(
          (t6) => action === "push" ? PgSquasher.unsquashPolicyPush(t6.values) : PgSquasher.unsquashPolicy(t6.values)
        ),
        created: indPolicyRes.added.map(
          (t6) => action === "push" ? PgSquasher.unsquashPolicyPush(t6.values) : PgSquasher.unsquashPolicy(t6.values)
        )
      });
      if (created.length > 0) {
        indPolicyCreates.push({
          policies: created
        });
      }
      if (deleted.length > 0) {
        indPolicyDeletes.push({
          policies: deleted
        });
      }
      const indPolicyRenamesDict = indPolicyRenames.reduce(
        (acc, it2) => {
          acc[it2.from.name] = {
            nameFrom: it2.from.name,
            nameTo: it2.to.name
          };
          return acc;
        },
        {}
      );
      const indPolicyPatchedSnap1 = copy(policyPatchedSnap1);
      indPolicyPatchedSnap1.policies = mapEntries(
        indPolicyPatchedSnap1.policies,
        (policyKey, policyValue) => {
          const key = policyKey;
          const change = indPolicyRenamesDict[key];
          if (change) {
            policyValue.name = change.nameTo;
          }
          return [policyKey, policyValue];
        }
      );
      const viewsDiff = diffSchemasOrTables(indPolicyPatchedSnap1.views, json22.views);
      const {
        created: createdViews,
        deleted: deletedViews,
        renamed: renamedViews,
        moved: movedViews
      } = await viewsResolver2({
        created: viewsDiff.added,
        deleted: viewsDiff.deleted
      });
      const renamesViewDic = {};
      renamedViews.forEach((it2) => {
        renamesViewDic[`${it2.from.schema}.${it2.from.name}`] = { to: it2.to.name, from: it2.from.name };
      });
      const movedViewDic = {};
      movedViews.forEach((it2) => {
        movedViewDic[`${it2.schemaFrom}.${it2.name}`] = { to: it2.schemaTo, from: it2.schemaFrom };
      });
      const viewsPatchedSnap1 = copy(policyPatchedSnap1);
      viewsPatchedSnap1.views = mapEntries(
        viewsPatchedSnap1.views,
        (viewKey, viewValue) => {
          const rename = renamesViewDic[`${viewValue.schema}.${viewValue.name}`];
          const moved = movedViewDic[`${viewValue.schema}.${viewValue.name}`];
          if (rename) {
            viewValue.name = rename.to;
            viewKey = `${viewValue.schema}.${viewValue.name}`;
          }
          if (moved) viewKey = `${moved.to}.${viewValue.name}`;
          return [viewKey, viewValue];
        }
      );
      const diffResult = applyJsonDiff(viewsPatchedSnap1, json22);
      const typedResult = diffResultScheme.parse(diffResult);
      const jsonStatements = [];
      const jsonCreateIndexesForCreatedTables = createdTables.map((it2) => {
        return preparePgCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.indexes,
          curFull,
          action
        );
      }).flat();
      const jsonDropTables = deletedTables.map((it2) => {
        return prepareDropTableJson(it2);
      });
      const jsonRenameTables = renamedTables.map((it2) => {
        return prepareRenameTableJson(it2.from, it2.to);
      });
      const alteredTables = typedResult.alteredTablesWithColumns;
      const jsonRenameColumnsStatements = [];
      const jsonDropColumnsStatemets = [];
      const jsonAddColumnsStatemets = [];
      for (let it2 of columnRenames) {
        jsonRenameColumnsStatements.push(
          ...prepareRenameColumns(it2.table, it2.schema, it2.renames)
        );
      }
      for (let it2 of columnDeletes) {
        jsonDropColumnsStatemets.push(
          ..._prepareDropColumns(it2.table, it2.schema, it2.columns)
        );
      }
      for (let it2 of columnCreates) {
        jsonAddColumnsStatemets.push(
          ..._prepareAddColumns(it2.table, it2.schema, it2.columns)
        );
      }
      const jsonAddedCompositePKs = [];
      const jsonDeletedCompositePKs = [];
      const jsonAlteredCompositePKs = [];
      const jsonAddedUniqueConstraints = [];
      const jsonDeletedUniqueConstraints = [];
      const jsonAlteredUniqueConstraints = [];
      const jsonSetTableSchemas = [];
      if (movedTables) {
        for (let it2 of movedTables) {
          jsonSetTableSchemas.push({
            type: "alter_table_set_schema",
            tableName: it2.name,
            schemaFrom: it2.schemaFrom || "public",
            schemaTo: it2.schemaTo || "public"
          });
        }
      }
      const jsonDeletedCheckConstraints = [];
      const jsonCreatedCheckConstraints = [];
      for (let it2 of alteredTables) {
        let addedColumns;
        for (const addedPkName of Object.keys(it2.addedCompositePKs)) {
          const addedPkColumns = it2.addedCompositePKs[addedPkName];
          addedColumns = PgSquasher.unsquashPK(addedPkColumns);
        }
        let deletedColumns;
        for (const deletedPkName of Object.keys(it2.deletedCompositePKs)) {
          const deletedPkColumns = it2.deletedCompositePKs[deletedPkName];
          deletedColumns = PgSquasher.unsquashPK(deletedPkColumns);
        }
        const doPerformDeleteAndCreate = JSON.stringify(addedColumns ?? {}) !== JSON.stringify(deletedColumns ?? {});
        let addedCompositePKs = [];
        let deletedCompositePKs = [];
        let alteredCompositePKs = [];
        if (doPerformDeleteAndCreate) {
          addedCompositePKs = prepareAddCompositePrimaryKeyPg(
            it2.name,
            it2.schema,
            it2.addedCompositePKs,
            curFull
          );
          deletedCompositePKs = prepareDeleteCompositePrimaryKeyPg(
            it2.name,
            it2.schema,
            it2.deletedCompositePKs,
            prevFull
          );
        }
        alteredCompositePKs = prepareAlterCompositePrimaryKeyPg(
          it2.name,
          it2.schema,
          it2.alteredCompositePKs,
          prevFull,
          curFull
        );
        let addedUniqueConstraints = [];
        let deletedUniqueConstraints = [];
        let alteredUniqueConstraints = [];
        let createCheckConstraints = [];
        let deleteCheckConstraints = [];
        addedUniqueConstraints = prepareAddUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.addedUniqueConstraints
        );
        deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.deletedUniqueConstraints
        );
        if (it2.alteredUniqueConstraints) {
          const added = {};
          const deleted2 = {};
          for (const k9 of Object.keys(it2.alteredUniqueConstraints)) {
            added[k9] = it2.alteredUniqueConstraints[k9].__new;
            deleted2[k9] = it2.alteredUniqueConstraints[k9].__old;
          }
          addedUniqueConstraints.push(
            ...prepareAddUniqueConstraintPg(it2.name, it2.schema, added)
          );
          deletedUniqueConstraints.push(
            ...prepareDeleteUniqueConstraintPg(it2.name, it2.schema, deleted2)
          );
        }
        createCheckConstraints = prepareAddCheckConstraint(it2.name, it2.schema, it2.addedCheckConstraints);
        deleteCheckConstraints = prepareDeleteCheckConstraint(
          it2.name,
          it2.schema,
          it2.deletedCheckConstraints
        );
        if (it2.alteredCheckConstraints && action !== "push") {
          const added = {};
          const deleted2 = {};
          for (const k9 of Object.keys(it2.alteredCheckConstraints)) {
            added[k9] = it2.alteredCheckConstraints[k9].__new;
            deleted2[k9] = it2.alteredCheckConstraints[k9].__old;
          }
          createCheckConstraints.push(...prepareAddCheckConstraint(it2.name, it2.schema, added));
          deleteCheckConstraints.push(...prepareDeleteCheckConstraint(it2.name, it2.schema, deleted2));
        }
        jsonCreatedCheckConstraints.push(...createCheckConstraints);
        jsonDeletedCheckConstraints.push(...deleteCheckConstraints);
        jsonAddedCompositePKs.push(...addedCompositePKs);
        jsonDeletedCompositePKs.push(...deletedCompositePKs);
        jsonAlteredCompositePKs.push(...alteredCompositePKs);
        jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
        jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
        jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
      }
      const rColumns = jsonRenameColumnsStatements.map((it2) => {
        const tableName = it2.tableName;
        const schema6 = it2.schema;
        return {
          from: { schema: schema6, table: tableName, column: it2.oldColumnName },
          to: { schema: schema6, table: tableName, column: it2.newColumnName }
        };
      });
      const jsonTableAlternations = alteredTables.map((it2) => {
        return preparePgAlterColumns(
          it2.name,
          it2.schema,
          it2.altered,
          json22,
          json1,
          action
        );
      }).flat();
      const jsonCreateIndexesFoAlteredTables = alteredTables.map((it2) => {
        return preparePgCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.addedIndexes || {},
          curFull,
          action
        );
      }).flat();
      const jsonDropIndexesForAllAlteredTables = alteredTables.map((it2) => {
        return prepareDropIndexesJson(
          it2.name,
          it2.schema,
          it2.deletedIndexes || {}
        );
      }).flat();
      const jsonCreatePoliciesStatements = [];
      const jsonDropPoliciesStatements = [];
      const jsonAlterPoliciesStatements = [];
      const jsonRenamePoliciesStatements = [];
      const jsonRenameIndPoliciesStatements = [];
      const jsonCreateIndPoliciesStatements = [];
      const jsonDropIndPoliciesStatements = [];
      const jsonAlterIndPoliciesStatements = [];
      const jsonEnableRLSStatements = [];
      const jsonDisableRLSStatements = [];
      for (let it2 of indPolicyRenames) {
        jsonRenameIndPoliciesStatements.push(
          ...prepareRenameIndPolicyJsons([it2])
        );
      }
      for (const it2 of indPolicyCreates) {
        jsonCreateIndPoliciesStatements.push(
          ...prepareCreateIndPolicyJsons(
            it2.policies
          )
        );
      }
      for (const it2 of indPolicyDeletes) {
        jsonDropIndPoliciesStatements.push(
          ...prepareDropIndPolicyJsons(
            it2.policies
          )
        );
      }
      typedResult.alteredPolicies.forEach(({ values: values2 }) => {
        const policy5 = action === "push" ? PgSquasher.unsquashPolicyPush(values2) : PgSquasher.unsquashPolicy(values2);
        const newPolicy = action === "push" ? PgSquasher.unsquashPolicyPush(json22.policies[policy5.name].values) : PgSquasher.unsquashPolicy(json22.policies[policy5.name].values);
        const oldPolicy = action === "push" ? PgSquasher.unsquashPolicyPush(json22.policies[policy5.name].values) : PgSquasher.unsquashPolicy(json1.policies[policy5.name].values);
        if (newPolicy.as !== oldPolicy.as) {
          jsonDropIndPoliciesStatements.push(
            ...prepareDropIndPolicyJsons(
              [oldPolicy]
            )
          );
          jsonCreateIndPoliciesStatements.push(
            ...prepareCreateIndPolicyJsons(
              [newPolicy]
            )
          );
          return;
        }
        if (newPolicy.for !== oldPolicy.for) {
          jsonDropIndPoliciesStatements.push(
            ...prepareDropIndPolicyJsons(
              [oldPolicy]
            )
          );
          jsonCreateIndPoliciesStatements.push(
            ...prepareCreateIndPolicyJsons(
              [newPolicy]
            )
          );
          return;
        }
        jsonAlterIndPoliciesStatements.push(
          prepareAlterIndPolicyJson(
            oldPolicy,
            newPolicy
          )
        );
      });
      for (let it2 of policyRenames) {
        jsonRenamePoliciesStatements.push(
          ...prepareRenamePolicyJsons(it2.table, it2.schema, it2.renames)
        );
      }
      for (const it2 of policyCreates) {
        jsonCreatePoliciesStatements.push(
          ...prepareCreatePolicyJsons(
            it2.table,
            it2.schema,
            it2.columns
          )
        );
      }
      for (const it2 of policyDeletes) {
        jsonDropPoliciesStatements.push(
          ...prepareDropPolicyJsons(
            it2.table,
            it2.schema,
            it2.columns
          )
        );
      }
      alteredTables.forEach((it2) => {
        Object.keys(it2.alteredPolicies).forEach((policyName) => {
          const newPolicy = action === "push" ? PgSquasher.unsquashPolicyPush(it2.alteredPolicies[policyName].__new) : PgSquasher.unsquashPolicy(it2.alteredPolicies[policyName].__new);
          const oldPolicy = action === "push" ? PgSquasher.unsquashPolicyPush(it2.alteredPolicies[policyName].__old) : PgSquasher.unsquashPolicy(it2.alteredPolicies[policyName].__old);
          if (newPolicy.as !== oldPolicy.as) {
            jsonDropPoliciesStatements.push(
              ...prepareDropPolicyJsons(
                it2.name,
                it2.schema,
                [oldPolicy]
              )
            );
            jsonCreatePoliciesStatements.push(
              ...prepareCreatePolicyJsons(
                it2.name,
                it2.schema,
                [newPolicy]
              )
            );
            return;
          }
          if (newPolicy.for !== oldPolicy.for) {
            jsonDropPoliciesStatements.push(
              ...prepareDropPolicyJsons(
                it2.name,
                it2.schema,
                [oldPolicy]
              )
            );
            jsonCreatePoliciesStatements.push(
              ...prepareCreatePolicyJsons(
                it2.name,
                it2.schema,
                [newPolicy]
              )
            );
            return;
          }
          jsonAlterPoliciesStatements.push(
            prepareAlterPolicyJson(
              it2.name,
              it2.schema,
              it2.alteredPolicies[policyName].__old,
              it2.alteredPolicies[policyName].__new
            )
          );
        });
        for (const table6 of Object.values(json22.tables)) {
          const policiesInCurrentState = Object.keys(table6.policies);
          const tableInPreviousState = columnsPatchedSnap1.tables[`${table6.schema === "" ? "public" : table6.schema}.${table6.name}`];
          const policiesInPreviousState = tableInPreviousState ? Object.keys(tableInPreviousState.policies) : [];
          if (policiesInPreviousState.length === 0 && policiesInCurrentState.length > 0 && !table6.isRLSEnabled) {
            jsonEnableRLSStatements.push({ type: "enable_rls", tableName: table6.name, schema: table6.schema });
          }
          if (policiesInPreviousState.length > 0 && policiesInCurrentState.length === 0 && !table6.isRLSEnabled) {
            jsonDisableRLSStatements.push({ type: "disable_rls", tableName: table6.name, schema: table6.schema });
          }
          const wasRlsEnabled = tableInPreviousState ? tableInPreviousState.isRLSEnabled : false;
          if (table6.isRLSEnabled !== wasRlsEnabled) {
            if (table6.isRLSEnabled) {
              jsonEnableRLSStatements.push({ type: "enable_rls", tableName: table6.name, schema: table6.schema });
            } else if (!table6.isRLSEnabled && policiesInCurrentState.length === 0) {
              jsonDisableRLSStatements.push({ type: "disable_rls", tableName: table6.name, schema: table6.schema });
            }
          }
        }
        for (const table6 of Object.values(columnsPatchedSnap1.tables)) {
          const tableInCurrentState = json22.tables[`${table6.schema === "" ? "public" : table6.schema}.${table6.name}`];
          if (tableInCurrentState === void 0 && !table6.isRLSEnabled) {
            jsonDisableRLSStatements.push({ type: "disable_rls", tableName: table6.name, schema: table6.schema });
          }
        }
        const droppedIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__old;
            return current;
          },
          {}
        );
        const createdIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__new;
            return current;
          },
          {}
        );
        jsonCreateIndexesFoAlteredTables.push(
          ...preparePgCreateIndexesJson(
            it2.name,
            it2.schema,
            createdIndexes || {},
            curFull,
            action
          )
        );
        jsonDropIndexesForAllAlteredTables.push(
          ...prepareDropIndexesJson(it2.name, it2.schema, droppedIndexes || {})
        );
      });
      const jsonCreateReferencesForCreatedTables = createdTables.map((it2) => {
        return prepareCreateReferencesJson(it2.name, it2.schema, it2.foreignKeys);
      }).flat();
      const jsonReferencesForAlteredTables = alteredTables.map((it2) => {
        const forAdded = prepareCreateReferencesJson(
          it2.name,
          it2.schema,
          it2.addedForeignKeys
        );
        const forAltered = prepareDropReferencesJson(
          it2.name,
          it2.schema,
          it2.deletedForeignKeys
        );
        const alteredFKs = prepareAlterReferencesJson(
          it2.name,
          it2.schema,
          it2.alteredForeignKeys
        );
        return [...forAdded, ...forAltered, ...alteredFKs];
      }).flat();
      const jsonCreatedReferencesForAlteredTables = jsonReferencesForAlteredTables.filter(
        (t6) => t6.type === "create_reference"
      );
      const jsonDroppedReferencesForAlteredTables = jsonReferencesForAlteredTables.filter(
        (t6) => t6.type === "delete_reference"
      );
      const createEnums = createdEnums.map((it2) => {
        return prepareCreateEnumJson(it2.name, it2.schema, it2.values);
      }) ?? [];
      const dropEnums = deletedEnums.map((it2) => {
        return prepareDropEnumJson(it2.name, it2.schema);
      });
      const moveEnums = movedEnums.map((it2) => {
        return prepareMoveEnumJson(it2.name, it2.schemaFrom, it2.schemaTo);
      });
      const renameEnums = renamedEnums.map((it2) => {
        return prepareRenameEnumJson(it2.from.name, it2.to.name, it2.to.schema);
      });
      const jsonAlterEnumsWithAddedValues = typedResult.alteredEnums.map((it2) => {
        return prepareAddValuesToEnumJson(it2.name, it2.schema, it2.addedValues);
      }).flat() ?? [];
      const jsonAlterEnumsWithDroppedValues = typedResult.alteredEnums.map((it2) => {
        return prepareDropEnumValues(it2.name, it2.schema, it2.deletedValues, curFull);
      }).flat() ?? [];
      const createSequences = createdSequences.map((it2) => {
        return prepareCreateSequenceJson(it2);
      }) ?? [];
      const dropSequences = deletedSequences.map((it2) => {
        return prepareDropSequenceJson(it2.name, it2.schema);
      });
      const moveSequences = movedSequences.map((it2) => {
        return prepareMoveSequenceJson(it2.name, it2.schemaFrom, it2.schemaTo);
      });
      const renameSequences = renamedSequences.map((it2) => {
        return prepareRenameSequenceJson(it2.from.name, it2.to.name, it2.to.schema);
      });
      const jsonAlterSequences = typedResult.alteredSequences.map((it2) => {
        return prepareAlterSequenceJson(it2);
      }).flat() ?? [];
      const createRoles = createdRoles.map((it2) => {
        return prepareCreateRoleJson(it2);
      }) ?? [];
      const dropRoles = deletedRoles.map((it2) => {
        return prepareDropRoleJson(it2.name);
      });
      const renameRoles = renamedRoles.map((it2) => {
        return prepareRenameRoleJson(it2.from.name, it2.to.name);
      });
      const jsonAlterRoles = typedResult.alteredRoles.map((it2) => {
        return prepareAlterRoleJson(it2);
      }).flat() ?? [];
      const createSchemas = prepareCreateSchemasJson(
        createdSchemas.map((it2) => it2.name)
      );
      const renameSchemas = prepareRenameSchemasJson(
        renamedSchemas.map((it2) => ({ from: it2.from.name, to: it2.to.name }))
      );
      const dropSchemas = prepareDeleteSchemasJson(
        deletedSchemas.map((it2) => it2.name)
      );
      const createTables = createdTables.map((it2) => {
        return preparePgCreateTableJson(it2, curFull);
      });
      jsonCreatePoliciesStatements.push(...[].concat(
        ...createdTables.map(
          (it2) => prepareCreatePolicyJsons(
            it2.name,
            it2.schema,
            Object.values(it2.policies).map(action === "push" ? PgSquasher.unsquashPolicyPush : PgSquasher.unsquashPolicy)
          )
        )
      ));
      const createViews = [];
      const dropViews = [];
      const renameViews = [];
      const alterViews = [];
      createViews.push(
        ...createdViews.filter((it2) => !it2.isExisting).map((it2) => {
          return preparePgCreateViewJson(
            it2.name,
            it2.schema,
            it2.definition,
            it2.materialized,
            it2.withNoData,
            it2.with,
            it2.using,
            it2.tablespace
          );
        })
      );
      dropViews.push(
        ...deletedViews.filter((it2) => !it2.isExisting).map((it2) => {
          return prepareDropViewJson(it2.name, it2.schema, it2.materialized);
        })
      );
      renameViews.push(
        ...renamedViews.filter((it2) => !it2.to.isExisting && !json1.views[`${it2.from.schema}.${it2.from.name}`].isExisting).map((it2) => {
          return prepareRenameViewJson(it2.to.name, it2.from.name, it2.to.schema, it2.to.materialized);
        })
      );
      alterViews.push(
        ...movedViews.filter(
          (it2) => !json22.views[`${it2.schemaTo}.${it2.name}`].isExisting && !json1.views[`${it2.schemaFrom}.${it2.name}`].isExisting
        ).map((it2) => {
          return preparePgAlterViewAlterSchemaJson(
            it2.schemaTo,
            it2.schemaFrom,
            it2.name,
            json22.views[`${it2.schemaTo}.${it2.name}`].materialized
          );
        })
      );
      const alteredViews = typedResult.alteredViews.filter((it2) => !json22.views[`${it2.schema}.${it2.name}`].isExisting);
      for (const alteredView of alteredViews) {
        const viewKey = `${alteredView.schema}.${alteredView.name}`;
        const { materialized, with: withOption, definition, withNoData, using, tablespace } = json22.views[viewKey];
        if (alteredView.alteredExisting || alteredView.alteredDefinition && action !== "push") {
          dropViews.push(prepareDropViewJson(alteredView.name, alteredView.schema, materialized));
          createViews.push(
            preparePgCreateViewJson(
              alteredView.name,
              alteredView.schema,
              definition,
              materialized,
              withNoData,
              withOption,
              using,
              tablespace
            )
          );
          continue;
        }
        if (alteredView.addedWithOption) {
          alterViews.push(
            preparePgAlterViewAddWithOptionJson(
              alteredView.name,
              alteredView.schema,
              materialized,
              alteredView.addedWithOption
            )
          );
        }
        if (alteredView.deletedWithOption) {
          alterViews.push(
            preparePgAlterViewDropWithOptionJson(
              alteredView.name,
              alteredView.schema,
              materialized,
              alteredView.deletedWithOption
            )
          );
        }
        if (alteredView.addedWith) {
          alterViews.push(
            preparePgAlterViewAddWithOptionJson(
              alteredView.name,
              alteredView.schema,
              materialized,
              alteredView.addedWith
            )
          );
        }
        if (alteredView.deletedWith) {
          alterViews.push(
            preparePgAlterViewDropWithOptionJson(
              alteredView.name,
              alteredView.schema,
              materialized,
              alteredView.deletedWith
            )
          );
        }
        if (alteredView.alteredWith) {
          alterViews.push(
            preparePgAlterViewAddWithOptionJson(
              alteredView.name,
              alteredView.schema,
              materialized,
              alteredView.alteredWith
            )
          );
        }
        if (alteredView.alteredTablespace) {
          alterViews.push(
            preparePgAlterViewAlterTablespaceJson(
              alteredView.name,
              alteredView.schema,
              materialized,
              alteredView.alteredTablespace.__new
            )
          );
        }
        if (alteredView.alteredUsing) {
          alterViews.push(
            preparePgAlterViewAlterUsingJson(
              alteredView.name,
              alteredView.schema,
              materialized,
              alteredView.alteredUsing.__new
            )
          );
        }
      }
      jsonStatements.push(...createSchemas);
      jsonStatements.push(...renameSchemas);
      jsonStatements.push(...createEnums);
      jsonStatements.push(...moveEnums);
      jsonStatements.push(...renameEnums);
      jsonStatements.push(...jsonAlterEnumsWithAddedValues);
      jsonStatements.push(...createSequences);
      jsonStatements.push(...moveSequences);
      jsonStatements.push(...renameSequences);
      jsonStatements.push(...jsonAlterSequences);
      jsonStatements.push(...renameRoles);
      jsonStatements.push(...dropRoles);
      jsonStatements.push(...createRoles);
      jsonStatements.push(...jsonAlterRoles);
      jsonStatements.push(...createTables);
      jsonStatements.push(...jsonEnableRLSStatements);
      jsonStatements.push(...jsonDisableRLSStatements);
      jsonStatements.push(...dropViews);
      jsonStatements.push(...renameViews);
      jsonStatements.push(...alterViews);
      jsonStatements.push(...jsonDropTables);
      jsonStatements.push(...jsonSetTableSchemas);
      jsonStatements.push(...jsonRenameTables);
      jsonStatements.push(...jsonRenameColumnsStatements);
      jsonStatements.push(...jsonDeletedUniqueConstraints);
      jsonStatements.push(...jsonDeletedCheckConstraints);
      jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
      jsonStatements.push(...jsonAlterEnumsWithDroppedValues);
      jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
      jsonStatements.push(...jsonDeletedCompositePKs);
      jsonStatements.push(...jsonTableAlternations);
      jsonStatements.push(...jsonAddedCompositePKs);
      jsonStatements.push(...jsonAddColumnsStatemets);
      jsonStatements.push(...jsonCreateReferencesForCreatedTables);
      jsonStatements.push(...jsonCreateIndexesForCreatedTables);
      jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
      jsonStatements.push(...jsonCreateIndexesFoAlteredTables);
      jsonStatements.push(...jsonDropColumnsStatemets);
      jsonStatements.push(...jsonAlteredCompositePKs);
      jsonStatements.push(...jsonAddedUniqueConstraints);
      jsonStatements.push(...jsonCreatedCheckConstraints);
      jsonStatements.push(...jsonAlteredUniqueConstraints);
      jsonStatements.push(...createViews);
      jsonStatements.push(...jsonRenamePoliciesStatements);
      jsonStatements.push(...jsonDropPoliciesStatements);
      jsonStatements.push(...jsonCreatePoliciesStatements);
      jsonStatements.push(...jsonAlterPoliciesStatements);
      jsonStatements.push(...jsonRenameIndPoliciesStatements);
      jsonStatements.push(...jsonDropIndPoliciesStatements);
      jsonStatements.push(...jsonCreateIndPoliciesStatements);
      jsonStatements.push(...jsonAlterIndPoliciesStatements);
      jsonStatements.push(...dropEnums);
      jsonStatements.push(...dropSequences);
      jsonStatements.push(...dropSchemas);
      const filteredJsonStatements = jsonStatements.filter((st2) => {
        if (st2.type === "alter_table_alter_column_drop_notnull") {
          if (jsonStatements.find(
            (it2) => it2.type === "alter_table_alter_column_drop_identity" && it2.tableName === st2.tableName && it2.schema === st2.schema
          )) {
            return false;
          }
        }
        if (st2.type === "alter_table_alter_column_set_notnull") {
          if (jsonStatements.find(
            (it2) => it2.type === "alter_table_alter_column_set_identity" && it2.tableName === st2.tableName && it2.schema === st2.schema
          )) {
            return false;
          }
        }
        return true;
      });
      const filteredEnumsJsonStatements = filteredJsonStatements.filter((st2) => {
        if (st2.type === "alter_type_add_value") {
          if (filteredJsonStatements.find(
            (it2) => it2.type === "alter_type_drop_value" && it2.name === st2.name && it2.enumSchema === st2.schema
          )) {
            return false;
          }
        }
        return true;
      });
      const filteredEnums2JsonStatements = filteredEnumsJsonStatements.filter((st2) => {
        if (st2.type === "alter_table_alter_column_set_default") {
          if (filteredEnumsJsonStatements.find(
            (it2) => it2.type === "pg_alter_table_alter_column_set_type" && it2.columnDefault === st2.newDefaultValue && it2.columnName === st2.columnName && it2.tableName === st2.tableName && it2.schema === st2.schema
          )) {
            return false;
          }
          if (filteredEnumsJsonStatements.find(
            (it2) => it2.type === "alter_type_drop_value" && it2.columnsWithEnum.find(
              (column6) => column6.default === st2.newDefaultValue && column6.column === st2.columnName && column6.table === st2.tableName && column6.tableSchema === st2.schema
            )
          )) {
            return false;
          }
        }
        return true;
      });
      const sqlStatements = fromJson(filteredEnums2JsonStatements, "postgresql", action);
      const uniqueSqlStatements = [];
      sqlStatements.forEach((ss) => {
        if (!uniqueSqlStatements.includes(ss)) {
          uniqueSqlStatements.push(ss);
        }
      });
      const rSchemas = renamedSchemas.map((it2) => ({
        from: it2.from.name,
        to: it2.to.name
      }));
      const rTables = renamedTables.map((it2) => {
        return { from: it2.from, to: it2.to };
      });
      const _meta = prepareMigrationMeta(rSchemas, rTables, rColumns);
      return {
        statements: filteredEnums2JsonStatements,
        sqlStatements: uniqueSqlStatements,
        _meta
      };
    };
    applyMysqlSnapshotsDiff = async (json1, json22, tablesResolver2, columnsResolver2, viewsResolver2, prevFull, curFull, action) => {
      for (const tableName in json1.tables) {
        const table6 = json1.tables[tableName];
        for (const indexName2 in table6.indexes) {
          const index7 = MySqlSquasher.unsquashIdx(table6.indexes[indexName2]);
          if (index7.isUnique) {
            table6.uniqueConstraints[indexName2] = MySqlSquasher.squashUnique({
              name: index7.name,
              columns: index7.columns
            });
            delete json1.tables[tableName].indexes[index7.name];
          }
        }
      }
      for (const tableName in json22.tables) {
        const table6 = json22.tables[tableName];
        for (const indexName2 in table6.indexes) {
          const index7 = MySqlSquasher.unsquashIdx(table6.indexes[indexName2]);
          if (index7.isUnique) {
            table6.uniqueConstraints[indexName2] = MySqlSquasher.squashUnique({
              name: index7.name,
              columns: index7.columns
            });
            delete json22.tables[tableName].indexes[index7.name];
          }
        }
      }
      const tablesDiff = diffSchemasOrTables(json1.tables, json22.tables);
      const {
        created: createdTables,
        deleted: deletedTables,
        renamed: renamedTables
        // renamed or moved
      } = await tablesResolver2({
        created: tablesDiff.added,
        deleted: tablesDiff.deleted
      });
      const tablesPatchedSnap1 = copy(json1);
      tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_7, it2) => {
        const { name: name3 } = nameChangeFor(it2, renamedTables);
        it2.name = name3;
        return [name3, it2];
      });
      const res = diffColumns(tablesPatchedSnap1.tables, json22.tables);
      const columnRenames = [];
      const columnCreates = [];
      const columnDeletes = [];
      for (let entry of Object.values(res)) {
        const { renamed, created, deleted } = await columnsResolver2({
          tableName: entry.name,
          schema: entry.schema,
          deleted: entry.columns.deleted,
          created: entry.columns.added
        });
        if (created.length > 0) {
          columnCreates.push({
            table: entry.name,
            columns: created
          });
        }
        if (deleted.length > 0) {
          columnDeletes.push({
            table: entry.name,
            columns: deleted
          });
        }
        if (renamed.length > 0) {
          columnRenames.push({
            table: entry.name,
            renames: renamed
          });
        }
      }
      const columnRenamesDict = columnRenames.reduce(
        (acc, it2) => {
          acc[it2.table] = it2.renames;
          return acc;
        },
        {}
      );
      const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
      columnsPatchedSnap1.tables = mapEntries(
        columnsPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedColumns = mapKeys(
            tableValue.columns,
            (columnKey, column6) => {
              const rens = columnRenamesDict[tableValue.name] || [];
              const newName = columnChangeFor(columnKey, rens);
              column6.name = newName;
              return newName;
            }
          );
          tableValue.columns = patchedColumns;
          return [tableKey2, tableValue];
        }
      );
      const viewsDiff = diffSchemasOrTables(json1.views, json22.views);
      const {
        created: createdViews,
        deleted: deletedViews,
        renamed: renamedViews
        // renamed or moved
      } = await viewsResolver2({
        created: viewsDiff.added,
        deleted: viewsDiff.deleted
      });
      const renamesViewDic = {};
      renamedViews.forEach((it2) => {
        renamesViewDic[it2.from.name] = { to: it2.to.name, from: it2.from.name };
      });
      const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
      viewsPatchedSnap1.views = mapEntries(
        viewsPatchedSnap1.views,
        (viewKey, viewValue) => {
          const rename = renamesViewDic[viewValue.name];
          if (rename) {
            viewValue.name = rename.to;
            viewKey = rename.to;
          }
          return [viewKey, viewValue];
        }
      );
      const diffResult = applyJsonDiff(viewsPatchedSnap1, json22);
      const typedResult = diffResultSchemeMysql.parse(diffResult);
      const jsonStatements = [];
      const jsonCreateIndexesForCreatedTables = createdTables.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.indexes,
          curFull.internal
        );
      }).flat();
      const jsonDropTables = deletedTables.map((it2) => {
        return prepareDropTableJson(it2);
      });
      const jsonRenameTables = renamedTables.map((it2) => {
        return prepareRenameTableJson(it2.from, it2.to);
      });
      const alteredTables = typedResult.alteredTablesWithColumns;
      const jsonAddedCompositePKs = [];
      const jsonDeletedCompositePKs = [];
      const jsonAlteredCompositePKs = [];
      const jsonAddedUniqueConstraints = [];
      const jsonDeletedUniqueConstraints = [];
      const jsonAlteredUniqueConstraints = [];
      const jsonCreatedCheckConstraints = [];
      const jsonDeletedCheckConstraints = [];
      const jsonRenameColumnsStatements = columnRenames.map((it2) => prepareRenameColumns(it2.table, "", it2.renames)).flat();
      const jsonAddColumnsStatemets = columnCreates.map((it2) => _prepareAddColumns(it2.table, "", it2.columns)).flat();
      const jsonDropColumnsStatemets = columnDeletes.map((it2) => _prepareDropColumns(it2.table, "", it2.columns)).flat();
      alteredTables.forEach((it2) => {
        let addedColumns = [];
        for (const addedPkName of Object.keys(it2.addedCompositePKs)) {
          const addedPkColumns = it2.addedCompositePKs[addedPkName];
          addedColumns = MySqlSquasher.unsquashPK(addedPkColumns).columns;
        }
        let deletedColumns = [];
        for (const deletedPkName of Object.keys(it2.deletedCompositePKs)) {
          const deletedPkColumns = it2.deletedCompositePKs[deletedPkName];
          deletedColumns = MySqlSquasher.unsquashPK(deletedPkColumns).columns;
        }
        const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
        let addedCompositePKs = [];
        let deletedCompositePKs = [];
        let alteredCompositePKs = [];
        addedCompositePKs = prepareAddCompositePrimaryKeyMySql(
          it2.name,
          it2.addedCompositePKs,
          prevFull,
          curFull
        );
        deletedCompositePKs = prepareDeleteCompositePrimaryKeyMySql(
          it2.name,
          it2.deletedCompositePKs,
          prevFull
        );
        alteredCompositePKs = prepareAlterCompositePrimaryKeyMySql(
          it2.name,
          it2.alteredCompositePKs,
          prevFull,
          curFull
        );
        let addedUniqueConstraints = [];
        let deletedUniqueConstraints = [];
        let alteredUniqueConstraints = [];
        let createdCheckConstraints = [];
        let deletedCheckConstraints = [];
        addedUniqueConstraints = prepareAddUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.addedUniqueConstraints
        );
        deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.deletedUniqueConstraints
        );
        if (it2.alteredUniqueConstraints) {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredUniqueConstraints)) {
            added[k9] = it2.alteredUniqueConstraints[k9].__new;
            deleted[k9] = it2.alteredUniqueConstraints[k9].__old;
          }
          addedUniqueConstraints.push(
            ...prepareAddUniqueConstraintPg(it2.name, it2.schema, added)
          );
          deletedUniqueConstraints.push(
            ...prepareDeleteUniqueConstraintPg(it2.name, it2.schema, deleted)
          );
        }
        createdCheckConstraints = prepareAddCheckConstraint(it2.name, it2.schema, it2.addedCheckConstraints);
        deletedCheckConstraints = prepareDeleteCheckConstraint(
          it2.name,
          it2.schema,
          it2.deletedCheckConstraints
        );
        if (it2.alteredCheckConstraints && action !== "push") {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredCheckConstraints)) {
            added[k9] = it2.alteredCheckConstraints[k9].__new;
            deleted[k9] = it2.alteredCheckConstraints[k9].__old;
          }
          createdCheckConstraints.push(...prepareAddCheckConstraint(it2.name, it2.schema, added));
          deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it2.name, it2.schema, deleted));
        }
        jsonAddedCompositePKs.push(...addedCompositePKs);
        jsonDeletedCompositePKs.push(...deletedCompositePKs);
        jsonAlteredCompositePKs.push(...alteredCompositePKs);
        jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
        jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
        jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
        jsonCreatedCheckConstraints.push(...createdCheckConstraints);
        jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
      });
      const rColumns = jsonRenameColumnsStatements.map((it2) => {
        const tableName = it2.tableName;
        const schema6 = it2.schema;
        return {
          from: { schema: schema6, table: tableName, column: it2.oldColumnName },
          to: { schema: schema6, table: tableName, column: it2.newColumnName }
        };
      });
      const jsonTableAlternations = alteredTables.map((it2) => {
        return prepareAlterColumnsMysql(
          it2.name,
          it2.schema,
          it2.altered,
          json1,
          json22,
          action
        );
      }).flat();
      const jsonCreateIndexesForAllAlteredTables = alteredTables.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.addedIndexes || {},
          curFull.internal
        );
      }).flat();
      const jsonDropIndexesForAllAlteredTables = alteredTables.map((it2) => {
        return prepareDropIndexesJson(
          it2.name,
          it2.schema,
          it2.deletedIndexes || {}
        );
      }).flat();
      alteredTables.forEach((it2) => {
        const droppedIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__old;
            return current;
          },
          {}
        );
        const createdIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__new;
            return current;
          },
          {}
        );
        jsonCreateIndexesForAllAlteredTables.push(
          ...prepareCreateIndexesJson(it2.name, it2.schema, createdIndexes || {})
        );
        jsonDropIndexesForAllAlteredTables.push(
          ...prepareDropIndexesJson(it2.name, it2.schema, droppedIndexes || {})
        );
      });
      const jsonCreateReferencesForCreatedTables = createdTables.map((it2) => {
        return prepareCreateReferencesJson(it2.name, it2.schema, it2.foreignKeys);
      }).flat();
      const jsonReferencesForAllAlteredTables = alteredTables.map((it2) => {
        const forAdded = prepareCreateReferencesJson(
          it2.name,
          it2.schema,
          it2.addedForeignKeys
        );
        const forAltered = prepareDropReferencesJson(
          it2.name,
          it2.schema,
          it2.deletedForeignKeys
        );
        const alteredFKs = prepareAlterReferencesJson(
          it2.name,
          it2.schema,
          it2.alteredForeignKeys
        );
        return [...forAdded, ...forAltered, ...alteredFKs];
      }).flat();
      const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
        (t6) => t6.type === "create_reference"
      );
      const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
        (t6) => t6.type === "delete_reference"
      );
      const jsonMySqlCreateTables = createdTables.map((it2) => {
        return prepareMySqlCreateTableJson(
          it2,
          curFull,
          curFull.internal
        );
      });
      const createViews = [];
      const dropViews = [];
      const renameViews = [];
      const alterViews = [];
      createViews.push(
        ...createdViews.filter((it2) => !it2.isExisting).map((it2) => {
          return prepareMySqlCreateViewJson(
            it2.name,
            it2.definition,
            it2.meta
          );
        })
      );
      dropViews.push(
        ...deletedViews.filter((it2) => !it2.isExisting).map((it2) => {
          return prepareDropViewJson(it2.name);
        })
      );
      renameViews.push(
        ...renamedViews.filter((it2) => !it2.to.isExisting && !json1.views[it2.from.name].isExisting).map((it2) => {
          return prepareRenameViewJson(it2.to.name, it2.from.name);
        })
      );
      const alteredViews = typedResult.alteredViews.filter((it2) => !json22.views[it2.name].isExisting);
      for (const alteredView of alteredViews) {
        const { definition, meta } = json22.views[alteredView.name];
        if (alteredView.alteredExisting) {
          dropViews.push(prepareDropViewJson(alteredView.name));
          createViews.push(
            prepareMySqlCreateViewJson(
              alteredView.name,
              definition,
              meta
            )
          );
          continue;
        }
        if (alteredView.alteredDefinition && action !== "push") {
          createViews.push(
            prepareMySqlCreateViewJson(
              alteredView.name,
              definition,
              meta,
              true
            )
          );
          continue;
        }
        if (alteredView.alteredMeta) {
          const view5 = curFull["views"][alteredView.name];
          alterViews.push(
            prepareMySqlAlterView(view5)
          );
        }
      }
      jsonStatements.push(...jsonMySqlCreateTables);
      jsonStatements.push(...jsonDropTables);
      jsonStatements.push(...jsonRenameTables);
      jsonStatements.push(...jsonRenameColumnsStatements);
      jsonStatements.push(...dropViews);
      jsonStatements.push(...renameViews);
      jsonStatements.push(...alterViews);
      jsonStatements.push(...jsonDeletedUniqueConstraints);
      jsonStatements.push(...jsonDeletedCheckConstraints);
      jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
      jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
      jsonStatements.push(...jsonDeletedCompositePKs);
      jsonStatements.push(...jsonTableAlternations);
      jsonStatements.push(...jsonAddedCompositePKs);
      jsonStatements.push(...jsonAddColumnsStatemets);
      jsonStatements.push(...jsonAddedUniqueConstraints);
      jsonStatements.push(...jsonDeletedUniqueConstraints);
      jsonStatements.push(...jsonCreateReferencesForCreatedTables);
      jsonStatements.push(...jsonCreateIndexesForCreatedTables);
      jsonStatements.push(...jsonCreatedCheckConstraints);
      jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
      jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
      jsonStatements.push(...jsonDropColumnsStatemets);
      jsonStatements.push(...jsonAlteredCompositePKs);
      jsonStatements.push(...createViews);
      jsonStatements.push(...jsonAlteredUniqueConstraints);
      const sqlStatements = fromJson(jsonStatements, "mysql");
      const uniqueSqlStatements = [];
      sqlStatements.forEach((ss) => {
        if (!uniqueSqlStatements.includes(ss)) {
          uniqueSqlStatements.push(ss);
        }
      });
      const rTables = renamedTables.map((it2) => {
        return { from: it2.from, to: it2.to };
      });
      const _meta = prepareMigrationMeta([], rTables, rColumns);
      return {
        statements: jsonStatements,
        sqlStatements: uniqueSqlStatements,
        _meta
      };
    };
    applySingleStoreSnapshotsDiff = async (json1, json22, tablesResolver2, columnsResolver2, prevFull, curFull, action) => {
      for (const tableName in json1.tables) {
        const table6 = json1.tables[tableName];
        for (const indexName2 in table6.indexes) {
          const index7 = SingleStoreSquasher.unsquashIdx(table6.indexes[indexName2]);
          if (index7.isUnique) {
            table6.uniqueConstraints[indexName2] = SingleStoreSquasher.squashUnique({
              name: index7.name,
              columns: index7.columns
            });
            delete json1.tables[tableName].indexes[index7.name];
          }
        }
      }
      for (const tableName in json22.tables) {
        const table6 = json22.tables[tableName];
        for (const indexName2 in table6.indexes) {
          const index7 = SingleStoreSquasher.unsquashIdx(table6.indexes[indexName2]);
          if (index7.isUnique) {
            table6.uniqueConstraints[indexName2] = SingleStoreSquasher.squashUnique({
              name: index7.name,
              columns: index7.columns
            });
            delete json22.tables[tableName].indexes[index7.name];
          }
        }
      }
      const tablesDiff = diffSchemasOrTables(json1.tables, json22.tables);
      const {
        created: createdTables,
        deleted: deletedTables,
        renamed: renamedTables
        // renamed or moved
      } = await tablesResolver2({
        created: tablesDiff.added,
        deleted: tablesDiff.deleted
      });
      const tablesPatchedSnap1 = copy(json1);
      tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_7, it2) => {
        const { name: name3 } = nameChangeFor(it2, renamedTables);
        it2.name = name3;
        return [name3, it2];
      });
      const res = diffColumns(tablesPatchedSnap1.tables, json22.tables);
      const columnRenames = [];
      const columnCreates = [];
      const columnDeletes = [];
      for (let entry of Object.values(res)) {
        const { renamed, created, deleted } = await columnsResolver2({
          tableName: entry.name,
          schema: entry.schema,
          deleted: entry.columns.deleted,
          created: entry.columns.added
        });
        if (created.length > 0) {
          columnCreates.push({
            table: entry.name,
            columns: created
          });
        }
        if (deleted.length > 0) {
          columnDeletes.push({
            table: entry.name,
            columns: deleted
          });
        }
        if (renamed.length > 0) {
          columnRenames.push({
            table: entry.name,
            renames: renamed
          });
        }
      }
      const columnRenamesDict = columnRenames.reduce(
        (acc, it2) => {
          acc[it2.table] = it2.renames;
          return acc;
        },
        {}
      );
      const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
      columnsPatchedSnap1.tables = mapEntries(
        columnsPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedColumns = mapKeys(
            tableValue.columns,
            (columnKey, column6) => {
              const rens = columnRenamesDict[tableValue.name] || [];
              const newName = columnChangeFor(columnKey, rens);
              column6.name = newName;
              return newName;
            }
          );
          tableValue.columns = patchedColumns;
          return [tableKey2, tableValue];
        }
      );
      const diffResult = applyJsonDiff(columnsPatchedSnap1, json22);
      const typedResult = diffResultSchemeSingleStore.parse(diffResult);
      const jsonStatements = [];
      const jsonCreateIndexesForCreatedTables = createdTables.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.indexes,
          curFull.internal
        );
      }).flat();
      const jsonDropTables = deletedTables.map((it2) => {
        return prepareDropTableJson(it2);
      });
      const jsonRenameTables = renamedTables.map((it2) => {
        return prepareRenameTableJson(it2.from, it2.to);
      });
      const alteredTables = typedResult.alteredTablesWithColumns;
      const jsonAddedCompositePKs = [];
      const jsonAddedUniqueConstraints = [];
      const jsonDeletedUniqueConstraints = [];
      const jsonAlteredUniqueConstraints = [];
      const jsonRenameColumnsStatements = columnRenames.map((it2) => prepareRenameColumns(it2.table, "", it2.renames)).flat();
      const jsonAddColumnsStatemets = columnCreates.map((it2) => _prepareAddColumns(it2.table, "", it2.columns)).flat();
      const jsonDropColumnsStatemets = columnDeletes.map((it2) => _prepareDropColumns(it2.table, "", it2.columns)).flat();
      alteredTables.forEach((it2) => {
        let addedColumns = [];
        for (const addedPkName of Object.keys(it2.addedCompositePKs)) {
          const addedPkColumns = it2.addedCompositePKs[addedPkName];
          addedColumns = SingleStoreSquasher.unsquashPK(addedPkColumns).columns;
        }
        let deletedColumns = [];
        for (const deletedPkName of Object.keys(it2.deletedCompositePKs)) {
          const deletedPkColumns = it2.deletedCompositePKs[deletedPkName];
          deletedColumns = SingleStoreSquasher.unsquashPK(deletedPkColumns).columns;
        }
        const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
        let addedUniqueConstraints = [];
        let deletedUniqueConstraints = [];
        let alteredUniqueConstraints = [];
        let createdCheckConstraints = [];
        let deletedCheckConstraints = [];
        addedUniqueConstraints = prepareAddUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.addedUniqueConstraints
        );
        deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.deletedUniqueConstraints
        );
        if (it2.alteredUniqueConstraints) {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredUniqueConstraints)) {
            added[k9] = it2.alteredUniqueConstraints[k9].__new;
            deleted[k9] = it2.alteredUniqueConstraints[k9].__old;
          }
          addedUniqueConstraints.push(
            ...prepareAddUniqueConstraintPg(it2.name, it2.schema, added)
          );
          deletedUniqueConstraints.push(
            ...prepareDeleteUniqueConstraintPg(it2.name, it2.schema, deleted)
          );
        }
        createdCheckConstraints = prepareAddCheckConstraint(it2.name, it2.schema, it2.addedCheckConstraints);
        deletedCheckConstraints = prepareDeleteCheckConstraint(
          it2.name,
          it2.schema,
          it2.deletedCheckConstraints
        );
        if (it2.alteredCheckConstraints && action !== "push") {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredCheckConstraints)) {
            added[k9] = it2.alteredCheckConstraints[k9].__new;
            deleted[k9] = it2.alteredCheckConstraints[k9].__old;
          }
          createdCheckConstraints.push(...prepareAddCheckConstraint(it2.name, it2.schema, added));
          deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it2.name, it2.schema, deleted));
        }
        jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
        jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
        jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
      });
      const rColumns = jsonRenameColumnsStatements.map((it2) => {
        const tableName = it2.tableName;
        const schema6 = it2.schema;
        return {
          from: { schema: schema6, table: tableName, column: it2.oldColumnName },
          to: { schema: schema6, table: tableName, column: it2.newColumnName }
        };
      });
      const jsonTableAlternations = alteredTables.map((it2) => {
        return prepareAlterColumnsMysql(
          it2.name,
          it2.schema,
          it2.altered,
          json1,
          json22,
          action
        );
      }).flat();
      const jsonCreateIndexesForAllAlteredTables = alteredTables.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.addedIndexes || {},
          curFull.internal
        );
      }).flat();
      const jsonDropIndexesForAllAlteredTables = alteredTables.map((it2) => {
        return prepareDropIndexesJson(
          it2.name,
          it2.schema,
          it2.deletedIndexes || {}
        );
      }).flat();
      alteredTables.forEach((it2) => {
        const droppedIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__old;
            return current;
          },
          {}
        );
        const createdIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__new;
            return current;
          },
          {}
        );
        jsonCreateIndexesForAllAlteredTables.push(
          ...prepareCreateIndexesJson(it2.name, it2.schema, createdIndexes || {})
        );
        jsonDropIndexesForAllAlteredTables.push(
          ...prepareDropIndexesJson(it2.name, it2.schema, droppedIndexes || {})
        );
      });
      const jsonSingleStoreCreateTables = createdTables.map((it2) => {
        return prepareSingleStoreCreateTableJson(
          it2,
          curFull,
          curFull.internal
        );
      });
      jsonStatements.push(...jsonSingleStoreCreateTables);
      jsonStatements.push(...jsonDropTables);
      jsonStatements.push(...jsonRenameTables);
      jsonStatements.push(...jsonRenameColumnsStatements);
      jsonStatements.push(...jsonDeletedUniqueConstraints);
      jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
      jsonStatements.push(...jsonTableAlternations);
      jsonStatements.push(...jsonAddedCompositePKs);
      jsonStatements.push(...jsonAddedUniqueConstraints);
      jsonStatements.push(...jsonDeletedUniqueConstraints);
      jsonStatements.push(...jsonAddColumnsStatemets);
      jsonStatements.push(...jsonCreateIndexesForCreatedTables);
      jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
      jsonStatements.push(...jsonDropColumnsStatemets);
      jsonStatements.push(...jsonAddedCompositePKs);
      jsonStatements.push(...jsonAlteredUniqueConstraints);
      const combinedJsonStatements = singleStoreCombineStatements(jsonStatements, json22);
      const sqlStatements = fromJson(combinedJsonStatements, "singlestore");
      const uniqueSqlStatements = [];
      sqlStatements.forEach((ss) => {
        if (!uniqueSqlStatements.includes(ss)) {
          uniqueSqlStatements.push(ss);
        }
      });
      const rTables = renamedTables.map((it2) => {
        return { from: it2.from, to: it2.to };
      });
      const _meta = prepareMigrationMeta([], rTables, rColumns);
      return {
        statements: combinedJsonStatements,
        sqlStatements: uniqueSqlStatements,
        _meta
      };
    };
    applySqliteSnapshotsDiff = async (json1, json22, tablesResolver2, columnsResolver2, viewsResolver2, prevFull, curFull, action) => {
      const tablesDiff = diffSchemasOrTables(json1.tables, json22.tables);
      const {
        created: createdTables,
        deleted: deletedTables,
        renamed: renamedTables
      } = await tablesResolver2({
        created: tablesDiff.added,
        deleted: tablesDiff.deleted
      });
      const tablesPatchedSnap1 = copy(json1);
      tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_7, it2) => {
        const { name: name3 } = nameChangeFor(it2, renamedTables);
        it2.name = name3;
        return [name3, it2];
      });
      const res = diffColumns(tablesPatchedSnap1.tables, json22.tables);
      const columnRenames = [];
      const columnCreates = [];
      const columnDeletes = [];
      for (let entry of Object.values(res)) {
        const { renamed, created, deleted } = await columnsResolver2({
          tableName: entry.name,
          schema: entry.schema,
          deleted: entry.columns.deleted,
          created: entry.columns.added
        });
        if (created.length > 0) {
          columnCreates.push({
            table: entry.name,
            columns: created
          });
        }
        if (deleted.length > 0) {
          columnDeletes.push({
            table: entry.name,
            columns: deleted
          });
        }
        if (renamed.length > 0) {
          columnRenames.push({
            table: entry.name,
            renames: renamed
          });
        }
      }
      const columnRenamesDict = columnRenames.reduce(
        (acc, it2) => {
          acc[it2.table] = it2.renames;
          return acc;
        },
        {}
      );
      const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
      columnsPatchedSnap1.tables = mapEntries(
        columnsPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedColumns = mapKeys(
            tableValue.columns,
            (columnKey, column6) => {
              const rens = columnRenamesDict[tableValue.name] || [];
              const newName = columnChangeFor(columnKey, rens);
              column6.name = newName;
              return newName;
            }
          );
          tableValue.columns = patchedColumns;
          return [tableKey2, tableValue];
        }
      );
      const viewsDiff = diffSchemasOrTables(json1.views, json22.views);
      const {
        created: createdViews,
        deleted: deletedViews,
        renamed: renamedViews
        // renamed or moved
      } = await viewsResolver2({
        created: viewsDiff.added,
        deleted: viewsDiff.deleted
      });
      const renamesViewDic = {};
      renamedViews.forEach((it2) => {
        renamesViewDic[it2.from.name] = { to: it2.to.name, from: it2.from.name };
      });
      const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
      viewsPatchedSnap1.views = mapEntries(
        viewsPatchedSnap1.views,
        (viewKey, viewValue) => {
          const rename = renamesViewDic[viewValue.name];
          if (rename) {
            viewValue.name = rename.to;
          }
          return [viewKey, viewValue];
        }
      );
      const diffResult = applyJsonDiff(viewsPatchedSnap1, json22);
      const typedResult = diffResultSchemeSQLite.parse(diffResult);
      const tablesMap = {};
      typedResult.alteredTablesWithColumns.forEach((obj) => {
        tablesMap[obj.name] = obj;
      });
      const jsonCreateTables = createdTables.map((it2) => {
        return prepareSQLiteCreateTable(it2, action);
      });
      const jsonCreateIndexesForCreatedTables = createdTables.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.indexes,
          curFull.internal
        );
      }).flat();
      const jsonDropTables = deletedTables.map((it2) => {
        return prepareDropTableJson(it2);
      });
      const jsonRenameTables = renamedTables.map((it2) => {
        return prepareRenameTableJson(it2.from, it2.to);
      });
      const jsonRenameColumnsStatements = columnRenames.map((it2) => prepareRenameColumns(it2.table, "", it2.renames)).flat();
      const jsonDropColumnsStatemets = columnDeletes.map((it2) => _prepareDropColumns(it2.table, "", it2.columns)).flat();
      const jsonAddColumnsStatemets = columnCreates.map((it2) => {
        return _prepareSqliteAddColumns(
          it2.table,
          it2.columns,
          tablesMap[it2.table] && tablesMap[it2.table].addedForeignKeys ? Object.values(tablesMap[it2.table].addedForeignKeys) : []
        );
      }).flat();
      const allAltered = typedResult.alteredTablesWithColumns;
      const jsonAddedCompositePKs = [];
      const jsonDeletedCompositePKs = [];
      const jsonAlteredCompositePKs = [];
      const jsonAddedUniqueConstraints = [];
      const jsonDeletedUniqueConstraints = [];
      const jsonAlteredUniqueConstraints = [];
      const jsonDeletedCheckConstraints = [];
      const jsonCreatedCheckConstraints = [];
      allAltered.forEach((it2) => {
        let addedColumns = [];
        for (const addedPkName of Object.keys(it2.addedCompositePKs)) {
          const addedPkColumns = it2.addedCompositePKs[addedPkName];
          addedColumns = SQLiteSquasher.unsquashPK(addedPkColumns);
        }
        let deletedColumns = [];
        for (const deletedPkName of Object.keys(it2.deletedCompositePKs)) {
          const deletedPkColumns = it2.deletedCompositePKs[deletedPkName];
          deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
        }
        const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
        let addedCompositePKs = [];
        let deletedCompositePKs = [];
        let alteredCompositePKs = [];
        if (doPerformDeleteAndCreate) {
          addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
            it2.name,
            it2.addedCompositePKs
          );
          deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
            it2.name,
            it2.deletedCompositePKs
          );
        }
        alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
          it2.name,
          it2.alteredCompositePKs
        );
        let addedUniqueConstraints = [];
        let deletedUniqueConstraints = [];
        let alteredUniqueConstraints = [];
        addedUniqueConstraints = prepareAddUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.addedUniqueConstraints
        );
        deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.deletedUniqueConstraints
        );
        if (it2.alteredUniqueConstraints) {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredUniqueConstraints)) {
            added[k9] = it2.alteredUniqueConstraints[k9].__new;
            deleted[k9] = it2.alteredUniqueConstraints[k9].__old;
          }
          addedUniqueConstraints.push(
            ...prepareAddUniqueConstraintPg(it2.name, it2.schema, added)
          );
          deletedUniqueConstraints.push(
            ...prepareDeleteUniqueConstraintPg(it2.name, it2.schema, deleted)
          );
        }
        let createdCheckConstraints = [];
        let deletedCheckConstraints = [];
        addedUniqueConstraints = prepareAddUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.addedUniqueConstraints
        );
        deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.deletedUniqueConstraints
        );
        if (it2.alteredUniqueConstraints) {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredUniqueConstraints)) {
            added[k9] = it2.alteredUniqueConstraints[k9].__new;
            deleted[k9] = it2.alteredUniqueConstraints[k9].__old;
          }
          addedUniqueConstraints.push(
            ...prepareAddUniqueConstraintPg(it2.name, it2.schema, added)
          );
          deletedUniqueConstraints.push(
            ...prepareDeleteUniqueConstraintPg(it2.name, it2.schema, deleted)
          );
        }
        createdCheckConstraints = prepareAddCheckConstraint(it2.name, it2.schema, it2.addedCheckConstraints);
        deletedCheckConstraints = prepareDeleteCheckConstraint(
          it2.name,
          it2.schema,
          it2.deletedCheckConstraints
        );
        if (it2.alteredCheckConstraints && action !== "push") {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredCheckConstraints)) {
            added[k9] = it2.alteredCheckConstraints[k9].__new;
            deleted[k9] = it2.alteredCheckConstraints[k9].__old;
          }
          createdCheckConstraints.push(...prepareAddCheckConstraint(it2.name, it2.schema, added));
          deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it2.name, it2.schema, deleted));
        }
        jsonAddedCompositePKs.push(...addedCompositePKs);
        jsonDeletedCompositePKs.push(...deletedCompositePKs);
        jsonAlteredCompositePKs.push(...alteredCompositePKs);
        jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
        jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
        jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
        jsonCreatedCheckConstraints.push(...createdCheckConstraints);
        jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
      });
      const rColumns = jsonRenameColumnsStatements.map((it2) => {
        const tableName = it2.tableName;
        const schema6 = it2.schema;
        return {
          from: { schema: schema6, table: tableName, column: it2.oldColumnName },
          to: { schema: schema6, table: tableName, column: it2.newColumnName }
        };
      });
      const jsonTableAlternations = allAltered.map((it2) => {
        return prepareSqliteAlterColumns(it2.name, it2.schema, it2.altered, json22);
      }).flat();
      const jsonCreateIndexesForAllAlteredTables = allAltered.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.addedIndexes || {},
          curFull.internal
        );
      }).flat();
      const jsonDropIndexesForAllAlteredTables = allAltered.map((it2) => {
        return prepareDropIndexesJson(
          it2.name,
          it2.schema,
          it2.deletedIndexes || {}
        );
      }).flat();
      allAltered.forEach((it2) => {
        const droppedIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__old;
            return current;
          },
          {}
        );
        const createdIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__new;
            return current;
          },
          {}
        );
        jsonCreateIndexesForAllAlteredTables.push(
          ...prepareCreateIndexesJson(
            it2.name,
            it2.schema,
            createdIndexes || {},
            curFull.internal
          )
        );
        jsonDropIndexesForAllAlteredTables.push(
          ...prepareDropIndexesJson(it2.name, it2.schema, droppedIndexes || {})
        );
      });
      const jsonReferencesForAllAlteredTables = allAltered.map((it2) => {
        const forAdded = prepareCreateReferencesJson(
          it2.name,
          it2.schema,
          it2.addedForeignKeys
        );
        const forAltered = prepareDropReferencesJson(
          it2.name,
          it2.schema,
          it2.deletedForeignKeys
        );
        const alteredFKs = prepareAlterReferencesJson(
          it2.name,
          it2.schema,
          it2.alteredForeignKeys
        );
        return [...forAdded, ...forAltered, ...alteredFKs];
      }).flat();
      const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
        (t6) => t6.type === "create_reference"
      );
      const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
        (t6) => t6.type === "delete_reference"
      );
      const createViews = [];
      const dropViews = [];
      createViews.push(
        ...createdViews.filter((it2) => !it2.isExisting).map((it2) => {
          return prepareSqliteCreateViewJson(
            it2.name,
            it2.definition
          );
        })
      );
      dropViews.push(
        ...deletedViews.filter((it2) => !it2.isExisting).map((it2) => {
          return prepareDropViewJson(it2.name);
        })
      );
      dropViews.push(
        ...renamedViews.filter((it2) => !it2.to.isExisting).map((it2) => {
          return prepareDropViewJson(it2.from.name);
        })
      );
      createViews.push(
        ...renamedViews.filter((it2) => !it2.to.isExisting).map((it2) => {
          return prepareSqliteCreateViewJson(it2.to.name, it2.to.definition);
        })
      );
      const alteredViews = typedResult.alteredViews.filter((it2) => !json22.views[it2.name].isExisting);
      for (const alteredView of alteredViews) {
        const { definition } = json22.views[alteredView.name];
        if (alteredView.alteredExisting || alteredView.alteredDefinition && action !== "push") {
          dropViews.push(prepareDropViewJson(alteredView.name));
          createViews.push(
            prepareSqliteCreateViewJson(
              alteredView.name,
              definition
            )
          );
        }
      }
      const jsonStatements = [];
      jsonStatements.push(...jsonCreateTables);
      jsonStatements.push(...jsonDropTables);
      jsonStatements.push(...jsonRenameTables);
      jsonStatements.push(...jsonRenameColumnsStatements);
      jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
      jsonStatements.push(...jsonDeletedCheckConstraints);
      jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
      jsonStatements.push(...jsonDeletedCompositePKs);
      jsonStatements.push(...jsonTableAlternations);
      jsonStatements.push(...jsonAddedCompositePKs);
      jsonStatements.push(...jsonAddColumnsStatemets);
      jsonStatements.push(...jsonCreateIndexesForCreatedTables);
      jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
      jsonStatements.push(...jsonCreatedCheckConstraints);
      jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
      jsonStatements.push(...jsonDropColumnsStatemets);
      jsonStatements.push(...jsonAlteredCompositePKs);
      jsonStatements.push(...jsonAlteredUniqueConstraints);
      jsonStatements.push(...dropViews);
      jsonStatements.push(...createViews);
      const combinedJsonStatements = sqliteCombineStatements(jsonStatements, json22, action);
      const sqlStatements = fromJson(combinedJsonStatements, "sqlite");
      const uniqueSqlStatements = [];
      sqlStatements.forEach((ss) => {
        if (!uniqueSqlStatements.includes(ss)) {
          uniqueSqlStatements.push(ss);
        }
      });
      const rTables = renamedTables.map((it2) => {
        return { from: it2.from, to: it2.to };
      });
      const _meta = prepareMigrationMeta([], rTables, rColumns);
      return {
        statements: combinedJsonStatements,
        sqlStatements: uniqueSqlStatements,
        _meta
      };
    };
    applyLibSQLSnapshotsDiff = async (json1, json22, tablesResolver2, columnsResolver2, viewsResolver2, prevFull, curFull, action) => {
      const tablesDiff = diffSchemasOrTables(json1.tables, json22.tables);
      const {
        created: createdTables,
        deleted: deletedTables,
        renamed: renamedTables
      } = await tablesResolver2({
        created: tablesDiff.added,
        deleted: tablesDiff.deleted
      });
      const tablesPatchedSnap1 = copy(json1);
      tablesPatchedSnap1.tables = mapEntries(tablesPatchedSnap1.tables, (_7, it2) => {
        const { name: name3 } = nameChangeFor(it2, renamedTables);
        it2.name = name3;
        return [name3, it2];
      });
      const res = diffColumns(tablesPatchedSnap1.tables, json22.tables);
      const columnRenames = [];
      const columnCreates = [];
      const columnDeletes = [];
      for (let entry of Object.values(res)) {
        const { renamed, created, deleted } = await columnsResolver2({
          tableName: entry.name,
          schema: entry.schema,
          deleted: entry.columns.deleted,
          created: entry.columns.added
        });
        if (created.length > 0) {
          columnCreates.push({
            table: entry.name,
            columns: created
          });
        }
        if (deleted.length > 0) {
          columnDeletes.push({
            table: entry.name,
            columns: deleted
          });
        }
        if (renamed.length > 0) {
          columnRenames.push({
            table: entry.name,
            renames: renamed
          });
        }
      }
      const columnRenamesDict = columnRenames.reduce(
        (acc, it2) => {
          acc[it2.table] = it2.renames;
          return acc;
        },
        {}
      );
      const columnsPatchedSnap1 = copy(tablesPatchedSnap1);
      columnsPatchedSnap1.tables = mapEntries(
        columnsPatchedSnap1.tables,
        (tableKey2, tableValue) => {
          const patchedColumns = mapKeys(
            tableValue.columns,
            (columnKey, column6) => {
              const rens = columnRenamesDict[tableValue.name] || [];
              const newName = columnChangeFor(columnKey, rens);
              column6.name = newName;
              return newName;
            }
          );
          tableValue.columns = patchedColumns;
          return [tableKey2, tableValue];
        }
      );
      const viewsDiff = diffSchemasOrTables(json1.views, json22.views);
      const {
        created: createdViews,
        deleted: deletedViews,
        renamed: renamedViews
        // renamed or moved
      } = await viewsResolver2({
        created: viewsDiff.added,
        deleted: viewsDiff.deleted
      });
      const renamesViewDic = {};
      renamedViews.forEach((it2) => {
        renamesViewDic[it2.from.name] = { to: it2.to.name, from: it2.from.name };
      });
      const viewsPatchedSnap1 = copy(columnsPatchedSnap1);
      viewsPatchedSnap1.views = mapEntries(
        viewsPatchedSnap1.views,
        (viewKey, viewValue) => {
          const rename = renamesViewDic[viewValue.name];
          if (rename) {
            viewValue.name = rename.to;
          }
          return [viewKey, viewValue];
        }
      );
      const diffResult = applyJsonDiff(viewsPatchedSnap1, json22);
      const typedResult = diffResultSchemeSQLite.parse(diffResult);
      const tablesMap = {};
      typedResult.alteredTablesWithColumns.forEach((obj) => {
        tablesMap[obj.name] = obj;
      });
      const jsonCreateTables = createdTables.map((it2) => {
        return prepareSQLiteCreateTable(it2, action);
      });
      const jsonCreateIndexesForCreatedTables = createdTables.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.indexes,
          curFull.internal
        );
      }).flat();
      const jsonDropTables = deletedTables.map((it2) => {
        return prepareDropTableJson(it2);
      });
      const jsonRenameTables = renamedTables.map((it2) => {
        return prepareRenameTableJson(it2.from, it2.to);
      });
      const jsonRenameColumnsStatements = columnRenames.map((it2) => prepareRenameColumns(it2.table, "", it2.renames)).flat();
      const jsonDropColumnsStatemets = columnDeletes.map((it2) => _prepareDropColumns(it2.table, "", it2.columns)).flat();
      const jsonAddColumnsStatemets = columnCreates.map((it2) => {
        return _prepareSqliteAddColumns(
          it2.table,
          it2.columns,
          tablesMap[it2.table] && tablesMap[it2.table].addedForeignKeys ? Object.values(tablesMap[it2.table].addedForeignKeys) : []
        );
      }).flat();
      const rColumns = jsonRenameColumnsStatements.map((it2) => {
        const tableName = it2.tableName;
        const schema6 = it2.schema;
        return {
          from: { schema: schema6, table: tableName, column: it2.oldColumnName },
          to: { schema: schema6, table: tableName, column: it2.newColumnName }
        };
      });
      const rTables = renamedTables.map((it2) => {
        return { from: it2.from, to: it2.to };
      });
      const _meta = prepareMigrationMeta([], rTables, rColumns);
      const allAltered = typedResult.alteredTablesWithColumns;
      const jsonAddedCompositePKs = [];
      const jsonDeletedCompositePKs = [];
      const jsonAlteredCompositePKs = [];
      const jsonAddedUniqueConstraints = [];
      const jsonDeletedUniqueConstraints = [];
      const jsonAlteredUniqueConstraints = [];
      const jsonDeletedCheckConstraints = [];
      const jsonCreatedCheckConstraints = [];
      allAltered.forEach((it2) => {
        let addedColumns = [];
        for (const addedPkName of Object.keys(it2.addedCompositePKs)) {
          const addedPkColumns = it2.addedCompositePKs[addedPkName];
          addedColumns = SQLiteSquasher.unsquashPK(addedPkColumns);
        }
        let deletedColumns = [];
        for (const deletedPkName of Object.keys(it2.deletedCompositePKs)) {
          const deletedPkColumns = it2.deletedCompositePKs[deletedPkName];
          deletedColumns = SQLiteSquasher.unsquashPK(deletedPkColumns);
        }
        const doPerformDeleteAndCreate = JSON.stringify(addedColumns) !== JSON.stringify(deletedColumns);
        let addedCompositePKs = [];
        let deletedCompositePKs = [];
        let alteredCompositePKs = [];
        if (doPerformDeleteAndCreate) {
          addedCompositePKs = prepareAddCompositePrimaryKeySqlite(
            it2.name,
            it2.addedCompositePKs
          );
          deletedCompositePKs = prepareDeleteCompositePrimaryKeySqlite(
            it2.name,
            it2.deletedCompositePKs
          );
        }
        alteredCompositePKs = prepareAlterCompositePrimaryKeySqlite(
          it2.name,
          it2.alteredCompositePKs
        );
        let addedUniqueConstraints = [];
        let deletedUniqueConstraints = [];
        let alteredUniqueConstraints = [];
        let createdCheckConstraints = [];
        let deletedCheckConstraints = [];
        addedUniqueConstraints = prepareAddUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.addedUniqueConstraints
        );
        deletedUniqueConstraints = prepareDeleteUniqueConstraintPg(
          it2.name,
          it2.schema,
          it2.deletedUniqueConstraints
        );
        if (it2.alteredUniqueConstraints) {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredUniqueConstraints)) {
            added[k9] = it2.alteredUniqueConstraints[k9].__new;
            deleted[k9] = it2.alteredUniqueConstraints[k9].__old;
          }
          addedUniqueConstraints.push(
            ...prepareAddUniqueConstraintPg(it2.name, it2.schema, added)
          );
          deletedUniqueConstraints.push(
            ...prepareDeleteUniqueConstraintPg(it2.name, it2.schema, deleted)
          );
        }
        createdCheckConstraints = prepareAddCheckConstraint(it2.name, it2.schema, it2.addedCheckConstraints);
        deletedCheckConstraints = prepareDeleteCheckConstraint(
          it2.name,
          it2.schema,
          it2.deletedCheckConstraints
        );
        if (it2.alteredCheckConstraints && action !== "push") {
          const added = {};
          const deleted = {};
          for (const k9 of Object.keys(it2.alteredCheckConstraints)) {
            added[k9] = it2.alteredCheckConstraints[k9].__new;
            deleted[k9] = it2.alteredCheckConstraints[k9].__old;
          }
          createdCheckConstraints.push(...prepareAddCheckConstraint(it2.name, it2.schema, added));
          deletedCheckConstraints.push(...prepareDeleteCheckConstraint(it2.name, it2.schema, deleted));
        }
        jsonAddedCompositePKs.push(...addedCompositePKs);
        jsonDeletedCompositePKs.push(...deletedCompositePKs);
        jsonAlteredCompositePKs.push(...alteredCompositePKs);
        jsonAddedUniqueConstraints.push(...addedUniqueConstraints);
        jsonDeletedUniqueConstraints.push(...deletedUniqueConstraints);
        jsonAlteredUniqueConstraints.push(...alteredUniqueConstraints);
        jsonCreatedCheckConstraints.push(...createdCheckConstraints);
        jsonDeletedCheckConstraints.push(...deletedCheckConstraints);
      });
      const jsonTableAlternations = allAltered.map((it2) => {
        return prepareSqliteAlterColumns(it2.name, it2.schema, it2.altered, json22);
      }).flat();
      const jsonCreateIndexesForAllAlteredTables = allAltered.map((it2) => {
        return prepareCreateIndexesJson(
          it2.name,
          it2.schema,
          it2.addedIndexes || {},
          curFull.internal
        );
      }).flat();
      const jsonDropIndexesForAllAlteredTables = allAltered.map((it2) => {
        return prepareDropIndexesJson(
          it2.name,
          it2.schema,
          it2.deletedIndexes || {}
        );
      }).flat();
      allAltered.forEach((it2) => {
        const droppedIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__old;
            return current;
          },
          {}
        );
        const createdIndexes = Object.keys(it2.alteredIndexes).reduce(
          (current, item) => {
            current[item] = it2.alteredIndexes[item].__new;
            return current;
          },
          {}
        );
        jsonCreateIndexesForAllAlteredTables.push(
          ...prepareCreateIndexesJson(
            it2.name,
            it2.schema,
            createdIndexes || {},
            curFull.internal
          )
        );
        jsonDropIndexesForAllAlteredTables.push(
          ...prepareDropIndexesJson(it2.name, it2.schema, droppedIndexes || {})
        );
      });
      const jsonReferencesForAllAlteredTables = allAltered.map((it2) => {
        const forAdded = prepareLibSQLCreateReferencesJson(
          it2.name,
          it2.schema,
          it2.addedForeignKeys,
          json22,
          action
        );
        const forAltered = prepareLibSQLDropReferencesJson(
          it2.name,
          it2.schema,
          it2.deletedForeignKeys,
          json22,
          _meta,
          action
        );
        const alteredFKs = prepareAlterReferencesJson(it2.name, it2.schema, it2.alteredForeignKeys);
        return [...forAdded, ...forAltered, ...alteredFKs];
      }).flat();
      const jsonCreatedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
        (t6) => t6.type === "create_reference"
      );
      const jsonDroppedReferencesForAlteredTables = jsonReferencesForAllAlteredTables.filter(
        (t6) => t6.type === "delete_reference"
      );
      const createViews = [];
      const dropViews = [];
      createViews.push(
        ...createdViews.filter((it2) => !it2.isExisting).map((it2) => {
          return prepareSqliteCreateViewJson(
            it2.name,
            it2.definition
          );
        })
      );
      dropViews.push(
        ...deletedViews.filter((it2) => !it2.isExisting).map((it2) => {
          return prepareDropViewJson(it2.name);
        })
      );
      dropViews.push(
        ...renamedViews.filter((it2) => !it2.to.isExisting).map((it2) => {
          return prepareDropViewJson(it2.from.name);
        })
      );
      createViews.push(
        ...renamedViews.filter((it2) => !it2.to.isExisting).map((it2) => {
          return prepareSqliteCreateViewJson(it2.to.name, it2.to.definition);
        })
      );
      const alteredViews = typedResult.alteredViews.filter((it2) => !json22.views[it2.name].isExisting);
      for (const alteredView of alteredViews) {
        const { definition } = json22.views[alteredView.name];
        if (alteredView.alteredExisting || alteredView.alteredDefinition && action !== "push") {
          dropViews.push(prepareDropViewJson(alteredView.name));
          createViews.push(
            prepareSqliteCreateViewJson(
              alteredView.name,
              definition
            )
          );
        }
      }
      const jsonStatements = [];
      jsonStatements.push(...jsonCreateTables);
      jsonStatements.push(...jsonDropTables);
      jsonStatements.push(...jsonRenameTables);
      jsonStatements.push(...jsonRenameColumnsStatements);
      jsonStatements.push(...jsonDroppedReferencesForAlteredTables);
      jsonStatements.push(...jsonDeletedCheckConstraints);
      jsonStatements.push(...jsonDropIndexesForAllAlteredTables);
      jsonStatements.push(...jsonDeletedCompositePKs);
      jsonStatements.push(...jsonTableAlternations);
      jsonStatements.push(...jsonAddedCompositePKs);
      jsonStatements.push(...jsonAddColumnsStatemets);
      jsonStatements.push(...jsonCreateIndexesForCreatedTables);
      jsonStatements.push(...jsonCreateIndexesForAllAlteredTables);
      jsonStatements.push(...jsonCreatedCheckConstraints);
      jsonStatements.push(...dropViews);
      jsonStatements.push(...createViews);
      jsonStatements.push(...jsonCreatedReferencesForAlteredTables);
      jsonStatements.push(...jsonDropColumnsStatemets);
      jsonStatements.push(...jsonAlteredCompositePKs);
      jsonStatements.push(...jsonAlteredUniqueConstraints);
      const combinedJsonStatements = libSQLCombineStatements(jsonStatements, json22, action);
      const sqlStatements = fromJson(
        combinedJsonStatements,
        "turso",
        action,
        json22
      );
      const uniqueSqlStatements = [];
      sqlStatements.forEach((ss) => {
        if (!uniqueSqlStatements.includes(ss)) {
          uniqueSqlStatements.push(ss);
        }
      });
      return {
        statements: combinedJsonStatements,
        sqlStatements: uniqueSqlStatements,
        _meta
      };
    };
  }
});

// src/utils/words.ts
var init_words = __esm({
  "src/utils/words.ts"() {
    "use strict";
  }
});

// src/schemaValidator.ts
var dialects, dialect4, commonSquashedSchema, commonSchema;
var init_schemaValidator = __esm({
  "src/schemaValidator.ts"() {
    "use strict";
    init_esm();
    init_mysqlSchema();
    init_pgSchema();
    init_singlestoreSchema();
    init_sqliteSchema();
    dialects = ["postgresql", "mysql", "sqlite", "turso", "singlestore", "gel"];
    dialect4 = enumType(dialects);
    commonSquashedSchema = unionType([
      pgSchemaSquashed,
      mysqlSchemaSquashed,
      SQLiteSchemaSquashed,
      singlestoreSchemaSquashed
    ]);
    commonSchema = unionType([pgSchema2, mysqlSchema, sqliteSchema, singlestoreSchema]);
  }
});

// src/cli/validations/common.ts
var sqliteDriversLiterals, postgresqlDriversLiterals, prefixes, prefix, casingTypes, casingType, sqliteDriver, postgresDriver, driver, configMigrations, configCommonSchema, casing, introspectParams, configIntrospectCliSchema, configGenerateSchema, configPushSchema;
var init_common5 = __esm({
  "src/cli/validations/common.ts"() {
    "use strict";
    init_esm();
    init_schemaValidator();
    init_outputs();
    sqliteDriversLiterals = [
      literalType("d1-http"),
      literalType("expo"),
      literalType("durable-sqlite")
    ];
    postgresqlDriversLiterals = [
      literalType("aws-data-api"),
      literalType("pglite")
    ];
    prefixes = [
      "index",
      "timestamp",
      "supabase",
      "unix",
      "none"
    ];
    prefix = enumType(prefixes);
    {
      const _7 = "";
    }
    casingTypes = ["snake_case", "camelCase"];
    casingType = enumType(casingTypes);
    sqliteDriver = unionType(sqliteDriversLiterals);
    postgresDriver = unionType(postgresqlDriversLiterals);
    driver = unionType([sqliteDriver, postgresDriver]);
    configMigrations = objectType({
      table: stringType().optional(),
      schema: stringType().optional(),
      prefix: prefix.optional().default("index")
    }).optional();
    configCommonSchema = objectType({
      dialect: dialect4,
      schema: unionType([stringType(), stringType().array()]).optional(),
      out: stringType().optional(),
      breakpoints: booleanType().optional().default(true),
      verbose: booleanType().optional().default(false),
      driver: driver.optional(),
      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"]),
      migrations: configMigrations,
      dbCredentials: anyType().optional(),
      casing: casingType.optional(),
      sql: booleanType().default(true)
    }).passthrough();
    casing = unionType([literalType("camel"), literalType("preserve")]).default(
      "camel"
    );
    introspectParams = objectType({
      schema: unionType([stringType(), stringType().array()]).optional(),
      out: stringType().optional().default("./drizzle"),
      breakpoints: booleanType().default(true),
      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"]),
      introspect: objectType({
        casing
      }).default({ casing: "camel" })
    });
    configIntrospectCliSchema = objectType({
      schema: unionType([stringType(), stringType().array()]).optional(),
      out: stringType().optional().default("./drizzle"),
      breakpoints: booleanType().default(true),
      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"]),
      introspectCasing: unionType([literalType("camel"), literalType("preserve")]).default(
        "camel"
      )
    });
    configGenerateSchema = objectType({
      schema: unionType([stringType(), stringType().array()]),
      out: stringType().optional().default("./drizzle"),
      breakpoints: booleanType().default(true)
    });
    configPushSchema = objectType({
      dialect: dialect4,
      schema: unionType([stringType(), stringType().array()]),
      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
      schemaFilter: unionType([stringType(), stringType().array()]).default(["public"]),
      verbose: booleanType().default(false),
      strict: booleanType().default(false),
      out: stringType().optional()
    });
  }
});

// src/cli/validations/outputs.ts
var withStyle;
var init_outputs = __esm({
  "src/cli/validations/outputs.ts"() {
    "use strict";
    init_source();
    init_common5();
    withStyle = {
      error: (str) => `${source_default.red(`${source_default.white.bgRed(" Invalid input ")} ${str}`)}`,
      warning: (str) => `${source_default.white.bgGray(" Warning ")} ${str}`,
      errorWarning: (str) => `${source_default.red(`${source_default.white.bgRed(" Warning ")} ${str}`)}`,
      fullWarning: (str) => `${source_default.black.bgYellow(" Warning ")} ${source_default.bold(str)}`,
      suggestion: (str) => `${source_default.white.bgGray(" Suggestion ")} ${str}`,
      info: (str) => `${source_default.grey(str)}`
    };
  }
});

// src/cli/commands/migrate.ts
var import_hanji2, schemasResolver, tablesResolver, viewsResolver, mySqlViewsResolver, sqliteViewsResolver, sequencesResolver, roleResolver, policyResolver, indPolicyResolver, enumsResolver, columnsResolver, promptColumnsConflicts, promptNamedConflict, promptNamedWithSchemasConflict, promptSchemasConflict, BREAKPOINT;
var init_migrate = __esm({
  "src/cli/commands/migrate.ts"() {
    "use strict";
    init_migrationPreparator();
    init_source();
    import_hanji2 = __toESM(require_hanji());
    init_singlestoreSchema();
    init_mysqlSchema();
    init_pgSchema();
    init_sqliteSchema();
    init_snapshotsDiffer();
    init_utils8();
    init_words();
    init_outputs();
    init_views();
    schemasResolver = async (input) => {
      try {
        const { created, deleted, renamed } = await promptSchemasConflict(
          input.created,
          input.deleted
        );
        return { created, deleted, renamed };
      } catch (e6) {
        console.error(e6);
        throw e6;
      }
    };
    tablesResolver = async (input) => {
      try {
        const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
          input.created,
          input.deleted,
          "table"
        );
        return {
          created,
          deleted,
          moved,
          renamed
        };
      } catch (e6) {
        console.error(e6);
        throw e6;
      }
    };
    viewsResolver = async (input) => {
      try {
        const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
          input.created,
          input.deleted,
          "view"
        );
        return {
          created,
          deleted,
          moved,
          renamed
        };
      } catch (e6) {
        console.error(e6);
        throw e6;
      }
    };
    mySqlViewsResolver = async (input) => {
      try {
        const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
          input.created,
          input.deleted,
          "view"
        );
        return {
          created,
          deleted,
          moved,
          renamed
        };
      } catch (e6) {
        console.error(e6);
        throw e6;
      }
    };
    sqliteViewsResolver = async (input) => {
      try {
        const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
          input.created,
          input.deleted,
          "view"
        );
        return {
          created,
          deleted,
          moved,
          renamed
        };
      } catch (e6) {
        console.error(e6);
        throw e6;
      }
    };
    sequencesResolver = async (input) => {
      try {
        const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
          input.created,
          input.deleted,
          "sequence"
        );
        return {
          created,
          deleted,
          moved,
          renamed
        };
      } catch (e6) {
        console.error(e6);
        throw e6;
      }
    };
    roleResolver = async (input) => {
      const result = await promptNamedConflict(
        input.created,
        input.deleted,
        "role"
      );
      return {
        created: result.created,
        deleted: result.deleted,
        renamed: result.renamed
      };
    };
    policyResolver = async (input) => {
      const result = await promptColumnsConflicts(
        input.tableName,
        input.created,
        input.deleted
      );
      return {
        tableName: input.tableName,
        schema: input.schema,
        created: result.created,
        deleted: result.deleted,
        renamed: result.renamed
      };
    };
    indPolicyResolver = async (input) => {
      const result = await promptNamedConflict(
        input.created,
        input.deleted,
        "policy"
      );
      return {
        created: result.created,
        deleted: result.deleted,
        renamed: result.renamed
      };
    };
    enumsResolver = async (input) => {
      try {
        const { created, deleted, moved, renamed } = await promptNamedWithSchemasConflict(
          input.created,
          input.deleted,
          "enum"
        );
        return {
          created,
          deleted,
          moved,
          renamed
        };
      } catch (e6) {
        console.error(e6);
        throw e6;
      }
    };
    columnsResolver = async (input) => {
      const result = await promptColumnsConflicts(
        input.tableName,
        input.created,
        input.deleted
      );
      return {
        tableName: input.tableName,
        schema: input.schema,
        created: result.created,
        deleted: result.deleted,
        renamed: result.renamed
      };
    };
    promptColumnsConflicts = async (tableName, newColumns, missingColumns) => {
      if (newColumns.length === 0 || missingColumns.length === 0) {
        return { created: newColumns, renamed: [], deleted: missingColumns };
      }
      const result = {
        created: [],
        renamed: [],
        deleted: []
      };
      let index7 = 0;
      let leftMissing = [...missingColumns];
      do {
        const created = newColumns[index7];
        const renames = leftMissing.map((it2) => {
          return { from: it2, to: created };
        });
        const promptData = [created, ...renames];
        const { status, data } = await (0, import_hanji2.render)(
          new ResolveColumnSelect(tableName, created, promptData)
        );
        if (status === "aborted") {
          console.error("ERROR");
          process.exit(1);
        }
        if (isRenamePromptItem(data)) {
          console.log(
            `${source_default.yellow("~")} ${data.from.name} \u203A ${data.to.name} ${source_default.gray(
              "column will be renamed"
            )}`
          );
          result.renamed.push(data);
          delete leftMissing[leftMissing.indexOf(data.from)];
          leftMissing = leftMissing.filter(Boolean);
        } else {
          console.log(
            `${source_default.green("+")} ${data.name} ${source_default.gray(
              "column will be created"
            )}`
          );
          result.created.push(created);
        }
        index7 += 1;
      } while (index7 < newColumns.length);
      console.log(
        source_default.gray(`--- all columns conflicts in ${tableName} table resolved ---
`)
      );
      result.deleted.push(...leftMissing);
      return result;
    };
    promptNamedConflict = async (newItems, missingItems, entity) => {
      if (missingItems.length === 0 || newItems.length === 0) {
        return {
          created: newItems,
          renamed: [],
          deleted: missingItems
        };
      }
      const result = { created: [], renamed: [], deleted: [] };
      let index7 = 0;
      let leftMissing = [...missingItems];
      do {
        const created = newItems[index7];
        const renames = leftMissing.map((it2) => {
          return { from: it2, to: created };
        });
        const promptData = [created, ...renames];
        const { status, data } = await (0, import_hanji2.render)(
          new ResolveSelectNamed(created, promptData, entity)
        );
        if (status === "aborted") {
          console.error("ERROR");
          process.exit(1);
        }
        if (isRenamePromptItem(data)) {
          console.log(
            `${source_default.yellow("~")} ${data.from.name} \u203A ${data.to.name} ${source_default.gray(
              `${entity} will be renamed/moved`
            )}`
          );
          if (data.from.name !== data.to.name) {
            result.renamed.push(data);
          }
          delete leftMissing[leftMissing.indexOf(data.from)];
          leftMissing = leftMissing.filter(Boolean);
        } else {
          console.log(
            `${source_default.green("+")} ${data.name} ${source_default.gray(
              `${entity} will be created`
            )}`
          );
          result.created.push(created);
        }
        index7 += 1;
      } while (index7 < newItems.length);
      console.log(source_default.gray(`--- all ${entity} conflicts resolved ---
`));
      result.deleted.push(...leftMissing);
      return result;
    };
    promptNamedWithSchemasConflict = async (newItems, missingItems, entity) => {
      if (missingItems.length === 0 || newItems.length === 0) {
        return {
          created: newItems,
          renamed: [],
          moved: [],
          deleted: missingItems
        };
      }
      const result = { created: [], renamed: [], moved: [], deleted: [] };
      let index7 = 0;
      let leftMissing = [...missingItems];
      do {
        const created = newItems[index7];
        const renames = leftMissing.map((it2) => {
          return { from: it2, to: created };
        });
        const promptData = [created, ...renames];
        const { status, data } = await (0, import_hanji2.render)(
          new ResolveSelect(created, promptData, entity)
        );
        if (status === "aborted") {
          console.error("ERROR");
          process.exit(1);
        }
        if (isRenamePromptItem(data)) {
          const schemaFromPrefix = !data.from.schema || data.from.schema === "public" ? "" : `${data.from.schema}.`;
          const schemaToPrefix = !data.to.schema || data.to.schema === "public" ? "" : `${data.to.schema}.`;
          console.log(
            `${source_default.yellow("~")} ${schemaFromPrefix}${data.from.name} \u203A ${schemaToPrefix}${data.to.name} ${source_default.gray(
              `${entity} will be renamed/moved`
            )}`
          );
          if (data.from.name !== data.to.name) {
            result.renamed.push(data);
          }
          if (data.from.schema !== data.to.schema) {
            result.moved.push({
              name: data.from.name,
              schemaFrom: data.from.schema || "public",
              schemaTo: data.to.schema || "public"
            });
          }
          delete leftMissing[leftMissing.indexOf(data.from)];
          leftMissing = leftMissing.filter(Boolean);
        } else {
          console.log(
            `${source_default.green("+")} ${data.name} ${source_default.gray(
              `${entity} will be created`
            )}`
          );
          result.created.push(created);
        }
        index7 += 1;
      } while (index7 < newItems.length);
      console.log(source_default.gray(`--- all ${entity} conflicts resolved ---
`));
      result.deleted.push(...leftMissing);
      return result;
    };
    promptSchemasConflict = async (newSchemas, missingSchemas) => {
      if (missingSchemas.length === 0 || newSchemas.length === 0) {
        return { created: newSchemas, renamed: [], deleted: missingSchemas };
      }
      const result = {
        created: [],
        renamed: [],
        deleted: []
      };
      let index7 = 0;
      let leftMissing = [...missingSchemas];
      do {
        const created = newSchemas[index7];
        const renames = leftMissing.map((it2) => {
          return { from: it2, to: created };
        });
        const promptData = [created, ...renames];
        const { status, data } = await (0, import_hanji2.render)(
          new ResolveSchemasSelect(created, promptData)
        );
        if (status === "aborted") {
          console.error("ERROR");
          process.exit(1);
        }
        if (isRenamePromptItem(data)) {
          console.log(
            `${source_default.yellow("~")} ${data.from.name} \u203A ${data.to.name} ${source_default.gray(
              "schema will be renamed"
            )}`
          );
          result.renamed.push(data);
          delete leftMissing[leftMissing.indexOf(data.from)];
          leftMissing = leftMissing.filter(Boolean);
        } else {
          console.log(
            `${source_default.green("+")} ${data.name} ${source_default.gray(
              "schema will be created"
            )}`
          );
          result.created.push(created);
        }
        index7 += 1;
      } while (index7 < newSchemas.length);
      console.log(source_default.gray("--- all schemas conflicts resolved ---\n"));
      result.deleted.push(...leftMissing);
      return result;
    };
    BREAKPOINT = "--> statement-breakpoint\n";
  }
});

// ../node_modules/.pnpm/minimatch@7.4.6/node_modules/minimatch/dist/mjs/brace-expressions.js
var posixClasses, braceEscape, regexpEscape, rangesToString, parseClass;
var init_brace_expressions = __esm({
  "../node_modules/.pnpm/minimatch@7.4.6/node_modules/minimatch/dist/mjs/brace-expressions.js"() {
    "use strict";
    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]
    };
    braceEscape = (s10) => s10.replace(/[[\]\\-]/g, "\\$&");
    regexpEscape = (s10) => s10.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
    rangesToString = (ranges) => ranges.join("");
    parseClass = (glob2, position) => {
      const pos = position;
      if (glob2.charAt(pos) !== "[") {
        throw new Error("not in a brace expression");
      }
      const ranges = [];
      const negs = [];
      let i8 = pos + 1;
      let sawStart = false;
      let uflag = false;
      let escaping = false;
      let negate2 = false;
      let endPos = pos;
      let rangeStart = "";
      WHILE: while (i8 < glob2.length) {
        const c6 = glob2.charAt(i8);
        if ((c6 === "!" || c6 === "^") && i8 === pos + 1) {
          negate2 = true;
          i8++;
          continue;
        }
        if (c6 === "]" && sawStart && !escaping) {
          endPos = i8 + 1;
          break;
        }
        sawStart = true;
        if (c6 === "\\") {
          if (!escaping) {
            escaping = true;
            i8++;
            continue;
          }
        }
        if (c6 === "[" && !escaping) {
          for (const [cls, [unip, u7, neg]] of Object.entries(posixClasses)) {
            if (glob2.startsWith(cls, i8)) {
              if (rangeStart) {
                return ["$.", false, glob2.length - pos, true];
              }
              i8 += cls.length;
              if (neg)
                negs.push(unip);
              else
                ranges.push(unip);
              uflag = uflag || u7;
              continue WHILE;
            }
          }
        }
        escaping = false;
        if (rangeStart) {
          if (c6 > rangeStart) {
            ranges.push(braceEscape(rangeStart) + "-" + braceEscape(c6));
          } else if (c6 === rangeStart) {
            ranges.push(braceEscape(c6));
          }
          rangeStart = "";
          i8++;
          continue;
        }
        if (glob2.startsWith("-]", i8 + 1)) {
          ranges.push(braceEscape(c6 + "-"));
          i8 += 2;
          continue;
        }
        if (glob2.startsWith("-", i8 + 1)) {
          rangeStart = c6;
          i8 += 2;
          continue;
        }
        ranges.push(braceEscape(c6));
        i8++;
      }
      if (endPos < i8) {
        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]) && !negate2) {
        const r6 = ranges[0].length === 2 ? ranges[0].slice(-1) : ranges[0];
        return [regexpEscape(r6), false, endPos - pos, false];
      }
      const sranges = "[" + (negate2 ? "^" : "") + rangesToString(ranges) + "]";
      const snegs = "[" + (negate2 ? "" : "^") + 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.6/node_modules/minimatch/dist/mjs/escape.js
var escape;
var init_escape = __esm({
  "../node_modules/.pnpm/minimatch@7.4.6/node_modules/minimatch/dist/mjs/escape.js"() {
    "use strict";
    escape = (s10, { windowsPathsNoEscape = false } = {}) => {
      return windowsPathsNoEscape ? s10.replace(/[?*()[\]]/g, "[$&]") : s10.replace(/[?*()[\]\\]/g, "\\$&");
    };
  }
});

// ../node_modules/.pnpm/minimatch@7.4.6/node_modules/minimatch/dist/mjs/unescape.js
var unescape2;
var init_unescape = __esm({
  "../node_modules/.pnpm/minimatch@7.4.6/node_modules/minimatch/dist/mjs/unescape.js"() {
    "use strict";
    unescape2 = (s10, { windowsPathsNoEscape = false } = {}) => {
      return windowsPathsNoEscape ? s10.replace(/\[([^\/\\])\]/g, "$1") : s10.replace(/((?!\\).|^)\[([^\/\\])\]/g, "$1$2").replace(/\\([^\/])/g, "$1");
    };
  }
});

// ../node_modules/.pnpm/minimatch@7.4.6/node_modules/minimatch/dist/mjs/index.js
var import_brace_expansion, minimatch, starDotExtRE, starDotExtTest, starDotExtTestDot, starDotExtTestNocase, starDotExtTestNocaseDot, starDotStarRE, starDotStarTest, starDotStarTestDot, dotStarRE, dotStarTest, starRE, starTest, starTestDot, qmarksRE, qmarksTestNocase, qmarksTestNocaseDot, qmarksTestDot, qmarksTest, qmarksTestNoExt, qmarksTestNoExtDot, defaultPlatform, path, sep, GLOBSTAR, plTypes, qmark, star, twoStarDot, twoStarNoDot, charSet, reSpecials, addPatternStartSet, filter, ext, defaults, braceExpand, MAX_PATTERN_LENGTH, assertValidPattern, makeRe, match, globUnescape, globMagic, regExpEscape, Minimatch;
var init_mjs = __esm({
  "../node_modules/.pnpm/minimatch@7.4.6/node_modules/minimatch/dist/mjs/index.js"() {
    "use strict";
    import_brace_expansion = __toESM(require_brace_expansion(), 1);
    init_brace_expressions();
    init_escape();
    init_unescape();
    init_escape();
    init_unescape();
    minimatch = (p11, pattern, options = {}) => {
      assertValidPattern(pattern);
      if (!options.nocomment && pattern.charAt(0) === "#") {
        return false;
      }
      return new Minimatch(pattern, options).match(p11);
    };
    starDotExtRE = /^\*+([^+@!?\*\[\(]*)$/;
    starDotExtTest = (ext2) => (f9) => !f9.startsWith(".") && f9.endsWith(ext2);
    starDotExtTestDot = (ext2) => (f9) => f9.endsWith(ext2);
    starDotExtTestNocase = (ext2) => {
      ext2 = ext2.toLowerCase();
      return (f9) => !f9.startsWith(".") && f9.toLowerCase().endsWith(ext2);
    };
    starDotExtTestNocaseDot = (ext2) => {
      ext2 = ext2.toLowerCase();
      return (f9) => f9.toLowerCase().endsWith(ext2);
    };
    starDotStarRE = /^\*+\.\*+$/;
    starDotStarTest = (f9) => !f9.startsWith(".") && f9.includes(".");
    starDotStarTestDot = (f9) => f9 !== "." && f9 !== ".." && f9.includes(".");
    dotStarRE = /^\.\*+$/;
    dotStarTest = (f9) => f9 !== "." && f9 !== ".." && f9.startsWith(".");
    starRE = /^\*+$/;
    starTest = (f9) => f9.length !== 0 && !f9.startsWith(".");
    starTestDot = (f9) => f9.length !== 0 && f9 !== "." && f9 !== "..";
    qmarksRE = /^\?+([^+@!?\*\[\(]*)?$/;
    qmarksTestNocase = ([$0, ext2 = ""]) => {
      const noext = qmarksTestNoExt([$0]);
      if (!ext2)
        return noext;
      ext2 = ext2.toLowerCase();
      return (f9) => noext(f9) && f9.toLowerCase().endsWith(ext2);
    };
    qmarksTestNocaseDot = ([$0, ext2 = ""]) => {
      const noext = qmarksTestNoExtDot([$0]);
      if (!ext2)
        return noext;
      ext2 = ext2.toLowerCase();
      return (f9) => noext(f9) && f9.toLowerCase().endsWith(ext2);
    };
    qmarksTestDot = ([$0, ext2 = ""]) => {
      const noext = qmarksTestNoExtDot([$0]);
      return !ext2 ? noext : (f9) => noext(f9) && f9.endsWith(ext2);
    };
    qmarksTest = ([$0, ext2 = ""]) => {
      const noext = qmarksTestNoExt([$0]);
      return !ext2 ? noext : (f9) => noext(f9) && f9.endsWith(ext2);
    };
    qmarksTestNoExt = ([$0]) => {
      const len = $0.length;
      return (f9) => f9.length === len && !f9.startsWith(".");
    };
    qmarksTestNoExtDot = ([$0]) => {
      const len = $0.length;
      return (f9) => f9.length === len && f9 !== "." && f9 !== "..";
    };
    defaultPlatform = typeof process === "object" && process ? typeof process.env === "object" && process.env && process.env.__MINIMATCH_TESTING_PLATFORM__ || process.platform : "posix";
    path = {
      win32: { sep: "\\" },
      posix: { sep: "/" }
    };
    sep = defaultPlatform === "win32" ? path.win32.sep : path.posix.sep;
    minimatch.sep = sep;
    GLOBSTAR = Symbol("globstar **");
    minimatch.GLOBSTAR = GLOBSTAR;
    plTypes = {
      "!": { open: "(?:(?!(?:", close: "))[^/]*?)" },
      "?": { open: "(?:", close: ")?" },
      "+": { open: "(?:", close: ")+" },
      "*": { open: "(?:", close: ")*" },
      "@": { open: "(?:", close: ")" }
    };
    qmark = "[^/]";
    star = qmark + "*?";
    twoStarDot = "(?:(?!(?:\\/|^)(?:\\.{1,2})($|\\/)).)*?";
    twoStarNoDot = "(?:(?!(?:\\/|^)\\.).)*?";
    charSet = (s10) => s10.split("").reduce((set, c6) => {
      set[c6] = true;
      return set;
    }, {});
    reSpecials = charSet("().*{}+?[]^$\\!");
    addPatternStartSet = charSet("[.(");
    filter = (pattern, options = {}) => (p11) => minimatch(p11, pattern, options);
    minimatch.filter = filter;
    ext = (a9, b9 = {}) => Object.assign({}, a9, b9);
    defaults = (def) => {
      if (!def || typeof def !== "object" || !Object.keys(def).length) {
        return minimatch;
      }
      const orig = minimatch;
      const m12 = (p11, pattern, options = {}) => orig(p11, pattern, ext(def, options));
      return Object.assign(m12, {
        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: (s10, options = {}) => orig.unescape(s10, ext(def, options)),
        escape: (s10, options = {}) => orig.escape(s10, 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;
    braceExpand = (pattern, options = {}) => {
      assertValidPattern(pattern);
      if (options.nobrace || !/\{(?:(?!\{).)*\}/.test(pattern)) {
        return [pattern];
      }
      return (0, import_brace_expansion.default)(pattern);
    };
    minimatch.braceExpand = braceExpand;
    MAX_PATTERN_LENGTH = 1024 * 64;
    assertValidPattern = (pattern) => {
      if (typeof pattern !== "string") {
        throw new TypeError("invalid pattern");
      }
      if (pattern.length > MAX_PATTERN_LENGTH) {
        throw new TypeError("pattern is too long");
      }
    };
    makeRe = (pattern, options = {}) => new Minimatch(pattern, options).makeRe();
    minimatch.makeRe = makeRe;
    match = (list, pattern, options = {}) => {
      const mm = new Minimatch(pattern, options);
      list = list.filter((f9) => mm.match(f9));
      if (mm.options.nonull && !list.length) {
        list.push(pattern);
      }
      return list;
    };
    minimatch.match = match;
    globUnescape = (s10) => s10.replace(/\\(.)/g, "$1");
    globMagic = /[?*]|[+@!]\(.*?\)|\[|\]/;
    regExpEscape = (s10) => s10.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&");
    Minimatch = class {
      constructor(pattern, options = {}) {
        __publicField(this, "options");
        __publicField(this, "set");
        __publicField(this, "pattern");
        __publicField(this, "windowsPathsNoEscape");
        __publicField(this, "nonegate");
        __publicField(this, "negate");
        __publicField(this, "comment");
        __publicField(this, "empty");
        __publicField(this, "preserveMultipleSlashes");
        __publicField(this, "partial");
        __publicField(this, "globSet");
        __publicField(this, "globParts");
        __publicField(this, "nocase");
        __publicField(this, "isWindows");
        __publicField(this, "platform");
        __publicField(this, "windowsNoMagicRoot");
        __publicField(this, "regexp");
        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(..._7) {
      }
      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 = (...args2) => console.error(...args2);
        }
        this.debug(this.pattern, this.globSet);
        const rawGlobParts = this.globSet.map((s10) => this.slashSplit(s10));
        this.globParts = this.preprocess(rawGlobParts);
        this.debug(this.pattern, this.globParts);
        let set = this.globParts.map((s10, _7, __) => {
          if (this.isWindows && this.windowsNoMagicRoot) {
            const isUNC = s10[0] === "" && s10[1] === "" && (s10[2] === "?" || !globMagic.test(s10[2])) && !globMagic.test(s10[3]);
            const isDrive = /^[a-z]:/i.test(s10[0]);
            if (isUNC) {
              return [...s10.slice(0, 4), ...s10.slice(4).map((ss) => this.parse(ss))];
            } else if (isDrive) {
              return [s10[0], ...s10.slice(1).map((ss) => this.parse(ss))];
            }
          }
          return s10.map((ss) => this.parse(ss));
        });
        this.debug(this.pattern, set);
        this.set = set.filter((s10) => s10.indexOf(false) === -1);
        if (this.isWindows) {
          for (let i8 = 0; i8 < this.set.length; i8++) {
            const p11 = this.set[i8];
            if (p11[0] === "" && p11[1] === "" && this.globParts[i8][2] === "?" && typeof p11[3] === "string" && /^[a-z]:$/i.test(p11[3])) {
              p11[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 i8 = 0; i8 < globParts.length; i8++) {
            for (let j7 = 0; j7 < globParts[i8].length; j7++) {
              if (globParts[i8][j7] === "**") {
                globParts[i8][j7] = "*";
              }
            }
          }
        }
        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((parts2) => {
          let gs3 = -1;
          while (-1 !== (gs3 = parts2.indexOf("**", gs3 + 1))) {
            let i8 = gs3;
            while (parts2[i8 + 1] === "**") {
              i8++;
            }
            if (i8 !== gs3) {
              parts2.splice(gs3, i8 - gs3);
            }
          }
          return parts2;
        });
      }
      // get rid of adjascent ** and resolve .. portions
      levelOneOptimize(globParts) {
        return globParts.map((parts2) => {
          parts2 = parts2.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 parts2.length === 0 ? [""] : parts2;
        });
      }
      levelTwoFileOptimize(parts2) {
        if (!Array.isArray(parts2)) {
          parts2 = this.slashSplit(parts2);
        }
        let didSomething = false;
        do {
          didSomething = false;
          if (!this.preserveMultipleSlashes) {
            for (let i8 = 1; i8 < parts2.length - 1; i8++) {
              const p11 = parts2[i8];
              if (i8 === 1 && p11 === "" && parts2[0] === "")
                continue;
              if (p11 === "." || p11 === "") {
                didSomething = true;
                parts2.splice(i8, 1);
                i8--;
              }
            }
            if (parts2[0] === "." && parts2.length === 2 && (parts2[1] === "." || parts2[1] === "")) {
              didSomething = true;
              parts2.pop();
            }
          }
          let dd = 0;
          while (-1 !== (dd = parts2.indexOf("..", dd + 1))) {
            const p11 = parts2[dd - 1];
            if (p11 && p11 !== "." && p11 !== ".." && p11 !== "**") {
              didSomething = true;
              parts2.splice(dd - 1, 2);
              dd -= 2;
            }
          }
        } while (didSomething);
        return parts2.length === 0 ? [""] : parts2;
      }
      // 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 parts2 of globParts) {
            let gs3 = -1;
            while (-1 !== (gs3 = parts2.indexOf("**", gs3 + 1))) {
              let gss = gs3;
              while (parts2[gss + 1] === "**") {
                gss++;
              }
              if (gss > gs3) {
                parts2.splice(gs3 + 1, gss - gs3);
              }
              let next = parts2[gs3 + 1];
              const p11 = parts2[gs3 + 2];
              const p22 = parts2[gs3 + 3];
              if (next !== "..")
                continue;
              if (!p11 || p11 === "." || p11 === ".." || !p22 || p22 === "." || p22 === "..") {
                continue;
              }
              didSomething = true;
              parts2.splice(gs3, 1);
              const other = parts2.slice(0);
              other[gs3] = "**";
              globParts.push(other);
              gs3--;
            }
            if (!this.preserveMultipleSlashes) {
              for (let i8 = 1; i8 < parts2.length - 1; i8++) {
                const p11 = parts2[i8];
                if (i8 === 1 && p11 === "" && parts2[0] === "")
                  continue;
                if (p11 === "." || p11 === "") {
                  didSomething = true;
                  parts2.splice(i8, 1);
                  i8--;
                }
              }
              if (parts2[0] === "." && parts2.length === 2 && (parts2[1] === "." || parts2[1] === "")) {
                didSomething = true;
                parts2.pop();
              }
            }
            let dd = 0;
            while (-1 !== (dd = parts2.indexOf("..", dd + 1))) {
              const p11 = parts2[dd - 1];
              if (p11 && p11 !== "." && p11 !== ".." && p11 !== "**") {
                didSomething = true;
                const needDot = dd === 1 && parts2[dd + 1] === "**";
                const splin = needDot ? ["."] : [];
                parts2.splice(dd - 1, 2, ...splin);
                if (parts2.length === 0)
                  parts2.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 i8 = 0; i8 < globParts.length - 1; i8++) {
          for (let j7 = i8 + 1; j7 < globParts.length; j7++) {
            const matched = this.partsMatch(globParts[i8], globParts[j7], !this.preserveMultipleSlashes);
            if (!matched)
              continue;
            globParts[i8] = matched;
            globParts[j7] = [];
          }
        }
        return globParts.filter((gs3) => gs3.length);
      }
      partsMatch(a9, b9, emptyGSMatch = false) {
        let ai = 0;
        let bi = 0;
        let result = [];
        let which = "";
        while (ai < a9.length && bi < b9.length) {
          if (a9[ai] === b9[bi]) {
            result.push(which === "b" ? b9[bi] : a9[ai]);
            ai++;
            bi++;
          } else if (emptyGSMatch && a9[ai] === "**" && b9[bi] === a9[ai + 1]) {
            result.push(a9[ai]);
            ai++;
          } else if (emptyGSMatch && b9[bi] === "**" && a9[ai] === b9[bi + 1]) {
            result.push(b9[bi]);
            bi++;
          } else if (a9[ai] === "*" && b9[bi] && (this.options.dot || !b9[bi].startsWith(".")) && b9[bi] !== "**") {
            if (which === "b")
              return false;
            which = "a";
            result.push(a9[ai]);
            ai++;
            bi++;
          } else if (b9[bi] === "*" && a9[ai] && (this.options.dot || !a9[ai].startsWith(".")) && a9[ai] !== "**") {
            if (which === "a")
              return false;
            which = "b";
            result.push(b9[bi]);
            ai++;
            bi++;
          } else {
            return false;
          }
        }
        return a9.length === b9.length && result;
      }
      parseNegate() {
        if (this.nonegate)
          return;
        const pattern = this.pattern;
        let negate2 = false;
        let negateOffset = 0;
        for (let i8 = 0; i8 < pattern.length && pattern.charAt(i8) === "!"; i8++) {
          negate2 = !negate2;
          negateOffset++;
        }
        if (negateOffset)
          this.pattern = pattern.slice(negateOffset);
        this.negate = negate2;
      }
      // 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 fi2 = 0, pi2 = 0, fl = file.length, pl = pattern.length; fi2 < fl && pi2 < pl; fi2++, pi2++) {
          this.debug("matchOne loop");
          var p11 = pattern[pi2];
          var f9 = file[fi2];
          this.debug(pattern, p11, f9);
          if (p11 === false) {
            return false;
          }
          if (p11 === GLOBSTAR) {
            this.debug("GLOBSTAR", [pattern, p11, f9]);
            var fr3 = fi2;
            var pr2 = pi2 + 1;
            if (pr2 === pl) {
              this.debug("** at the end");
              for (; fi2 < fl; fi2++) {
                if (file[fi2] === "." || file[fi2] === ".." || !options.dot && file[fi2].charAt(0) === ".")
                  return false;
              }
              return true;
            }
            while (fr3 < fl) {
              var swallowee = file[fr3];
              this.debug("\nglobstar while", file, fr3, pattern, pr2, swallowee);
              if (this.matchOne(file.slice(fr3), pattern.slice(pr2), partial)) {
                this.debug("globstar found match!", fr3, fl, swallowee);
                return true;
              } else {
                if (swallowee === "." || swallowee === ".." || !options.dot && swallowee.charAt(0) === ".") {
                  this.debug("dot detected!", file, fr3, pattern, pr2);
                  break;
                }
                this.debug("globstar swallow a segment, and continue");
                fr3++;
              }
            }
            if (partial) {
              this.debug("\n>>> no match, partial?", file, fr3, pattern, pr2);
              if (fr3 === fl) {
                return true;
              }
            }
            return false;
          }
          let hit;
          if (typeof p11 === "string") {
            hit = f9 === p11;
            this.debug("string match", p11, f9, hit);
          } else {
            hit = p11.test(f9);
            this.debug("pattern match", p11, f9, hit);
          }
          if (!hit)
            return false;
        }
        if (fi2 === fl && pi2 === pl) {
          return true;
        } else if (fi2 === fl) {
          return partial;
        } else if (pi2 === pl) {
          return fi2 === fl - 1 && file[fi2] === "";
        } 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 m12;
        let fastTest = null;
        if (m12 = pattern.match(starRE)) {
          fastTest = options.dot ? starTestDot : starTest;
        } else if (m12 = pattern.match(starDotExtRE)) {
          fastTest = (options.nocase ? options.dot ? starDotExtTestNocaseDot : starDotExtTestNocase : options.dot ? starDotExtTestDot : starDotExtTest)(m12[1]);
        } else if (m12 = pattern.match(qmarksRE)) {
          fastTest = (options.nocase ? options.dot ? qmarksTestNocaseDot : qmarksTestNocase : options.dot ? qmarksTestDot : qmarksTest)(m12);
        } else if (m12 = pattern.match(starDotStarRE)) {
          fastTest = options.dot ? starDotStarTestDot : starDotStarTest;
        } else if (m12 = pattern.match(dotStarRE)) {
          fastTest = dotStarTest;
        }
        let re3 = "";
        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 = (p11) => p11.charAt(0) === "." ? "" : options.dot ? "(?!(?:^|\\/)\\.{1,2}(?:$|\\/))" : "(?!\\.)";
        const clearStateChar = () => {
          if (stateChar) {
            switch (stateChar) {
              case "*":
                re3 += star;
                hasMagic = true;
                break;
              case "?":
                re3 += qmark;
                hasMagic = true;
                break;
              default:
                re3 += "\\" + stateChar;
                break;
            }
            this.debug("clearStateChar %j %j", stateChar, re3);
            stateChar = false;
          }
        };
        for (let i8 = 0, c6; i8 < pattern.length && (c6 = pattern.charAt(i8)); i8++) {
          this.debug("%s	%s %s %j", pattern, i8, re3, c6);
          if (escaping) {
            if (c6 === "/") {
              return false;
            }
            if (reSpecials[c6]) {
              re3 += "\\";
            }
            re3 += c6;
            escaping = false;
            continue;
          }
          switch (c6) {
            // Should already be path-split by now.
            /* c8 ignore start */
            case "/": {
              return false;
            }
            /* c8 ignore stop */
            case "\\":
              clearStateChar();
              escaping = true;
              continue;
            // the various stateChar values
            // for the "extglob" stuff.
            case "?":
            case "*":
            case "+":
            case "@":
            case "!":
              this.debug("%s	%s %s %j <-- stateChar", pattern, i8, re3, c6);
              this.debug("call clearStateChar %j", stateChar);
              clearStateChar();
              stateChar = c6;
              if (options.noext)
                clearStateChar();
              continue;
            case "(": {
              if (!stateChar) {
                re3 += "\\(";
                continue;
              }
              const plEntry = {
                type: stateChar,
                start: i8 - 1,
                reStart: re3.length,
                open: plTypes[stateChar].open,
                close: plTypes[stateChar].close
              };
              this.debug(this.pattern, "	", plEntry);
              patternListStack.push(plEntry);
              re3 += plEntry.open;
              if (plEntry.start === 0 && plEntry.type !== "!") {
                dotTravAllowed = true;
                re3 += subPatternStart(pattern.slice(i8 + 1));
              }
              this.debug("plType %j %j", stateChar, re3);
              stateChar = false;
              continue;
            }
            case ")": {
              const plEntry = patternListStack[patternListStack.length - 1];
              if (!plEntry) {
                re3 += "\\)";
                continue;
              }
              patternListStack.pop();
              clearStateChar();
              hasMagic = true;
              pl = plEntry;
              re3 += pl.close;
              if (pl.type === "!") {
                negativeLists.push(Object.assign(pl, { reEnd: re3.length }));
              }
              continue;
            }
            case "|": {
              const plEntry = patternListStack[patternListStack.length - 1];
              if (!plEntry) {
                re3 += "\\|";
                continue;
              }
              clearStateChar();
              re3 += "|";
              if (plEntry.start === 0 && plEntry.type !== "!") {
                dotTravAllowed = true;
                re3 += subPatternStart(pattern.slice(i8 + 1));
              }
              continue;
            }
            // these are mostly the same in regexp and glob
            case "[":
              clearStateChar();
              const [src, needUflag, consumed, magic] = parseClass(pattern, i8);
              if (consumed) {
                re3 += src;
                uflag = uflag || needUflag;
                i8 += consumed - 1;
                hasMagic = hasMagic || magic;
              } else {
                re3 += "\\[";
              }
              continue;
            case "]":
              re3 += "\\" + c6;
              continue;
            default:
              clearStateChar();
              re3 += regExpEscape(c6);
              break;
          }
        }
        for (pl = patternListStack.pop(); pl; pl = patternListStack.pop()) {
          let tail;
          tail = re3.slice(pl.reStart + pl.open.length);
          this.debug(this.pattern, "setting tail", re3, pl);
          tail = tail.replace(/((?:\\{2}){0,64})(\\?)\|/g, (_7, $1, $22) => {
            if (!$22) {
              $22 = "\\";
            }
            return $1 + $1 + $22 + "|";
          });
          this.debug("tail=%j\n   %s", tail, tail, pl, re3);
          const t6 = pl.type === "*" ? star : pl.type === "?" ? qmark : "\\" + pl.type;
          hasMagic = true;
          re3 = re3.slice(0, pl.reStart) + t6 + "\\(" + tail;
        }
        clearStateChar();
        if (escaping) {
          re3 += "\\\\";
        }
        const addPatternStart = addPatternStartSet[re3.charAt(0)];
        for (let n7 = negativeLists.length - 1; n7 > -1; n7--) {
          const nl = negativeLists[n7];
          const nlBefore = re3.slice(0, nl.reStart);
          const nlFirst = re3.slice(nl.reStart, nl.reEnd - 8);
          let nlAfter = re3.slice(nl.reEnd);
          const nlLast = re3.slice(nl.reEnd - 8, nl.reEnd) + nlAfter;
          const closeParensBefore = nlBefore.split(")").length;
          const openParensBefore = nlBefore.split("(").length - closeParensBefore;
          let cleanAfter = nlAfter;
          for (let i8 = 0; i8 < openParensBefore; i8++) {
            cleanAfter = cleanAfter.replace(/\)[+*?]?/, "");
          }
          nlAfter = cleanAfter;
          const dollar = nlAfter === "" ? "(?:$|\\/)" : "";
          re3 = nlBefore + nlFirst + nlAfter + dollar + nlLast;
        }
        if (re3 !== "" && hasMagic) {
          re3 = "(?=.)" + re3;
        }
        if (addPatternStart) {
          re3 = patternStart() + re3;
        }
        if (options.nocase && !hasMagic && !options.nocaseMagicOnly) {
          hasMagic = pattern.toUpperCase() !== pattern.toLowerCase();
        }
        if (!hasMagic) {
          return globUnescape(re3);
        }
        const flags2 = (options.nocase ? "i" : "") + (uflag ? "u" : "");
        try {
          const ext2 = fastTest ? {
            _glob: pattern,
            _src: re3,
            test: fastTest
          } : {
            _glob: pattern,
            _src: re3
          };
          return Object.assign(new RegExp("^" + re3 + "$", flags2), ext2);
        } catch (er3) {
          this.debug("invalid regexp", er3);
          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 flags2 = options.nocase ? "i" : "";
        let re3 = set.map((pattern) => {
          const pp = pattern.map((p11) => typeof p11 === "string" ? regExpEscape(p11) : p11 === GLOBSTAR ? GLOBSTAR : p11._src);
          pp.forEach((p11, i8) => {
            const next = pp[i8 + 1];
            const prev = pp[i8 - 1];
            if (p11 !== GLOBSTAR || prev === GLOBSTAR) {
              return;
            }
            if (prev === void 0) {
              if (next !== void 0 && next !== GLOBSTAR) {
                pp[i8 + 1] = "(?:\\/|" + twoStar + "\\/)?" + next;
              } else {
                pp[i8] = twoStar;
              }
            } else if (next === void 0) {
              pp[i8 - 1] = prev + "(?:\\/|" + twoStar + ")?";
            } else if (next !== GLOBSTAR) {
              pp[i8 - 1] = prev + "(?:\\/|\\/" + twoStar + "\\/)" + next;
              pp[i8 + 1] = GLOBSTAR;
            }
          });
          return pp.filter((p11) => p11 !== GLOBSTAR).join("/");
        }).join("|");
        re3 = "^(?:" + re3 + ")$";
        if (this.negate)
          re3 = "^(?!" + re3 + ").*$";
        try {
          this.regexp = new RegExp(re3, flags2);
        } catch (ex) {
          this.regexp = false;
        }
        return this.regexp;
      }
      slashSplit(p11) {
        if (this.preserveMultipleSlashes) {
          return p11.split("/");
        } else if (this.isWindows && /^\/\/[^\/]+/.test(p11)) {
          return ["", ...p11.split(/\/+/)];
        } else {
          return p11.split(/\/+/);
        }
      }
      match(f9, partial = this.partial) {
        this.debug("match", f9, this.pattern);
        if (this.comment) {
          return false;
        }
        if (this.empty) {
          return f9 === "";
        }
        if (f9 === "/" && partial) {
          return true;
        }
        const options = this.options;
        if (this.isWindows) {
          f9 = f9.split("\\").join("/");
        }
        const ff = this.slashSplit(f9);
        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 i8 = ff.length - 2; !filename && i8 >= 0; i8--) {
            filename = ff[i8];
          }
        }
        for (let i8 = 0; i8 < set.length; i8++) {
          const pattern = set[i8];
          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 = unescape2;
  }
});

// src/extensions/vector.ts
var vectorOps;
var init_vector4 = __esm({
  "src/extensions/vector.ts"() {
    "use strict";
    vectorOps = [
      "vector_l2_ops",
      "vector_ip_ops",
      "vector_cosine_ops",
      "vector_l1_ops",
      "bit_hamming_ops",
      "bit_jaccard_ops",
      "halfvec_l2_ops",
      "sparsevec_l2_ops"
    ];
  }
});

// src/serializer/utils.ts
function getColumnCasing(column6, casing2) {
  if (!column6.name) return "";
  return !column6.keyAsName || casing2 === void 0 ? column6.name : casing2 === "camelCase" ? toCamelCase(column6.name) : toSnakeCase(column6.name);
}
var sqlToStr;
var init_utils9 = __esm({
  "src/serializer/utils.ts"() {
    "use strict";
    init_casing();
    sqlToStr = (sql3, casing2) => {
      return sql3.toQuery({
        escapeName: () => {
          throw new Error("we don't support params for `sql` default values");
        },
        escapeParam: () => {
          throw new Error("we don't support params for `sql` default values");
        },
        escapeString: () => {
          throw new Error("we don't support params for `sql` default values");
        },
        casing: new CasingCache(casing2)
      }).sql;
    };
  }
});

// src/serializer/pgSerializer.ts
function stringFromIdentityProperty(field) {
  return typeof field === "string" ? field : typeof field === "undefined" ? void 0 : String(field);
}
function maxRangeForIdentityBasedOn(columnType) {
  return columnType === "integer" ? "2147483647" : columnType === "bigint" ? "9223372036854775807" : "32767";
}
function minRangeForIdentityBasedOn(columnType) {
  return columnType === "integer" ? "-2147483648" : columnType === "bigint" ? "-9223372036854775808" : "-32768";
}
function stringFromDatabaseIdentityProperty(field) {
  return typeof field === "string" ? field : typeof field === "undefined" ? void 0 : typeof field === "bigint" ? field.toString() : String(field);
}
function buildArrayString(array3, sqlType) {
  sqlType = sqlType.split("[")[0];
  const values2 = array3.map((value) => {
    if (typeof value === "number" || typeof value === "bigint") {
      return value.toString();
    } else if (typeof value === "boolean") {
      return value ? "true" : "false";
    } else if (Array.isArray(value)) {
      return buildArrayString(value, sqlType);
    } else if (value instanceof Date) {
      if (sqlType === "date") {
        return `"${value.toISOString().split("T")[0]}"`;
      } else if (sqlType === "timestamp") {
        return `"${value.toISOString().replace("T", " ").slice(0, 23)}"`;
      } else {
        return `"${value.toISOString()}"`;
      }
    } else if (typeof value === "object") {
      return `"${JSON.stringify(value).replaceAll('"', '\\"')}"`;
    }
    return `"${value}"`;
  }).join(",");
  return `{${values2}}`;
}
function prepareRoles(entities) {
  let useRoles = false;
  const includeRoles = [];
  const excludeRoles = [];
  if (entities && entities.roles) {
    if (typeof entities.roles === "object") {
      if (entities.roles.provider) {
        if (entities.roles.provider === "supabase") {
          excludeRoles.push(...[
            "anon",
            "authenticator",
            "authenticated",
            "service_role",
            "supabase_auth_admin",
            "supabase_storage_admin",
            "dashboard_user",
            "supabase_admin"
          ]);
        } else if (entities.roles.provider === "neon") {
          excludeRoles.push(...["authenticated", "anonymous"]);
        }
      }
      if (entities.roles.include) {
        includeRoles.push(...entities.roles.include);
      }
      if (entities.roles.exclude) {
        excludeRoles.push(...entities.roles.exclude);
      }
    } else {
      useRoles = entities.roles;
    }
  }
  return { useRoles, includeRoles, excludeRoles };
}
var indexName, generatePgSnapshot, trimChar, fromDatabase, defaultForColumn, getColumnsInfoQuery;
var init_pgSerializer = __esm({
  "src/serializer/pgSerializer.ts"() {
    "use strict";
    init_source();
    init_dist();
    init_pg_core();
    init_vector4();
    init_outputs();
    init_utils8();
    init_utils9();
    indexName = (tableName, columns) => {
      return `${tableName}_${columns.join("_")}_index`;
    };
    generatePgSnapshot = (tables, enums, schemas, sequences, roles, policies, views, matViews, casing2, schemaFilter) => {
      const dialect6 = new PgDialect({ casing: casing2 });
      const result = {};
      const resultViews = {};
      const sequencesToReturn = {};
      const rolesToReturn = {};
      const policiesToReturn = {};
      const indexesInSchema = {};
      for (const table6 of tables) {
        const checksInTable = {};
        const {
          name: tableName,
          columns,
          indexes,
          foreignKeys,
          checks,
          schema: schema6,
          primaryKeys,
          uniqueConstraints,
          policies: policies2,
          enableRLS
        } = getTableConfig2(table6);
        if (schemaFilter && !schemaFilter.includes(schema6 ?? "public")) {
          continue;
        }
        const columnsObject = {};
        const indexesObject = {};
        const checksObject = {};
        const foreignKeysObject = {};
        const primaryKeysObject = {};
        const uniqueConstraintObject = {};
        const policiesObject = {};
        columns.forEach((column6) => {
          const name3 = getColumnCasing(column6, casing2);
          const notNull = column6.notNull;
          const primaryKey2 = column6.primary;
          const sqlTypeLowered = column6.getSQLType().toLowerCase();
          const getEnumSchema = (column7) => {
            while (is(column7, PgArray)) {
              column7 = column7.baseColumn;
            }
            return is(column7, PgEnumColumn) ? column7.enum.schema || "public" : void 0;
          };
          const typeSchema = getEnumSchema(column6);
          const generated = column6.generated;
          const identity = column6.generatedIdentity;
          const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? "1";
          const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue) ?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column6.columnType) : "1");
          const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue) ?? (parseFloat(increment) < 0 ? "-1" : maxRangeForIdentityBasedOn(column6.getSQLType()));
          const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith) ?? (parseFloat(increment) < 0 ? maxValue : minValue);
          const cache5 = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? "1";
          const columnToSet = {
            name: name3,
            type: column6.getSQLType(),
            typeSchema,
            primaryKey: primaryKey2,
            notNull,
            generated: generated ? {
              as: is(generated.as, SQL) ? dialect6.sqlToQuery(generated.as).sql : typeof generated.as === "function" ? dialect6.sqlToQuery(generated.as()).sql : generated.as,
              type: "stored"
            } : void 0,
            identity: identity ? {
              type: identity.type,
              name: identity.sequenceName ?? `${tableName}_${name3}_seq`,
              schema: schema6 ?? "public",
              increment,
              startWith,
              minValue,
              maxValue,
              cache: cache5,
              cycle: identity?.sequenceOptions?.cycle ?? false
            } : void 0
          };
          if (column6.isUnique) {
            const existingUnique = uniqueConstraintObject[column6.uniqueName];
            if (typeof existingUnique !== "undefined") {
              console.log(
                `
${withStyle.errorWarning(`We've found duplicated unique constraint names in ${source_default.underline.blue(
                  tableName
                )} table. 
          The unique constraint ${source_default.underline.blue(
                  column6.uniqueName
                )} on the ${source_default.underline.blue(
                  name3
                )} column is conflicting with a unique constraint name already defined for ${source_default.underline.blue(
                  existingUnique.columns.join(",")
                )} columns
`)}`
              );
              process.exit(1);
            }
            uniqueConstraintObject[column6.uniqueName] = {
              name: column6.uniqueName,
              nullsNotDistinct: column6.uniqueType === "not distinct",
              columns: [columnToSet.name]
            };
          }
          if (column6.default !== void 0) {
            if (is(column6.default, SQL)) {
              columnToSet.default = sqlToStr(column6.default, casing2);
            } else {
              if (typeof column6.default === "string") {
                columnToSet.default = `'${escapeSingleQuotes(column6.default)}'`;
              } else {
                if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
                  columnToSet.default = `'${JSON.stringify(column6.default)}'::${sqlTypeLowered}`;
                } else if (column6.default instanceof Date) {
                  if (sqlTypeLowered === "date") {
                    columnToSet.default = `'${column6.default.toISOString().split("T")[0]}'`;
                  } else if (sqlTypeLowered === "timestamp") {
                    columnToSet.default = `'${column6.default.toISOString().replace("T", " ").slice(0, 23)}'`;
                  } else {
                    columnToSet.default = `'${column6.default.toISOString()}'`;
                  }
                } else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column6.default)) {
                  columnToSet.default = `'${buildArrayString(column6.default, sqlTypeLowered)}'`;
                } else {
                  columnToSet.default = column6.default;
                }
              }
            }
          }
          columnsObject[name3] = columnToSet;
        });
        primaryKeys.map((pk) => {
          const originalColumnNames = pk.columns.map((c6) => c6.name);
          const columnNames = pk.columns.map((c6) => getColumnCasing(c6, casing2));
          let name3 = pk.getName();
          if (casing2 !== void 0) {
            for (let i8 = 0; i8 < originalColumnNames.length; i8++) {
              name3 = name3.replace(originalColumnNames[i8], columnNames[i8]);
            }
          }
          primaryKeysObject[name3] = {
            name: name3,
            columns: columnNames
          };
        });
        uniqueConstraints?.map((unq) => {
          const columnNames = unq.columns.map((c6) => getColumnCasing(c6, casing2));
          const name3 = unq.name ?? uniqueKeyName(table6, columnNames);
          const existingUnique = uniqueConstraintObject[name3];
          if (typeof existingUnique !== "undefined") {
            console.log(
              `
${withStyle.errorWarning(
                `We've found duplicated unique constraint names in ${source_default.underline.blue(tableName)} table. 
        The unique constraint ${source_default.underline.blue(name3)} on the ${source_default.underline.blue(
                  columnNames.join(",")
                )} columns is confilcting with a unique constraint name already defined for ${source_default.underline.blue(existingUnique.columns.join(","))} columns
`
              )}`
            );
            process.exit(1);
          }
          uniqueConstraintObject[name3] = {
            name: unq.name,
            nullsNotDistinct: unq.nullsNotDistinct,
            columns: columnNames
          };
        });
        const fks = foreignKeys.map((fk5) => {
          const tableFrom = tableName;
          const onDelete = fk5.onDelete;
          const onUpdate = fk5.onUpdate;
          const reference = fk5.reference();
          const tableTo = getTableName(reference.foreignTable);
          const schemaTo = getTableConfig2(reference.foreignTable).schema;
          const originalColumnsFrom = reference.columns.map((it2) => it2.name);
          const columnsFrom = reference.columns.map((it2) => getColumnCasing(it2, casing2));
          const originalColumnsTo = reference.foreignColumns.map((it2) => it2.name);
          const columnsTo = reference.foreignColumns.map((it2) => getColumnCasing(it2, casing2));
          let name3 = fk5.getName();
          if (casing2 !== void 0) {
            for (let i8 = 0; i8 < originalColumnsFrom.length; i8++) {
              name3 = name3.replace(originalColumnsFrom[i8], columnsFrom[i8]);
            }
            for (let i8 = 0; i8 < originalColumnsTo.length; i8++) {
              name3 = name3.replace(originalColumnsTo[i8], columnsTo[i8]);
            }
          }
          return {
            name: name3,
            tableFrom,
            tableTo,
            schemaTo,
            columnsFrom,
            columnsTo,
            onDelete,
            onUpdate
          };
        });
        fks.forEach((it2) => {
          foreignKeysObject[it2.name] = it2;
        });
        indexes.forEach((value) => {
          const columns2 = value.config.columns;
          let indexColumnNames = [];
          columns2.forEach((it2) => {
            if (is(it2, SQL)) {
              if (typeof value.config.name === "undefined") {
                console.log(
                  `
${withStyle.errorWarning(
                    `Please specify an index name in ${getTableName(value.config.table)} table that has "${dialect6.sqlToQuery(it2).sql}" expression. We can generate index names for indexes on columns only; for expressions in indexes, you need to specify the name yourself.`
                  )}`
                );
                process.exit(1);
              }
            }
            it2 = it2;
            const name4 = getColumnCasing(it2, casing2);
            if (!is(it2, SQL) && it2.type === "PgVector" && typeof it2.indexConfig.opClass === "undefined") {
              console.log(
                `
${withStyle.errorWarning(
                  `You are specifying an index on the ${source_default.blueBright(
                    name4
                  )} column inside the ${source_default.blueBright(
                    tableName
                  )} table with the ${source_default.blueBright(
                    "vector"
                  )} type without specifying an operator class. Vector extension doesn't have a default operator class, so you need to specify one of the available options. Here is a list of available op classes for the vector extension: [${vectorOps.map((it3) => `${source_default.underline(`${it3}`)}`).join(", ")}].

You can specify it using current syntax: ${source_default.underline(
                    `index("${value.config.name}").using("${value.config.method}", table.${name4}.op("${vectorOps[0]}"))`
                  )}

You can check the "pg_vector" docs for more info: https://github.com/pgvector/pgvector?tab=readme-ov-file#indexing
`
                )}`
              );
              process.exit(1);
            }
            indexColumnNames.push(name4);
          });
          const name3 = value.config.name ? value.config.name : indexName(tableName, indexColumnNames);
          let indexColumns = columns2.map(
            (it2) => {
              if (is(it2, SQL)) {
                return {
                  expression: dialect6.sqlToQuery(it2, "indexes").sql,
                  asc: true,
                  isExpression: true,
                  nulls: "last"
                };
              } else {
                it2 = it2;
                return {
                  expression: getColumnCasing(it2, casing2),
                  isExpression: false,
                  asc: it2.indexConfig?.order === "asc",
                  nulls: it2.indexConfig?.nulls ? it2.indexConfig?.nulls : it2.indexConfig?.order === "desc" ? "first" : "last",
                  opclass: it2.indexConfig?.opClass
                };
              }
            }
          );
          if (typeof indexesInSchema[schema6 ?? "public"] !== "undefined") {
            if (indexesInSchema[schema6 ?? "public"].includes(name3)) {
              console.log(
                `
${withStyle.errorWarning(
                  `We've found duplicated index name across ${source_default.underline.blue(schema6 ?? "public")} schema. Please rename your index in either the ${source_default.underline.blue(
                    tableName
                  )} table or the table with the duplicated index name`
                )}`
              );
              process.exit(1);
            }
            indexesInSchema[schema6 ?? "public"].push(name3);
          } else {
            indexesInSchema[schema6 ?? "public"] = [name3];
          }
          indexesObject[name3] = {
            name: name3,
            columns: indexColumns,
            isUnique: value.config.unique ?? false,
            where: value.config.where ? dialect6.sqlToQuery(value.config.where).sql : void 0,
            concurrently: value.config.concurrently ?? false,
            method: value.config.method ?? "btree",
            with: value.config.with ?? {}
          };
        });
        policies2.forEach((policy5) => {
          const mappedTo = [];
          if (!policy5.to) {
            mappedTo.push("public");
          } else {
            if (policy5.to && typeof policy5.to === "string") {
              mappedTo.push(policy5.to);
            } else if (policy5.to && is(policy5.to, PgRole)) {
              mappedTo.push(policy5.to.name);
            } else if (policy5.to && Array.isArray(policy5.to)) {
              policy5.to.forEach((it2) => {
                if (typeof it2 === "string") {
                  mappedTo.push(it2);
                } else if (is(it2, PgRole)) {
                  mappedTo.push(it2.name);
                }
              });
            }
          }
          if (policiesObject[policy5.name] !== void 0) {
            console.log(
              `
${withStyle.errorWarning(
                `We've found duplicated policy name across ${source_default.underline.blue(tableKey2)} table. Please rename one of the policies with ${source_default.underline.blue(
                  policy5.name
                )} name`
              )}`
            );
            process.exit(1);
          }
          policiesObject[policy5.name] = {
            name: policy5.name,
            as: policy5.as?.toUpperCase() ?? "PERMISSIVE",
            for: policy5.for?.toUpperCase() ?? "ALL",
            to: mappedTo.sort(),
            using: is(policy5.using, SQL) ? dialect6.sqlToQuery(policy5.using).sql : void 0,
            withCheck: is(policy5.withCheck, SQL) ? dialect6.sqlToQuery(policy5.withCheck).sql : void 0
          };
        });
        checks.forEach((check2) => {
          const checkName = check2.name;
          if (typeof checksInTable[`"${schema6 ?? "public"}"."${tableName}"`] !== "undefined") {
            if (checksInTable[`"${schema6 ?? "public"}"."${tableName}"`].includes(check2.name)) {
              console.log(
                `
${withStyle.errorWarning(
                  `We've found duplicated check constraint name across ${source_default.underline.blue(
                    schema6 ?? "public"
                  )} schema in ${source_default.underline.blue(
                    tableName
                  )}. Please rename your check constraint in either the ${source_default.underline.blue(
                    tableName
                  )} table or the table with the duplicated check contraint name`
                )}`
              );
              process.exit(1);
            }
            checksInTable[`"${schema6 ?? "public"}"."${tableName}"`].push(checkName);
          } else {
            checksInTable[`"${schema6 ?? "public"}"."${tableName}"`] = [check2.name];
          }
          checksObject[checkName] = {
            name: checkName,
            value: dialect6.sqlToQuery(check2.value).sql
          };
        });
        const tableKey2 = `${schema6 ?? "public"}.${tableName}`;
        result[tableKey2] = {
          name: tableName,
          schema: schema6 ?? "",
          columns: columnsObject,
          indexes: indexesObject,
          foreignKeys: foreignKeysObject,
          compositePrimaryKeys: primaryKeysObject,
          uniqueConstraints: uniqueConstraintObject,
          policies: policiesObject,
          checkConstraints: checksObject,
          isRLSEnabled: enableRLS
        };
      }
      for (const policy5 of policies) {
        if (!policy5._linkedTable) {
          console.log(
            `
${withStyle.errorWarning(
              `"Policy ${policy5.name} was skipped because it was not linked to any table. You should either include the policy in a table or use .link() on the policy to link it to any table you have. For more information, please check:`
            )}`
          );
          continue;
        }
        const tableConfig = getTableConfig2(policy5._linkedTable);
        const tableKey2 = `${tableConfig.schema ?? "public"}.${tableConfig.name}`;
        const mappedTo = [];
        if (!policy5.to) {
          mappedTo.push("public");
        } else {
          if (policy5.to && typeof policy5.to === "string") {
            mappedTo.push(policy5.to);
          } else if (policy5.to && is(policy5.to, PgRole)) {
            mappedTo.push(policy5.to.name);
          } else if (policy5.to && Array.isArray(policy5.to)) {
            policy5.to.forEach((it2) => {
              if (typeof it2 === "string") {
                mappedTo.push(it2);
              } else if (is(it2, PgRole)) {
                mappedTo.push(it2.name);
              }
            });
          }
        }
        if (result[tableKey2]?.policies[policy5.name] !== void 0 || policiesToReturn[policy5.name] !== void 0) {
          console.log(
            `
${withStyle.errorWarning(
              `We've found duplicated policy name across ${source_default.underline.blue(tableKey2)} table. Please rename one of the policies with ${source_default.underline.blue(
                policy5.name
              )} name`
            )}`
          );
          process.exit(1);
        }
        const mappedPolicy = {
          name: policy5.name,
          as: policy5.as?.toUpperCase() ?? "PERMISSIVE",
          for: policy5.for?.toUpperCase() ?? "ALL",
          to: mappedTo.sort(),
          using: is(policy5.using, SQL) ? dialect6.sqlToQuery(policy5.using).sql : void 0,
          withCheck: is(policy5.withCheck, SQL) ? dialect6.sqlToQuery(policy5.withCheck).sql : void 0
        };
        if (result[tableKey2]) {
          result[tableKey2].policies[policy5.name] = mappedPolicy;
        } else {
          policiesToReturn[policy5.name] = {
            ...mappedPolicy,
            schema: tableConfig.schema ?? "public",
            on: `"${tableConfig.schema ?? "public"}"."${tableConfig.name}"`
          };
        }
      }
      for (const sequence of sequences) {
        const name3 = sequence.seqName;
        if (typeof sequencesToReturn[`${sequence.schema ?? "public"}.${name3}`] === "undefined") {
          const increment = stringFromIdentityProperty(sequence?.seqOptions?.increment) ?? "1";
          const minValue = stringFromIdentityProperty(sequence?.seqOptions?.minValue) ?? (parseFloat(increment) < 0 ? "-9223372036854775808" : "1");
          const maxValue = stringFromIdentityProperty(sequence?.seqOptions?.maxValue) ?? (parseFloat(increment) < 0 ? "-1" : "9223372036854775807");
          const startWith = stringFromIdentityProperty(sequence?.seqOptions?.startWith) ?? (parseFloat(increment) < 0 ? maxValue : minValue);
          const cache5 = stringFromIdentityProperty(sequence?.seqOptions?.cache) ?? "1";
          sequencesToReturn[`${sequence.schema ?? "public"}.${name3}`] = {
            name: name3,
            schema: sequence.schema ?? "public",
            increment,
            startWith,
            minValue,
            maxValue,
            cache: cache5,
            cycle: sequence.seqOptions?.cycle ?? false
          };
        } else {
        }
      }
      for (const role of roles) {
        if (!role._existing) {
          rolesToReturn[role.name] = {
            name: role.name,
            createDb: role.createDb === void 0 ? false : role.createDb,
            createRole: role.createRole === void 0 ? false : role.createRole,
            inherit: role.inherit === void 0 ? true : role.inherit
          };
        }
      }
      const combinedViews = [...views, ...matViews];
      for (const view5 of combinedViews) {
        let viewName;
        let schema6;
        let query;
        let selectedFields;
        let isExisting;
        let withOption;
        let tablespace;
        let using;
        let withNoData;
        let materialized = false;
        if (is(view5, PgView)) {
          ({ name: viewName, schema: schema6, query, selectedFields, isExisting, with: withOption } = getViewConfig2(view5));
        } else {
          ({ name: viewName, schema: schema6, query, selectedFields, isExisting, with: withOption, tablespace, using, withNoData } = getMaterializedViewConfig(view5));
          materialized = true;
        }
        const viewSchema = schema6 ?? "public";
        const viewKey = `${viewSchema}.${viewName}`;
        const columnsObject = {};
        const uniqueConstraintObject = {};
        const existingView = resultViews[viewKey];
        if (typeof existingView !== "undefined") {
          console.log(
            `
${withStyle.errorWarning(
              `We've found duplicated view name across ${source_default.underline.blue(schema6 ?? "public")} schema. Please rename your view`
            )}`
          );
          process.exit(1);
        }
        for (const key in selectedFields) {
          if (is(selectedFields[key], PgColumn)) {
            const column6 = selectedFields[key];
            const notNull = column6.notNull;
            const primaryKey2 = column6.primary;
            const sqlTypeLowered = column6.getSQLType().toLowerCase();
            const typeSchema = is(column6, PgEnumColumn) ? column6.enum.schema || "public" : void 0;
            const generated = column6.generated;
            const identity = column6.generatedIdentity;
            const increment = stringFromIdentityProperty(identity?.sequenceOptions?.increment) ?? "1";
            const minValue = stringFromIdentityProperty(identity?.sequenceOptions?.minValue) ?? (parseFloat(increment) < 0 ? minRangeForIdentityBasedOn(column6.columnType) : "1");
            const maxValue = stringFromIdentityProperty(identity?.sequenceOptions?.maxValue) ?? (parseFloat(increment) < 0 ? "-1" : maxRangeForIdentityBasedOn(column6.getSQLType()));
            const startWith = stringFromIdentityProperty(identity?.sequenceOptions?.startWith) ?? (parseFloat(increment) < 0 ? maxValue : minValue);
            const cache5 = stringFromIdentityProperty(identity?.sequenceOptions?.cache) ?? "1";
            const columnToSet = {
              name: column6.name,
              type: column6.getSQLType(),
              typeSchema,
              primaryKey: primaryKey2,
              notNull,
              generated: generated ? {
                as: is(generated.as, SQL) ? dialect6.sqlToQuery(generated.as).sql : typeof generated.as === "function" ? dialect6.sqlToQuery(generated.as()).sql : generated.as,
                type: "stored"
              } : void 0,
              identity: identity ? {
                type: identity.type,
                name: identity.sequenceName ?? `${viewName}_${column6.name}_seq`,
                schema: schema6 ?? "public",
                increment,
                startWith,
                minValue,
                maxValue,
                cache: cache5,
                cycle: identity?.sequenceOptions?.cycle ?? false
              } : void 0
            };
            if (column6.isUnique) {
              const existingUnique = uniqueConstraintObject[column6.uniqueName];
              if (typeof existingUnique !== "undefined") {
                console.log(
                  `
${withStyle.errorWarning(
                    `We've found duplicated unique constraint names in ${source_default.underline.blue(viewName)} table. 
          The unique constraint ${source_default.underline.blue(column6.uniqueName)} on the ${source_default.underline.blue(
                      column6.name
                    )} column is confilcting with a unique constraint name already defined for ${source_default.underline.blue(existingUnique.columns.join(","))} columns
`
                  )}`
                );
                process.exit(1);
              }
              uniqueConstraintObject[column6.uniqueName] = {
                name: column6.uniqueName,
                nullsNotDistinct: column6.uniqueType === "not distinct",
                columns: [columnToSet.name]
              };
            }
            if (column6.default !== void 0) {
              if (is(column6.default, SQL)) {
                columnToSet.default = sqlToStr(column6.default, casing2);
              } else {
                if (typeof column6.default === "string") {
                  columnToSet.default = `'${column6.default}'`;
                } else {
                  if (sqlTypeLowered === "jsonb" || sqlTypeLowered === "json") {
                    columnToSet.default = `'${JSON.stringify(column6.default)}'::${sqlTypeLowered}`;
                  } else if (column6.default instanceof Date) {
                    if (sqlTypeLowered === "date") {
                      columnToSet.default = `'${column6.default.toISOString().split("T")[0]}'`;
                    } else if (sqlTypeLowered === "timestamp") {
                      columnToSet.default = `'${column6.default.toISOString().replace("T", " ").slice(0, 23)}'`;
                    } else {
                      columnToSet.default = `'${column6.default.toISOString()}'`;
                    }
                  } else if (isPgArrayType(sqlTypeLowered) && Array.isArray(column6.default)) {
                    columnToSet.default = `'${buildArrayString(column6.default, sqlTypeLowered)}'`;
                  } else {
                    columnToSet.default = column6.default;
                  }
                }
              }
            }
            columnsObject[column6.name] = columnToSet;
          }
        }
        resultViews[viewKey] = {
          columns: columnsObject,
          definition: isExisting ? void 0 : dialect6.sqlToQuery(query).sql,
          name: viewName,
          schema: viewSchema,
          isExisting,
          with: withOption,
          withNoData,
          materialized,
          tablespace,
          using
        };
      }
      const enumsToReturn = enums.reduce((map2, obj) => {
        const enumSchema4 = obj.schema || "public";
        const key = `${enumSchema4}.${obj.enumName}`;
        map2[key] = {
          name: obj.enumName,
          schema: enumSchema4,
          values: obj.enumValues
        };
        return map2;
      }, {});
      const schemasObject = Object.fromEntries(
        schemas.filter((it2) => {
          if (schemaFilter) {
            return schemaFilter.includes(it2.schemaName) && it2.schemaName !== "public";
          } else {
            return it2.schemaName !== "public";
          }
        }).map((it2) => [it2.schemaName, it2.schemaName])
      );
      return {
        version: "7",
        dialect: "postgresql",
        tables: result,
        enums: enumsToReturn,
        schemas: schemasObject,
        sequences: sequencesToReturn,
        roles: rolesToReturn,
        policies: policiesToReturn,
        views: resultViews,
        _meta: {
          schemas: {},
          tables: {},
          columns: {}
        }
      };
    };
    trimChar = (str, char4) => {
      let start2 = 0;
      let end = str.length;
      while (start2 < end && str[start2] === char4) ++start2;
      while (end > start2 && str[end - 1] === char4) --end;
      return start2 > 0 || end < str.length ? str.substring(start2, end) : str.toString();
    };
    fromDatabase = async (db2, tablesFilter = () => true, schemaFilters, entities, progressCallback, tsSchema) => {
      const result = {};
      const views = {};
      const policies = {};
      const internals = { tables: {} };
      const where = schemaFilters.map((t6) => `n.nspname = '${t6}'`).join(" or ");
      const allTables = await db2.query(
        `SELECT 
    n.nspname AS table_schema, 
    c.relname AS table_name, 
    CASE 
        WHEN c.relkind = 'r' THEN 'table'
        WHEN c.relkind = 'v' THEN 'view'
        WHEN c.relkind = 'm' THEN 'materialized_view'
    END AS type,
	c.relrowsecurity AS rls_enabled
FROM 
    pg_catalog.pg_class c
JOIN 
    pg_catalog.pg_namespace n ON n.oid = c.relnamespace
WHERE 
	c.relkind IN ('r', 'v', 'm') 
    ${where === "" ? "" : ` AND ${where}`};`
      );
      const schemas = new Set(allTables.map((it2) => it2.table_schema));
      schemas.delete("public");
      const allSchemas = await db2.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;
      let checksCount = 0;
      let viewsCount = 0;
      const sequencesToReturn = {};
      const seqWhere = schemaFilters.map((t6) => `schemaname = '${t6}'`).join(" or ");
      const allSequences = await db2.query(
        `select schemaname, sequencename, start_value, min_value, max_value, increment_by, cycle, cache_size from pg_sequences as seq${seqWhere === "" ? "" : ` WHERE ${seqWhere}`};`
      );
      for (const dbSeq of allSequences) {
        const schemaName = dbSeq.schemaname;
        const sequenceName = dbSeq.sequencename;
        const startValue = stringFromDatabaseIdentityProperty(dbSeq.start_value);
        const minValue = stringFromDatabaseIdentityProperty(dbSeq.min_value);
        const maxValue = stringFromDatabaseIdentityProperty(dbSeq.max_value);
        const incrementBy = stringFromDatabaseIdentityProperty(dbSeq.increment_by);
        const cycle = dbSeq.cycle;
        const cacheSize = stringFromDatabaseIdentityProperty(dbSeq.cache_size);
        const key = `${schemaName}.${sequenceName}`;
        sequencesToReturn[key] = {
          name: sequenceName,
          schema: schemaName,
          startWith: startValue,
          minValue,
          maxValue,
          increment: incrementBy,
          cycle,
          cache: cacheSize
        };
      }
      const whereEnums = schemaFilters.map((t6) => `n.nspname = '${t6}'`).join(" or ");
      const allEnums = await db2.query(
        `select n.nspname as enum_schema,
  t.typname as enum_name,
  e.enumlabel as enum_value,
  e.enumsortorder as sort_order
  from pg_type t
  join pg_enum e on t.oid = e.enumtypid
  join pg_catalog.pg_namespace n ON n.oid = t.typnamespace
  ${whereEnums === "" ? "" : ` WHERE ${whereEnums}`}
  order by enum_schema, enum_name, sort_order;`
      );
      const enumsToReturn = {};
      for (const dbEnum of allEnums) {
        const enumName = dbEnum.enum_name;
        const enumValue = dbEnum.enum_value;
        const enumSchema4 = dbEnum.enum_schema || "public";
        const key = `${enumSchema4}.${enumName}`;
        if (enumsToReturn[key] !== void 0 && enumsToReturn[key] !== null) {
          enumsToReturn[key].values.push(enumValue);
        } else {
          enumsToReturn[key] = {
            name: enumName,
            values: [enumValue],
            schema: enumSchema4
          };
        }
      }
      if (progressCallback) {
        progressCallback("enums", Object.keys(enumsToReturn).length, "done");
      }
      const allRoles = await db2.query(
        `SELECT rolname, rolinherit, rolcreatedb, rolcreaterole FROM pg_roles;`
      );
      const rolesToReturn = {};
      const preparedRoles = prepareRoles(entities);
      if (preparedRoles.useRoles || !(preparedRoles.includeRoles.length === 0 && preparedRoles.excludeRoles.length === 0)) {
        for (const dbRole of allRoles) {
          if (preparedRoles.useRoles) {
            rolesToReturn[dbRole.rolname] = {
              createDb: dbRole.rolcreatedb,
              createRole: dbRole.rolcreatedb,
              inherit: dbRole.rolinherit,
              name: dbRole.rolname
            };
          } else {
            if (preparedRoles.includeRoles.length === 0 && preparedRoles.excludeRoles.length === 0) continue;
            if (preparedRoles.includeRoles.includes(dbRole.rolname) && preparedRoles.excludeRoles.includes(dbRole.rolname)) continue;
            if (preparedRoles.excludeRoles.includes(dbRole.rolname)) continue;
            if (!preparedRoles.includeRoles.includes(dbRole.rolname)) continue;
            rolesToReturn[dbRole.rolname] = {
              createDb: dbRole.rolcreatedb,
              createRole: dbRole.rolcreaterole,
              inherit: dbRole.rolinherit,
              name: dbRole.rolname
            };
          }
        }
      }
      const schemasForLinkedPoliciesInSchema = Object.values(tsSchema?.policies ?? {}).map((it2) => it2.schema);
      const wherePolicies = [...schemaFilters, ...schemasForLinkedPoliciesInSchema].map((t6) => `schemaname = '${t6}'`).join(" or ");
      const policiesByTable = {};
      const allPolicies = await db2.query(`SELECT schemaname, tablename, policyname as name, permissive as "as", roles as to, cmd as for, qual as using, with_check as "withCheck" FROM pg_policies${wherePolicies === "" ? "" : ` WHERE ${wherePolicies}`};`);
      for (const dbPolicy of allPolicies) {
        const { tablename, schemaname, to: to3, withCheck, using, ...rest } = dbPolicy;
        const tableForPolicy = policiesByTable[`${schemaname}.${tablename}`];
        const parsedTo = typeof to3 === "string" ? to3.slice(1, -1).split(",") : to3;
        const parsedWithCheck = withCheck === null ? void 0 : withCheck;
        const parsedUsing = using === null ? void 0 : using;
        if (tableForPolicy) {
          tableForPolicy[dbPolicy.name] = { ...rest, to: parsedTo };
        } else {
          policiesByTable[`${schemaname}.${tablename}`] = {
            [dbPolicy.name]: { ...rest, to: parsedTo, withCheck: parsedWithCheck, using: parsedUsing }
          };
        }
        if (tsSchema?.policies[dbPolicy.name]) {
          policies[dbPolicy.name] = {
            ...rest,
            to: parsedTo,
            withCheck: parsedWithCheck,
            using: parsedUsing,
            on: tsSchema?.policies[dbPolicy.name].on
          };
        }
      }
      if (progressCallback) {
        progressCallback(
          "policies",
          Object.values(policiesByTable).reduce((total, innerRecord) => {
            return total + Object.keys(innerRecord).length;
          }, 0),
          "done"
        );
      }
      const sequencesInColumns = [];
      const all = allTables.filter((it2) => it2.type === "table").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 checkConstraints = {};
            const tableResponse = await getColumnsInfoQuery({ schema: tableSchema, table: tableName, db: db2 });
            const tableConstraints = await db2.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}';`
            );
            const tableChecks = await db2.query(`SELECT 
						tc.constraint_name,
						tc.constraint_type,
						pg_get_constraintdef(con.oid) AS constraint_definition
					FROM 
						information_schema.table_constraints AS tc
						JOIN pg_constraint AS con 
							ON tc.constraint_name = con.conname
							AND con.conrelid = (
								SELECT oid 
								FROM pg_class 
								WHERE relname = tc.table_name 
								AND relnamespace = (
									SELECT oid 
									FROM pg_namespace 
									WHERE nspname = tc.constraint_schema
								)
							)
					WHERE 
						tc.table_name = '${tableName}'
						AND tc.constraint_schema = '${tableSchema}'
						AND tc.constraint_type = 'CHECK';`);
            columnsCount += tableResponse.length;
            if (progressCallback) {
              progressCallback("columns", columnsCount, "fetching");
            }
            const tableForeignKeys = await db2.query(
              `SELECT
            con.contype AS constraint_type,
            nsp.nspname AS constraint_schema,
            con.conname AS constraint_name,
            rel.relname AS table_name,
            att.attname AS column_name,
            fnsp.nspname AS foreign_table_schema,
            frel.relname AS foreign_table_name,
            fatt.attname AS foreign_column_name,
            CASE con.confupdtype
              WHEN 'a' THEN 'NO ACTION'
              WHEN 'r' THEN 'RESTRICT'
              WHEN 'n' THEN 'SET NULL'
              WHEN 'c' THEN 'CASCADE'
              WHEN 'd' THEN 'SET DEFAULT'
            END AS update_rule,
            CASE con.confdeltype
              WHEN 'a' THEN 'NO ACTION'
              WHEN 'r' THEN 'RESTRICT'
              WHEN 'n' THEN 'SET NULL'
              WHEN 'c' THEN 'CASCADE'
              WHEN 'd' THEN 'SET DEFAULT'
            END AS delete_rule
          FROM
            pg_catalog.pg_constraint con
            JOIN pg_catalog.pg_class rel ON rel.oid = con.conrelid
            JOIN pg_catalog.pg_namespace nsp ON nsp.oid = con.connamespace
            LEFT JOIN pg_catalog.pg_attribute att ON att.attnum = ANY (con.conkey)
              AND att.attrelid = con.conrelid
            LEFT JOIN pg_catalog.pg_class frel ON frel.oid = con.confrelid
            LEFT JOIN pg_catalog.pg_namespace fnsp ON fnsp.oid = frel.relnamespace
            LEFT JOIN pg_catalog.pg_attribute fatt ON fatt.attnum = ANY (con.confkey)
              AND fatt.attrelid = con.confrelid
          WHERE
            nsp.nspname = '${tableSchema}'
            AND rel.relname = '${tableName}'
            AND con.contype IN ('f');`
            );
            foreignKeysCount += tableForeignKeys.length;
            if (progressCallback) {
              progressCallback("fks", foreignKeysCount, "fetching");
            }
            for (const fk5 of tableForeignKeys) {
              const columnFrom = fk5.column_name;
              const tableTo = fk5.foreign_table_name;
              const columnTo = fk5.foreign_column_name;
              const schemaTo = fk5.foreign_table_schema;
              const foreignKeyName = fk5.constraint_name;
              const onUpdate = fk5.update_rule?.toLowerCase();
              const onDelete = fk5.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,
                  schemaTo,
                  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
                };
              }
            }
            checksCount += tableChecks.length;
            if (progressCallback) {
              progressCallback("checks", checksCount, "fetching");
            }
            for (const checks of tableChecks) {
              let checkValue = checks.constraint_definition;
              const constraintName = checks.constraint_name;
              checkValue = checkValue.replace(/^CHECK\s*\(\(/, "").replace(/\)\)\s*$/, "");
              checkConstraints[constraintName] = {
                name: constraintName,
                value: checkValue
              };
            }
            for (const columnResponse of tableResponse) {
              const columnName = columnResponse.column_name;
              const columnAdditionalDT = columnResponse.additional_dt;
              const columnDimensions = columnResponse.array_dimensions;
              const enumType2 = columnResponse.enum_name;
              let columnType = columnResponse.data_type;
              const typeSchema = columnResponse.type_schema;
              const defaultValueRes = columnResponse.column_default;
              const isGenerated = columnResponse.is_generated === "ALWAYS";
              const generationExpression = columnResponse.generation_expression;
              const isIdentity = columnResponse.is_identity === "YES";
              const identityGeneration = columnResponse.identity_generation === "ALWAYS" ? "always" : "byDefault";
              const identityStart = columnResponse.identity_start;
              const identityIncrement = columnResponse.identity_increment;
              const identityMaximum = columnResponse.identity_maximum;
              const identityMinimum = columnResponse.identity_minimum;
              const identityCycle = columnResponse.identity_cycle === "YES";
              const identityName = columnResponse.seq_name;
              const primaryKey2 = 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 db2.query(
                  `SELECT conname AS primary_key
            FROM   pg_constraint join pg_class on (pg_class.oid = conrelid)
            WHERE  contype = 'p' 
            AND    connamespace = $1::regnamespace  
            AND    pg_class.relname = $2;`,
                  [tableSchema, tableName]
                );
                primaryKeys[tableCompositePkName[0].primary_key] = {
                  name: tableCompositePkName[0].primary_key,
                  columns: cprimaryKey.map((c6) => c6.column_name)
                };
              }
              let columnTypeMapped = columnType;
              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)
                    };
                  }
                }
              }
              const defaultValue = defaultForColumn(columnResponse, internals, tableName);
              if (defaultValue === "NULL" || defaultValueRes && defaultValueRes.startsWith("(") && defaultValueRes.endsWith(")")) {
                if (typeof internals.tables[tableName] === "undefined") {
                  internals.tables[tableName] = {
                    columns: {
                      [columnName]: {
                        isDefaultAnExpression: true
                      }
                    }
                  };
                } else {
                  if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
                    internals.tables[tableName].columns[columnName] = {
                      isDefaultAnExpression: true
                    };
                  } else {
                    internals.tables[tableName].columns[columnName].isDefaultAnExpression = true;
                  }
                }
              }
              const isSerial = columnType === "serial";
              if (columnTypeMapped.startsWith("numeric(")) {
                columnTypeMapped = columnTypeMapped.replace(",", ", ");
              }
              if (columnAdditionalDT === "ARRAY") {
                for (let i8 = 1; i8 < Number(columnDimensions); i8++) {
                  columnTypeMapped += "[]";
                }
              }
              columnTypeMapped = columnTypeMapped.replace("character varying", "varchar").replace(" without time zone", "").replace("character", "char");
              columnTypeMapped = trimChar(columnTypeMapped, '"');
              columnToReturn[columnName] = {
                name: columnName,
                type: (
                  // filter vectors, but in future we should filter any extension that was installed by user
                  columnAdditionalDT === "USER-DEFINED" && !["vector", "geometry", "halfvec", "sparsevec", "bit"].includes(enumType2) ? enumType2 : columnTypeMapped
                ),
                typeSchema: enumsToReturn[`${typeSchema}.${enumType2}`] !== void 0 ? enumsToReturn[`${typeSchema}.${enumType2}`].schema : void 0,
                primaryKey: primaryKey2.length === 1 && cprimaryKey.length < 2,
                // default: isSerial ? undefined : defaultValue,
                notNull: columnResponse.is_nullable === "NO",
                generated: isGenerated ? { as: generationExpression, type: "stored" } : void 0,
                identity: isIdentity ? {
                  type: identityGeneration,
                  name: identityName,
                  increment: stringFromDatabaseIdentityProperty(identityIncrement),
                  minValue: stringFromDatabaseIdentityProperty(identityMinimum),
                  maxValue: stringFromDatabaseIdentityProperty(identityMaximum),
                  startWith: stringFromDatabaseIdentityProperty(identityStart),
                  cache: sequencesToReturn[identityName]?.cache ? sequencesToReturn[identityName]?.cache : sequencesToReturn[`${tableSchema}.${identityName}`]?.cache ? sequencesToReturn[`${tableSchema}.${identityName}`]?.cache : void 0,
                  cycle: identityCycle,
                  schema: tableSchema
                } : void 0
              };
              if (identityName && typeof identityName === "string") {
                delete sequencesToReturn[`${tableSchema}.${identityName.startsWith('"') && identityName.endsWith('"') ? identityName.slice(1, -1) : identityName}`];
                delete sequencesToReturn[identityName];
              }
              if (!isSerial && typeof defaultValue !== "undefined") {
                columnToReturn[columnName].default = defaultValue;
              }
            }
            const dbIndexes = await db2.query(
              `SELECT  DISTINCT ON (t.relname, ic.relname, k.i) t.relname as table_name, ic.relname AS indexname,
        k.i AS index_order,
        i.indisunique as is_unique,
        am.amname as method,
        ic.reloptions as with,
        coalesce(a.attname, pg_get_indexdef(i.indexrelid, k.i, false)) AS column_name,
          CASE
        WHEN pg_get_expr(i.indexprs, i.indrelid) IS NOT NULL THEN 1
        ELSE 0
    END AS is_expression,
        i.indoption[k.i-1] & 1 = 1 AS descending,
        i.indoption[k.i-1] & 2 = 2 AS nulls_first,
        pg_get_expr(
                              i.indpred,
                              i.indrelid
                          ) as where,
         opc.opcname
      FROM pg_class t
          LEFT JOIN pg_index i ON t.oid = i.indrelid
          LEFT JOIN pg_class ic ON ic.oid = i.indexrelid
		  CROSS JOIN LATERAL (SELECT unnest(i.indkey), generate_subscripts(i.indkey, 1) + 1) AS k(attnum, i)
          LEFT JOIN pg_attribute AS a
            ON i.indrelid = a.attrelid AND k.attnum = a.attnum
          JOIN pg_namespace c on c.oid = t.relnamespace
        LEFT JOIN pg_am AS am ON ic.relam = am.oid
        JOIN pg_opclass opc ON opc.oid = ANY(i.indclass)
      WHERE
      c.nspname = '${tableSchema}' AND
      t.relname = '${tableName}';`
            );
            const dbIndexFromConstraint = await db2.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((it2) => it2.generated_by_constraint === 1).map(
              (it2) => it2.index_name
            );
            for (const dbIndex of dbIndexes) {
              const indexName2 = dbIndex.indexname;
              const indexColumnName = dbIndex.column_name;
              const indexIsUnique = dbIndex.is_unique;
              const indexMethod = dbIndex.method;
              const indexWith = dbIndex.with;
              const indexWhere = dbIndex.where;
              const opclass = dbIndex.opcname;
              const isExpression = dbIndex.is_expression === 1;
              const desc2 = dbIndex.descending;
              const nullsFirst = dbIndex.nulls_first;
              const mappedWith = {};
              if (indexWith !== null) {
                indexWith.forEach((it2) => {
                  const splitted = it2.split("=");
                  mappedWith[splitted[0]] = splitted[1];
                });
              }
              if (idxsInConsteraint.includes(indexName2)) continue;
              if (typeof indexToReturn[indexName2] !== "undefined") {
                indexToReturn[indexName2].columns.push({
                  expression: indexColumnName,
                  asc: !desc2,
                  nulls: nullsFirst ? "first" : "last",
                  opclass,
                  isExpression
                });
              } else {
                indexToReturn[indexName2] = {
                  name: indexName2,
                  columns: [
                    {
                      expression: indexColumnName,
                      asc: !desc2,
                      nulls: nullsFirst ? "first" : "last",
                      opclass,
                      isExpression
                    }
                  ],
                  isUnique: indexIsUnique,
                  // should not be a part of diff detects
                  concurrently: false,
                  method: indexMethod,
                  where: indexWhere === null ? void 0 : indexWhere,
                  with: mappedWith
                };
              }
            }
            indexesCount += Object.keys(indexToReturn).length;
            if (progressCallback) {
              progressCallback("indexes", indexesCount, "fetching");
            }
            result[`${tableSchema}.${tableName}`] = {
              name: tableName,
              schema: tableSchema !== "public" ? tableSchema : "",
              columns: columnToReturn,
              indexes: indexToReturn,
              foreignKeys: foreignKeysToReturn,
              compositePrimaryKeys: primaryKeys,
              uniqueConstraints: uniqueConstrains,
              checkConstraints,
              policies: policiesByTable[`${tableSchema}.${tableName}`] ?? {},
              isRLSEnabled: row.rls_enabled
            };
          } catch (e6) {
            rej(e6);
            return;
          }
          res("");
        });
      });
      if (progressCallback) {
        progressCallback("tables", tableCount, "done");
      }
      for await (const _7 of all) {
      }
      const allViews = allTables.filter((it2) => it2.type === "view" || it2.type === "materialized_view").map((row) => {
        return new Promise(async (res, rej) => {
          const viewName = row.table_name;
          if (!tablesFilter(viewName)) return res("");
          tableCount += 1;
          const viewSchema = row.table_schema;
          try {
            const columnToReturn = {};
            const viewResponses = await getColumnsInfoQuery({ schema: viewSchema, table: viewName, db: db2 });
            for (const viewResponse of viewResponses) {
              const columnName = viewResponse.column_name;
              const columnAdditionalDT = viewResponse.additional_dt;
              const columnDimensions = viewResponse.array_dimensions;
              const enumType2 = viewResponse.enum_name;
              let columnType = viewResponse.data_type;
              const typeSchema = viewResponse.type_schema;
              const isGenerated = viewResponse.is_generated === "ALWAYS";
              const generationExpression = viewResponse.generation_expression;
              const isIdentity = viewResponse.is_identity === "YES";
              const identityGeneration = viewResponse.identity_generation === "ALWAYS" ? "always" : "byDefault";
              const identityStart = viewResponse.identity_start;
              const identityIncrement = viewResponse.identity_increment;
              const identityMaximum = viewResponse.identity_maximum;
              const identityMinimum = viewResponse.identity_minimum;
              const identityCycle = viewResponse.identity_cycle === "YES";
              const identityName = viewResponse.seq_name;
              const defaultValueRes = viewResponse.column_default;
              const primaryKey2 = viewResponse.constraint_type === "PRIMARY KEY";
              let columnTypeMapped = columnType;
              if (columnAdditionalDT === "ARRAY") {
                if (typeof internals.tables[viewName] === "undefined") {
                  internals.tables[viewName] = {
                    columns: {
                      [columnName]: {
                        isArray: true,
                        dimensions: columnDimensions,
                        rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2)
                      }
                    }
                  };
                } else {
                  if (typeof internals.tables[viewName].columns[columnName] === "undefined") {
                    internals.tables[viewName].columns[columnName] = {
                      isArray: true,
                      dimensions: columnDimensions,
                      rawType: columnTypeMapped.substring(0, columnTypeMapped.length - 2)
                    };
                  }
                }
              }
              const defaultValue = defaultForColumn(viewResponse, internals, viewName);
              if (defaultValue === "NULL" || defaultValueRes && defaultValueRes.startsWith("(") && defaultValueRes.endsWith(")")) {
                if (typeof internals.tables[viewName] === "undefined") {
                  internals.tables[viewName] = {
                    columns: {
                      [columnName]: {
                        isDefaultAnExpression: true
                      }
                    }
                  };
                } else {
                  if (typeof internals.tables[viewName].columns[columnName] === "undefined") {
                    internals.tables[viewName].columns[columnName] = {
                      isDefaultAnExpression: true
                    };
                  } else {
                    internals.tables[viewName].columns[columnName].isDefaultAnExpression = true;
                  }
                }
              }
              const isSerial = columnType === "serial";
              if (columnTypeMapped.startsWith("numeric(")) {
                columnTypeMapped = columnTypeMapped.replace(",", ", ");
              }
              if (columnAdditionalDT === "ARRAY") {
                for (let i8 = 1; i8 < Number(columnDimensions); i8++) {
                  columnTypeMapped += "[]";
                }
              }
              columnTypeMapped = columnTypeMapped.replace("character varying", "varchar").replace(" without time zone", "").replace("character", "char");
              columnTypeMapped = trimChar(columnTypeMapped, '"');
              columnToReturn[columnName] = {
                name: columnName,
                type: (
                  // filter vectors, but in future we should filter any extension that was installed by user
                  columnAdditionalDT === "USER-DEFINED" && !["vector", "geometry", "halfvec", "sparsevec", "bit"].includes(enumType2) ? enumType2 : columnTypeMapped
                ),
                typeSchema: enumsToReturn[`${typeSchema}.${enumType2}`] !== void 0 ? enumsToReturn[`${typeSchema}.${enumType2}`].schema : void 0,
                primaryKey: primaryKey2,
                notNull: viewResponse.is_nullable === "NO",
                generated: isGenerated ? { as: generationExpression, type: "stored" } : void 0,
                identity: isIdentity ? {
                  type: identityGeneration,
                  name: identityName,
                  increment: stringFromDatabaseIdentityProperty(identityIncrement),
                  minValue: stringFromDatabaseIdentityProperty(identityMinimum),
                  maxValue: stringFromDatabaseIdentityProperty(identityMaximum),
                  startWith: stringFromDatabaseIdentityProperty(identityStart),
                  cache: sequencesToReturn[identityName]?.cache ? sequencesToReturn[identityName]?.cache : sequencesToReturn[`${viewSchema}.${identityName}`]?.cache ? sequencesToReturn[`${viewSchema}.${identityName}`]?.cache : void 0,
                  cycle: identityCycle,
                  schema: viewSchema
                } : void 0
              };
              if (identityName) {
                delete sequencesToReturn[`${viewSchema}.${identityName.startsWith('"') && identityName.endsWith('"') ? identityName.slice(1, -1) : identityName}`];
                delete sequencesToReturn[identityName];
              }
              if (!isSerial && typeof defaultValue !== "undefined") {
                columnToReturn[columnName].default = defaultValue;
              }
            }
            const [viewInfo] = await db2.query(`
					SELECT
    c.relname AS view_name,
    n.nspname AS schema_name,
    pg_get_viewdef(c.oid, true) AS definition,
    ts.spcname AS tablespace_name,
    c.reloptions AS options,
    pg_tablespace_location(ts.oid) AS location
FROM
    pg_class c
JOIN
    pg_namespace n ON c.relnamespace = n.oid
LEFT JOIN
    pg_tablespace ts ON c.reltablespace = ts.oid 
WHERE
    (c.relkind = 'm' OR c.relkind = 'v')
    AND n.nspname = '${viewSchema}'
    AND c.relname = '${viewName}';`);
            const resultWith = {};
            if (viewInfo.options) {
              viewInfo.options.forEach((pair) => {
                const splitted = pair.split("=");
                const key = splitted[0];
                const value = splitted[1];
                if (value === "true") {
                  resultWith[key] = true;
                } else if (value === "false") {
                  resultWith[key] = false;
                } else if (!isNaN(Number(value))) {
                  resultWith[key] = Number(value);
                } else {
                  resultWith[key] = value;
                }
              });
            }
            const definition = viewInfo.definition.replace(/\s+/g, " ").replace(";", "").trim();
            const withOption = Object.values(resultWith).length ? Object.fromEntries(Object.entries(resultWith).map(([key, value]) => [key.camelCase(), value])) : void 0;
            const materialized = row.type === "materialized_view";
            views[`${viewSchema}.${viewName}`] = {
              name: viewName,
              schema: viewSchema,
              columns: columnToReturn,
              isExisting: false,
              definition,
              materialized,
              with: withOption,
              tablespace: viewInfo.tablespace_name ?? void 0
            };
          } catch (e6) {
            rej(e6);
            return;
          }
          res("");
        });
      });
      viewsCount = allViews.length;
      for await (const _7 of allViews) {
      }
      if (progressCallback) {
        progressCallback("columns", columnsCount, "done");
        progressCallback("indexes", indexesCount, "done");
        progressCallback("fks", foreignKeysCount, "done");
        progressCallback("checks", checksCount, "done");
        progressCallback("views", viewsCount, "done");
      }
      const schemasObject = Object.fromEntries([...schemas].map((it2) => [it2, it2]));
      return {
        version: "7",
        dialect: "postgresql",
        tables: result,
        enums: enumsToReturn,
        schemas: schemasObject,
        sequences: sequencesToReturn,
        roles: rolesToReturn,
        policies,
        views,
        _meta: {
          schemas: {},
          tables: {},
          columns: {}
        },
        internal: internals
      };
    };
    defaultForColumn = (column6, internals, tableName) => {
      const columnName = column6.column_name;
      const isArray = internals?.tables[tableName]?.columns[columnName]?.isArray ?? false;
      if (column6.column_default === null || column6.column_default === void 0 || column6.data_type === "serial" || column6.data_type === "smallserial" || column6.data_type === "bigserial") {
        return void 0;
      }
      if (column6.column_default.endsWith("[]")) {
        column6.column_default = column6.column_default.slice(0, -2);
      }
      column6.column_default = column6.column_default.replace(/::(.*?)(?<![^\w"])(?=$)/, "");
      const columnDefaultAsString = column6.column_default.toString();
      if (isArray) {
        return `'{${columnDefaultAsString.slice(2, -2).split(/\s*,\s*/g).map((value) => {
          if (["integer", "smallint", "bigint", "double precision", "real"].includes(column6.data_type.slice(0, -2))) {
            return value;
          } else if (column6.data_type.startsWith("timestamp")) {
            return `${value}`;
          } else if (column6.data_type.slice(0, -2) === "interval") {
            return value.replaceAll('"', `"`);
          } else if (column6.data_type.slice(0, -2) === "boolean") {
            return value === "t" ? "true" : "false";
          } else if (["json", "jsonb"].includes(column6.data_type.slice(0, -2))) {
            return JSON.stringify(JSON.stringify(JSON.parse(JSON.parse(value)), null, 0));
          } else {
            return `"${value}"`;
          }
        }).join(",")}}'`;
      }
      if (["integer", "smallint", "bigint", "double precision", "real"].includes(column6.data_type)) {
        if (/^-?[\d.]+(?:e-?\d+)?$/.test(columnDefaultAsString)) {
          return Number(columnDefaultAsString);
        } else {
          if (typeof internals.tables[tableName] === "undefined") {
            internals.tables[tableName] = {
              columns: {
                [columnName]: {
                  isDefaultAnExpression: true
                }
              }
            };
          } else {
            if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
              internals.tables[tableName].columns[columnName] = {
                isDefaultAnExpression: true
              };
            } else {
              internals.tables[tableName].columns[columnName].isDefaultAnExpression = true;
            }
          }
          return columnDefaultAsString;
        }
      } else if (column6.data_type.includes("numeric")) {
        return columnDefaultAsString.includes("'") ? columnDefaultAsString : `'${columnDefaultAsString}'`;
      } else if (column6.data_type === "json" || column6.data_type === "jsonb") {
        const jsonWithoutSpaces = JSON.stringify(JSON.parse(columnDefaultAsString.slice(1, -1)));
        return `'${jsonWithoutSpaces}'::${column6.data_type}`;
      } else if (column6.data_type === "boolean") {
        return column6.column_default === "true";
      } else if (columnDefaultAsString === "NULL") {
        return `NULL`;
      } else if (columnDefaultAsString.startsWith("'") && columnDefaultAsString.endsWith("'")) {
        return columnDefaultAsString;
      } else {
        return `${columnDefaultAsString.replace(/\\/g, "`\\")}`;
      }
    };
    getColumnsInfoQuery = ({ schema: schema6, table: table6, db: db2 }) => {
      return db2.query(
        `SELECT 
    a.attrelid::regclass::text AS table_name,  -- Table, view, or materialized view name
    a.attname AS column_name,   -- Column name
    CASE 
        WHEN NOT a.attisdropped THEN 
            CASE 
                WHEN a.attnotnull THEN 'NO'
                ELSE 'YES'
            END 
        ELSE NULL 
    END AS is_nullable,  -- NULL or NOT NULL constraint
    a.attndims AS array_dimensions,  -- 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,  -- Column data type
--    ns.nspname AS type_schema,  -- Schema name
    pg_get_serial_sequence('"${schema6}"."${table6}"', a.attname)::regclass AS seq_name,  -- Serial sequence (if any)
    c.column_default,  -- Column default value
    c.data_type AS additional_dt,  -- Data type from information_schema
    c.udt_name AS enum_name,  -- Enum type (if applicable)
    c.is_generated,  -- Is it a generated column?
    c.generation_expression,  -- Generation expression (if generated)
    c.is_identity,  -- Is it an identity column?
    c.identity_generation,  -- Identity generation strategy (ALWAYS or BY DEFAULT)
    c.identity_start,  -- Start value of identity column
    c.identity_increment,  -- Increment for identity column
    c.identity_maximum,  -- Maximum value for identity column
    c.identity_minimum,  -- Minimum value for identity column
    c.identity_cycle,  -- Does the identity column cycle?
    enum_ns.nspname AS type_schema  -- Schema of the enum type
FROM 
    pg_attribute a
JOIN 
    pg_class cls ON cls.oid = a.attrelid  -- Join pg_class to get table/view/materialized view info
JOIN 
    pg_namespace ns ON ns.oid = cls.relnamespace  -- Join namespace to get schema info
LEFT JOIN 
    information_schema.columns c ON c.column_name = a.attname 
        AND c.table_schema = ns.nspname 
        AND c.table_name = cls.relname  -- Match schema and table/view name
LEFT JOIN 
    pg_type enum_t ON enum_t.oid = a.atttypid  -- Join to get the type info
LEFT JOIN 
    pg_namespace enum_ns ON enum_ns.oid = enum_t.typnamespace  -- Join to get the enum schema
WHERE 
    a.attnum > 0  -- Valid column numbers only
    AND NOT a.attisdropped  -- Skip dropped columns
    AND cls.relkind IN ('r', 'v', 'm')  -- Include regular tables ('r'), views ('v'), and materialized views ('m')
    AND ns.nspname = '${schema6}'  -- Filter by schema
    AND cls.relname = '${table6}'  -- Filter by table name
ORDER BY 
    a.attnum;  -- Order by column number`
      );
    };
  }
});

// src/cli/selector-ui.ts
var import_hanji4, Select;
var init_selector_ui = __esm({
  "src/cli/selector-ui.ts"() {
    "use strict";
    init_source();
    import_hanji4 = __toESM(require_hanji());
    Select = class extends import_hanji4.Prompt {
      constructor(items) {
        super();
        this.on("attach", (terminal) => terminal.toggleCursor("hide"));
        this.on("detach", (terminal) => terminal.toggleCursor("show"));
        this.data = new import_hanji4.SelectState(
          items.map((it2) => ({ label: it2, value: `${it2}-value` }))
        );
        this.data.bind(this);
      }
      render(status) {
        if (status === "submitted" || status === "aborted") return "";
        let text5 = ``;
        this.data.items.forEach((it2, idx) => {
          text5 += idx === this.data.selectedIdx ? `${source_default.green("\u276F " + it2.label)}` : `  ${it2.label}`;
          text5 += idx != this.data.items.length - 1 ? "\n" : "";
        });
        return text5;
      }
      result() {
        return {
          index: this.data.selectedIdx,
          value: this.data.items[this.data.selectedIdx].value
        };
      }
    };
  }
});

// src/serializer/sqliteSerializer.ts
function mapSqlToSqliteType(sqlType) {
  const lowered = sqlType.toLowerCase();
  if ([
    "int",
    "integer",
    "integer auto_increment",
    "tinyint",
    "smallint",
    "mediumint",
    "bigint",
    "unsigned big int",
    "int2",
    "int8"
  ].some((it2) => lowered.startsWith(it2))) {
    return "integer";
  } else if ([
    "character",
    "varchar",
    "varying character",
    "national varying character",
    "nchar",
    "native character",
    "nvarchar",
    "text",
    "clob"
  ].some((it2) => lowered.startsWith(it2))) {
    const match2 = lowered.match(/\d+/);
    if (match2) {
      return `text(${match2[0]})`;
    }
    return "text";
  } else if (lowered.startsWith("blob")) {
    return "blob";
  } else if (["real", "double", "double precision", "float"].some((it2) => lowered.startsWith(it2))) {
    return "real";
  } else {
    return "numeric";
  }
}
function extractGeneratedColumns(input) {
  const columns = {};
  const lines = input.split(/,\s*(?![^()]*\))/);
  for (const line2 of lines) {
    if (line2.includes("GENERATED ALWAYS AS")) {
      const parts2 = line2.trim().split(/\s+/);
      const columnName = parts2[0].replace(/[`'"]/g, "");
      const expression = line2.substring(line2.indexOf("("), line2.indexOf(")") + 1).trim();
      const typeIndex = parts2.findIndex((part) => part.match(/(stored|virtual)/i));
      let type = "virtual";
      if (typeIndex !== -1) {
        type = parts2[typeIndex].replace(/[^a-z]/gi, "").toLowerCase();
      }
      columns[columnName] = {
        columnName,
        expression,
        type
      };
    }
  }
  return columns;
}
function filterIgnoredTablesByField(fieldName) {
  return `${fieldName} != '__drizzle_migrations'
			AND ${fieldName} NOT LIKE '\\_cf\\_%' ESCAPE '\\'
			AND ${fieldName} NOT LIKE '\\_litestream\\_%' ESCAPE '\\'
			AND ${fieldName} NOT LIKE 'libsql\\_%' ESCAPE '\\'
			AND ${fieldName} NOT LIKE 'sqlite\\_%' ESCAPE '\\'`;
}
var generateSqliteSnapshot, fromDatabase2;
var init_sqliteSerializer = __esm({
  "src/serializer/sqliteSerializer.ts"() {
    "use strict";
    init_source();
    init_dist();
    init_sqlite_core();
    init_outputs();
    init_utils8();
    init_utils9();
    generateSqliteSnapshot = (tables, views, casing2) => {
      const dialect6 = new SQLiteSyncDialect({ casing: casing2 });
      const result = {};
      const resultViews = {};
      const internal = { indexes: {} };
      for (const table6 of tables) {
        const columnsObject = {};
        const indexesObject = {};
        const foreignKeysObject = {};
        const primaryKeysObject = {};
        const uniqueConstraintObject = {};
        const checkConstraintObject = {};
        const checksInTable = {};
        const {
          name: tableName,
          columns,
          indexes,
          checks,
          foreignKeys: tableForeignKeys,
          primaryKeys,
          uniqueConstraints
        } = getTableConfig4(table6);
        columns.forEach((column6) => {
          const name3 = getColumnCasing(column6, casing2);
          const notNull = column6.notNull;
          const primaryKey2 = column6.primary;
          const generated = column6.generated;
          const columnToSet = {
            name: name3,
            type: column6.getSQLType(),
            primaryKey: primaryKey2,
            notNull,
            autoincrement: is(column6, SQLiteBaseInteger) ? column6.autoIncrement : false,
            generated: generated ? {
              as: is(generated.as, SQL) ? `(${dialect6.sqlToQuery(generated.as, "indexes").sql})` : typeof generated.as === "function" ? `(${dialect6.sqlToQuery(generated.as(), "indexes").sql})` : `(${generated.as})`,
              type: generated.mode ?? "virtual"
            } : void 0
          };
          if (column6.default !== void 0) {
            if (is(column6.default, SQL)) {
              columnToSet.default = sqlToStr(column6.default, casing2);
            } else {
              columnToSet.default = typeof column6.default === "string" ? `'${escapeSingleQuotes(column6.default)}'` : typeof column6.default === "object" || Array.isArray(column6.default) ? `'${JSON.stringify(column6.default)}'` : column6.default;
            }
          }
          columnsObject[name3] = columnToSet;
          if (column6.isUnique) {
            const existingUnique = indexesObject[column6.uniqueName];
            if (typeof existingUnique !== "undefined") {
              console.log(
                `
${withStyle.errorWarning(`We've found duplicated unique constraint names in ${source_default.underline.blue(
                  tableName
                )} table. 
          The unique constraint ${source_default.underline.blue(
                  column6.uniqueName
                )} on the ${source_default.underline.blue(
                  name3
                )} column is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                  existingUnique.columns.join(",")
                )} columns
`)}`
              );
              process.exit(1);
            }
            indexesObject[column6.uniqueName] = {
              name: column6.uniqueName,
              columns: [columnToSet.name],
              isUnique: true
            };
          }
        });
        const foreignKeys = tableForeignKeys.map((fk5) => {
          const tableFrom = tableName;
          const onDelete = fk5.onDelete ?? "no action";
          const onUpdate = fk5.onUpdate ?? "no action";
          const reference = fk5.reference();
          const referenceFT = reference.foreignTable;
          const tableTo = getTableName(referenceFT);
          const originalColumnsFrom = reference.columns.map((it2) => it2.name);
          const columnsFrom = reference.columns.map((it2) => getColumnCasing(it2, casing2));
          const originalColumnsTo = reference.foreignColumns.map((it2) => it2.name);
          const columnsTo = reference.foreignColumns.map((it2) => getColumnCasing(it2, casing2));
          let name3 = fk5.getName();
          if (casing2 !== void 0) {
            for (let i8 = 0; i8 < originalColumnsFrom.length; i8++) {
              name3 = name3.replace(originalColumnsFrom[i8], columnsFrom[i8]);
            }
            for (let i8 = 0; i8 < originalColumnsTo.length; i8++) {
              name3 = name3.replace(originalColumnsTo[i8], columnsTo[i8]);
            }
          }
          return {
            name: name3,
            tableFrom,
            tableTo,
            columnsFrom,
            columnsTo,
            onDelete,
            onUpdate
          };
        });
        foreignKeys.forEach((it2) => {
          foreignKeysObject[it2.name] = it2;
        });
        indexes.forEach((value) => {
          const columns2 = value.config.columns;
          const name3 = value.config.name;
          let indexColumns = columns2.map((it2) => {
            if (is(it2, SQL)) {
              const sql3 = dialect6.sqlToQuery(it2, "indexes").sql;
              if (typeof internal.indexes[name3] === "undefined") {
                internal.indexes[name3] = {
                  columns: {
                    [sql3]: {
                      isExpression: true
                    }
                  }
                };
              } else {
                if (typeof internal.indexes[name3]?.columns[sql3] === "undefined") {
                  internal.indexes[name3].columns[sql3] = {
                    isExpression: true
                  };
                } else {
                  internal.indexes[name3].columns[sql3].isExpression = true;
                }
              }
              return sql3;
            } else {
              return getColumnCasing(it2, casing2);
            }
          });
          let where = void 0;
          if (value.config.where !== void 0) {
            if (is(value.config.where, SQL)) {
              where = dialect6.sqlToQuery(value.config.where).sql;
            }
          }
          indexesObject[name3] = {
            name: name3,
            columns: indexColumns,
            isUnique: value.config.unique ?? false,
            where
          };
        });
        uniqueConstraints?.map((unq) => {
          const columnNames = unq.columns.map((c6) => getColumnCasing(c6, casing2));
          const name3 = unq.name ?? uniqueKeyName4(table6, columnNames);
          const existingUnique = indexesObject[name3];
          if (typeof existingUnique !== "undefined") {
            console.log(
              `
${withStyle.errorWarning(
                `We've found duplicated unique constraint names in ${source_default.underline.blue(
                  tableName
                )} table. 
The unique constraint ${source_default.underline.blue(
                  name3
                )} on the ${source_default.underline.blue(
                  columnNames.join(",")
                )} columns is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                  existingUnique.columns.join(",")
                )} columns
`
              )}`
            );
            process.exit(1);
          }
          indexesObject[name3] = {
            name: unq.name,
            columns: columnNames,
            isUnique: true
          };
        });
        primaryKeys.forEach((it2) => {
          if (it2.columns.length > 1) {
            const originalColumnNames = it2.columns.map((c6) => c6.name);
            const columnNames = it2.columns.map((c6) => getColumnCasing(c6, casing2));
            let name3 = it2.getName();
            if (casing2 !== void 0) {
              for (let i8 = 0; i8 < originalColumnNames.length; i8++) {
                name3 = name3.replace(originalColumnNames[i8], columnNames[i8]);
              }
            }
            primaryKeysObject[name3] = {
              columns: columnNames,
              name: name3
            };
          } else {
            columnsObject[getColumnCasing(it2.columns[0], casing2)].primaryKey = true;
          }
        });
        checks.forEach((check2) => {
          const checkName = check2.name;
          if (typeof checksInTable[tableName] !== "undefined") {
            if (checksInTable[tableName].includes(check2.name)) {
              console.log(
                `
${withStyle.errorWarning(
                  `We've found duplicated check constraint name in ${source_default.underline.blue(
                    tableName
                  )}. Please rename your check constraint in the ${source_default.underline.blue(
                    tableName
                  )} table`
                )}`
              );
              process.exit(1);
            }
            checksInTable[tableName].push(checkName);
          } else {
            checksInTable[tableName] = [check2.name];
          }
          checkConstraintObject[checkName] = {
            name: checkName,
            value: dialect6.sqlToQuery(check2.value).sql
          };
        });
        result[tableName] = {
          name: tableName,
          columns: columnsObject,
          indexes: indexesObject,
          foreignKeys: foreignKeysObject,
          compositePrimaryKeys: primaryKeysObject,
          uniqueConstraints: uniqueConstraintObject,
          checkConstraints: checkConstraintObject
        };
      }
      for (const view5 of views) {
        const { name: name3, isExisting, selectedFields, query, schema: schema6 } = getViewConfig3(view5);
        const columnsObject = {};
        const existingView = resultViews[name3];
        if (typeof existingView !== "undefined") {
          console.log(
            `
${withStyle.errorWarning(
              `We've found duplicated view name across ${source_default.underline.blue(
                schema6 ?? "public"
              )} schema. Please rename your view`
            )}`
          );
          process.exit(1);
        }
        for (const key in selectedFields) {
          if (is(selectedFields[key], SQLiteColumn)) {
            const column6 = selectedFields[key];
            const notNull = column6.notNull;
            const primaryKey2 = column6.primary;
            const generated = column6.generated;
            const columnToSet = {
              name: column6.name,
              type: column6.getSQLType(),
              primaryKey: primaryKey2,
              notNull,
              autoincrement: is(column6, SQLiteBaseInteger) ? column6.autoIncrement : false,
              generated: generated ? {
                as: is(generated.as, SQL) ? `(${dialect6.sqlToQuery(generated.as, "indexes").sql})` : typeof generated.as === "function" ? `(${dialect6.sqlToQuery(generated.as(), "indexes").sql})` : `(${generated.as})`,
                type: generated.mode ?? "virtual"
              } : void 0
            };
            if (column6.default !== void 0) {
              if (is(column6.default, SQL)) {
                columnToSet.default = sqlToStr(column6.default, casing2);
              } else {
                columnToSet.default = typeof column6.default === "string" ? `'${column6.default}'` : typeof column6.default === "object" || Array.isArray(column6.default) ? `'${JSON.stringify(column6.default)}'` : column6.default;
              }
            }
            columnsObject[column6.name] = columnToSet;
          }
        }
        resultViews[name3] = {
          columns: columnsObject,
          name: name3,
          isExisting,
          definition: isExisting ? void 0 : dialect6.sqlToQuery(query).sql
        };
      }
      return {
        version: "6",
        dialect: "sqlite",
        tables: result,
        views: resultViews,
        enums: {},
        _meta: {
          tables: {},
          columns: {}
        },
        internal
      };
    };
    fromDatabase2 = async (db2, tablesFilter = (table6) => true, progressCallback) => {
      const result = {};
      const resultViews = {};
      const columns = await db2.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,
		  p.hidden as hidden,
		  m.sql,
		  m.type as type
		FROM sqlite_master AS m
		JOIN pragma_table_xinfo(m.name) AS p
		WHERE (m.type = 'table' OR m.type = 'view') 
		  AND ${filterIgnoredTablesByField("m.tbl_name")};`);
      const tablesWithSeq = [];
      const seq = await db2.query(`SELECT
		  *
		FROM sqlite_master
		WHERE sql GLOB '*[ *' || CHAR(9) || CHAR(10) || CHAR(13) || ']AUTOINCREMENT[^'']*'
    	  AND ${filterIgnoredTablesByField("tbl_name")};`);
      for (const s10 of seq) {
        tablesWithSeq.push(s10.name);
      }
      let columnsCount = 0;
      let tablesCount = /* @__PURE__ */ new Set();
      let indexesCount = 0;
      let foreignKeysCount = 0;
      let checksCount = 0;
      let viewsCount = 0;
      const tableToPk = {};
      let tableToGeneratedColumnsInfo = {};
      for (const column6 of columns) {
        if (!tablesFilter(column6.tableName)) continue;
        if (column6.type !== "view") {
          columnsCount += 1;
        }
        if (progressCallback) {
          progressCallback("columns", columnsCount, "fetching");
        }
        const tableName = column6.tableName;
        tablesCount.add(tableName);
        if (progressCallback) {
          progressCallback("tables", tablesCount.size, "fetching");
        }
        const columnName = column6.columnName;
        const isNotNull2 = column6.notNull === 1;
        const columnType = column6.columnType;
        const isPrimary = column6.pk !== 0;
        const columnDefault = column6.defaultValue;
        const isAutoincrement = isPrimary && tablesWithSeq.includes(tableName);
        if (isPrimary) {
          if (typeof tableToPk[tableName] === "undefined") {
            tableToPk[tableName] = [columnName];
          } else {
            tableToPk[tableName].push(columnName);
          }
        }
        const table6 = result[tableName];
        if (column6.hidden === 2 || column6.hidden === 3) {
          if (typeof tableToGeneratedColumnsInfo[column6.tableName] === "undefined") {
            tableToGeneratedColumnsInfo[column6.tableName] = extractGeneratedColumns(
              column6.sql
            );
          }
        }
        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})`,
          autoincrement: isAutoincrement,
          name: columnName,
          type: mapSqlToSqliteType(columnType),
          primaryKey: false,
          notNull: isNotNull2,
          generated: tableToGeneratedColumnsInfo[tableName] && tableToGeneratedColumnsInfo[tableName][columnName] ? {
            type: tableToGeneratedColumnsInfo[tableName][columnName].type,
            as: tableToGeneratedColumnsInfo[tableName][columnName].expression
          } : void 0
        };
        if (!table6) {
          result[tableName] = {
            name: tableName,
            columns: {
              [columnName]: newColumn
            },
            compositePrimaryKeys: {},
            indexes: {},
            foreignKeys: {},
            uniqueConstraints: {},
            checkConstraints: {}
          };
        } else {
          result[tableName].columns[columnName] = newColumn;
        }
      }
      for (const [key, value] of Object.entries(tableToPk)) {
        if (value.length > 1) {
          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 db2.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
      		WHERE ${filterIgnoredTablesByField("m.tbl_name")};`);
        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?.toLowerCase(),
              onUpdate: 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 (e6) {
      }
      if (progressCallback) {
        progressCallback("fks", foreignKeysCount, "done");
      }
      const idxs = await db2.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\\_%' ESCAPE '\\'
    	  AND ${filterIgnoredTablesByField("m.tbl_name")};`);
      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" && columnName) {
          tableInResult.indexes[constraintName].columns.push(columnName);
        } else {
          tableInResult.indexes[constraintName] = {
            name: constraintName,
            columns: columnName ? [columnName] : [],
            isUnique
          };
        }
      }
      if (progressCallback) {
        progressCallback("indexes", indexesCount, "done");
        progressCallback("enums", 0, "done");
      }
      const views = await db2.query(
        `SELECT name AS view_name, sql AS sql FROM sqlite_master WHERE type = 'view';`
      );
      viewsCount = views.length;
      if (progressCallback) {
        progressCallback("views", viewsCount, "fetching");
      }
      for (const view5 of views) {
        const viewName = view5["view_name"];
        const sql3 = view5["sql"];
        const regex = new RegExp(`\\bAS\\b\\s+(SELECT.+)$`, "i");
        const match2 = sql3.match(regex);
        if (!match2) {
          console.log("Could not process view");
          process.exit(1);
        }
        const viewDefinition = match2[1];
        const columns2 = result[viewName].columns;
        delete result[viewName];
        resultViews[viewName] = {
          columns: columns2,
          isExisting: false,
          name: viewName,
          definition: viewDefinition
        };
      }
      if (progressCallback) {
        progressCallback("views", viewsCount, "done");
      }
      const namedCheckPattern = /CONSTRAINT\s*["']?(\w+)["']?\s*CHECK\s*\((.*?)\)/gi;
      const unnamedCheckPattern = /CHECK\s*\((.*?)\)/gi;
      let checkCounter = 0;
      const checkConstraints = {};
      const checks = await db2.query(`SELECT
		  name as "tableName",
		  sql as "sql"
		FROM sqlite_master 
		WHERE type = 'table'
		  AND ${filterIgnoredTablesByField("tbl_name")};`);
      for (const check2 of checks) {
        if (!tablesFilter(check2.tableName)) continue;
        const { tableName, sql: sql3 } = check2;
        let namedChecks = [...sql3.matchAll(namedCheckPattern)];
        if (namedChecks.length > 0) {
          namedChecks.forEach(([_7, checkName, checkValue]) => {
            checkConstraints[checkName] = {
              name: checkName,
              value: checkValue.trim()
            };
          });
        } else {
          let unnamedChecks = [...sql3.matchAll(unnamedCheckPattern)];
          unnamedChecks.forEach(([_7, checkValue]) => {
            let checkName = `${tableName}_check_${++checkCounter}`;
            checkConstraints[checkName] = {
              name: checkName,
              value: checkValue.trim()
            };
          });
        }
        checksCount += Object.values(checkConstraints).length;
        if (progressCallback) {
          progressCallback("checks", checksCount, "fetching");
        }
        const table6 = result[tableName];
        if (!table6) {
          result[tableName] = {
            name: tableName,
            columns: {},
            compositePrimaryKeys: {},
            indexes: {},
            foreignKeys: {},
            uniqueConstraints: {},
            checkConstraints
          };
        } else {
          result[tableName].checkConstraints = checkConstraints;
        }
      }
      if (progressCallback) {
        progressCallback("checks", checksCount, "done");
      }
      return {
        version: "6",
        dialect: "sqlite",
        tables: result,
        views: resultViews,
        enums: {},
        _meta: {
          tables: {},
          columns: {}
        }
      };
    };
  }
});

// src/extensions/getTablesFilterByExtensions.ts
var getTablesFilterByExtensions;
var init_getTablesFilterByExtensions = __esm({
  "src/extensions/getTablesFilterByExtensions.ts"() {
    "use strict";
    getTablesFilterByExtensions = ({
      extensionsFilters,
      dialect: dialect6
    }) => {
      if (extensionsFilters) {
        if (extensionsFilters.includes("postgis") && dialect6 === "postgresql") {
          return ["!geography_columns", "!geometry_columns", "!spatial_ref_sys"];
        }
      }
      return [];
    };
  }
});

// src/serializer/mysqlSerializer.ts
function clearDefaults(defaultValue, collate) {
  if (typeof collate === "undefined" || collate === null) {
    collate = `utf8mb4`;
  }
  let resultDefault = defaultValue;
  collate = `_${collate}`;
  if (defaultValue.startsWith(collate)) {
    resultDefault = resultDefault.substring(collate.length, defaultValue.length).replace(/\\/g, "");
    if (resultDefault.startsWith("'") && resultDefault.endsWith("'")) {
      return `('${escapeSingleQuotes(resultDefault.substring(1, resultDefault.length - 1))}')`;
    } else {
      return `'${escapeSingleQuotes(resultDefault.substring(1, resultDefault.length - 1))}'`;
    }
  } else {
    return `(${resultDefault})`;
  }
}
var handleEnumType, generateMySqlSnapshot, fromDatabase3;
var init_mysqlSerializer = __esm({
  "src/serializer/mysqlSerializer.ts"() {
    "use strict";
    init_source();
    init_dist();
    init_mysql_core();
    init_outputs();
    init_utils8();
    init_utils9();
    handleEnumType = (type) => {
      let str = type.split("(")[1];
      str = str.substring(0, str.length - 1);
      const values2 = str.split(",").map((v11) => `'${escapeSingleQuotes(v11.substring(1, v11.length - 1))}'`);
      return `enum(${values2.join(",")})`;
    };
    generateMySqlSnapshot = (tables, views, casing2) => {
      const dialect6 = new MySqlDialect({ casing: casing2 });
      const result = {};
      const resultViews = {};
      const internal = { tables: {}, indexes: {} };
      for (const table6 of tables) {
        const {
          name: tableName,
          columns,
          indexes,
          foreignKeys,
          schema: schema6,
          checks,
          primaryKeys,
          uniqueConstraints
        } = getTableConfig(table6);
        const columnsObject = {};
        const indexesObject = {};
        const foreignKeysObject = {};
        const primaryKeysObject = {};
        const uniqueConstraintObject = {};
        const checkConstraintObject = {};
        let checksInTable = {};
        columns.forEach((column6) => {
          const name3 = getColumnCasing(column6, casing2);
          const notNull = column6.notNull;
          const sqlType = column6.getSQLType();
          const sqlTypeLowered = sqlType.toLowerCase();
          const autoIncrement = typeof column6.autoIncrement === "undefined" ? false : column6.autoIncrement;
          const generated = column6.generated;
          const columnToSet = {
            name: name3,
            type: sqlType.startsWith("enum") ? handleEnumType(sqlType) : sqlType,
            primaryKey: false,
            // If field is autoincrement it's notNull by default
            // notNull: autoIncrement ? true : notNull,
            notNull,
            autoincrement: autoIncrement,
            onUpdate: column6.hasOnUpdateNow,
            generated: generated ? {
              as: is(generated.as, SQL) ? dialect6.sqlToQuery(generated.as).sql : typeof generated.as === "function" ? dialect6.sqlToQuery(generated.as()).sql : generated.as,
              type: generated.mode ?? "stored"
            } : void 0
          };
          if (column6.primary) {
            primaryKeysObject[`${tableName}_${name3}`] = {
              name: `${tableName}_${name3}`,
              columns: [name3]
            };
          }
          if (column6.isUnique) {
            const existingUnique = uniqueConstraintObject[column6.uniqueName];
            if (typeof existingUnique !== "undefined") {
              console.log(
                `
${withStyle.errorWarning(`We've found duplicated unique constraint names in ${source_default.underline.blue(
                  tableName
                )} table. 
          The unique constraint ${source_default.underline.blue(
                  column6.uniqueName
                )} on the ${source_default.underline.blue(
                  name3
                )} column is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                  existingUnique.columns.join(",")
                )} columns
`)}`
              );
              process.exit(1);
            }
            uniqueConstraintObject[column6.uniqueName] = {
              name: column6.uniqueName,
              columns: [columnToSet.name]
            };
          }
          if (column6.default !== void 0) {
            if (is(column6.default, SQL)) {
              columnToSet.default = sqlToStr(column6.default, casing2);
            } else {
              if (typeof column6.default === "string") {
                columnToSet.default = `'${escapeSingleQuotes(column6.default)}'`;
              } else {
                if (sqlTypeLowered === "json") {
                  columnToSet.default = `'${JSON.stringify(column6.default)}'`;
                } else if (column6.default instanceof Date) {
                  if (sqlTypeLowered === "date") {
                    columnToSet.default = `'${column6.default.toISOString().split("T")[0]}'`;
                  } else if (sqlTypeLowered.startsWith("datetime") || sqlTypeLowered.startsWith("timestamp")) {
                    columnToSet.default = `'${column6.default.toISOString().replace("T", " ").slice(0, 23)}'`;
                  }
                } else {
                  columnToSet.default = column6.default;
                }
              }
              if (["blob", "text", "json"].includes(column6.getSQLType())) {
                columnToSet.default = `(${columnToSet.default})`;
              }
            }
          }
          columnsObject[name3] = columnToSet;
        });
        primaryKeys.map((pk) => {
          const originalColumnNames = pk.columns.map((c6) => c6.name);
          const columnNames = pk.columns.map((c6) => getColumnCasing(c6, casing2));
          let name3 = pk.getName();
          if (casing2 !== void 0) {
            for (let i8 = 0; i8 < originalColumnNames.length; i8++) {
              name3 = name3.replace(originalColumnNames[i8], columnNames[i8]);
            }
          }
          primaryKeysObject[name3] = {
            name: name3,
            columns: columnNames
          };
          for (const column6 of pk.columns) {
            columnsObject[getColumnCasing(column6, casing2)].notNull = true;
          }
        });
        uniqueConstraints?.map((unq) => {
          const columnNames = unq.columns.map((c6) => getColumnCasing(c6, casing2));
          const name3 = unq.name ?? uniqueKeyName2(table6, columnNames);
          const existingUnique = uniqueConstraintObject[name3];
          if (typeof existingUnique !== "undefined") {
            console.log(
              `
${withStyle.errorWarning(
                `We've found duplicated unique constraint names in ${source_default.underline.blue(
                  tableName
                )} table. 
The unique constraint ${source_default.underline.blue(
                  name3
                )} on the ${source_default.underline.blue(
                  columnNames.join(",")
                )} columns is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                  existingUnique.columns.join(",")
                )} columns
`
              )}`
            );
            process.exit(1);
          }
          uniqueConstraintObject[name3] = {
            name: unq.name,
            columns: columnNames
          };
        });
        const fks = foreignKeys.map((fk5) => {
          const tableFrom = tableName;
          const onDelete = fk5.onDelete ?? "no action";
          const onUpdate = fk5.onUpdate ?? "no action";
          const reference = fk5.reference();
          const referenceFT = reference.foreignTable;
          const tableTo = getTableName(referenceFT);
          const originalColumnsFrom = reference.columns.map((it2) => it2.name);
          const columnsFrom = reference.columns.map((it2) => getColumnCasing(it2, casing2));
          const originalColumnsTo = reference.foreignColumns.map((it2) => it2.name);
          const columnsTo = reference.foreignColumns.map((it2) => getColumnCasing(it2, casing2));
          let name3 = fk5.getName();
          if (casing2 !== void 0) {
            for (let i8 = 0; i8 < originalColumnsFrom.length; i8++) {
              name3 = name3.replace(originalColumnsFrom[i8], columnsFrom[i8]);
            }
            for (let i8 = 0; i8 < originalColumnsTo.length; i8++) {
              name3 = name3.replace(originalColumnsTo[i8], columnsTo[i8]);
            }
          }
          return {
            name: name3,
            tableFrom,
            tableTo,
            columnsFrom,
            columnsTo,
            onDelete,
            onUpdate
          };
        });
        fks.forEach((it2) => {
          foreignKeysObject[it2.name] = it2;
        });
        indexes.forEach((value) => {
          const columns2 = value.config.columns;
          const name3 = value.config.name;
          let indexColumns = columns2.map((it2) => {
            if (is(it2, SQL)) {
              const sql3 = dialect6.sqlToQuery(it2, "indexes").sql;
              if (typeof internal.indexes[name3] === "undefined") {
                internal.indexes[name3] = {
                  columns: {
                    [sql3]: {
                      isExpression: true
                    }
                  }
                };
              } else {
                if (typeof internal.indexes[name3]?.columns[sql3] === "undefined") {
                  internal.indexes[name3].columns[sql3] = {
                    isExpression: true
                  };
                } else {
                  internal.indexes[name3].columns[sql3].isExpression = true;
                }
              }
              return sql3;
            } else {
              return `${getColumnCasing(it2, casing2)}`;
            }
          });
          if (value.config.unique) {
            if (typeof uniqueConstraintObject[name3] !== "undefined") {
              console.log(
                `
${withStyle.errorWarning(
                  `We've found duplicated unique constraint names in ${source_default.underline.blue(
                    tableName
                  )} table. 
The unique index ${source_default.underline.blue(
                    name3
                  )} on the ${source_default.underline.blue(
                    indexColumns.join(",")
                  )} columns is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                    uniqueConstraintObject[name3].columns.join(",")
                  )} columns
`
                )}`
              );
              process.exit(1);
            }
          } else {
            if (typeof foreignKeysObject[name3] !== "undefined") {
              console.log(
                `
${withStyle.errorWarning(
                  `In MySQL, when creating a foreign key, an index is automatically generated with the same name as the foreign key constraint.

We have encountered a collision between the index name on columns ${source_default.underline.blue(
                    indexColumns.join(",")
                  )} and the foreign key on columns ${source_default.underline.blue(
                    foreignKeysObject[name3].columnsFrom.join(",")
                  )}. Please change either the index name or the foreign key name. For more information, please refer to https://dev.mysql.com/doc/refman/8.0/en/constraint-foreign-key.html

            `
                )}`
              );
              process.exit(1);
            }
          }
          indexesObject[name3] = {
            name: name3,
            columns: indexColumns,
            isUnique: value.config.unique ?? false,
            using: value.config.using,
            algorithm: value.config.algorythm,
            lock: value.config.lock
          };
        });
        checks.forEach((check2) => {
          check2;
          const checkName = check2.name;
          if (typeof checksInTable[tableName] !== "undefined") {
            if (checksInTable[tableName].includes(check2.name)) {
              console.log(
                `
${withStyle.errorWarning(
                  `We've found duplicated check constraint name in ${source_default.underline.blue(
                    tableName
                  )}. Please rename your check constraint in the ${source_default.underline.blue(
                    tableName
                  )} table`
                )}`
              );
              process.exit(1);
            }
            checksInTable[tableName].push(checkName);
          } else {
            checksInTable[tableName] = [check2.name];
          }
          checkConstraintObject[checkName] = {
            name: checkName,
            value: dialect6.sqlToQuery(check2.value).sql
          };
        });
        if (!schema6) {
          result[tableName] = {
            name: tableName,
            columns: columnsObject,
            indexes: indexesObject,
            foreignKeys: foreignKeysObject,
            compositePrimaryKeys: primaryKeysObject,
            uniqueConstraints: uniqueConstraintObject,
            checkConstraint: checkConstraintObject
          };
        }
      }
      for (const view5 of views) {
        const {
          isExisting,
          name: name3,
          query,
          schema: schema6,
          selectedFields,
          algorithm,
          sqlSecurity,
          withCheckOption
        } = getViewConfig(view5);
        const columnsObject = {};
        const existingView = resultViews[name3];
        if (typeof existingView !== "undefined") {
          console.log(
            `
${withStyle.errorWarning(
              `We've found duplicated view name across ${source_default.underline.blue(
                schema6 ?? "public"
              )} schema. Please rename your view`
            )}`
          );
          process.exit(1);
        }
        for (const key in selectedFields) {
          if (is(selectedFields[key], MySqlColumn)) {
            const column6 = selectedFields[key];
            const notNull = column6.notNull;
            const sqlTypeLowered = column6.getSQLType().toLowerCase();
            const autoIncrement = typeof column6.autoIncrement === "undefined" ? false : column6.autoIncrement;
            const generated = column6.generated;
            const columnToSet = {
              name: column6.name,
              type: column6.getSQLType(),
              primaryKey: false,
              // If field is autoincrement it's notNull by default
              // notNull: autoIncrement ? true : notNull,
              notNull,
              autoincrement: autoIncrement,
              onUpdate: column6.hasOnUpdateNow,
              generated: generated ? {
                as: is(generated.as, SQL) ? dialect6.sqlToQuery(generated.as).sql : typeof generated.as === "function" ? dialect6.sqlToQuery(generated.as()).sql : generated.as,
                type: generated.mode ?? "stored"
              } : void 0
            };
            if (column6.default !== void 0) {
              if (is(column6.default, SQL)) {
                columnToSet.default = sqlToStr(column6.default, casing2);
              } else {
                if (typeof column6.default === "string") {
                  columnToSet.default = `'${column6.default}'`;
                } else {
                  if (sqlTypeLowered === "json") {
                    columnToSet.default = `'${JSON.stringify(column6.default)}'`;
                  } else if (column6.default instanceof Date) {
                    if (sqlTypeLowered === "date") {
                      columnToSet.default = `'${column6.default.toISOString().split("T")[0]}'`;
                    } else if (sqlTypeLowered.startsWith("datetime") || sqlTypeLowered.startsWith("timestamp")) {
                      columnToSet.default = `'${column6.default.toISOString().replace("T", " ").slice(0, 23)}'`;
                    }
                  } else {
                    columnToSet.default = column6.default;
                  }
                }
                if (["blob", "text", "json"].includes(column6.getSQLType())) {
                  columnToSet.default = `(${columnToSet.default})`;
                }
              }
            }
            columnsObject[column6.name] = columnToSet;
          }
        }
        resultViews[name3] = {
          columns: columnsObject,
          name: name3,
          isExisting,
          definition: isExisting ? void 0 : dialect6.sqlToQuery(query).sql,
          withCheckOption,
          algorithm: algorithm ?? "undefined",
          // set default values
          sqlSecurity: sqlSecurity ?? "definer"
          // set default values
        };
      }
      return {
        version: "5",
        dialect: "mysql",
        tables: result,
        views: resultViews,
        _meta: {
          tables: {},
          columns: {}
        },
        internal
      };
    };
    fromDatabase3 = async (db2, inputSchema, tablesFilter = (table6) => true, progressCallback) => {
      const result = {};
      const internals = { tables: {}, indexes: {} };
      const columns = await db2.query(`select * from information_schema.columns
	where table_schema = '${inputSchema}' and table_name != '__drizzle_migrations'
	order by table_name, ordinal_position;`);
      const response = columns;
      const schemas = [];
      let columnsCount = 0;
      let tablesCount = /* @__PURE__ */ new Set();
      let indexesCount = 0;
      let foreignKeysCount = 0;
      let checksCount = 0;
      let viewsCount = 0;
      const idxs = await db2.query(
        `select * from INFORMATION_SCHEMA.STATISTICS
	WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = '${inputSchema}' and INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY';`
      );
      const idxRows = idxs;
      for (const column6 of response) {
        if (!tablesFilter(column6["TABLE_NAME"])) continue;
        columnsCount += 1;
        if (progressCallback) {
          progressCallback("columns", columnsCount, "fetching");
        }
        const schema6 = column6["TABLE_SCHEMA"];
        const tableName = column6["TABLE_NAME"];
        tablesCount.add(`${schema6}.${tableName}`);
        if (progressCallback) {
          progressCallback("columns", tablesCount.size, "fetching");
        }
        const columnName = column6["COLUMN_NAME"];
        const isNullable = column6["IS_NULLABLE"] === "YES";
        const dataType = column6["DATA_TYPE"];
        const columnType = column6["COLUMN_TYPE"];
        const isPrimary = column6["COLUMN_KEY"] === "PRI";
        const columnDefault = column6["COLUMN_DEFAULT"];
        const collation = column6["CHARACTER_SET_NAME"];
        const geenratedExpression = column6["GENERATION_EXPRESSION"];
        let columnExtra = column6["EXTRA"];
        let isAutoincrement = false;
        let isDefaultAnExpression = false;
        if (typeof column6["EXTRA"] !== "undefined") {
          columnExtra = column6["EXTRA"];
          isAutoincrement = column6["EXTRA"] === "auto_increment";
          isDefaultAnExpression = column6["EXTRA"].includes("DEFAULT_GENERATED");
        }
        if (schema6 !== inputSchema) {
          schemas.push(schema6);
        }
        const table6 = result[tableName];
        let changedType = columnType;
        if (columnType === "bigint unsigned" && !isNullable && isAutoincrement) {
          const uniqueIdx = idxRows.filter(
            (it2) => it2["COLUMN_NAME"] === columnName && it2["TABLE_NAME"] === tableName && it2["NON_UNIQUE"] === 0
          );
          if (uniqueIdx && uniqueIdx.length === 1) {
            changedType = columnType.replace("bigint unsigned", "serial");
          }
        }
        if (columnType.includes("decimal(10,0)")) {
          changedType = columnType.replace("decimal(10,0)", "decimal");
        }
        let onUpdate = void 0;
        if (columnType.startsWith("timestamp") && typeof columnExtra !== "undefined" && columnExtra.includes("on update CURRENT_TIMESTAMP")) {
          onUpdate = true;
        }
        const newColumn = {
          default: columnDefault === null || columnDefault === void 0 ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) && !["decimal", "char", "varchar"].some((type) => columnType.startsWith(type)) ? Number(columnDefault) : isDefaultAnExpression ? clearDefaults(columnDefault, collation) : `'${escapeSingleQuotes(columnDefault)}'`,
          autoincrement: isAutoincrement,
          name: columnName,
          type: changedType,
          primaryKey: false,
          notNull: !isNullable,
          onUpdate,
          generated: geenratedExpression ? {
            as: geenratedExpression,
            type: columnExtra === "VIRTUAL GENERATED" ? "virtual" : "stored"
          } : void 0
        };
        if (isDefaultAnExpression) {
          if (typeof internals.tables[tableName] === "undefined") {
            internals.tables[tableName] = {
              columns: {
                [columnName]: {
                  isDefaultAnExpression: true
                }
              }
            };
          } else {
            if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
              internals.tables[tableName].columns[columnName] = {
                isDefaultAnExpression: true
              };
            } else {
              internals.tables[tableName].columns[columnName].isDefaultAnExpression = true;
            }
          }
        }
        if (!table6) {
          result[tableName] = {
            name: tableName,
            columns: {
              [columnName]: newColumn
            },
            compositePrimaryKeys: {},
            indexes: {},
            foreignKeys: {},
            uniqueConstraints: {},
            checkConstraint: {}
          };
        } else {
          result[tableName].columns[columnName] = newColumn;
        }
      }
      const tablePks = await db2.query(
        `SELECT table_name, column_name, ordinal_position
  FROM information_schema.table_constraints t
  LEFT JOIN information_schema.key_column_usage k
  USING(constraint_name,table_schema,table_name)
  WHERE t.constraint_type='PRIMARY KEY'
      and table_name != '__drizzle_migrations'
      AND t.table_schema = '${inputSchema}'
      ORDER BY ordinal_position`
      );
      const tableToPk = {};
      const tableToPkRows = tablePks;
      for (const tableToPkRow of tableToPkRows) {
        const tableName = tableToPkRow["TABLE_NAME"];
        const columnName = tableToPkRow["COLUMN_NAME"];
        const position = tableToPkRow["ordinal_position"];
        if (typeof result[tableName] === "undefined") {
          continue;
        }
        if (typeof tableToPk[tableName] === "undefined") {
          tableToPk[tableName] = [columnName];
        } else {
          tableToPk[tableName].push(columnName);
        }
      }
      for (const [key, value] of Object.entries(tableToPk)) {
        result[key].compositePrimaryKeys = {
          [`${key}_${value.join("_")}`]: {
            name: `${key}_${value.join("_")}`,
            columns: value
          }
        };
      }
      if (progressCallback) {
        progressCallback("columns", columnsCount, "done");
        progressCallback("tables", tablesCount.size, "done");
      }
      try {
        const fks = await db2.query(
          `SELECT 
      kcu.TABLE_SCHEMA,
      kcu.TABLE_NAME,
      kcu.CONSTRAINT_NAME,
      kcu.COLUMN_NAME,
      kcu.REFERENCED_TABLE_SCHEMA,
      kcu.REFERENCED_TABLE_NAME,
      kcu.REFERENCED_COLUMN_NAME,
      rc.UPDATE_RULE,
      rc.DELETE_RULE
  FROM 
      INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
  LEFT JOIN 
      information_schema.referential_constraints rc 
      ON kcu.CONSTRAINT_NAME = rc.CONSTRAINT_NAME
  WHERE kcu.TABLE_SCHEMA = '${inputSchema}' AND kcu.CONSTRAINT_NAME != 'PRIMARY' 
      AND kcu.REFERENCED_TABLE_NAME IS NOT NULL;`
        );
        const fkRows = fks;
        for (const fkRow of fkRows) {
          foreignKeysCount += 1;
          if (progressCallback) {
            progressCallback("fks", foreignKeysCount, "fetching");
          }
          const tableSchema = fkRow["TABLE_SCHEMA"];
          const tableName = fkRow["TABLE_NAME"];
          const constraintName = fkRow["CONSTRAINT_NAME"];
          const columnName = fkRow["COLUMN_NAME"];
          const refTableSchema = fkRow["REFERENCED_TABLE_SCHEMA"];
          const refTableName = fkRow["REFERENCED_TABLE_NAME"];
          const refColumnName = fkRow["REFERENCED_COLUMN_NAME"];
          const updateRule = fkRow["UPDATE_RULE"];
          const deleteRule = fkRow["DELETE_RULE"];
          const tableInResult = result[tableName];
          if (typeof tableInResult === "undefined") continue;
          if (typeof tableInResult.foreignKeys[constraintName] !== "undefined") {
            tableInResult.foreignKeys[constraintName].columnsFrom.push(columnName);
            tableInResult.foreignKeys[constraintName].columnsTo.push(
              refColumnName
            );
          } else {
            tableInResult.foreignKeys[constraintName] = {
              name: constraintName,
              tableFrom: tableName,
              tableTo: refTableName,
              columnsFrom: [columnName],
              columnsTo: [refColumnName],
              onDelete: deleteRule?.toLowerCase(),
              onUpdate: updateRule?.toLowerCase()
            };
          }
          tableInResult.foreignKeys[constraintName].columnsFrom = [
            ...new Set(tableInResult.foreignKeys[constraintName].columnsFrom)
          ];
          tableInResult.foreignKeys[constraintName].columnsTo = [
            ...new Set(tableInResult.foreignKeys[constraintName].columnsTo)
          ];
        }
      } catch (e6) {
      }
      if (progressCallback) {
        progressCallback("fks", foreignKeysCount, "done");
      }
      for (const idxRow of idxRows) {
        const tableSchema = idxRow["TABLE_SCHEMA"];
        const tableName = idxRow["TABLE_NAME"];
        const constraintName = idxRow["INDEX_NAME"];
        const columnName = idxRow["COLUMN_NAME"];
        const isUnique = idxRow["NON_UNIQUE"] === 0;
        const tableInResult = result[tableName];
        if (typeof tableInResult === "undefined") continue;
        indexesCount += 1;
        if (progressCallback) {
          progressCallback("indexes", indexesCount, "fetching");
        }
        if (isUnique) {
          if (typeof tableInResult.uniqueConstraints[constraintName] !== "undefined") {
            tableInResult.uniqueConstraints[constraintName].columns.push(
              columnName
            );
          } else {
            tableInResult.uniqueConstraints[constraintName] = {
              name: constraintName,
              columns: [columnName]
            };
          }
        } else {
          if (typeof tableInResult.foreignKeys[constraintName] === "undefined") {
            if (typeof tableInResult.indexes[constraintName] !== "undefined") {
              tableInResult.indexes[constraintName].columns.push(columnName);
            } else {
              tableInResult.indexes[constraintName] = {
                name: constraintName,
                columns: [columnName],
                isUnique
              };
            }
          }
        }
      }
      const views = await db2.query(
        `select * from INFORMATION_SCHEMA.VIEWS WHERE table_schema = '${inputSchema}';`
      );
      const resultViews = {};
      viewsCount = views.length;
      if (progressCallback) {
        progressCallback("views", viewsCount, "fetching");
      }
      for await (const view5 of views) {
        const viewName = view5["TABLE_NAME"];
        const definition = view5["VIEW_DEFINITION"];
        const withCheckOption = view5["CHECK_OPTION"] === "NONE" ? void 0 : view5["CHECK_OPTION"].toLowerCase();
        const sqlSecurity = view5["SECURITY_TYPE"].toLowerCase();
        const [createSqlStatement] = await db2.query(`SHOW CREATE VIEW \`${viewName}\`;`);
        const algorithmMatch = createSqlStatement["Create View"].match(/ALGORITHM=([^ ]+)/);
        const algorithm = algorithmMatch ? algorithmMatch[1].toLowerCase() : void 0;
        const columns2 = result[viewName].columns;
        delete result[viewName];
        resultViews[viewName] = {
          columns: columns2,
          isExisting: false,
          name: viewName,
          algorithm,
          definition,
          sqlSecurity,
          withCheckOption
        };
      }
      if (progressCallback) {
        progressCallback("indexes", indexesCount, "done");
        progressCallback("enums", 0, "done");
        progressCallback("views", viewsCount, "done");
      }
      const checkConstraints = await db2.query(
        `SELECT 
    tc.table_name, 
    tc.constraint_name, 
    cc.check_clause
FROM 
    information_schema.table_constraints tc
JOIN 
    information_schema.check_constraints cc 
    ON tc.constraint_name = cc.constraint_name
WHERE 
    tc.constraint_schema = '${inputSchema}'
AND 
    tc.constraint_type = 'CHECK';`
      );
      checksCount += checkConstraints.length;
      if (progressCallback) {
        progressCallback("checks", checksCount, "fetching");
      }
      for (const checkConstraintRow of checkConstraints) {
        const constraintName = checkConstraintRow["CONSTRAINT_NAME"];
        const constraintValue = checkConstraintRow["CHECK_CLAUSE"];
        const tableName = checkConstraintRow["TABLE_NAME"];
        const tableInResult = result[tableName];
        tableInResult.checkConstraint[constraintName] = {
          name: constraintName,
          value: constraintValue
        };
      }
      if (progressCallback) {
        progressCallback("checks", checksCount, "done");
      }
      return {
        version: "5",
        dialect: "mysql",
        tables: result,
        views: resultViews,
        _meta: {
          tables: {},
          columns: {}
        },
        internal: internals
      };
    };
  }
});

// src/cli/validations/cli.ts
var cliConfigGenerate, pushParams, pullParams, configCheck, cliConfigCheck;
var init_cli = __esm({
  "src/cli/validations/cli.ts"() {
    "use strict";
    init_esm();
    init_schemaValidator();
    init_common5();
    cliConfigGenerate = objectType({
      dialect: dialect4.optional(),
      schema: unionType([stringType(), stringType().array()]).optional(),
      out: stringType().optional().default("./drizzle"),
      config: stringType().optional(),
      name: stringType().optional(),
      prefix: prefix.optional(),
      breakpoints: booleanType().optional().default(true),
      custom: booleanType().optional().default(false)
    }).strict();
    pushParams = objectType({
      dialect: dialect4,
      casing: casingType.optional(),
      schema: unionType([stringType(), stringType().array()]),
      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
      schemaFilter: unionType([stringType(), stringType().array()]).optional().default(["public"]),
      extensionsFilters: literalType("postgis").array().optional(),
      verbose: booleanType().optional(),
      strict: booleanType().optional(),
      entities: objectType({
        roles: booleanType().or(objectType({
          provider: stringType().optional(),
          include: stringType().array().optional(),
          exclude: stringType().array().optional()
        })).optional().default(false)
      }).optional()
    }).passthrough();
    pullParams = objectType({
      config: stringType().optional(),
      dialect: dialect4,
      out: stringType().optional().default("drizzle"),
      tablesFilter: unionType([stringType(), stringType().array()]).optional(),
      schemaFilter: unionType([stringType(), stringType().array()]).optional().default(["public"]),
      extensionsFilters: literalType("postgis").array().optional(),
      casing,
      breakpoints: booleanType().optional().default(true),
      migrations: objectType({
        prefix: prefix.optional().default("index")
      }).optional(),
      entities: objectType({
        roles: booleanType().or(objectType({
          provider: stringType().optional(),
          include: stringType().array().optional(),
          exclude: stringType().array().optional()
        })).optional().default(false)
      }).optional()
    }).passthrough();
    configCheck = objectType({
      dialect: dialect4.optional(),
      out: stringType().optional()
    });
    cliConfigCheck = intersectionType(
      objectType({
        config: stringType().optional()
      }),
      configCheck
    );
  }
});

// src/cli/validations/gel.ts
var gelCredentials;
var init_gel = __esm({
  "src/cli/validations/gel.ts"() {
    "use strict";
    init_esm();
    init_views();
    init_common5();
    gelCredentials = unionType([
      objectType({
        driver: undefinedType(),
        host: stringType().min(1),
        port: coerce.number().min(1).optional(),
        user: stringType().min(1).optional(),
        password: stringType().min(1).optional(),
        database: stringType().min(1),
        tlsSecurity: unionType([
          literalType("insecure"),
          literalType("no_host_verification"),
          literalType("strict"),
          literalType("default")
        ]).optional()
      }).transform((o9) => {
        delete o9.driver;
        return o9;
      }),
      objectType({
        driver: undefinedType(),
        url: stringType().min(1),
        tlsSecurity: unionType([
          literalType("insecure"),
          literalType("no_host_verification"),
          literalType("strict"),
          literalType("default")
        ]).optional()
      }).transform((o9) => {
        delete o9.driver;
        return o9;
      }),
      objectType({
        driver: undefinedType()
      }).transform((o9) => {
        return void 0;
      })
    ]);
  }
});

// src/cli/validations/libsql.ts
var libSQLCredentials;
var init_libsql = __esm({
  "src/cli/validations/libsql.ts"() {
    "use strict";
    init_esm();
    init_views();
    init_common5();
    libSQLCredentials = objectType({
      url: stringType().min(1),
      authToken: stringType().min(1).optional()
    });
  }
});

// src/cli/validations/mysql.ts
var mysqlCredentials;
var init_mysql = __esm({
  "src/cli/validations/mysql.ts"() {
    "use strict";
    init_esm();
    init_views();
    init_common5();
    init_outputs();
    mysqlCredentials = unionType([
      objectType({
        host: stringType().min(1),
        port: coerce.number().min(1).optional(),
        user: stringType().min(1).optional(),
        password: stringType().min(1).optional(),
        database: stringType().min(1),
        ssl: unionType([
          stringType(),
          objectType({
            pfx: stringType().optional(),
            key: stringType().optional(),
            passphrase: stringType().optional(),
            cert: stringType().optional(),
            ca: unionType([stringType(), stringType().array()]).optional(),
            crl: unionType([stringType(), stringType().array()]).optional(),
            ciphers: stringType().optional(),
            rejectUnauthorized: booleanType().optional()
          })
        ]).optional()
      }),
      objectType({
        url: stringType().min(1)
      })
    ]);
  }
});

// src/cli/validations/postgres.ts
var postgresCredentials;
var init_postgres = __esm({
  "src/cli/validations/postgres.ts"() {
    "use strict";
    init_esm();
    init_views();
    init_common5();
    postgresCredentials = unionType([
      objectType({
        driver: undefinedType(),
        host: stringType().min(1),
        port: coerce.number().min(1).optional(),
        user: stringType().min(1).optional(),
        password: stringType().min(1).optional(),
        database: stringType().min(1),
        ssl: unionType([
          literalType("require"),
          literalType("allow"),
          literalType("prefer"),
          literalType("verify-full"),
          booleanType(),
          objectType({}).passthrough()
        ]).optional()
      }).transform((o9) => {
        delete o9.driver;
        return o9;
      }),
      objectType({
        driver: undefinedType(),
        url: stringType().min(1)
      }).transform((o9) => {
        delete o9.driver;
        return o9;
      }),
      objectType({
        driver: literalType("aws-data-api"),
        database: stringType().min(1),
        secretArn: stringType().min(1),
        resourceArn: stringType().min(1)
      }),
      objectType({
        driver: literalType("pglite"),
        url: stringType().min(1)
      })
    ]);
  }
});

// src/cli/validations/singlestore.ts
var singlestoreCredentials;
var init_singlestore = __esm({
  "src/cli/validations/singlestore.ts"() {
    "use strict";
    init_esm();
    init_views();
    init_common5();
    init_outputs();
    singlestoreCredentials = unionType([
      objectType({
        host: stringType().min(1),
        port: coerce.number().min(1).optional(),
        user: stringType().min(1).optional(),
        password: stringType().min(1).optional(),
        database: stringType().min(1),
        ssl: unionType([
          stringType(),
          objectType({
            pfx: stringType().optional(),
            key: stringType().optional(),
            passphrase: stringType().optional(),
            cert: stringType().optional(),
            ca: unionType([stringType(), stringType().array()]).optional(),
            crl: unionType([stringType(), stringType().array()]).optional(),
            ciphers: stringType().optional(),
            rejectUnauthorized: booleanType().optional()
          })
        ]).optional()
      }),
      objectType({
        url: stringType().min(1)
      })
    ]);
  }
});

// src/cli/validations/sqlite.ts
var sqliteCredentials;
var init_sqlite = __esm({
  "src/cli/validations/sqlite.ts"() {
    "use strict";
    init_global();
    init_esm();
    init_views();
    init_common5();
    sqliteCredentials = unionType([
      objectType({
        driver: literalType("turso"),
        url: stringType().min(1),
        authToken: stringType().min(1).optional()
      }),
      objectType({
        driver: literalType("d1-http"),
        accountId: stringType().min(1),
        databaseId: stringType().min(1),
        token: stringType().min(1)
      }),
      objectType({
        driver: undefinedType(),
        url: stringType().min(1)
      }).transform((o9) => {
        delete o9.driver;
        return o9;
      })
    ]);
  }
});

// src/cli/validations/studio.ts
var credentials, studioCliParams, studioConfig;
var init_studio = __esm({
  "src/cli/validations/studio.ts"() {
    "use strict";
    init_esm();
    init_schemaValidator();
    init_common5();
    init_mysql();
    init_postgres();
    init_sqlite();
    credentials = intersectionType(
      postgresCredentials,
      mysqlCredentials,
      sqliteCredentials
    );
    studioCliParams = objectType({
      port: coerce.number().optional().default(4983),
      host: stringType().optional().default("127.0.0.1"),
      config: stringType().optional()
    });
    studioConfig = objectType({
      dialect: dialect4,
      schema: unionType([stringType(), stringType().array()]).optional(),
      casing: casingType.optional()
    });
  }
});

// src/cli/commands/_es5.ts
var es5_exports = {};
__export(es5_exports, {
  default: () => es5_default
});
var _, es5_default;
var init_es5 = __esm({
  "src/cli/commands/_es5.ts"() {
    "use strict";
    _ = "";
    es5_default = _;
  }
});

// src/cli/commands/utils.ts
var import_hanji7, assertES5, safeRegister, migrateConfig;
var init_utils10 = __esm({
  "src/cli/commands/utils.ts"() {
    "use strict";
    import_hanji7 = __toESM(require_hanji());
    init_esm();
    init_getTablesFilterByExtensions();
    init_global();
    init_schemaValidator();
    init_serializer();
    init_cli();
    init_common5();
    init_gel();
    init_libsql();
    init_mysql();
    init_outputs();
    init_postgres();
    init_singlestore();
    init_sqlite();
    init_studio();
    init_views();
    assertES5 = async (unregister) => {
      try {
        init_es5();
      } catch (e6) {
        if ("errors" in e6 && Array.isArray(e6.errors) && e6.errors.length > 0) {
          const es5Error = e6.errors.filter((it2) => it2.text?.includes(`("es5") is not supported yet`)).length > 0;
          if (es5Error) {
            console.log(
              error(
                `Please change compilerOptions.target from 'es5' to 'es6' or above in your tsconfig.json`
              )
            );
            process.exit(1);
          }
        }
        console.error(e6);
        process.exit(1);
      }
    };
    safeRegister = async () => {
      const { register } = require("esbuild-register/dist/node");
      let res;
      try {
        res = register({
          format: "cjs",
          loader: "ts"
        });
      } catch {
        res = {
          unregister: () => {
          }
        };
      }
      await assertES5(res.unregister);
      return res;
    };
    migrateConfig = objectType({
      dialect: dialect4,
      out: stringType().optional().default("drizzle"),
      migrations: configMigrations
    });
  }
});

// src/serializer/pgImports.ts
var prepareFromExports;
var init_pgImports = __esm({
  "src/serializer/pgImports.ts"() {
    "use strict";
    init_dist();
    init_pg_core();
    init_relations();
    init_utils10();
    prepareFromExports = (exports2) => {
      const tables = [];
      const enums = [];
      const schemas = [];
      const sequences = [];
      const roles = [];
      const policies = [];
      const views = [];
      const matViews = [];
      const relations2 = [];
      const i0values = Object.values(exports2);
      i0values.forEach((t6) => {
        if (isPgEnum(t6)) {
          enums.push(t6);
          return;
        }
        if (is(t6, PgTable)) {
          tables.push(t6);
        }
        if (is(t6, PgSchema)) {
          schemas.push(t6);
        }
        if (isPgView(t6)) {
          views.push(t6);
        }
        if (isPgMaterializedView(t6)) {
          matViews.push(t6);
        }
        if (isPgSequence(t6)) {
          sequences.push(t6);
        }
        if (is(t6, PgRole)) {
          roles.push(t6);
        }
        if (is(t6, PgPolicy)) {
          policies.push(t6);
        }
        if (is(t6, Relations)) {
          relations2.push(t6);
        }
      });
      return { tables, enums, schemas, sequences, views, matViews, roles, policies, relations: relations2 };
    };
  }
});

// src/serializer/singlestoreSerializer.ts
function clearDefaults2(defaultValue, collate) {
  if (typeof collate === "undefined" || collate === null) {
    collate = `utf8mb4`;
  }
  let resultDefault = defaultValue;
  collate = `_${collate}`;
  if (defaultValue.startsWith(collate)) {
    resultDefault = resultDefault.substring(collate.length, defaultValue.length).replace(/\\/g, "");
    if (resultDefault.startsWith("'") && resultDefault.endsWith("'")) {
      return `('${resultDefault.substring(1, resultDefault.length - 1)}')`;
    } else {
      return `'${resultDefault}'`;
    }
  } else {
    return `(${resultDefault})`;
  }
}
var dialect5, generateSingleStoreSnapshot, fromDatabase4;
var init_singlestoreSerializer = __esm({
  "src/serializer/singlestoreSerializer.ts"() {
    "use strict";
    init_source();
    init_dist();
    init_singlestore_core();
    init_outputs();
    init_utils9();
    dialect5 = new SingleStoreDialect();
    generateSingleStoreSnapshot = (tables, casing2) => {
      const dialect6 = new SingleStoreDialect({ casing: casing2 });
      const result = {};
      const internal = { tables: {}, indexes: {} };
      for (const table6 of tables) {
        const {
          name: tableName,
          columns,
          indexes,
          schema: schema6,
          primaryKeys,
          uniqueConstraints
        } = getTableConfig3(table6);
        const columnsObject = {};
        const indexesObject = {};
        const primaryKeysObject = {};
        const uniqueConstraintObject = {};
        columns.forEach((column6) => {
          const notNull = column6.notNull;
          const sqlTypeLowered = column6.getSQLType().toLowerCase();
          const autoIncrement = typeof column6.autoIncrement === "undefined" ? false : column6.autoIncrement;
          const generated = column6.generated;
          const columnToSet = {
            name: column6.name,
            type: column6.getSQLType(),
            primaryKey: false,
            // If field is autoincrement it's notNull by default
            // notNull: autoIncrement ? true : notNull,
            notNull,
            autoincrement: autoIncrement,
            onUpdate: column6.hasOnUpdateNow,
            generated: generated ? {
              as: is(generated.as, SQL) ? dialect6.sqlToQuery(generated.as).sql : typeof generated.as === "function" ? dialect6.sqlToQuery(generated.as()).sql : generated.as,
              type: generated.mode ?? "stored"
            } : void 0
          };
          if (column6.primary) {
            primaryKeysObject[`${tableName}_${column6.name}`] = {
              name: `${tableName}_${column6.name}`,
              columns: [column6.name]
            };
          }
          if (column6.isUnique) {
            const existingUnique = uniqueConstraintObject[column6.uniqueName];
            if (typeof existingUnique !== "undefined") {
              console.log(
                `
${withStyle.errorWarning(`We've found duplicated unique constraint names in ${source_default.underline.blue(
                  tableName
                )} table. 
          The unique constraint ${source_default.underline.blue(
                  column6.uniqueName
                )} on the ${source_default.underline.blue(
                  column6.name
                )} column is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                  existingUnique.columns.join(",")
                )} columns
`)}`
              );
              process.exit(1);
            }
            uniqueConstraintObject[column6.uniqueName] = {
              name: column6.uniqueName,
              columns: [columnToSet.name]
            };
          }
          if (column6.default !== void 0) {
            if (is(column6.default, SQL)) {
              columnToSet.default = sqlToStr(column6.default, casing2);
            } else {
              if (typeof column6.default === "string") {
                columnToSet.default = `'${column6.default}'`;
              } else {
                if (sqlTypeLowered === "json" || Array.isArray(column6.default)) {
                  columnToSet.default = `'${JSON.stringify(column6.default)}'`;
                } else if (column6.default instanceof Date) {
                  if (sqlTypeLowered === "date") {
                    columnToSet.default = `'${column6.default.toISOString().split("T")[0]}'`;
                  } else if (sqlTypeLowered.startsWith("datetime") || sqlTypeLowered.startsWith("timestamp")) {
                    columnToSet.default = `'${column6.default.toISOString().replace("T", " ").slice(0, 23)}'`;
                  }
                } else {
                  columnToSet.default = column6.default;
                }
              }
            }
          }
          columnsObject[column6.name] = columnToSet;
        });
        primaryKeys.map((pk) => {
          const columnNames = pk.columns.map((c6) => c6.name);
          primaryKeysObject[pk.getName()] = {
            name: pk.getName(),
            columns: columnNames
          };
          for (const column6 of pk.columns) {
            columnsObject[column6.name].notNull = true;
          }
        });
        uniqueConstraints?.map((unq) => {
          const columnNames = unq.columns.map((c6) => c6.name);
          const name3 = unq.name ?? uniqueKeyName3(table6, columnNames);
          const existingUnique = uniqueConstraintObject[name3];
          if (typeof existingUnique !== "undefined") {
            console.log(
              `
${withStyle.errorWarning(
                `We've found duplicated unique constraint names in ${source_default.underline.blue(
                  tableName
                )} table. 
The unique constraint ${source_default.underline.blue(
                  name3
                )} on the ${source_default.underline.blue(
                  columnNames.join(",")
                )} columns is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                  existingUnique.columns.join(",")
                )} columns
`
              )}`
            );
            process.exit(1);
          }
          uniqueConstraintObject[name3] = {
            name: unq.name,
            columns: columnNames
          };
        });
        indexes.forEach((value) => {
          const columns2 = value.config.columns;
          const name3 = value.config.name;
          let indexColumns = columns2.map((it2) => {
            if (is(it2, SQL)) {
              const sql3 = dialect6.sqlToQuery(it2, "indexes").sql;
              if (typeof internal.indexes[name3] === "undefined") {
                internal.indexes[name3] = {
                  columns: {
                    [sql3]: {
                      isExpression: true
                    }
                  }
                };
              } else {
                if (typeof internal.indexes[name3]?.columns[sql3] === "undefined") {
                  internal.indexes[name3].columns[sql3] = {
                    isExpression: true
                  };
                } else {
                  internal.indexes[name3].columns[sql3].isExpression = true;
                }
              }
              return sql3;
            } else {
              return `${it2.name}`;
            }
          });
          if (value.config.unique) {
            if (typeof uniqueConstraintObject[name3] !== "undefined") {
              console.log(
                `
${withStyle.errorWarning(
                  `We've found duplicated unique constraint names in ${source_default.underline.blue(
                    tableName
                  )} table. 
The unique index ${source_default.underline.blue(
                    name3
                  )} on the ${source_default.underline.blue(
                    indexColumns.join(",")
                  )} columns is confilcting with a unique constraint name already defined for ${source_default.underline.blue(
                    uniqueConstraintObject[name3].columns.join(",")
                  )} columns
`
                )}`
              );
              process.exit(1);
            }
          }
          indexesObject[name3] = {
            name: name3,
            columns: indexColumns,
            isUnique: value.config.unique ?? false,
            using: value.config.using,
            algorithm: value.config.algorythm,
            lock: value.config.lock
          };
        });
        if (!schema6) {
          result[tableName] = {
            name: tableName,
            columns: columnsObject,
            indexes: indexesObject,
            compositePrimaryKeys: primaryKeysObject,
            uniqueConstraints: uniqueConstraintObject
          };
        }
      }
      return {
        version: "1",
        dialect: "singlestore",
        tables: result,
        /* views: resultViews, */
        _meta: {
          tables: {},
          columns: {}
        },
        internal
      };
    };
    fromDatabase4 = async (db2, inputSchema, tablesFilter = (table6) => true, progressCallback) => {
      const result = {};
      const internals = { tables: {}, indexes: {} };
      const columns = await db2.query(`select * from information_schema.columns
	where table_schema = '${inputSchema}' and table_name != '__drizzle_migrations'
	order by table_name, ordinal_position;`);
      const response = columns;
      const schemas = [];
      let columnsCount = 0;
      let tablesCount = /* @__PURE__ */ new Set();
      let indexesCount = 0;
      const idxs = await db2.query(
        `select * from INFORMATION_SCHEMA.STATISTICS
	WHERE INFORMATION_SCHEMA.STATISTICS.TABLE_SCHEMA = '${inputSchema}' and INFORMATION_SCHEMA.STATISTICS.INDEX_NAME != 'PRIMARY';`
      );
      const idxRows = idxs;
      for (const column6 of response) {
        if (!tablesFilter(column6["TABLE_NAME"])) continue;
        columnsCount += 1;
        if (progressCallback) {
          progressCallback("columns", columnsCount, "fetching");
        }
        const schema6 = column6["TABLE_SCHEMA"];
        const tableName = column6["TABLE_NAME"];
        tablesCount.add(`${schema6}.${tableName}`);
        if (progressCallback) {
          progressCallback("columns", tablesCount.size, "fetching");
        }
        const columnName = column6["COLUMN_NAME"];
        const isNullable = column6["IS_NULLABLE"] === "YES";
        const dataType = column6["DATA_TYPE"];
        const columnType = column6["COLUMN_TYPE"];
        const isPrimary = column6["COLUMN_KEY"] === "PRI";
        let columnDefault = column6["COLUMN_DEFAULT"];
        const collation = column6["CHARACTER_SET_NAME"];
        const geenratedExpression = column6["GENERATION_EXPRESSION"];
        let columnExtra = column6["EXTRA"];
        let isAutoincrement = false;
        let isDefaultAnExpression = false;
        if (typeof column6["EXTRA"] !== "undefined") {
          columnExtra = column6["EXTRA"];
          isAutoincrement = column6["EXTRA"] === "auto_increment";
          isDefaultAnExpression = column6["EXTRA"].includes("DEFAULT_GENERATED");
        }
        if (schema6 !== inputSchema) {
          schemas.push(schema6);
        }
        const table6 = result[tableName];
        let changedType = columnType;
        if (columnType === "bigint unsigned" && !isNullable && isAutoincrement) {
          const uniqueIdx = idxRows.filter(
            (it2) => it2["COLUMN_NAME"] === columnName && it2["TABLE_NAME"] === tableName && it2["NON_UNIQUE"] === 0
          );
          if (uniqueIdx && uniqueIdx.length === 1) {
            changedType = columnType.replace("bigint unsigned", "serial");
          }
        }
        if (columnType.startsWith("bigint(") || columnType.startsWith("tinyint(") || columnType.startsWith("date(") || columnType.startsWith("int(") || columnType.startsWith("mediumint(") || columnType.startsWith("smallint(") || columnType.startsWith("text(") || columnType.startsWith("time(") || columnType.startsWith("year(")) {
          changedType = columnType.replace(/\(\s*[^)]*\)$/, "");
        }
        if (columnType.includes("decimal(10,0)")) {
          changedType = columnType.replace("decimal(10,0)", "decimal");
        }
        if (columnDefault?.endsWith(".")) {
          columnDefault = columnDefault.slice(0, -1);
        }
        let onUpdate = void 0;
        if (columnType.startsWith("timestamp") && typeof columnExtra !== "undefined" && columnExtra.includes("on update CURRENT_TIMESTAMP")) {
          onUpdate = true;
        }
        const newColumn = {
          default: columnDefault === null ? void 0 : /^-?[\d.]+(?:e-?\d+)?$/.test(columnDefault) && !["decimal", "char", "varchar"].some((type) => columnType.startsWith(type)) ? Number(columnDefault) : isDefaultAnExpression ? clearDefaults2(columnDefault, collation) : columnDefault.startsWith("CURRENT_TIMESTAMP") ? "CURRENT_TIMESTAMP" : `'${columnDefault}'`,
          autoincrement: isAutoincrement,
          name: columnName,
          type: changedType,
          primaryKey: false,
          notNull: !isNullable,
          onUpdate,
          generated: geenratedExpression ? {
            as: geenratedExpression,
            type: columnExtra === "VIRTUAL GENERATED" ? "virtual" : "stored"
          } : void 0
        };
        if (isDefaultAnExpression) {
          if (typeof internals.tables[tableName] === "undefined") {
            internals.tables[tableName] = {
              columns: {
                [columnName]: {
                  isDefaultAnExpression: true
                }
              }
            };
          } else {
            if (typeof internals.tables[tableName].columns[columnName] === "undefined") {
              internals.tables[tableName].columns[columnName] = {
                isDefaultAnExpression: true
              };
            } else {
              internals.tables[tableName].columns[columnName].isDefaultAnExpression = true;
            }
          }
        }
        if (!table6) {
          result[tableName] = {
            name: tableName,
            columns: {
              [columnName]: newColumn
            },
            compositePrimaryKeys: {},
            indexes: {},
            uniqueConstraints: {}
          };
        } else {
          result[tableName].columns[columnName] = newColumn;
        }
      }
      const tablePks = await db2.query(
        `SELECT table_name, column_name, ordinal_position
  FROM information_schema.table_constraints t
  LEFT JOIN information_schema.key_column_usage k
  USING(constraint_name,table_schema,table_name)
  WHERE t.constraint_type='UNIQUE'
      and table_name != '__drizzle_migrations'
      AND t.table_schema = '${inputSchema}'
      ORDER BY ordinal_position`
      );
      const tableToPk = {};
      const tableToPkRows = tablePks;
      for (const tableToPkRow of tableToPkRows) {
        const tableName = tableToPkRow["table_name"];
        const columnName = tableToPkRow["column_name"];
        const position = tableToPkRow["ordinal_position"];
        if (typeof result[tableName] === "undefined") {
          continue;
        }
        if (typeof tableToPk[tableName] === "undefined") {
          tableToPk[tableName] = [columnName];
        } else {
          tableToPk[tableName].push(columnName);
        }
      }
      for (const [key, value] of Object.entries(tableToPk)) {
        result[key].compositePrimaryKeys = {
          [`${key}_${value.join("_")}`]: {
            name: `${key}_${value.join("_")}`,
            columns: value
          }
        };
      }
      if (progressCallback) {
        progressCallback("columns", columnsCount, "done");
        progressCallback("tables", tablesCount.size, "done");
      }
      for (const idxRow of idxRows) {
        const tableSchema = idxRow["TABLE_SCHEMA"];
        const tableName = idxRow["TABLE_NAME"];
        const constraintName = idxRow["INDEX_NAME"];
        const columnName = idxRow["COLUMN_NAME"];
        const isUnique = idxRow["NON_UNIQUE"] === 0;
        const tableInResult = result[tableName];
        if (typeof tableInResult === "undefined") continue;
        indexesCount += 1;
        if (progressCallback) {
          progressCallback("indexes", indexesCount, "fetching");
        }
        if (isUnique) {
          if (typeof tableInResult.uniqueConstraints[constraintName] !== "undefined") {
            tableInResult.uniqueConstraints[constraintName].columns.push(
              columnName
            );
          } else {
            tableInResult.uniqueConstraints[constraintName] = {
              name: constraintName,
              columns: [columnName]
            };
          }
        }
      }
      if (progressCallback) {
        progressCallback("indexes", indexesCount, "done");
        progressCallback("enums", 0, "done");
      }
      return {
        version: "1",
        dialect: "singlestore",
        tables: result,
        /* views: resultViews, */
        _meta: {
          tables: {},
          columns: {}
        },
        internal: internals
      };
    };
  }
});

// ../node_modules/.pnpm/@hono+node-server@1.14.3_hono@4.7.10/node_modules/@hono/node-server/dist/index.mjs
function writeFromReadableStream(stream, writable) {
  if (stream.locked) {
    throw new TypeError("ReadableStream is locked.");
  } else if (writable.destroyed) {
    stream.cancel();
    return;
  }
  const reader = stream.getReader();
  writable.on("close", cancel);
  writable.on("error", cancel);
  reader.read().then(flow, cancel);
  return reader.closed.finally(() => {
    writable.off("close", cancel);
    writable.off("error", cancel);
  });
  function cancel(error2) {
    reader.cancel(error2).catch(() => {
    });
    if (error2) {
      writable.destroy(error2);
    }
  }
  function onDrain() {
    reader.read().then(flow, cancel);
  }
  function flow({ done, value }) {
    try {
      if (done) {
        writable.end();
      } else if (!writable.write(value)) {
        writable.once("drain", onDrain);
      } else {
        return reader.read().then(flow, cancel);
      }
    } catch (e6) {
      cancel(e6);
    }
  }
}
var import_http, import_http2, import_stream, import_crypto, RequestError, toRequestError, GlobalRequest, Request2, newRequestFromIncoming, getRequestCache, requestCache, incomingKey, urlKey, abortControllerKey, getAbortController, requestPrototype, newRequest, responseCache, getResponseCache, cacheKey, GlobalResponse, _body, _init, _a437, Response2, buildOutgoingHttpHeaders, X_ALREADY_SENT, webFetch, regBuffer, regContentType, handleRequestError, handleFetchError, handleResponseError, responseViaCache, responseViaResponseObject, getRequestListener, createAdaptorServer, serve;
var init_dist2 = __esm({
  "../node_modules/.pnpm/@hono+node-server@1.14.3_hono@4.7.10/node_modules/@hono/node-server/dist/index.mjs"() {
    "use strict";
    import_http = require("http");
    import_http2 = require("http2");
    import_stream = require("stream");
    import_crypto = __toESM(require("crypto"), 1);
    RequestError = class extends Error {
      constructor(message, options) {
        super(message, options);
        this.name = "RequestError";
      }
    };
    toRequestError = (e6) => {
      if (e6 instanceof RequestError) {
        return e6;
      }
      return new RequestError(e6.message, { cause: e6 });
    };
    GlobalRequest = global.Request;
    Request2 = class extends GlobalRequest {
      constructor(input, options) {
        if (typeof input === "object" && getRequestCache in input) {
          input = input[getRequestCache]();
        }
        if (typeof options?.body?.getReader !== "undefined") {
          ;
          options.duplex ??= "half";
        }
        super(input, options);
      }
    };
    newRequestFromIncoming = (method, url, incoming, abortController) => {
      const headerRecord = [];
      const rawHeaders = incoming.rawHeaders;
      for (let i8 = 0; i8 < rawHeaders.length; i8 += 2) {
        const { [i8]: key, [i8 + 1]: value } = rawHeaders;
        if (key.charCodeAt(0) !== /*:*/
        58) {
          headerRecord.push([key, value]);
        }
      }
      const init3 = {
        method,
        headers: headerRecord,
        signal: abortController.signal
      };
      if (method === "TRACE") {
        init3.method = "GET";
        const req = new Request2(url, init3);
        Object.defineProperty(req, "method", {
          get() {
            return "TRACE";
          }
        });
        return req;
      }
      if (!(method === "GET" || method === "HEAD")) {
        if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
          init3.body = new ReadableStream({
            start(controller) {
              controller.enqueue(incoming.rawBody);
              controller.close();
            }
          });
        } else {
          init3.body = import_stream.Readable.toWeb(incoming);
        }
      }
      return new Request2(url, init3);
    };
    getRequestCache = Symbol("getRequestCache");
    requestCache = Symbol("requestCache");
    incomingKey = Symbol("incomingKey");
    urlKey = Symbol("urlKey");
    abortControllerKey = Symbol("abortControllerKey");
    getAbortController = Symbol("getAbortController");
    requestPrototype = {
      get method() {
        return this[incomingKey].method || "GET";
      },
      get url() {
        return this[urlKey];
      },
      [getAbortController]() {
        this[getRequestCache]();
        return this[abortControllerKey];
      },
      [getRequestCache]() {
        this[abortControllerKey] ||= new AbortController();
        return this[requestCache] ||= newRequestFromIncoming(
          this.method,
          this[urlKey],
          this[incomingKey],
          this[abortControllerKey]
        );
      }
    };
    [
      "body",
      "bodyUsed",
      "cache",
      "credentials",
      "destination",
      "headers",
      "integrity",
      "mode",
      "redirect",
      "referrer",
      "referrerPolicy",
      "signal",
      "keepalive"
    ].forEach((k9) => {
      Object.defineProperty(requestPrototype, k9, {
        get() {
          return this[getRequestCache]()[k9];
        }
      });
    });
    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k9) => {
      Object.defineProperty(requestPrototype, k9, {
        value: function() {
          return this[getRequestCache]()[k9]();
        }
      });
    });
    Object.setPrototypeOf(requestPrototype, Request2.prototype);
    newRequest = (incoming, defaultHostname) => {
      const req = Object.create(requestPrototype);
      req[incomingKey] = incoming;
      const incomingUrl = incoming.url || "";
      if (incomingUrl[0] !== "/" && // short-circuit for performance. most requests are relative URL.
      (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
        if (incoming instanceof import_http2.Http2ServerRequest) {
          throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
        }
        try {
          const url2 = new URL(incomingUrl);
          req[urlKey] = url2.href;
        } catch (e6) {
          throw new RequestError("Invalid absolute URL", { cause: e6 });
        }
        return req;
      }
      const host = (incoming instanceof import_http2.Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
      if (!host) {
        throw new RequestError("Missing host header");
      }
      let scheme;
      if (incoming instanceof import_http2.Http2ServerRequest) {
        scheme = incoming.scheme;
        if (!(scheme === "http" || scheme === "https")) {
          throw new RequestError("Unsupported scheme");
        }
      } else {
        scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
      }
      const url = new URL(`${scheme}://${host}${incomingUrl}`);
      if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
        throw new RequestError("Invalid host header");
      }
      req[urlKey] = url.href;
      return req;
    };
    responseCache = Symbol("responseCache");
    getResponseCache = Symbol("getResponseCache");
    cacheKey = Symbol("cache");
    GlobalResponse = global.Response;
    Response2 = (_a437 = class {
      constructor(body2, init3) {
        __privateAdd(this, _body);
        __privateAdd(this, _init);
        let headers;
        __privateSet(this, _body, body2);
        if (init3 instanceof _a437) {
          const cachedGlobalResponse = init3[responseCache];
          if (cachedGlobalResponse) {
            __privateSet(this, _init, cachedGlobalResponse);
            this[getResponseCache]();
            return;
          } else {
            __privateSet(this, _init, __privateGet(init3, _init));
            headers = new Headers(__privateGet(init3, _init).headers);
          }
        } else {
          __privateSet(this, _init, init3);
        }
        if (typeof body2 === "string" || typeof body2?.getReader !== "undefined" || body2 instanceof Blob || body2 instanceof Uint8Array) {
          headers ||= init3?.headers || { "content-type": "text/plain; charset=UTF-8" };
          this[cacheKey] = [init3?.status || 200, body2, headers];
        }
      }
      [getResponseCache]() {
        delete this[cacheKey];
        return this[responseCache] ||= new GlobalResponse(__privateGet(this, _body), __privateGet(this, _init));
      }
      get headers() {
        const cache5 = this[cacheKey];
        if (cache5) {
          if (!(cache5[2] instanceof Headers)) {
            cache5[2] = new Headers(cache5[2]);
          }
          return cache5[2];
        }
        return this[getResponseCache]().headers;
      }
      get status() {
        return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
      }
      get ok() {
        const status = this.status;
        return status >= 200 && status < 300;
      }
    }, _body = new WeakMap(), _init = new WeakMap(), _a437);
    ["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k9) => {
      Object.defineProperty(Response2.prototype, k9, {
        get() {
          return this[getResponseCache]()[k9];
        }
      });
    });
    ["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k9) => {
      Object.defineProperty(Response2.prototype, k9, {
        value: function() {
          return this[getResponseCache]()[k9]();
        }
      });
    });
    Object.setPrototypeOf(Response2, GlobalResponse);
    Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
    buildOutgoingHttpHeaders = (headers) => {
      const res = {};
      if (!(headers instanceof Headers)) {
        headers = new Headers(headers ?? void 0);
      }
      const cookies = [];
      for (const [k9, v11] of headers) {
        if (k9 === "set-cookie") {
          cookies.push(v11);
        } else {
          res[k9] = v11;
        }
      }
      if (cookies.length > 0) {
        res["set-cookie"] = cookies;
      }
      res["content-type"] ??= "text/plain; charset=UTF-8";
      return res;
    };
    X_ALREADY_SENT = "x-hono-already-sent";
    webFetch = global.fetch;
    if (typeof global.crypto === "undefined") {
      global.crypto = import_crypto.default;
    }
    global.fetch = (info3, init3) => {
      init3 = {
        // Disable compression handling so people can return the result of a fetch
        // directly in the loader without messing with the Content-Encoding header.
        compress: false,
        ...init3
      };
      return webFetch(info3, init3);
    };
    regBuffer = /^no$/i;
    regContentType = /^(application\/json\b|text\/(?!event-stream\b))/i;
    handleRequestError = () => new Response(null, {
      status: 400
    });
    handleFetchError = (e6) => new Response(null, {
      status: e6 instanceof Error && (e6.name === "TimeoutError" || e6.constructor.name === "TimeoutError") ? 504 : 500
    });
    handleResponseError = (e6, outgoing) => {
      const err3 = e6 instanceof Error ? e6 : new Error("unknown error", { cause: e6 });
      if (err3.code === "ERR_STREAM_PREMATURE_CLOSE") {
        console.info("The user aborted a request.");
      } else {
        console.error(e6);
        if (!outgoing.headersSent) {
          outgoing.writeHead(500, { "Content-Type": "text/plain" });
        }
        outgoing.end(`Error: ${err3.message}`);
        outgoing.destroy(err3);
      }
    };
    responseViaCache = async (res, outgoing) => {
      let [status, body2, header] = res[cacheKey];
      if (header instanceof Headers) {
        header = buildOutgoingHttpHeaders(header);
      }
      if (typeof body2 === "string") {
        header["Content-Length"] = Buffer.byteLength(body2);
      } else if (body2 instanceof Uint8Array) {
        header["Content-Length"] = body2.byteLength;
      } else if (body2 instanceof Blob) {
        header["Content-Length"] = body2.size;
      }
      outgoing.writeHead(status, header);
      if (typeof body2 === "string" || body2 instanceof Uint8Array) {
        outgoing.end(body2);
      } else if (body2 instanceof Blob) {
        outgoing.end(new Uint8Array(await body2.arrayBuffer()));
      } else {
        return writeFromReadableStream(body2, outgoing)?.catch(
          (e6) => handleResponseError(e6, outgoing)
        );
      }
    };
    responseViaResponseObject = async (res, outgoing, options = {}) => {
      if (res instanceof Promise) {
        if (options.errorHandler) {
          try {
            res = await res;
          } catch (err3) {
            const errRes = await options.errorHandler(err3);
            if (!errRes) {
              return;
            }
            res = errRes;
          }
        } else {
          res = await res.catch(handleFetchError);
        }
      }
      if (cacheKey in res) {
        return responseViaCache(res, outgoing);
      }
      const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
      if (res.body) {
        const {
          "transfer-encoding": transferEncoding,
          "content-encoding": contentEncoding,
          "content-length": contentLength,
          "x-accel-buffering": accelBuffering,
          "content-type": contentType
        } = resHeaderRecord;
        if (transferEncoding || contentEncoding || contentLength || // nginx buffering variant
        accelBuffering && regBuffer.test(accelBuffering) || !regContentType.test(contentType)) {
          outgoing.writeHead(res.status, resHeaderRecord);
          await writeFromReadableStream(res.body, outgoing);
        } else {
          const buffer2 = await res.arrayBuffer();
          resHeaderRecord["content-length"] = buffer2.byteLength;
          outgoing.writeHead(res.status, resHeaderRecord);
          outgoing.end(new Uint8Array(buffer2));
        }
      } else if (resHeaderRecord[X_ALREADY_SENT]) {
      } else {
        outgoing.writeHead(res.status, resHeaderRecord);
        outgoing.end();
      }
    };
    getRequestListener = (fetchCallback, options = {}) => {
      if (options.overrideGlobalObjects !== false && global.Request !== Request2) {
        Object.defineProperty(global, "Request", {
          value: Request2
        });
        Object.defineProperty(global, "Response", {
          value: Response2
        });
      }
      return async (incoming, outgoing) => {
        let res, req;
        try {
          req = newRequest(incoming, options.hostname);
          outgoing.on("close", () => {
            const abortController = req[abortControllerKey];
            if (!abortController) {
              return;
            }
            if (incoming.errored) {
              req[abortControllerKey].abort(incoming.errored.toString());
            } else if (!outgoing.writableFinished) {
              req[abortControllerKey].abort("Client connection prematurely closed.");
            }
          });
          res = fetchCallback(req, { incoming, outgoing });
          if (cacheKey in res) {
            return responseViaCache(res, outgoing);
          }
        } catch (e6) {
          if (!res) {
            if (options.errorHandler) {
              res = await options.errorHandler(req ? e6 : toRequestError(e6));
              if (!res) {
                return;
              }
            } else if (!req) {
              res = handleRequestError();
            } else {
              res = handleFetchError(e6);
            }
          } else {
            return handleResponseError(e6, outgoing);
          }
        }
        try {
          return await responseViaResponseObject(res, outgoing, options);
        } catch (e6) {
          return handleResponseError(e6, outgoing);
        }
      };
    };
    createAdaptorServer = (options) => {
      const fetchCallback = options.fetch;
      const requestListener = getRequestListener(fetchCallback, {
        hostname: options.hostname,
        overrideGlobalObjects: options.overrideGlobalObjects
      });
      const createServer2 = options.createServer || import_http.createServer;
      const server = createServer2(options.serverOptions || {}, requestListener);
      return server;
    };
    serve = (options, listeningListener) => {
      const server = createAdaptorServer(options);
      server.listen(options?.port ?? 3e3, options.hostname, () => {
        const serverInfo = server.address();
        listeningListener && listeningListener(serverInfo);
      });
      return server;
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/url.js
var splitPath, splitRoutingPath, extractGroupsFromPath, replaceGroupMarks, patternCache, getPattern, tryDecode, tryDecodeURI, getPath, getPathNoStrict, mergePath, checkOptionalParameter, _decodeURI, _getQueryParam, getQueryParam, getQueryParams, decodeURIComponent_;
var init_url = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/url.js"() {
    "use strict";
    splitPath = (path3) => {
      const paths = path3.split("/");
      if (paths[0] === "") {
        paths.shift();
      }
      return paths;
    };
    splitRoutingPath = (routePath) => {
      const { groups, path: path3 } = extractGroupsFromPath(routePath);
      const paths = splitPath(path3);
      return replaceGroupMarks(paths, groups);
    };
    extractGroupsFromPath = (path3) => {
      const groups = [];
      path3 = path3.replace(/\{[^}]+\}/g, (match2, index7) => {
        const mark = `@${index7}`;
        groups.push([mark, match2]);
        return mark;
      });
      return { groups, path: path3 };
    };
    replaceGroupMarks = (paths, groups) => {
      for (let i8 = groups.length - 1; i8 >= 0; i8--) {
        const [mark] = groups[i8];
        for (let j7 = paths.length - 1; j7 >= 0; j7--) {
          if (paths[j7].includes(mark)) {
            paths[j7] = paths[j7].replace(mark, groups[i8][1]);
            break;
          }
        }
      }
      return paths;
    };
    patternCache = {};
    getPattern = (label, next) => {
      if (label === "*") {
        return "*";
      }
      const match2 = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
      if (match2) {
        const cacheKey2 = `${label}#${next}`;
        if (!patternCache[cacheKey2]) {
          if (match2[2]) {
            patternCache[cacheKey2] = next && next[0] !== ":" && next[0] !== "*" ? [cacheKey2, match2[1], new RegExp(`^${match2[2]}(?=/${next})`)] : [label, match2[1], new RegExp(`^${match2[2]}$`)];
          } else {
            patternCache[cacheKey2] = [label, match2[1], true];
          }
        }
        return patternCache[cacheKey2];
      }
      return null;
    };
    tryDecode = (str, decoder2) => {
      try {
        return decoder2(str);
      } catch {
        return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match2) => {
          try {
            return decoder2(match2);
          } catch {
            return match2;
          }
        });
      }
    };
    tryDecodeURI = (str) => tryDecode(str, decodeURI);
    getPath = (request2) => {
      const url = request2.url;
      const start2 = url.indexOf("/", 8);
      let i8 = start2;
      for (; i8 < url.length; i8++) {
        const charCode = url.charCodeAt(i8);
        if (charCode === 37) {
          const queryIndex = url.indexOf("?", i8);
          const path3 = url.slice(start2, queryIndex === -1 ? void 0 : queryIndex);
          return tryDecodeURI(path3.includes("%25") ? path3.replace(/%25/g, "%2525") : path3);
        } else if (charCode === 63) {
          break;
        }
      }
      return url.slice(start2, i8);
    };
    getPathNoStrict = (request2) => {
      const result = getPath(request2);
      return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
    };
    mergePath = (base, sub, ...rest) => {
      if (rest.length) {
        sub = mergePath(sub, ...rest);
      }
      return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
    };
    checkOptionalParameter = (path3) => {
      if (path3.charCodeAt(path3.length - 1) !== 63 || !path3.includes(":")) {
        return null;
      }
      const segments = path3.split("/");
      const results = [];
      let basePath = "";
      segments.forEach((segment) => {
        if (segment !== "" && !/\:/.test(segment)) {
          basePath += "/" + segment;
        } else if (/\:/.test(segment)) {
          if (/\?/.test(segment)) {
            if (results.length === 0 && basePath === "") {
              results.push("/");
            } else {
              results.push(basePath);
            }
            const optionalSegment = segment.replace("?", "");
            basePath += "/" + optionalSegment;
            results.push(basePath);
          } else {
            basePath += "/" + segment;
          }
        }
      });
      return results.filter((v11, i8, a9) => a9.indexOf(v11) === i8);
    };
    _decodeURI = (value) => {
      if (!/[%+]/.test(value)) {
        return value;
      }
      if (value.indexOf("+") !== -1) {
        value = value.replace(/\+/g, " ");
      }
      return value.indexOf("%") !== -1 ? decodeURIComponent_(value) : value;
    };
    _getQueryParam = (url, key, multiple) => {
      let encoded;
      if (!multiple && key && !/[%+]/.test(key)) {
        let keyIndex2 = url.indexOf(`?${key}`, 8);
        if (keyIndex2 === -1) {
          keyIndex2 = url.indexOf(`&${key}`, 8);
        }
        while (keyIndex2 !== -1) {
          const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
          if (trailingKeyCode === 61) {
            const valueIndex = keyIndex2 + key.length + 2;
            const endIndex = url.indexOf("&", valueIndex);
            return _decodeURI(url.slice(valueIndex, endIndex === -1 ? void 0 : endIndex));
          } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode)) {
            return "";
          }
          keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
        }
        encoded = /[%+]/.test(url);
        if (!encoded) {
          return void 0;
        }
      }
      const results = {};
      encoded ??= /[%+]/.test(url);
      let keyIndex = url.indexOf("?", 8);
      while (keyIndex !== -1) {
        const nextKeyIndex = url.indexOf("&", keyIndex + 1);
        let valueIndex = url.indexOf("=", keyIndex);
        if (valueIndex > nextKeyIndex && nextKeyIndex !== -1) {
          valueIndex = -1;
        }
        let name3 = url.slice(
          keyIndex + 1,
          valueIndex === -1 ? nextKeyIndex === -1 ? void 0 : nextKeyIndex : valueIndex
        );
        if (encoded) {
          name3 = _decodeURI(name3);
        }
        keyIndex = nextKeyIndex;
        if (name3 === "") {
          continue;
        }
        let value;
        if (valueIndex === -1) {
          value = "";
        } else {
          value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? void 0 : nextKeyIndex);
          if (encoded) {
            value = _decodeURI(value);
          }
        }
        if (multiple) {
          if (!(results[name3] && Array.isArray(results[name3]))) {
            results[name3] = [];
          }
          ;
          results[name3].push(value);
        } else {
          results[name3] ??= value;
        }
      }
      return key ? results[key] : results;
    };
    getQueryParam = _getQueryParam;
    getQueryParams = (url, key) => {
      return _getQueryParam(url, key, true);
    };
    decodeURIComponent_ = decodeURIComponent;
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/cookie.js
var validCookieNameRegEx, validCookieValueRegEx, parse2;
var init_cookie = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/cookie.js"() {
    "use strict";
    init_url();
    validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
    validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
    parse2 = (cookie, name3) => {
      if (name3 && cookie.indexOf(name3) === -1) {
        return {};
      }
      const pairs = cookie.trim().split(";");
      const parsedCookie = {};
      for (let pairStr of pairs) {
        pairStr = pairStr.trim();
        const valueStartPos = pairStr.indexOf("=");
        if (valueStartPos === -1) {
          continue;
        }
        const cookieName = pairStr.substring(0, valueStartPos).trim();
        if (name3 && name3 !== cookieName || !validCookieNameRegEx.test(cookieName)) {
          continue;
        }
        let cookieValue = pairStr.substring(valueStartPos + 1).trim();
        if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
          cookieValue = cookieValue.slice(1, -1);
        }
        if (validCookieValueRegEx.test(cookieValue)) {
          parsedCookie[cookieName] = decodeURIComponent_(cookieValue);
          if (name3) {
            break;
          }
        }
      }
      return parsedCookie;
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/helper/cookie/index.js
var getCookie;
var init_cookie2 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/helper/cookie/index.js"() {
    "use strict";
    init_cookie();
    getCookie = (c6, key, prefix2) => {
      const cookie = c6.req.raw.headers.get("Cookie");
      if (typeof key === "string") {
        if (!cookie) {
          return void 0;
        }
        let finalKey = key;
        if (prefix2 === "secure") {
          finalKey = "__Secure-" + key;
        } else if (prefix2 === "host") {
          finalKey = "__Host-" + key;
        }
        const obj2 = parse2(cookie, finalKey);
        return obj2[finalKey];
      }
      if (!cookie) {
        return {};
      }
      const obj = parse2(cookie);
      return obj;
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/http-exception.js
var HTTPException;
var init_http_exception = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/http-exception.js"() {
    "use strict";
    HTTPException = class extends Error {
      constructor(status = 500, options) {
        super(options?.message, { cause: options?.cause });
        __publicField(this, "res");
        __publicField(this, "status");
        this.res = options?.res;
        this.status = status;
      }
      getResponse() {
        if (this.res) {
          const newResponse = new Response(this.res.body, {
            status: this.status,
            headers: this.res.headers
          });
          return newResponse;
        }
        return new Response(this.message, {
          status: this.status
        });
      }
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/crypto.js
var init_crypto = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/crypto.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/buffer.js
var bufferToFormData;
var init_buffer = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/buffer.js"() {
    "use strict";
    init_crypto();
    bufferToFormData = (arrayBuffer, contentType) => {
      const response = new Response(arrayBuffer, {
        headers: {
          "Content-Type": contentType
        }
      });
      return response.formData();
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/validator/validator.js
var jsonRegex, multipartRegex, urlencodedRegex, validator;
var init_validator = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/validator/validator.js"() {
    "use strict";
    init_cookie2();
    init_http_exception();
    init_buffer();
    jsonRegex = /^application\/([a-z-\.]+\+)?json(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
    multipartRegex = /^multipart\/form-data(;\s?boundary=[a-zA-Z0-9'"()+_,\-./:=?]+)?$/;
    urlencodedRegex = /^application\/x-www-form-urlencoded(;\s*[a-zA-Z0-9\-]+\=([^;]+))*$/;
    validator = (target, validationFunc) => {
      return async (c6, next) => {
        let value = {};
        const contentType = c6.req.header("Content-Type");
        switch (target) {
          case "json":
            if (!contentType || !jsonRegex.test(contentType)) {
              break;
            }
            try {
              value = await c6.req.json();
            } catch {
              const message = "Malformed JSON in request body";
              throw new HTTPException(400, { message });
            }
            break;
          case "form": {
            if (!contentType || !(multipartRegex.test(contentType) || urlencodedRegex.test(contentType))) {
              break;
            }
            let formData;
            if (c6.req.bodyCache.formData) {
              formData = await c6.req.bodyCache.formData;
            } else {
              try {
                const arrayBuffer = await c6.req.arrayBuffer();
                formData = await bufferToFormData(arrayBuffer, contentType);
                c6.req.bodyCache.formData = formData;
              } catch (e6) {
                let message = "Malformed FormData request.";
                message += e6 instanceof Error ? ` ${e6.message}` : ` ${String(e6)}`;
                throw new HTTPException(400, { message });
              }
            }
            const form = {};
            formData.forEach((value2, key) => {
              if (key.endsWith("[]")) {
                ;
                (form[key] ??= []).push(value2);
              } else if (Array.isArray(form[key])) {
                ;
                form[key].push(value2);
              } else if (key in form) {
                form[key] = [form[key], value2];
              } else {
                form[key] = value2;
              }
            });
            value = form;
            break;
          }
          case "query":
            value = Object.fromEntries(
              Object.entries(c6.req.queries()).map(([k9, v11]) => {
                return v11.length === 1 ? [k9, v11[0]] : [k9, v11];
              })
            );
            break;
          case "param":
            value = c6.req.param();
            break;
          case "header":
            value = c6.req.header();
            break;
          case "cookie":
            value = getCookie(c6);
            break;
        }
        const res = await validationFunc(value, c6);
        if (res instanceof Response) {
          return res;
        }
        c6.req.addValidatedData(target, res);
        await next();
      };
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/validator/index.js
var init_validator2 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/validator/index.js"() {
    "use strict";
    init_validator();
  }
});

// ../node_modules/.pnpm/@hono+zod-validator@0.2.2_hono@4.7.10_zod@3.25.42/node_modules/@hono/zod-validator/dist/esm/index.js
var zValidator;
var init_esm2 = __esm({
  "../node_modules/.pnpm/@hono+zod-validator@0.2.2_hono@4.7.10_zod@3.25.42/node_modules/@hono/zod-validator/dist/esm/index.js"() {
    "use strict";
    init_validator2();
    zValidator = (target, schema6, hook) => (
      // @ts-expect-error not typed well
      validator(target, async (value, c6) => {
        const result = await schema6.safeParseAsync(value);
        if (hook) {
          const hookResult = await hook({ data: value, ...result }, c6);
          if (hookResult) {
            if (hookResult instanceof Response) {
              return hookResult;
            }
            if ("response" in hookResult) {
              return hookResult.response;
            }
          }
        }
        if (!result.success) {
          return c6.json(result, 400);
        }
        return result.data;
      })
    );
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/compose.js
var compose;
var init_compose = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/compose.js"() {
    "use strict";
    compose = (middleware, onError, onNotFound) => {
      return (context, next) => {
        let index7 = -1;
        return dispatch(0);
        async function dispatch(i8) {
          if (i8 <= index7) {
            throw new Error("next() called multiple times");
          }
          index7 = i8;
          let res;
          let isError = false;
          let handler;
          if (middleware[i8]) {
            handler = middleware[i8][0][0];
            context.req.routeIndex = i8;
          } else {
            handler = i8 === middleware.length && next || void 0;
          }
          if (handler) {
            try {
              res = await handler(context, () => dispatch(i8 + 1));
            } catch (err3) {
              if (err3 instanceof Error && onError) {
                context.error = err3;
                res = await onError(err3, context);
                isError = true;
              } else {
                throw err3;
              }
            }
          } else {
            if (context.finalized === false && onNotFound) {
              res = await onNotFound(context);
            }
          }
          if (res && (context.finalized === false || isError)) {
            context.res = res;
          }
          return context;
        }
      };
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/body.js
async function parseFormData(request2, options) {
  const formData = await request2.formData();
  if (formData) {
    return convertFormDataToBodyData(formData, options);
  }
  return {};
}
function convertFormDataToBodyData(formData, options) {
  const form = /* @__PURE__ */ Object.create(null);
  formData.forEach((value, key) => {
    const shouldParseAllValues = options.all || key.endsWith("[]");
    if (!shouldParseAllValues) {
      form[key] = value;
    } else {
      handleParsingAllValues(form, key, value);
    }
  });
  if (options.dot) {
    Object.entries(form).forEach(([key, value]) => {
      const shouldParseDotValues = key.includes(".");
      if (shouldParseDotValues) {
        handleParsingNestedValues(form, key, value);
        delete form[key];
      }
    });
  }
  return form;
}
var parseBody, handleParsingAllValues, handleParsingNestedValues;
var init_body = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/body.js"() {
    "use strict";
    init_request();
    parseBody = async (request2, options = /* @__PURE__ */ Object.create(null)) => {
      const { all = false, dot = false } = options;
      const headers = request2 instanceof HonoRequest ? request2.raw.headers : request2.headers;
      const contentType = headers.get("Content-Type");
      if (contentType?.startsWith("multipart/form-data") || contentType?.startsWith("application/x-www-form-urlencoded")) {
        return parseFormData(request2, { all, dot });
      }
      return {};
    };
    handleParsingAllValues = (form, key, value) => {
      if (form[key] !== void 0) {
        if (Array.isArray(form[key])) {
          ;
          form[key].push(value);
        } else {
          form[key] = [form[key], value];
        }
      } else {
        form[key] = value;
      }
    };
    handleParsingNestedValues = (form, key, value) => {
      let nestedForm = form;
      const keys = key.split(".");
      keys.forEach((key2, index7) => {
        if (index7 === keys.length - 1) {
          nestedForm[key2] = value;
        } else {
          if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
            nestedForm[key2] = /* @__PURE__ */ Object.create(null);
          }
          nestedForm = nestedForm[key2];
        }
      });
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/request.js
var tryDecodeURIComponent, _validatedData, _matchResult, _HonoRequest_instances, getDecodedParam_fn, getAllDecodedParams_fn, getParamValue_fn, _cachedBody, _a438, HonoRequest;
var init_request = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/request.js"() {
    "use strict";
    init_body();
    init_url();
    tryDecodeURIComponent = (str) => tryDecode(str, decodeURIComponent_);
    HonoRequest = (_a438 = class {
      constructor(request2, path3 = "/", matchResult = [[]]) {
        __privateAdd(this, _HonoRequest_instances);
        __publicField(this, "raw");
        __privateAdd(this, _validatedData);
        __privateAdd(this, _matchResult);
        __publicField(this, "routeIndex", 0);
        __publicField(this, "path");
        __publicField(this, "bodyCache", {});
        __privateAdd(this, _cachedBody, (key) => {
          const { bodyCache, raw: raw2 } = this;
          const cachedBody = bodyCache[key];
          if (cachedBody) {
            return cachedBody;
          }
          const anyCachedKey = Object.keys(bodyCache)[0];
          if (anyCachedKey) {
            return bodyCache[anyCachedKey].then((body2) => {
              if (anyCachedKey === "json") {
                body2 = JSON.stringify(body2);
              }
              return new Response(body2)[key]();
            });
          }
          return bodyCache[key] = raw2[key]();
        });
        this.raw = request2;
        this.path = path3;
        __privateSet(this, _matchResult, matchResult);
        __privateSet(this, _validatedData, {});
      }
      param(key) {
        return key ? __privateMethod(this, _HonoRequest_instances, getDecodedParam_fn).call(this, key) : __privateMethod(this, _HonoRequest_instances, getAllDecodedParams_fn).call(this);
      }
      query(key) {
        return getQueryParam(this.url, key);
      }
      queries(key) {
        return getQueryParams(this.url, key);
      }
      header(name3) {
        if (name3) {
          return this.raw.headers.get(name3) ?? void 0;
        }
        const headerData = {};
        this.raw.headers.forEach((value, key) => {
          headerData[key] = value;
        });
        return headerData;
      }
      async parseBody(options) {
        return this.bodyCache.parsedBody ??= await parseBody(this, options);
      }
      json() {
        return __privateGet(this, _cachedBody).call(this, "json");
      }
      text() {
        return __privateGet(this, _cachedBody).call(this, "text");
      }
      arrayBuffer() {
        return __privateGet(this, _cachedBody).call(this, "arrayBuffer");
      }
      blob() {
        return __privateGet(this, _cachedBody).call(this, "blob");
      }
      formData() {
        return __privateGet(this, _cachedBody).call(this, "formData");
      }
      addValidatedData(target, data) {
        __privateGet(this, _validatedData)[target] = data;
      }
      valid(target) {
        return __privateGet(this, _validatedData)[target];
      }
      get url() {
        return this.raw.url;
      }
      get method() {
        return this.raw.method;
      }
      get matchedRoutes() {
        return __privateGet(this, _matchResult)[0].map(([[, route]]) => route);
      }
      get routePath() {
        return __privateGet(this, _matchResult)[0].map(([[, route]]) => route)[this.routeIndex].path;
      }
    }, _validatedData = new WeakMap(), _matchResult = new WeakMap(), _HonoRequest_instances = new WeakSet(), getDecodedParam_fn = function(key) {
      const paramKey = __privateGet(this, _matchResult)[0][this.routeIndex][1][key];
      const param2 = __privateMethod(this, _HonoRequest_instances, getParamValue_fn).call(this, paramKey);
      return param2 ? /\%/.test(param2) ? tryDecodeURIComponent(param2) : param2 : void 0;
    }, getAllDecodedParams_fn = function() {
      const decoded = {};
      const keys = Object.keys(__privateGet(this, _matchResult)[0][this.routeIndex][1]);
      for (const key of keys) {
        const value = __privateMethod(this, _HonoRequest_instances, getParamValue_fn).call(this, __privateGet(this, _matchResult)[0][this.routeIndex][1][key]);
        if (value && typeof value === "string") {
          decoded[key] = /\%/.test(value) ? tryDecodeURIComponent(value) : value;
        }
      }
      return decoded;
    }, getParamValue_fn = function(paramKey) {
      return __privateGet(this, _matchResult)[1] ? __privateGet(this, _matchResult)[1][paramKey] : paramKey;
    }, _cachedBody = new WeakMap(), _a438);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/html.js
var HtmlEscapedCallbackPhase, raw, resolveCallback;
var init_html = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/html.js"() {
    "use strict";
    HtmlEscapedCallbackPhase = {
      Stringify: 1,
      BeforeStream: 2,
      Stream: 3
    };
    raw = (value, callbacks) => {
      const escapedString = new String(value);
      escapedString.isEscaped = true;
      escapedString.callbacks = callbacks;
      return escapedString;
    };
    resolveCallback = async (str, phase, preserveCallbacks, context, buffer2) => {
      if (typeof str === "object" && !(str instanceof String)) {
        if (!(str instanceof Promise)) {
          str = str.toString();
        }
        if (str instanceof Promise) {
          str = await str;
        }
      }
      const callbacks = str.callbacks;
      if (!callbacks?.length) {
        return Promise.resolve(str);
      }
      if (buffer2) {
        buffer2[0] += str;
      } else {
        buffer2 = [str];
      }
      const resStr = Promise.all(callbacks.map((c6) => c6({ phase, buffer: buffer2, context }))).then(
        (res) => Promise.all(
          res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer2))
        ).then(() => buffer2[0])
      );
      if (preserveCallbacks) {
        return raw(await resStr, callbacks);
      } else {
        return resStr;
      }
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/context.js
var TEXT_PLAIN, setHeaders, _rawRequest, _req, _var, _status, _executionCtx, _headers, _preparedHeaders, _res, _isFresh, _layout, _renderer, _notFoundHandler, _matchResult2, _path, _Context_instances, newResponse_fn, _a439, Context;
var init_context = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/context.js"() {
    "use strict";
    init_request();
    init_html();
    TEXT_PLAIN = "text/plain; charset=UTF-8";
    setHeaders = (headers, map2 = {}) => {
      for (const key of Object.keys(map2)) {
        headers.set(key, map2[key]);
      }
      return headers;
    };
    Context = (_a439 = class {
      constructor(req, options) {
        __privateAdd(this, _Context_instances);
        __privateAdd(this, _rawRequest);
        __privateAdd(this, _req);
        __publicField(this, "env", {});
        __privateAdd(this, _var);
        __publicField(this, "finalized", false);
        __publicField(this, "error");
        __privateAdd(this, _status, 200);
        __privateAdd(this, _executionCtx);
        __privateAdd(this, _headers);
        __privateAdd(this, _preparedHeaders);
        __privateAdd(this, _res);
        __privateAdd(this, _isFresh, true);
        __privateAdd(this, _layout);
        __privateAdd(this, _renderer);
        __privateAdd(this, _notFoundHandler);
        __privateAdd(this, _matchResult2);
        __privateAdd(this, _path);
        __publicField(this, "render", (...args2) => {
          __privateGet(this, _renderer) ?? __privateSet(this, _renderer, (content) => this.html(content));
          return __privateGet(this, _renderer).call(this, ...args2);
        });
        __publicField(this, "setLayout", (layout) => __privateSet(this, _layout, layout));
        __publicField(this, "getLayout", () => __privateGet(this, _layout));
        __publicField(this, "setRenderer", (renderer) => {
          __privateSet(this, _renderer, renderer);
        });
        __publicField(this, "header", (name3, value, options) => {
          if (this.finalized) {
            __privateSet(this, _res, new Response(__privateGet(this, _res).body, __privateGet(this, _res)));
          }
          if (value === void 0) {
            if (__privateGet(this, _headers)) {
              __privateGet(this, _headers).delete(name3);
            } else if (__privateGet(this, _preparedHeaders)) {
              delete __privateGet(this, _preparedHeaders)[name3.toLocaleLowerCase()];
            }
            if (this.finalized) {
              this.res.headers.delete(name3);
            }
            return;
          }
          if (options?.append) {
            if (!__privateGet(this, _headers)) {
              __privateSet(this, _isFresh, false);
              __privateSet(this, _headers, new Headers(__privateGet(this, _preparedHeaders)));
              __privateSet(this, _preparedHeaders, {});
            }
            __privateGet(this, _headers).append(name3, value);
          } else {
            if (__privateGet(this, _headers)) {
              __privateGet(this, _headers).set(name3, value);
            } else {
              __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
              __privateGet(this, _preparedHeaders)[name3.toLowerCase()] = value;
            }
          }
          if (this.finalized) {
            if (options?.append) {
              this.res.headers.append(name3, value);
            } else {
              this.res.headers.set(name3, value);
            }
          }
        });
        __publicField(this, "status", (status) => {
          __privateSet(this, _isFresh, false);
          __privateSet(this, _status, status);
        });
        __publicField(this, "set", (key, value) => {
          __privateGet(this, _var) ?? __privateSet(this, _var, /* @__PURE__ */ new Map());
          __privateGet(this, _var).set(key, value);
        });
        __publicField(this, "get", (key) => {
          return __privateGet(this, _var) ? __privateGet(this, _var).get(key) : void 0;
        });
        __publicField(this, "newResponse", (...args2) => __privateMethod(this, _Context_instances, newResponse_fn).call(this, ...args2));
        __publicField(this, "body", (data, arg, headers) => {
          return typeof arg === "number" ? __privateMethod(this, _Context_instances, newResponse_fn).call(this, data, arg, headers) : __privateMethod(this, _Context_instances, newResponse_fn).call(this, data, arg);
        });
        __publicField(this, "text", (text5, arg, headers) => {
          if (!__privateGet(this, _preparedHeaders)) {
            if (__privateGet(this, _isFresh) && !headers && !arg) {
              return new Response(text5);
            }
            __privateSet(this, _preparedHeaders, {});
          }
          __privateGet(this, _preparedHeaders)["content-type"] = TEXT_PLAIN;
          if (typeof arg === "number") {
            return __privateMethod(this, _Context_instances, newResponse_fn).call(this, text5, arg, headers);
          }
          return __privateMethod(this, _Context_instances, newResponse_fn).call(this, text5, arg);
        });
        __publicField(this, "json", (object2, arg, headers) => {
          const body2 = JSON.stringify(object2);
          __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
          __privateGet(this, _preparedHeaders)["content-type"] = "application/json";
          return typeof arg === "number" ? __privateMethod(this, _Context_instances, newResponse_fn).call(this, body2, arg, headers) : __privateMethod(this, _Context_instances, newResponse_fn).call(this, body2, arg);
        });
        __publicField(this, "html", (html, arg, headers) => {
          __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
          __privateGet(this, _preparedHeaders)["content-type"] = "text/html; charset=UTF-8";
          if (typeof html === "object") {
            return resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then((html2) => {
              return typeof arg === "number" ? __privateMethod(this, _Context_instances, newResponse_fn).call(this, html2, arg, headers) : __privateMethod(this, _Context_instances, newResponse_fn).call(this, html2, arg);
            });
          }
          return typeof arg === "number" ? __privateMethod(this, _Context_instances, newResponse_fn).call(this, html, arg, headers) : __privateMethod(this, _Context_instances, newResponse_fn).call(this, html, arg);
        });
        __publicField(this, "redirect", (location2, status) => {
          __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
          __privateGet(this, _headers).set("Location", String(location2));
          return this.newResponse(null, status ?? 302);
        });
        __publicField(this, "notFound", () => {
          __privateGet(this, _notFoundHandler) ?? __privateSet(this, _notFoundHandler, () => new Response());
          return __privateGet(this, _notFoundHandler).call(this, this);
        });
        __privateSet(this, _rawRequest, req);
        if (options) {
          __privateSet(this, _executionCtx, options.executionCtx);
          this.env = options.env;
          __privateSet(this, _notFoundHandler, options.notFoundHandler);
          __privateSet(this, _path, options.path);
          __privateSet(this, _matchResult2, options.matchResult);
        }
      }
      get req() {
        __privateGet(this, _req) ?? __privateSet(this, _req, new HonoRequest(__privateGet(this, _rawRequest), __privateGet(this, _path), __privateGet(this, _matchResult2)));
        return __privateGet(this, _req);
      }
      get event() {
        if (__privateGet(this, _executionCtx) && "respondWith" in __privateGet(this, _executionCtx)) {
          return __privateGet(this, _executionCtx);
        } else {
          throw Error("This context has no FetchEvent");
        }
      }
      get executionCtx() {
        if (__privateGet(this, _executionCtx)) {
          return __privateGet(this, _executionCtx);
        } else {
          throw Error("This context has no ExecutionContext");
        }
      }
      get res() {
        __privateSet(this, _isFresh, false);
        return __privateGet(this, _res) || __privateSet(this, _res, new Response("404 Not Found", { status: 404 }));
      }
      set res(_res2) {
        __privateSet(this, _isFresh, false);
        if (__privateGet(this, _res) && _res2) {
          _res2 = new Response(_res2.body, _res2);
          for (const [k9, v11] of __privateGet(this, _res).headers.entries()) {
            if (k9 === "content-type") {
              continue;
            }
            if (k9 === "set-cookie") {
              const cookies = __privateGet(this, _res).headers.getSetCookie();
              _res2.headers.delete("set-cookie");
              for (const cookie of cookies) {
                _res2.headers.append("set-cookie", cookie);
              }
            } else {
              _res2.headers.set(k9, v11);
            }
          }
        }
        __privateSet(this, _res, _res2);
        this.finalized = true;
      }
      get var() {
        if (!__privateGet(this, _var)) {
          return {};
        }
        return Object.fromEntries(__privateGet(this, _var));
      }
    }, _rawRequest = new WeakMap(), _req = new WeakMap(), _var = new WeakMap(), _status = new WeakMap(), _executionCtx = new WeakMap(), _headers = new WeakMap(), _preparedHeaders = new WeakMap(), _res = new WeakMap(), _isFresh = new WeakMap(), _layout = new WeakMap(), _renderer = new WeakMap(), _notFoundHandler = new WeakMap(), _matchResult2 = new WeakMap(), _path = new WeakMap(), _Context_instances = new WeakSet(), newResponse_fn = function(data, arg, headers) {
      if (__privateGet(this, _isFresh) && !headers && !arg && __privateGet(this, _status) === 200) {
        return new Response(data, {
          headers: __privateGet(this, _preparedHeaders)
        });
      }
      if (arg && typeof arg !== "number") {
        const header = new Headers(arg.headers);
        if (__privateGet(this, _headers)) {
          __privateGet(this, _headers).forEach((v11, k9) => {
            if (k9 === "set-cookie") {
              header.append(k9, v11);
            } else {
              header.set(k9, v11);
            }
          });
        }
        const headers2 = setHeaders(header, __privateGet(this, _preparedHeaders));
        return new Response(data, {
          headers: headers2,
          status: arg.status ?? __privateGet(this, _status)
        });
      }
      const status = typeof arg === "number" ? arg : __privateGet(this, _status);
      __privateGet(this, _preparedHeaders) ?? __privateSet(this, _preparedHeaders, {});
      __privateGet(this, _headers) ?? __privateSet(this, _headers, new Headers());
      setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
      if (__privateGet(this, _res)) {
        __privateGet(this, _res).headers.forEach((v11, k9) => {
          if (k9 === "set-cookie") {
            __privateGet(this, _headers)?.append(k9, v11);
          } else {
            __privateGet(this, _headers)?.set(k9, v11);
          }
        });
        setHeaders(__privateGet(this, _headers), __privateGet(this, _preparedHeaders));
      }
      headers ??= {};
      for (const [k9, v11] of Object.entries(headers)) {
        if (typeof v11 === "string") {
          __privateGet(this, _headers).set(k9, v11);
        } else {
          __privateGet(this, _headers).delete(k9);
          for (const v22 of v11) {
            __privateGet(this, _headers).append(k9, v22);
          }
        }
      }
      return new Response(data, {
        status,
        headers: __privateGet(this, _headers)
      });
    }, _a439);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router.js
var METHOD_NAME_ALL, METHOD_NAME_ALL_LOWERCASE, METHODS, MESSAGE_MATCHER_IS_ALREADY_BUILT, UnsupportedPathError;
var init_router = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router.js"() {
    "use strict";
    METHOD_NAME_ALL = "ALL";
    METHOD_NAME_ALL_LOWERCASE = "all";
    METHODS = ["get", "post", "put", "delete", "options", "patch"];
    MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
    UnsupportedPathError = class extends Error {
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/constants.js
var COMPOSED_HANDLER;
var init_constants = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/constants.js"() {
    "use strict";
    COMPOSED_HANDLER = "__COMPOSED_HANDLER";
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/hono-base.js
var notFoundHandler, errorHandler, _path2, _Hono_instances, clone_fn, _notFoundHandler2, addRoute_fn, handleError_fn, dispatch_fn, _a440, Hono;
var init_hono_base = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/hono-base.js"() {
    "use strict";
    init_compose();
    init_context();
    init_router();
    init_constants();
    init_url();
    notFoundHandler = (c6) => {
      return c6.text("404 Not Found", 404);
    };
    errorHandler = (err3, c6) => {
      if ("getResponse" in err3) {
        return err3.getResponse();
      }
      console.error(err3);
      return c6.text("Internal Server Error", 500);
    };
    Hono = (_a440 = class {
      constructor(options = {}) {
        __privateAdd(this, _Hono_instances);
        __publicField(this, "get");
        __publicField(this, "post");
        __publicField(this, "put");
        __publicField(this, "delete");
        __publicField(this, "options");
        __publicField(this, "patch");
        __publicField(this, "all");
        __publicField(this, "on");
        __publicField(this, "use");
        __publicField(this, "router");
        __publicField(this, "getPath");
        __publicField(this, "_basePath", "/");
        __privateAdd(this, _path2, "/");
        __publicField(this, "routes", []);
        __privateAdd(this, _notFoundHandler2, notFoundHandler);
        __publicField(this, "errorHandler", errorHandler);
        __publicField(this, "onError", (handler) => {
          this.errorHandler = handler;
          return this;
        });
        __publicField(this, "notFound", (handler) => {
          __privateSet(this, _notFoundHandler2, handler);
          return this;
        });
        __publicField(this, "fetch", (request2, ...rest) => {
          return __privateMethod(this, _Hono_instances, dispatch_fn).call(this, request2, rest[1], rest[0], request2.method);
        });
        __publicField(this, "request", (input, requestInit, Env, executionCtx) => {
          if (input instanceof Request) {
            return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
          }
          input = input.toString();
          return this.fetch(
            new Request(
              /^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`,
              requestInit
            ),
            Env,
            executionCtx
          );
        });
        __publicField(this, "fire", () => {
          addEventListener("fetch", (event) => {
            event.respondWith(__privateMethod(this, _Hono_instances, dispatch_fn).call(this, event.request, event, void 0, event.request.method));
          });
        });
        const allMethods = [...METHODS, METHOD_NAME_ALL_LOWERCASE];
        allMethods.forEach((method) => {
          this[method] = (args1, ...args2) => {
            if (typeof args1 === "string") {
              __privateSet(this, _path2, args1);
            } else {
              __privateMethod(this, _Hono_instances, addRoute_fn).call(this, method, __privateGet(this, _path2), args1);
            }
            args2.forEach((handler) => {
              __privateMethod(this, _Hono_instances, addRoute_fn).call(this, method, __privateGet(this, _path2), handler);
            });
            return this;
          };
        });
        this.on = (method, path3, ...handlers) => {
          for (const p11 of [path3].flat()) {
            __privateSet(this, _path2, p11);
            for (const m12 of [method].flat()) {
              handlers.map((handler) => {
                __privateMethod(this, _Hono_instances, addRoute_fn).call(this, m12.toUpperCase(), __privateGet(this, _path2), handler);
              });
            }
          }
          return this;
        };
        this.use = (arg1, ...handlers) => {
          if (typeof arg1 === "string") {
            __privateSet(this, _path2, arg1);
          } else {
            __privateSet(this, _path2, "*");
            handlers.unshift(arg1);
          }
          handlers.forEach((handler) => {
            __privateMethod(this, _Hono_instances, addRoute_fn).call(this, METHOD_NAME_ALL, __privateGet(this, _path2), handler);
          });
          return this;
        };
        const { strict, ...optionsWithoutStrict } = options;
        Object.assign(this, optionsWithoutStrict);
        this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
      }
      route(path3, app) {
        const subApp = this.basePath(path3);
        app.routes.map((r6) => {
          var _a506;
          let handler;
          if (app.errorHandler === errorHandler) {
            handler = r6.handler;
          } else {
            handler = async (c6, next) => (await compose([], app.errorHandler)(c6, () => r6.handler(c6, next))).res;
            handler[COMPOSED_HANDLER] = r6.handler;
          }
          __privateMethod(_a506 = subApp, _Hono_instances, addRoute_fn).call(_a506, r6.method, r6.path, handler);
        });
        return this;
      }
      basePath(path3) {
        const subApp = __privateMethod(this, _Hono_instances, clone_fn).call(this);
        subApp._basePath = mergePath(this._basePath, path3);
        return subApp;
      }
      mount(path3, applicationHandler, options) {
        let replaceRequest;
        let optionHandler;
        if (options) {
          if (typeof options === "function") {
            optionHandler = options;
          } else {
            optionHandler = options.optionHandler;
            if (options.replaceRequest === false) {
              replaceRequest = (request2) => request2;
            } else {
              replaceRequest = options.replaceRequest;
            }
          }
        }
        const getOptions = optionHandler ? (c6) => {
          const options2 = optionHandler(c6);
          return Array.isArray(options2) ? options2 : [options2];
        } : (c6) => {
          let executionContext = void 0;
          try {
            executionContext = c6.executionCtx;
          } catch {
          }
          return [c6.env, executionContext];
        };
        replaceRequest ||= (() => {
          const mergedPath = mergePath(this._basePath, path3);
          const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
          return (request2) => {
            const url = new URL(request2.url);
            url.pathname = url.pathname.slice(pathPrefixLength) || "/";
            return new Request(url, request2);
          };
        })();
        const handler = async (c6, next) => {
          const res = await applicationHandler(replaceRequest(c6.req.raw), ...getOptions(c6));
          if (res) {
            return res;
          }
          await next();
        };
        __privateMethod(this, _Hono_instances, addRoute_fn).call(this, METHOD_NAME_ALL, mergePath(path3, "*"), handler);
        return this;
      }
    }, _path2 = new WeakMap(), _Hono_instances = new WeakSet(), clone_fn = function() {
      const clone2 = new Hono({
        router: this.router,
        getPath: this.getPath
      });
      clone2.errorHandler = this.errorHandler;
      __privateSet(clone2, _notFoundHandler2, __privateGet(this, _notFoundHandler2));
      clone2.routes = this.routes;
      return clone2;
    }, _notFoundHandler2 = new WeakMap(), addRoute_fn = function(method, path3, handler) {
      method = method.toUpperCase();
      path3 = mergePath(this._basePath, path3);
      const r6 = { path: path3, method, handler };
      this.router.add(method, path3, [handler, r6]);
      this.routes.push(r6);
    }, handleError_fn = function(err3, c6) {
      if (err3 instanceof Error) {
        return this.errorHandler(err3, c6);
      }
      throw err3;
    }, dispatch_fn = function(request2, executionCtx, env4, method) {
      if (method === "HEAD") {
        return (async () => new Response(null, await __privateMethod(this, _Hono_instances, dispatch_fn).call(this, request2, executionCtx, env4, "GET")))();
      }
      const path3 = this.getPath(request2, { env: env4 });
      const matchResult = this.router.match(method, path3);
      const c6 = new Context(request2, {
        path: path3,
        matchResult,
        env: env4,
        executionCtx,
        notFoundHandler: __privateGet(this, _notFoundHandler2)
      });
      if (matchResult[0].length === 1) {
        let res;
        try {
          res = matchResult[0][0][0][0](c6, async () => {
            c6.res = await __privateGet(this, _notFoundHandler2).call(this, c6);
          });
        } catch (err3) {
          return __privateMethod(this, _Hono_instances, handleError_fn).call(this, err3, c6);
        }
        return res instanceof Promise ? res.then(
          (resolved) => resolved || (c6.finalized ? c6.res : __privateGet(this, _notFoundHandler2).call(this, c6))
        ).catch((err3) => __privateMethod(this, _Hono_instances, handleError_fn).call(this, err3, c6)) : res ?? __privateGet(this, _notFoundHandler2).call(this, c6);
      }
      const composed = compose(matchResult[0], this.errorHandler, __privateGet(this, _notFoundHandler2));
      return (async () => {
        try {
          const context = await composed(c6);
          if (!context.finalized) {
            throw new Error(
              "Context is not finalized. Did you forget to return a Response object or `await next()`?"
            );
          }
          return context.res;
        } catch (err3) {
          return __privateMethod(this, _Hono_instances, handleError_fn).call(this, err3, c6);
        }
      })();
    }, _a440);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/node.js
function compareKey(a9, b9) {
  if (a9.length === 1) {
    return b9.length === 1 ? a9 < b9 ? -1 : 1 : -1;
  }
  if (b9.length === 1) {
    return 1;
  }
  if (a9 === ONLY_WILDCARD_REG_EXP_STR || a9 === TAIL_WILDCARD_REG_EXP_STR) {
    return 1;
  } else if (b9 === ONLY_WILDCARD_REG_EXP_STR || b9 === TAIL_WILDCARD_REG_EXP_STR) {
    return -1;
  }
  if (a9 === LABEL_REG_EXP_STR) {
    return 1;
  } else if (b9 === LABEL_REG_EXP_STR) {
    return -1;
  }
  return a9.length === b9.length ? a9 < b9 ? -1 : 1 : b9.length - a9.length;
}
var LABEL_REG_EXP_STR, ONLY_WILDCARD_REG_EXP_STR, TAIL_WILDCARD_REG_EXP_STR, PATH_ERROR, regExpMetaChars, _index, _varIndex, _children, _a441, Node;
var init_node = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/node.js"() {
    "use strict";
    LABEL_REG_EXP_STR = "[^/]+";
    ONLY_WILDCARD_REG_EXP_STR = ".*";
    TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
    PATH_ERROR = Symbol();
    regExpMetaChars = new Set(".\\+*[^]$()");
    Node = (_a441 = class {
      constructor() {
        __privateAdd(this, _index);
        __privateAdd(this, _varIndex);
        __privateAdd(this, _children, /* @__PURE__ */ Object.create(null));
      }
      insert(tokens, index7, paramMap, context, pathErrorCheckOnly) {
        if (tokens.length === 0) {
          if (__privateGet(this, _index) !== void 0) {
            throw PATH_ERROR;
          }
          if (pathErrorCheckOnly) {
            return;
          }
          __privateSet(this, _index, index7);
          return;
        }
        const [token, ...restTokens] = tokens;
        const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
        let node;
        if (pattern) {
          const name3 = pattern[1];
          let regexpStr = pattern[2] || LABEL_REG_EXP_STR;
          if (name3 && pattern[2]) {
            regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
            if (/\((?!\?:)/.test(regexpStr)) {
              throw PATH_ERROR;
            }
          }
          node = __privateGet(this, _children)[regexpStr];
          if (!node) {
            if (Object.keys(__privateGet(this, _children)).some(
              (k9) => k9 !== ONLY_WILDCARD_REG_EXP_STR && k9 !== TAIL_WILDCARD_REG_EXP_STR
            )) {
              throw PATH_ERROR;
            }
            if (pathErrorCheckOnly) {
              return;
            }
            node = __privateGet(this, _children)[regexpStr] = new Node();
            if (name3 !== "") {
              __privateSet(node, _varIndex, context.varIndex++);
            }
          }
          if (!pathErrorCheckOnly && name3 !== "") {
            paramMap.push([name3, __privateGet(node, _varIndex)]);
          }
        } else {
          node = __privateGet(this, _children)[token];
          if (!node) {
            if (Object.keys(__privateGet(this, _children)).some(
              (k9) => k9.length > 1 && k9 !== ONLY_WILDCARD_REG_EXP_STR && k9 !== TAIL_WILDCARD_REG_EXP_STR
            )) {
              throw PATH_ERROR;
            }
            if (pathErrorCheckOnly) {
              return;
            }
            node = __privateGet(this, _children)[token] = new Node();
          }
        }
        node.insert(restTokens, index7, paramMap, context, pathErrorCheckOnly);
      }
      buildRegExpStr() {
        const childKeys = Object.keys(__privateGet(this, _children)).sort(compareKey);
        const strList = childKeys.map((k9) => {
          const c6 = __privateGet(this, _children)[k9];
          return (typeof __privateGet(c6, _varIndex) === "number" ? `(${k9})@${__privateGet(c6, _varIndex)}` : regExpMetaChars.has(k9) ? `\\${k9}` : k9) + c6.buildRegExpStr();
        });
        if (typeof __privateGet(this, _index) === "number") {
          strList.unshift(`#${__privateGet(this, _index)}`);
        }
        if (strList.length === 0) {
          return "";
        }
        if (strList.length === 1) {
          return strList[0];
        }
        return "(?:" + strList.join("|") + ")";
      }
    }, _index = new WeakMap(), _varIndex = new WeakMap(), _children = new WeakMap(), _a441);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/trie.js
var _context, _root, _a442, Trie;
var init_trie = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/trie.js"() {
    "use strict";
    init_node();
    Trie = (_a442 = class {
      constructor() {
        __privateAdd(this, _context, { varIndex: 0 });
        __privateAdd(this, _root, new Node());
      }
      insert(path3, index7, pathErrorCheckOnly) {
        const paramAssoc = [];
        const groups = [];
        for (let i8 = 0; ; ) {
          let replaced = false;
          path3 = path3.replace(/\{[^}]+\}/g, (m12) => {
            const mark = `@\\${i8}`;
            groups[i8] = [mark, m12];
            i8++;
            replaced = true;
            return mark;
          });
          if (!replaced) {
            break;
          }
        }
        const tokens = path3.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
        for (let i8 = groups.length - 1; i8 >= 0; i8--) {
          const [mark] = groups[i8];
          for (let j7 = tokens.length - 1; j7 >= 0; j7--) {
            if (tokens[j7].indexOf(mark) !== -1) {
              tokens[j7] = tokens[j7].replace(mark, groups[i8][1]);
              break;
            }
          }
        }
        __privateGet(this, _root).insert(tokens, index7, paramAssoc, __privateGet(this, _context), pathErrorCheckOnly);
        return paramAssoc;
      }
      buildRegExp() {
        let regexp = __privateGet(this, _root).buildRegExpStr();
        if (regexp === "") {
          return [/^$/, [], []];
        }
        let captureIndex = 0;
        const indexReplacementMap = [];
        const paramReplacementMap = [];
        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_7, handlerIndex, paramIndex) => {
          if (handlerIndex !== void 0) {
            indexReplacementMap[++captureIndex] = Number(handlerIndex);
            return "$()";
          }
          if (paramIndex !== void 0) {
            paramReplacementMap[Number(paramIndex)] = ++captureIndex;
            return "";
          }
          return "";
        });
        return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
      }
    }, _context = new WeakMap(), _root = new WeakMap(), _a442);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/router.js
function buildWildcardRegExp(path3) {
  return wildcardRegExpCache[path3] ??= new RegExp(
    path3 === "*" ? "" : `^${path3.replace(
      /\/\*$|([.\\+*[^\]$()])/g,
      (_7, metaChar) => metaChar ? `\\${metaChar}` : "(?:|/.*)"
    )}$`
  );
}
function clearWildcardRegExpCache() {
  wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
}
function buildMatcherFromPreprocessedRoutes(routes) {
  const trie = new Trie();
  const handlerData = [];
  if (routes.length === 0) {
    return nullMatcher;
  }
  const routesWithStaticPathFlag = routes.map(
    (route) => [!/\*|\/:/.test(route[0]), ...route]
  ).sort(
    ([isStaticA, pathA], [isStaticB, pathB]) => isStaticA ? 1 : isStaticB ? -1 : pathA.length - pathB.length
  );
  const staticMap = /* @__PURE__ */ Object.create(null);
  for (let i8 = 0, j7 = -1, len = routesWithStaticPathFlag.length; i8 < len; i8++) {
    const [pathErrorCheckOnly, path3, handlers] = routesWithStaticPathFlag[i8];
    if (pathErrorCheckOnly) {
      staticMap[path3] = [handlers.map(([h8]) => [h8, /* @__PURE__ */ Object.create(null)]), emptyParam];
    } else {
      j7++;
    }
    let paramAssoc;
    try {
      paramAssoc = trie.insert(path3, j7, pathErrorCheckOnly);
    } catch (e6) {
      throw e6 === PATH_ERROR ? new UnsupportedPathError(path3) : e6;
    }
    if (pathErrorCheckOnly) {
      continue;
    }
    handlerData[j7] = handlers.map(([h8, paramCount]) => {
      const paramIndexMap = /* @__PURE__ */ Object.create(null);
      paramCount -= 1;
      for (; paramCount >= 0; paramCount--) {
        const [key, value] = paramAssoc[paramCount];
        paramIndexMap[key] = value;
      }
      return [h8, paramIndexMap];
    });
  }
  const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
  for (let i8 = 0, len = handlerData.length; i8 < len; i8++) {
    for (let j7 = 0, len2 = handlerData[i8].length; j7 < len2; j7++) {
      const map2 = handlerData[i8][j7]?.[1];
      if (!map2) {
        continue;
      }
      const keys = Object.keys(map2);
      for (let k9 = 0, len3 = keys.length; k9 < len3; k9++) {
        map2[keys[k9]] = paramReplacementMap[map2[keys[k9]]];
      }
    }
  }
  const handlerMap = [];
  for (const i8 in indexReplacementMap) {
    handlerMap[i8] = handlerData[indexReplacementMap[i8]];
  }
  return [regexp, handlerMap, staticMap];
}
function findMiddleware(middleware, path3) {
  if (!middleware) {
    return void 0;
  }
  for (const k9 of Object.keys(middleware).sort((a9, b9) => b9.length - a9.length)) {
    if (buildWildcardRegExp(k9).test(path3)) {
      return [...middleware[k9]];
    }
  }
  return void 0;
}
var emptyParam, nullMatcher, wildcardRegExpCache, _middleware, _routes, _RegExpRouter_instances, buildAllMatchers_fn, buildMatcher_fn, _a443, RegExpRouter;
var init_router2 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/router.js"() {
    "use strict";
    init_router();
    init_url();
    init_node();
    init_trie();
    emptyParam = [];
    nullMatcher = [/^$/, [], /* @__PURE__ */ Object.create(null)];
    wildcardRegExpCache = /* @__PURE__ */ Object.create(null);
    RegExpRouter = (_a443 = class {
      constructor() {
        __privateAdd(this, _RegExpRouter_instances);
        __publicField(this, "name", "RegExpRouter");
        __privateAdd(this, _middleware);
        __privateAdd(this, _routes);
        __privateSet(this, _middleware, { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) });
        __privateSet(this, _routes, { [METHOD_NAME_ALL]: /* @__PURE__ */ Object.create(null) });
      }
      add(method, path3, handler) {
        const middleware = __privateGet(this, _middleware);
        const routes = __privateGet(this, _routes);
        if (!middleware || !routes) {
          throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
        }
        if (!middleware[method]) {
          ;
          [middleware, routes].forEach((handlerMap) => {
            handlerMap[method] = /* @__PURE__ */ Object.create(null);
            Object.keys(handlerMap[METHOD_NAME_ALL]).forEach((p11) => {
              handlerMap[method][p11] = [...handlerMap[METHOD_NAME_ALL][p11]];
            });
          });
        }
        if (path3 === "/*") {
          path3 = "*";
        }
        const paramCount = (path3.match(/\/:/g) || []).length;
        if (/\*$/.test(path3)) {
          const re3 = buildWildcardRegExp(path3);
          if (method === METHOD_NAME_ALL) {
            Object.keys(middleware).forEach((m12) => {
              middleware[m12][path3] ||= findMiddleware(middleware[m12], path3) || findMiddleware(middleware[METHOD_NAME_ALL], path3) || [];
            });
          } else {
            middleware[method][path3] ||= findMiddleware(middleware[method], path3) || findMiddleware(middleware[METHOD_NAME_ALL], path3) || [];
          }
          Object.keys(middleware).forEach((m12) => {
            if (method === METHOD_NAME_ALL || method === m12) {
              Object.keys(middleware[m12]).forEach((p11) => {
                re3.test(p11) && middleware[m12][p11].push([handler, paramCount]);
              });
            }
          });
          Object.keys(routes).forEach((m12) => {
            if (method === METHOD_NAME_ALL || method === m12) {
              Object.keys(routes[m12]).forEach(
                (p11) => re3.test(p11) && routes[m12][p11].push([handler, paramCount])
              );
            }
          });
          return;
        }
        const paths = checkOptionalParameter(path3) || [path3];
        for (let i8 = 0, len = paths.length; i8 < len; i8++) {
          const path22 = paths[i8];
          Object.keys(routes).forEach((m12) => {
            if (method === METHOD_NAME_ALL || method === m12) {
              routes[m12][path22] ||= [
                ...findMiddleware(middleware[m12], path22) || findMiddleware(middleware[METHOD_NAME_ALL], path22) || []
              ];
              routes[m12][path22].push([handler, paramCount - len + i8 + 1]);
            }
          });
        }
      }
      match(method, path3) {
        clearWildcardRegExpCache();
        const matchers = __privateMethod(this, _RegExpRouter_instances, buildAllMatchers_fn).call(this);
        this.match = (method2, path22) => {
          const matcher = matchers[method2] || matchers[METHOD_NAME_ALL];
          const staticMatch = matcher[2][path22];
          if (staticMatch) {
            return staticMatch;
          }
          const match2 = path22.match(matcher[0]);
          if (!match2) {
            return [[], emptyParam];
          }
          const index7 = match2.indexOf("", 1);
          return [matcher[1][index7], match2];
        };
        return this.match(method, path3);
      }
    }, _middleware = new WeakMap(), _routes = new WeakMap(), _RegExpRouter_instances = new WeakSet(), buildAllMatchers_fn = function() {
      const matchers = /* @__PURE__ */ Object.create(null);
      Object.keys(__privateGet(this, _routes)).concat(Object.keys(__privateGet(this, _middleware))).forEach((method) => {
        matchers[method] ||= __privateMethod(this, _RegExpRouter_instances, buildMatcher_fn).call(this, method);
      });
      __privateSet(this, _middleware, __privateSet(this, _routes, void 0));
      return matchers;
    }, buildMatcher_fn = function(method) {
      const routes = [];
      let hasOwnRoute = method === METHOD_NAME_ALL;
      [__privateGet(this, _middleware), __privateGet(this, _routes)].forEach((r6) => {
        const ownRoute = r6[method] ? Object.keys(r6[method]).map((path3) => [path3, r6[method][path3]]) : [];
        if (ownRoute.length !== 0) {
          hasOwnRoute ||= true;
          routes.push(...ownRoute);
        } else if (method !== METHOD_NAME_ALL) {
          routes.push(
            ...Object.keys(r6[METHOD_NAME_ALL]).map((path3) => [path3, r6[METHOD_NAME_ALL][path3]])
          );
        }
      });
      if (!hasOwnRoute) {
        return null;
      } else {
        return buildMatcherFromPreprocessedRoutes(routes);
      }
    }, _a443);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/index.js
var init_reg_exp_router = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/reg-exp-router/index.js"() {
    "use strict";
    init_router2();
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/smart-router/router.js
var _routers, _routes2, _a444, SmartRouter;
var init_router3 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/smart-router/router.js"() {
    "use strict";
    init_router();
    SmartRouter = (_a444 = class {
      constructor(init3) {
        __publicField(this, "name", "SmartRouter");
        __privateAdd(this, _routers, []);
        __privateAdd(this, _routes2, []);
        __privateSet(this, _routers, init3.routers);
      }
      add(method, path3, handler) {
        if (!__privateGet(this, _routes2)) {
          throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
        }
        __privateGet(this, _routes2).push([method, path3, handler]);
      }
      match(method, path3) {
        if (!__privateGet(this, _routes2)) {
          throw new Error("Fatal error");
        }
        const routers = __privateGet(this, _routers);
        const routes = __privateGet(this, _routes2);
        const len = routers.length;
        let i8 = 0;
        let res;
        for (; i8 < len; i8++) {
          const router = routers[i8];
          try {
            for (let i22 = 0, len2 = routes.length; i22 < len2; i22++) {
              router.add(...routes[i22]);
            }
            res = router.match(method, path3);
          } catch (e6) {
            if (e6 instanceof UnsupportedPathError) {
              continue;
            }
            throw e6;
          }
          this.match = router.match.bind(router);
          __privateSet(this, _routers, [router]);
          __privateSet(this, _routes2, void 0);
          break;
        }
        if (i8 === len) {
          throw new Error("Fatal error");
        }
        this.name = `SmartRouter + ${this.activeRouter.name}`;
        return res;
      }
      get activeRouter() {
        if (__privateGet(this, _routes2) || __privateGet(this, _routers).length !== 1) {
          throw new Error("No active router has been determined yet.");
        }
        return __privateGet(this, _routers)[0];
      }
    }, _routers = new WeakMap(), _routes2 = new WeakMap(), _a444);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/smart-router/index.js
var init_smart_router = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/smart-router/index.js"() {
    "use strict";
    init_router3();
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/trie-router/node.js
var emptyParams, _methods, _children2, _patterns, _order, _params, _Node_instances, getHandlerSets_fn, _a445, Node2;
var init_node2 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/trie-router/node.js"() {
    "use strict";
    init_router();
    init_url();
    emptyParams = /* @__PURE__ */ Object.create(null);
    Node2 = (_a445 = class {
      constructor(method, handler, children) {
        __privateAdd(this, _Node_instances);
        __privateAdd(this, _methods);
        __privateAdd(this, _children2);
        __privateAdd(this, _patterns);
        __privateAdd(this, _order, 0);
        __privateAdd(this, _params, emptyParams);
        __privateSet(this, _children2, children || /* @__PURE__ */ Object.create(null));
        __privateSet(this, _methods, []);
        if (method && handler) {
          const m12 = /* @__PURE__ */ Object.create(null);
          m12[method] = { handler, possibleKeys: [], score: 0 };
          __privateSet(this, _methods, [m12]);
        }
        __privateSet(this, _patterns, []);
      }
      insert(method, path3, handler) {
        __privateSet(this, _order, ++__privateWrapper(this, _order)._);
        let curNode = this;
        const parts2 = splitRoutingPath(path3);
        const possibleKeys = [];
        for (let i8 = 0, len = parts2.length; i8 < len; i8++) {
          const p11 = parts2[i8];
          const nextP = parts2[i8 + 1];
          const pattern = getPattern(p11, nextP);
          const key = Array.isArray(pattern) ? pattern[0] : p11;
          if (Object.keys(__privateGet(curNode, _children2)).includes(key)) {
            curNode = __privateGet(curNode, _children2)[key];
            const pattern2 = getPattern(p11, nextP);
            if (pattern2) {
              possibleKeys.push(pattern2[1]);
            }
            continue;
          }
          __privateGet(curNode, _children2)[key] = new Node2();
          if (pattern) {
            __privateGet(curNode, _patterns).push(pattern);
            possibleKeys.push(pattern[1]);
          }
          curNode = __privateGet(curNode, _children2)[key];
        }
        const m12 = /* @__PURE__ */ Object.create(null);
        const handlerSet = {
          handler,
          possibleKeys: possibleKeys.filter((v11, i8, a9) => a9.indexOf(v11) === i8),
          score: __privateGet(this, _order)
        };
        m12[method] = handlerSet;
        __privateGet(curNode, _methods).push(m12);
        return curNode;
      }
      search(method, path3) {
        const handlerSets = [];
        __privateSet(this, _params, emptyParams);
        const curNode = this;
        let curNodes = [curNode];
        const parts2 = splitPath(path3);
        const curNodesQueue = [];
        for (let i8 = 0, len = parts2.length; i8 < len; i8++) {
          const part = parts2[i8];
          const isLast = i8 === len - 1;
          const tempNodes = [];
          for (let j7 = 0, len2 = curNodes.length; j7 < len2; j7++) {
            const node = curNodes[j7];
            const nextNode = __privateGet(node, _children2)[part];
            if (nextNode) {
              __privateSet(nextNode, _params, __privateGet(node, _params));
              if (isLast) {
                if (__privateGet(nextNode, _children2)["*"]) {
                  handlerSets.push(
                    ...__privateMethod(this, _Node_instances, getHandlerSets_fn).call(this, __privateGet(nextNode, _children2)["*"], method, __privateGet(node, _params))
                  );
                }
                handlerSets.push(...__privateMethod(this, _Node_instances, getHandlerSets_fn).call(this, nextNode, method, __privateGet(node, _params)));
              } else {
                tempNodes.push(nextNode);
              }
            }
            for (let k9 = 0, len3 = __privateGet(node, _patterns).length; k9 < len3; k9++) {
              const pattern = __privateGet(node, _patterns)[k9];
              const params = __privateGet(node, _params) === emptyParams ? {} : { ...__privateGet(node, _params) };
              if (pattern === "*") {
                const astNode = __privateGet(node, _children2)["*"];
                if (astNode) {
                  handlerSets.push(...__privateMethod(this, _Node_instances, getHandlerSets_fn).call(this, astNode, method, __privateGet(node, _params)));
                  __privateSet(astNode, _params, params);
                  tempNodes.push(astNode);
                }
                continue;
              }
              if (part === "") {
                continue;
              }
              const [key, name3, matcher] = pattern;
              const child = __privateGet(node, _children2)[key];
              const restPathString = parts2.slice(i8).join("/");
              if (matcher instanceof RegExp) {
                const m12 = matcher.exec(restPathString);
                if (m12) {
                  params[name3] = m12[0];
                  handlerSets.push(...__privateMethod(this, _Node_instances, getHandlerSets_fn).call(this, child, method, __privateGet(node, _params), params));
                  if (Object.keys(__privateGet(child, _children2)).length) {
                    __privateSet(child, _params, params);
                    const componentCount = m12[0].match(/\//)?.length ?? 0;
                    const targetCurNodes = curNodesQueue[componentCount] ||= [];
                    targetCurNodes.push(child);
                  }
                  continue;
                }
              }
              if (matcher === true || matcher.test(part)) {
                params[name3] = part;
                if (isLast) {
                  handlerSets.push(...__privateMethod(this, _Node_instances, getHandlerSets_fn).call(this, child, method, params, __privateGet(node, _params)));
                  if (__privateGet(child, _children2)["*"]) {
                    handlerSets.push(
                      ...__privateMethod(this, _Node_instances, getHandlerSets_fn).call(this, __privateGet(child, _children2)["*"], method, params, __privateGet(node, _params))
                    );
                  }
                } else {
                  __privateSet(child, _params, params);
                  tempNodes.push(child);
                }
              }
            }
          }
          curNodes = tempNodes.concat(curNodesQueue.shift() ?? []);
        }
        if (handlerSets.length > 1) {
          handlerSets.sort((a9, b9) => {
            return a9.score - b9.score;
          });
        }
        return [handlerSets.map(({ handler, params }) => [handler, params])];
      }
    }, _methods = new WeakMap(), _children2 = new WeakMap(), _patterns = new WeakMap(), _order = new WeakMap(), _params = new WeakMap(), _Node_instances = new WeakSet(), getHandlerSets_fn = function(node, method, nodeParams, params) {
      const handlerSets = [];
      for (let i8 = 0, len = __privateGet(node, _methods).length; i8 < len; i8++) {
        const m12 = __privateGet(node, _methods)[i8];
        const handlerSet = m12[method] || m12[METHOD_NAME_ALL];
        const processedSet = {};
        if (handlerSet !== void 0) {
          handlerSet.params = /* @__PURE__ */ Object.create(null);
          handlerSets.push(handlerSet);
          if (nodeParams !== emptyParams || params && params !== emptyParams) {
            for (let i22 = 0, len2 = handlerSet.possibleKeys.length; i22 < len2; i22++) {
              const key = handlerSet.possibleKeys[i22];
              const processed = processedSet[handlerSet.score];
              handlerSet.params[key] = params?.[key] && !processed ? params[key] : nodeParams[key] ?? params?.[key];
              processedSet[handlerSet.score] = true;
            }
          }
        }
      }
      return handlerSets;
    }, _a445);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/trie-router/router.js
var _node, _a446, TrieRouter;
var init_router4 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/trie-router/router.js"() {
    "use strict";
    init_url();
    init_node2();
    TrieRouter = (_a446 = class {
      constructor() {
        __publicField(this, "name", "TrieRouter");
        __privateAdd(this, _node);
        __privateSet(this, _node, new Node2());
      }
      add(method, path3, handler) {
        const results = checkOptionalParameter(path3);
        if (results) {
          for (let i8 = 0, len = results.length; i8 < len; i8++) {
            __privateGet(this, _node).insert(method, results[i8], handler);
          }
          return;
        }
        __privateGet(this, _node).insert(method, path3, handler);
      }
      match(method, path3) {
        return __privateGet(this, _node).search(method, path3);
      }
    }, _node = new WeakMap(), _a446);
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/trie-router/index.js
var init_trie_router = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/router/trie-router/index.js"() {
    "use strict";
    init_router4();
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/hono.js
var Hono2;
var init_hono = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/hono.js"() {
    "use strict";
    init_hono_base();
    init_reg_exp_router();
    init_smart_router();
    init_trie_router();
    Hono2 = class extends Hono {
      constructor(options = {}) {
        super(options);
        this.router = options.router ?? new SmartRouter({
          routers: [new RegExpRouter(), new TrieRouter()]
        });
      }
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/index.js
var init_dist3 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/index.js"() {
    "use strict";
    init_hono();
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/compress.js
var COMPRESSIBLE_CONTENT_TYPE_REGEX;
var init_compress = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/utils/compress.js"() {
    "use strict";
    COMPRESSIBLE_CONTENT_TYPE_REGEX = /^\s*(?:text\/(?!event-stream(?:[;\s]|$))[^;\s]+|application\/(?:javascript|json|xml|xml-dtd|ecmascript|dart|postscript|rtf|tar|toml|vnd\.dart|vnd\.ms-fontobject|vnd\.ms-opentype|wasm|x-httpd-php|x-javascript|x-ns-proxy-autoconfig|x-sh|x-tar|x-virtualbox-hdd|x-virtualbox-ova|x-virtualbox-ovf|x-virtualbox-vbox|x-virtualbox-vdi|x-virtualbox-vhd|x-virtualbox-vmdk|x-www-form-urlencoded)|font\/(?:otf|ttf)|image\/(?:bmp|vnd\.adobe\.photoshop|vnd\.microsoft\.icon|vnd\.ms-dds|x-icon|x-ms-bmp)|message\/rfc822|model\/gltf-binary|x-shader\/x-fragment|x-shader\/x-vertex|[^;\s]+?\+(?:json|text|xml|yaml))(?:[;\s]|$)/i;
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/middleware/compress/index.js
var ENCODING_TYPES, cacheControlNoTransformRegExp, compress, shouldCompress, shouldTransform;
var init_compress2 = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/middleware/compress/index.js"() {
    "use strict";
    init_compress();
    ENCODING_TYPES = ["gzip", "deflate"];
    cacheControlNoTransformRegExp = /(?:^|,)\s*?no-transform\s*?(?:,|$)/i;
    compress = (options) => {
      const threshold = options?.threshold ?? 1024;
      return async function compress2(ctx, next) {
        await next();
        const contentLength = ctx.res.headers.get("Content-Length");
        if (ctx.res.headers.has("Content-Encoding") || ctx.res.headers.has("Transfer-Encoding") || ctx.req.method === "HEAD" || contentLength && Number(contentLength) < threshold || !shouldCompress(ctx.res) || !shouldTransform(ctx.res)) {
          return;
        }
        const accepted = ctx.req.header("Accept-Encoding");
        const encoding = options?.encoding ?? ENCODING_TYPES.find((encoding2) => accepted?.includes(encoding2));
        if (!encoding || !ctx.res.body) {
          return;
        }
        const stream = new CompressionStream(encoding);
        ctx.res = new Response(ctx.res.body.pipeThrough(stream), ctx.res);
        ctx.res.headers.delete("Content-Length");
        ctx.res.headers.set("Content-Encoding", encoding);
      };
    };
    shouldCompress = (res) => {
      const type = res.headers.get("Content-Type");
      return type && COMPRESSIBLE_CONTENT_TYPE_REGEX.test(type);
    };
    shouldTransform = (res) => {
      const cacheControl = res.headers.get("Cache-Control");
      return !cacheControl || !cacheControlNoTransformRegExp.test(cacheControl);
    };
  }
});

// ../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/middleware/cors/index.js
var cors;
var init_cors = __esm({
  "../node_modules/.pnpm/hono@4.7.10/node_modules/hono/dist/middleware/cors/index.js"() {
    "use strict";
    cors = (options) => {
      const defaults3 = {
        origin: "*",
        allowMethods: ["GET", "HEAD", "PUT", "POST", "DELETE", "PATCH"],
        allowHeaders: [],
        exposeHeaders: []
      };
      const opts = {
        ...defaults3,
        ...options
      };
      const findAllowOrigin = ((optsOrigin) => {
        if (typeof optsOrigin === "string") {
          if (optsOrigin === "*") {
            return () => optsOrigin;
          } else {
            return (origin) => optsOrigin === origin ? origin : null;
          }
        } else if (typeof optsOrigin === "function") {
          return optsOrigin;
        } else {
          return (origin) => optsOrigin.includes(origin) ? origin : null;
        }
      })(opts.origin);
      return async function cors2(c6, next) {
        function set(key, value) {
          c6.res.headers.set(key, value);
        }
        const allowOrigin = findAllowOrigin(c6.req.header("origin") || "", c6);
        if (allowOrigin) {
          set("Access-Control-Allow-Origin", allowOrigin);
        }
        if (opts.origin !== "*") {
          const existingVary = c6.req.header("Vary");
          if (existingVary) {
            set("Vary", existingVary);
          } else {
            set("Vary", "Origin");
          }
        }
        if (opts.credentials) {
          set("Access-Control-Allow-Credentials", "true");
        }
        if (opts.exposeHeaders?.length) {
          set("Access-Control-Expose-Headers", opts.exposeHeaders.join(","));
        }
        if (c6.req.method === "OPTIONS") {
          if (opts.maxAge != null) {
            set("Access-Control-Max-Age", opts.maxAge.toString());
          }
          if (opts.allowMethods?.length) {
            set("Access-Control-Allow-Methods", opts.allowMethods.join(","));
          }
          let headers = opts.allowHeaders;
          if (!headers?.length) {
            const requestHeaders = c6.req.header("Access-Control-Request-Headers");
            if (requestHeaders) {
              headers = requestHeaders.split(/\s*,\s*/);
            }
          }
          if (headers?.length) {
            set("Access-Control-Allow-Headers", headers.join(","));
            c6.res.headers.append("Vary", "Access-Control-Request-Headers");
          }
          c6.res.headers.delete("Content-Length");
          c6.res.headers.delete("Content-Type");
          return new Response(null, {
            headers: c6.res.headers,
            status: 204,
            statusText: "No Content"
          });
        }
        await next();
      };
    };
  }
});

// ../node_modules/.pnpm/data-uri-to-buffer@4.0.1/node_modules/data-uri-to-buffer/dist/index.js
function dataUriToBuffer(uri) {
  if (!/^data:/i.test(uri)) {
    throw new TypeError('`uri` does not appear to be a Data URI (must begin with "data:")');
  }
  uri = uri.replace(/\r?\n/g, "");
  const firstComma = uri.indexOf(",");
  if (firstComma === -1 || firstComma <= 4) {
    throw new TypeError("malformed data: URI");
  }
  const meta = uri.substring(5, firstComma).split(";");
  let charset = "";
  let base64 = false;
  const type = meta[0] || "text/plain";
  let typeFull = type;
  for (let i8 = 1; i8 < meta.length; i8++) {
    if (meta[i8] === "base64") {
      base64 = true;
    } else if (meta[i8]) {
      typeFull += `;${meta[i8]}`;
      if (meta[i8].indexOf("charset=") === 0) {
        charset = meta[i8].substring(8);
      }
    }
  }
  if (!meta[0] && !charset.length) {
    typeFull += ";charset=US-ASCII";
    charset = "US-ASCII";
  }
  const encoding = base64 ? "base64" : "ascii";
  const data = unescape(uri.substring(firstComma + 1));
  const buffer2 = Buffer.from(data, encoding);
  buffer2.type = type;
  buffer2.typeFull = typeFull;
  buffer2.charset = charset;
  return buffer2;
}
var dist_default;
var init_dist4 = __esm({
  "../node_modules/.pnpm/data-uri-to-buffer@4.0.1/node_modules/data-uri-to-buffer/dist/index.js"() {
    "use strict";
    dist_default = dataUriToBuffer;
  }
});

// ../node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js
var require_ponyfill_es2018 = __commonJS({
  "../node_modules/.pnpm/web-streams-polyfill@3.3.3/node_modules/web-streams-polyfill/dist/ponyfill.es2018.js"(exports2, module2) {
    "use strict";
    (function(global2, factory) {
      typeof exports2 === "object" && typeof module2 !== "undefined" ? factory(exports2) : typeof define === "function" && define.amd ? define(["exports"], factory) : (global2 = typeof globalThis !== "undefined" ? globalThis : global2 || self, factory(global2.WebStreamsPolyfill = {}));
    })(exports2, function(exports3) {
      "use strict";
      function noop4() {
        return void 0;
      }
      function typeIsObject(x11) {
        return typeof x11 === "object" && x11 !== null || typeof x11 === "function";
      }
      const rethrowAssertionErrorRejection = noop4;
      function setFunctionName(fn3, name3) {
        try {
          Object.defineProperty(fn3, "name", {
            value: name3,
            configurable: true
          });
        } catch (_a507) {
        }
      }
      const originalPromise = Promise;
      const originalPromiseThen = Promise.prototype.then;
      const originalPromiseReject = Promise.reject.bind(originalPromise);
      function newPromise(executor) {
        return new originalPromise(executor);
      }
      function promiseResolvedWith(value) {
        return newPromise((resolve2) => resolve2(value));
      }
      function promiseRejectedWith(reason) {
        return originalPromiseReject(reason);
      }
      function PerformPromiseThen(promise, onFulfilled, onRejected) {
        return originalPromiseThen.call(promise, onFulfilled, onRejected);
      }
      function uponPromise(promise, onFulfilled, onRejected) {
        PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), void 0, rethrowAssertionErrorRejection);
      }
      function uponFulfillment(promise, onFulfilled) {
        uponPromise(promise, onFulfilled);
      }
      function uponRejection(promise, onRejected) {
        uponPromise(promise, void 0, onRejected);
      }
      function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
        return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
      }
      function setPromiseIsHandledToTrue(promise) {
        PerformPromiseThen(promise, void 0, rethrowAssertionErrorRejection);
      }
      let _queueMicrotask2 = (callback) => {
        if (typeof queueMicrotask === "function") {
          _queueMicrotask2 = queueMicrotask;
        } else {
          const resolvedPromise = promiseResolvedWith(void 0);
          _queueMicrotask2 = (cb) => PerformPromiseThen(resolvedPromise, cb);
        }
        return _queueMicrotask2(callback);
      };
      function reflectCall(F6, V2, args2) {
        if (typeof F6 !== "function") {
          throw new TypeError("Argument is not a function");
        }
        return Function.prototype.apply.call(F6, V2, args2);
      }
      function promiseCall(F6, V2, args2) {
        try {
          return promiseResolvedWith(reflectCall(F6, V2, args2));
        } catch (value) {
          return promiseRejectedWith(value);
        }
      }
      const QUEUE_MAX_ARRAY_SIZE = 16384;
      class SimpleQueue {
        constructor() {
          this._cursor = 0;
          this._size = 0;
          this._front = {
            _elements: [],
            _next: void 0
          };
          this._back = this._front;
          this._cursor = 0;
          this._size = 0;
        }
        get length() {
          return this._size;
        }
        // For exception safety, this method is structured in order:
        // 1. Read state
        // 2. Calculate required state mutations
        // 3. Perform state mutations
        push(element) {
          const oldBack = this._back;
          let newBack = oldBack;
          if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
            newBack = {
              _elements: [],
              _next: void 0
            };
          }
          oldBack._elements.push(element);
          if (newBack !== oldBack) {
            this._back = newBack;
            oldBack._next = newBack;
          }
          ++this._size;
        }
        // Like push(), shift() follows the read -> calculate -> mutate pattern for
        // exception safety.
        shift() {
          const oldFront = this._front;
          let newFront = oldFront;
          const oldCursor = this._cursor;
          let newCursor = oldCursor + 1;
          const elements = oldFront._elements;
          const element = elements[oldCursor];
          if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
            newFront = oldFront._next;
            newCursor = 0;
          }
          --this._size;
          this._cursor = newCursor;
          if (oldFront !== newFront) {
            this._front = newFront;
          }
          elements[oldCursor] = void 0;
          return element;
        }
        // The tricky thing about forEach() is that it can be called
        // re-entrantly. The queue may be mutated inside the callback. It is easy to
        // see that push() within the callback has no negative effects since the end
        // of the queue is checked for on every iteration. If shift() is called
        // repeatedly within the callback then the next iteration may return an
        // element that has been removed. In this case the callback will be called
        // with undefined values until we either "catch up" with elements that still
        // exist or reach the back of the queue.
        forEach(callback) {
          let i8 = this._cursor;
          let node = this._front;
          let elements = node._elements;
          while (i8 !== elements.length || node._next !== void 0) {
            if (i8 === elements.length) {
              node = node._next;
              elements = node._elements;
              i8 = 0;
              if (elements.length === 0) {
                break;
              }
            }
            callback(elements[i8]);
            ++i8;
          }
        }
        // Return the element that would be returned if shift() was called now,
        // without modifying the queue.
        peek() {
          const front = this._front;
          const cursor = this._cursor;
          return front._elements[cursor];
        }
      }
      const AbortSteps = Symbol("[[AbortSteps]]");
      const ErrorSteps = Symbol("[[ErrorSteps]]");
      const CancelSteps = Symbol("[[CancelSteps]]");
      const PullSteps = Symbol("[[PullSteps]]");
      const ReleaseSteps = Symbol("[[ReleaseSteps]]");
      function ReadableStreamReaderGenericInitialize(reader, stream) {
        reader._ownerReadableStream = stream;
        stream._reader = reader;
        if (stream._state === "readable") {
          defaultReaderClosedPromiseInitialize(reader);
        } else if (stream._state === "closed") {
          defaultReaderClosedPromiseInitializeAsResolved(reader);
        } else {
          defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
        }
      }
      function ReadableStreamReaderGenericCancel(reader, reason) {
        const stream = reader._ownerReadableStream;
        return ReadableStreamCancel(stream, reason);
      }
      function ReadableStreamReaderGenericRelease(reader) {
        const stream = reader._ownerReadableStream;
        if (stream._state === "readable") {
          defaultReaderClosedPromiseReject(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
        } else {
          defaultReaderClosedPromiseResetToRejected(reader, new TypeError(`Reader was released and can no longer be used to monitor the stream's closedness`));
        }
        stream._readableStreamController[ReleaseSteps]();
        stream._reader = void 0;
        reader._ownerReadableStream = void 0;
      }
      function readerLockException(name3) {
        return new TypeError("Cannot " + name3 + " a stream using a released reader");
      }
      function defaultReaderClosedPromiseInitialize(reader) {
        reader._closedPromise = newPromise((resolve2, reject) => {
          reader._closedPromise_resolve = resolve2;
          reader._closedPromise_reject = reject;
        });
      }
      function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
        defaultReaderClosedPromiseInitialize(reader);
        defaultReaderClosedPromiseReject(reader, reason);
      }
      function defaultReaderClosedPromiseInitializeAsResolved(reader) {
        defaultReaderClosedPromiseInitialize(reader);
        defaultReaderClosedPromiseResolve(reader);
      }
      function defaultReaderClosedPromiseReject(reader, reason) {
        if (reader._closedPromise_reject === void 0) {
          return;
        }
        setPromiseIsHandledToTrue(reader._closedPromise);
        reader._closedPromise_reject(reason);
        reader._closedPromise_resolve = void 0;
        reader._closedPromise_reject = void 0;
      }
      function defaultReaderClosedPromiseResetToRejected(reader, reason) {
        defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
      }
      function defaultReaderClosedPromiseResolve(reader) {
        if (reader._closedPromise_resolve === void 0) {
          return;
        }
        reader._closedPromise_resolve(void 0);
        reader._closedPromise_resolve = void 0;
        reader._closedPromise_reject = void 0;
      }
      const NumberIsFinite = Number.isFinite || function(x11) {
        return typeof x11 === "number" && isFinite(x11);
      };
      const MathTrunc = Math.trunc || function(v11) {
        return v11 < 0 ? Math.ceil(v11) : Math.floor(v11);
      };
      function isDictionary(x11) {
        return typeof x11 === "object" || typeof x11 === "function";
      }
      function assertDictionary(obj, context) {
        if (obj !== void 0 && !isDictionary(obj)) {
          throw new TypeError(`${context} is not an object.`);
        }
      }
      function assertFunction(x11, context) {
        if (typeof x11 !== "function") {
          throw new TypeError(`${context} is not a function.`);
        }
      }
      function isObject(x11) {
        return typeof x11 === "object" && x11 !== null || typeof x11 === "function";
      }
      function assertObject(x11, context) {
        if (!isObject(x11)) {
          throw new TypeError(`${context} is not an object.`);
        }
      }
      function assertRequiredArgument(x11, position, context) {
        if (x11 === void 0) {
          throw new TypeError(`Parameter ${position} is required in '${context}'.`);
        }
      }
      function assertRequiredField(x11, field, context) {
        if (x11 === void 0) {
          throw new TypeError(`${field} is required in '${context}'.`);
        }
      }
      function convertUnrestrictedDouble(value) {
        return Number(value);
      }
      function censorNegativeZero(x11) {
        return x11 === 0 ? 0 : x11;
      }
      function integerPart(x11) {
        return censorNegativeZero(MathTrunc(x11));
      }
      function convertUnsignedLongLongWithEnforceRange(value, context) {
        const lowerBound = 0;
        const upperBound = Number.MAX_SAFE_INTEGER;
        let x11 = Number(value);
        x11 = censorNegativeZero(x11);
        if (!NumberIsFinite(x11)) {
          throw new TypeError(`${context} is not a finite number`);
        }
        x11 = integerPart(x11);
        if (x11 < lowerBound || x11 > upperBound) {
          throw new TypeError(`${context} is outside the accepted range of ${lowerBound} to ${upperBound}, inclusive`);
        }
        if (!NumberIsFinite(x11) || x11 === 0) {
          return 0;
        }
        return x11;
      }
      function assertReadableStream(x11, context) {
        if (!IsReadableStream(x11)) {
          throw new TypeError(`${context} is not a ReadableStream.`);
        }
      }
      function AcquireReadableStreamDefaultReader(stream) {
        return new ReadableStreamDefaultReader(stream);
      }
      function ReadableStreamAddReadRequest(stream, readRequest) {
        stream._reader._readRequests.push(readRequest);
      }
      function ReadableStreamFulfillReadRequest(stream, chunk, done) {
        const reader = stream._reader;
        const readRequest = reader._readRequests.shift();
        if (done) {
          readRequest._closeSteps();
        } else {
          readRequest._chunkSteps(chunk);
        }
      }
      function ReadableStreamGetNumReadRequests(stream) {
        return stream._reader._readRequests.length;
      }
      function ReadableStreamHasDefaultReader(stream) {
        const reader = stream._reader;
        if (reader === void 0) {
          return false;
        }
        if (!IsReadableStreamDefaultReader(reader)) {
          return false;
        }
        return true;
      }
      class ReadableStreamDefaultReader {
        constructor(stream) {
          assertRequiredArgument(stream, 1, "ReadableStreamDefaultReader");
          assertReadableStream(stream, "First parameter");
          if (IsReadableStreamLocked(stream)) {
            throw new TypeError("This stream has already been locked for exclusive reading by another reader");
          }
          ReadableStreamReaderGenericInitialize(this, stream);
          this._readRequests = new SimpleQueue();
        }
        /**
         * Returns a promise that will be fulfilled when the stream becomes closed,
         * or rejected if the stream ever errors or the reader's lock is released before the stream finishes closing.
         */
        get closed() {
          if (!IsReadableStreamDefaultReader(this)) {
            return promiseRejectedWith(defaultReaderBrandCheckException("closed"));
          }
          return this._closedPromise;
        }
        /**
         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
         */
        cancel(reason = void 0) {
          if (!IsReadableStreamDefaultReader(this)) {
            return promiseRejectedWith(defaultReaderBrandCheckException("cancel"));
          }
          if (this._ownerReadableStream === void 0) {
            return promiseRejectedWith(readerLockException("cancel"));
          }
          return ReadableStreamReaderGenericCancel(this, reason);
        }
        /**
         * Returns a promise that allows access to the next chunk from the stream's internal queue, if available.
         *
         * If reading a chunk causes the queue to become empty, more data will be pulled from the underlying source.
         */
        read() {
          if (!IsReadableStreamDefaultReader(this)) {
            return promiseRejectedWith(defaultReaderBrandCheckException("read"));
          }
          if (this._ownerReadableStream === void 0) {
            return promiseRejectedWith(readerLockException("read from"));
          }
          let resolvePromise;
          let rejectPromise;
          const promise = newPromise((resolve2, reject) => {
            resolvePromise = resolve2;
            rejectPromise = reject;
          });
          const readRequest = {
            _chunkSteps: (chunk) => resolvePromise({ value: chunk, done: false }),
            _closeSteps: () => resolvePromise({ value: void 0, done: true }),
            _errorSteps: (e6) => rejectPromise(e6)
          };
          ReadableStreamDefaultReaderRead(this, readRequest);
          return promise;
        }
        /**
         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
         * from now on; otherwise, the reader will appear closed.
         *
         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
         * the reader's {@link ReadableStreamDefaultReader.read | read()} method has not yet been settled. Attempting to
         * do so will throw a `TypeError` and leave the reader locked to the stream.
         */
        releaseLock() {
          if (!IsReadableStreamDefaultReader(this)) {
            throw defaultReaderBrandCheckException("releaseLock");
          }
          if (this._ownerReadableStream === void 0) {
            return;
          }
          ReadableStreamDefaultReaderRelease(this);
        }
      }
      Object.defineProperties(ReadableStreamDefaultReader.prototype, {
        cancel: { enumerable: true },
        read: { enumerable: true },
        releaseLock: { enumerable: true },
        closed: { enumerable: true }
      });
      setFunctionName(ReadableStreamDefaultReader.prototype.cancel, "cancel");
      setFunctionName(ReadableStreamDefaultReader.prototype.read, "read");
      setFunctionName(ReadableStreamDefaultReader.prototype.releaseLock, "releaseLock");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(ReadableStreamDefaultReader.prototype, Symbol.toStringTag, {
          value: "ReadableStreamDefaultReader",
          configurable: true
        });
      }
      function IsReadableStreamDefaultReader(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_readRequests")) {
          return false;
        }
        return x11 instanceof ReadableStreamDefaultReader;
      }
      function ReadableStreamDefaultReaderRead(reader, readRequest) {
        const stream = reader._ownerReadableStream;
        stream._disturbed = true;
        if (stream._state === "closed") {
          readRequest._closeSteps();
        } else if (stream._state === "errored") {
          readRequest._errorSteps(stream._storedError);
        } else {
          stream._readableStreamController[PullSteps](readRequest);
        }
      }
      function ReadableStreamDefaultReaderRelease(reader) {
        ReadableStreamReaderGenericRelease(reader);
        const e6 = new TypeError("Reader was released");
        ReadableStreamDefaultReaderErrorReadRequests(reader, e6);
      }
      function ReadableStreamDefaultReaderErrorReadRequests(reader, e6) {
        const readRequests = reader._readRequests;
        reader._readRequests = new SimpleQueue();
        readRequests.forEach((readRequest) => {
          readRequest._errorSteps(e6);
        });
      }
      function defaultReaderBrandCheckException(name3) {
        return new TypeError(`ReadableStreamDefaultReader.prototype.${name3} can only be used on a ReadableStreamDefaultReader`);
      }
      const AsyncIteratorPrototype = Object.getPrototypeOf(Object.getPrototypeOf(async function* () {
      }).prototype);
      class ReadableStreamAsyncIteratorImpl {
        constructor(reader, preventCancel) {
          this._ongoingPromise = void 0;
          this._isFinished = false;
          this._reader = reader;
          this._preventCancel = preventCancel;
        }
        next() {
          const nextSteps = () => this._nextSteps();
          this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps();
          return this._ongoingPromise;
        }
        return(value) {
          const returnSteps = () => this._returnSteps(value);
          return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
        }
        _nextSteps() {
          if (this._isFinished) {
            return Promise.resolve({ value: void 0, done: true });
          }
          const reader = this._reader;
          let resolvePromise;
          let rejectPromise;
          const promise = newPromise((resolve2, reject) => {
            resolvePromise = resolve2;
            rejectPromise = reject;
          });
          const readRequest = {
            _chunkSteps: (chunk) => {
              this._ongoingPromise = void 0;
              _queueMicrotask2(() => resolvePromise({ value: chunk, done: false }));
            },
            _closeSteps: () => {
              this._ongoingPromise = void 0;
              this._isFinished = true;
              ReadableStreamReaderGenericRelease(reader);
              resolvePromise({ value: void 0, done: true });
            },
            _errorSteps: (reason) => {
              this._ongoingPromise = void 0;
              this._isFinished = true;
              ReadableStreamReaderGenericRelease(reader);
              rejectPromise(reason);
            }
          };
          ReadableStreamDefaultReaderRead(reader, readRequest);
          return promise;
        }
        _returnSteps(value) {
          if (this._isFinished) {
            return Promise.resolve({ value, done: true });
          }
          this._isFinished = true;
          const reader = this._reader;
          if (!this._preventCancel) {
            const result = ReadableStreamReaderGenericCancel(reader, value);
            ReadableStreamReaderGenericRelease(reader);
            return transformPromiseWith(result, () => ({ value, done: true }));
          }
          ReadableStreamReaderGenericRelease(reader);
          return promiseResolvedWith({ value, done: true });
        }
      }
      const ReadableStreamAsyncIteratorPrototype = {
        next() {
          if (!IsReadableStreamAsyncIterator(this)) {
            return promiseRejectedWith(streamAsyncIteratorBrandCheckException("next"));
          }
          return this._asyncIteratorImpl.next();
        },
        return(value) {
          if (!IsReadableStreamAsyncIterator(this)) {
            return promiseRejectedWith(streamAsyncIteratorBrandCheckException("return"));
          }
          return this._asyncIteratorImpl.return(value);
        }
      };
      Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
      function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
        const reader = AcquireReadableStreamDefaultReader(stream);
        const impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
        const iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
        iterator._asyncIteratorImpl = impl;
        return iterator;
      }
      function IsReadableStreamAsyncIterator(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_asyncIteratorImpl")) {
          return false;
        }
        try {
          return x11._asyncIteratorImpl instanceof ReadableStreamAsyncIteratorImpl;
        } catch (_a507) {
          return false;
        }
      }
      function streamAsyncIteratorBrandCheckException(name3) {
        return new TypeError(`ReadableStreamAsyncIterator.${name3} can only be used on a ReadableSteamAsyncIterator`);
      }
      const NumberIsNaN = Number.isNaN || function(x11) {
        return x11 !== x11;
      };
      var _a506, _b375, _c14;
      function CreateArrayFromList(elements) {
        return elements.slice();
      }
      function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n7) {
        new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n7), destOffset);
      }
      let TransferArrayBuffer = (O6) => {
        if (typeof O6.transfer === "function") {
          TransferArrayBuffer = (buffer2) => buffer2.transfer();
        } else if (typeof structuredClone === "function") {
          TransferArrayBuffer = (buffer2) => structuredClone(buffer2, { transfer: [buffer2] });
        } else {
          TransferArrayBuffer = (buffer2) => buffer2;
        }
        return TransferArrayBuffer(O6);
      };
      let IsDetachedBuffer = (O6) => {
        if (typeof O6.detached === "boolean") {
          IsDetachedBuffer = (buffer2) => buffer2.detached;
        } else {
          IsDetachedBuffer = (buffer2) => buffer2.byteLength === 0;
        }
        return IsDetachedBuffer(O6);
      };
      function ArrayBufferSlice(buffer2, begin, end) {
        if (buffer2.slice) {
          return buffer2.slice(begin, end);
        }
        const length = end - begin;
        const slice = new ArrayBuffer(length);
        CopyDataBlockBytes(slice, 0, buffer2, begin, length);
        return slice;
      }
      function GetMethod(receiver, prop) {
        const func2 = receiver[prop];
        if (func2 === void 0 || func2 === null) {
          return void 0;
        }
        if (typeof func2 !== "function") {
          throw new TypeError(`${String(prop)} is not a function`);
        }
        return func2;
      }
      function CreateAsyncFromSyncIterator(syncIteratorRecord) {
        const syncIterable = {
          [Symbol.iterator]: () => syncIteratorRecord.iterator
        };
        const asyncIterator = async function* () {
          return yield* syncIterable;
        }();
        const nextMethod = asyncIterator.next;
        return { iterator: asyncIterator, nextMethod, done: false };
      }
      const SymbolAsyncIterator = (_c14 = (_a506 = Symbol.asyncIterator) !== null && _a506 !== void 0 ? _a506 : (_b375 = Symbol.for) === null || _b375 === void 0 ? void 0 : _b375.call(Symbol, "Symbol.asyncIterator")) !== null && _c14 !== void 0 ? _c14 : "@@asyncIterator";
      function GetIterator(obj, hint = "sync", method) {
        if (method === void 0) {
          if (hint === "async") {
            method = GetMethod(obj, SymbolAsyncIterator);
            if (method === void 0) {
              const syncMethod = GetMethod(obj, Symbol.iterator);
              const syncIteratorRecord = GetIterator(obj, "sync", syncMethod);
              return CreateAsyncFromSyncIterator(syncIteratorRecord);
            }
          } else {
            method = GetMethod(obj, Symbol.iterator);
          }
        }
        if (method === void 0) {
          throw new TypeError("The object is not iterable");
        }
        const iterator = reflectCall(method, obj, []);
        if (!typeIsObject(iterator)) {
          throw new TypeError("The iterator method must return an object");
        }
        const nextMethod = iterator.next;
        return { iterator, nextMethod, done: false };
      }
      function IteratorNext(iteratorRecord) {
        const result = reflectCall(iteratorRecord.nextMethod, iteratorRecord.iterator, []);
        if (!typeIsObject(result)) {
          throw new TypeError("The iterator.next() method must return an object");
        }
        return result;
      }
      function IteratorComplete(iterResult) {
        return Boolean(iterResult.done);
      }
      function IteratorValue(iterResult) {
        return iterResult.value;
      }
      function IsNonNegativeNumber(v11) {
        if (typeof v11 !== "number") {
          return false;
        }
        if (NumberIsNaN(v11)) {
          return false;
        }
        if (v11 < 0) {
          return false;
        }
        return true;
      }
      function CloneAsUint8Array(O6) {
        const buffer2 = ArrayBufferSlice(O6.buffer, O6.byteOffset, O6.byteOffset + O6.byteLength);
        return new Uint8Array(buffer2);
      }
      function DequeueValue(container) {
        const pair = container._queue.shift();
        container._queueTotalSize -= pair.size;
        if (container._queueTotalSize < 0) {
          container._queueTotalSize = 0;
        }
        return pair.value;
      }
      function EnqueueValueWithSize(container, value, size2) {
        if (!IsNonNegativeNumber(size2) || size2 === Infinity) {
          throw new RangeError("Size must be a finite, non-NaN, non-negative number.");
        }
        container._queue.push({ value, size: size2 });
        container._queueTotalSize += size2;
      }
      function PeekQueueValue(container) {
        const pair = container._queue.peek();
        return pair.value;
      }
      function ResetQueue(container) {
        container._queue = new SimpleQueue();
        container._queueTotalSize = 0;
      }
      function isDataViewConstructor(ctor) {
        return ctor === DataView;
      }
      function isDataView(view5) {
        return isDataViewConstructor(view5.constructor);
      }
      function arrayBufferViewElementSize(ctor) {
        if (isDataViewConstructor(ctor)) {
          return 1;
        }
        return ctor.BYTES_PER_ELEMENT;
      }
      class ReadableStreamBYOBRequest {
        constructor() {
          throw new TypeError("Illegal constructor");
        }
        /**
         * Returns the view for writing in to, or `null` if the BYOB request has already been responded to.
         */
        get view() {
          if (!IsReadableStreamBYOBRequest(this)) {
            throw byobRequestBrandCheckException("view");
          }
          return this._view;
        }
        respond(bytesWritten) {
          if (!IsReadableStreamBYOBRequest(this)) {
            throw byobRequestBrandCheckException("respond");
          }
          assertRequiredArgument(bytesWritten, 1, "respond");
          bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, "First parameter");
          if (this._associatedReadableByteStreamController === void 0) {
            throw new TypeError("This BYOB request has been invalidated");
          }
          if (IsDetachedBuffer(this._view.buffer)) {
            throw new TypeError(`The BYOB request's buffer has been detached and so cannot be used as a response`);
          }
          ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
        }
        respondWithNewView(view5) {
          if (!IsReadableStreamBYOBRequest(this)) {
            throw byobRequestBrandCheckException("respondWithNewView");
          }
          assertRequiredArgument(view5, 1, "respondWithNewView");
          if (!ArrayBuffer.isView(view5)) {
            throw new TypeError("You can only respond with array buffer views");
          }
          if (this._associatedReadableByteStreamController === void 0) {
            throw new TypeError("This BYOB request has been invalidated");
          }
          if (IsDetachedBuffer(view5.buffer)) {
            throw new TypeError("The given view's buffer has been detached and so cannot be used as a response");
          }
          ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view5);
        }
      }
      Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
        respond: { enumerable: true },
        respondWithNewView: { enumerable: true },
        view: { enumerable: true }
      });
      setFunctionName(ReadableStreamBYOBRequest.prototype.respond, "respond");
      setFunctionName(ReadableStreamBYOBRequest.prototype.respondWithNewView, "respondWithNewView");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(ReadableStreamBYOBRequest.prototype, Symbol.toStringTag, {
          value: "ReadableStreamBYOBRequest",
          configurable: true
        });
      }
      class ReadableByteStreamController {
        constructor() {
          throw new TypeError("Illegal constructor");
        }
        /**
         * Returns the current BYOB pull request, or `null` if there isn't one.
         */
        get byobRequest() {
          if (!IsReadableByteStreamController(this)) {
            throw byteStreamControllerBrandCheckException("byobRequest");
          }
          return ReadableByteStreamControllerGetBYOBRequest(this);
        }
        /**
         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
         * over-full. An underlying byte source ought to use this information to determine when and how to apply backpressure.
         */
        get desiredSize() {
          if (!IsReadableByteStreamController(this)) {
            throw byteStreamControllerBrandCheckException("desiredSize");
          }
          return ReadableByteStreamControllerGetDesiredSize(this);
        }
        /**
         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
         * the stream, but once those are read, the stream will become closed.
         */
        close() {
          if (!IsReadableByteStreamController(this)) {
            throw byteStreamControllerBrandCheckException("close");
          }
          if (this._closeRequested) {
            throw new TypeError("The stream has already been closed; do not close it again!");
          }
          const state2 = this._controlledReadableByteStream._state;
          if (state2 !== "readable") {
            throw new TypeError(`The stream (in ${state2} state) is not in the readable state and cannot be closed`);
          }
          ReadableByteStreamControllerClose(this);
        }
        enqueue(chunk) {
          if (!IsReadableByteStreamController(this)) {
            throw byteStreamControllerBrandCheckException("enqueue");
          }
          assertRequiredArgument(chunk, 1, "enqueue");
          if (!ArrayBuffer.isView(chunk)) {
            throw new TypeError("chunk must be an array buffer view");
          }
          if (chunk.byteLength === 0) {
            throw new TypeError("chunk must have non-zero byteLength");
          }
          if (chunk.buffer.byteLength === 0) {
            throw new TypeError(`chunk's buffer must have non-zero byteLength`);
          }
          if (this._closeRequested) {
            throw new TypeError("stream is closed or draining");
          }
          const state2 = this._controlledReadableByteStream._state;
          if (state2 !== "readable") {
            throw new TypeError(`The stream (in ${state2} state) is not in the readable state and cannot be enqueued to`);
          }
          ReadableByteStreamControllerEnqueue(this, chunk);
        }
        /**
         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
         */
        error(e6 = void 0) {
          if (!IsReadableByteStreamController(this)) {
            throw byteStreamControllerBrandCheckException("error");
          }
          ReadableByteStreamControllerError(this, e6);
        }
        /** @internal */
        [CancelSteps](reason) {
          ReadableByteStreamControllerClearPendingPullIntos(this);
          ResetQueue(this);
          const result = this._cancelAlgorithm(reason);
          ReadableByteStreamControllerClearAlgorithms(this);
          return result;
        }
        /** @internal */
        [PullSteps](readRequest) {
          const stream = this._controlledReadableByteStream;
          if (this._queueTotalSize > 0) {
            ReadableByteStreamControllerFillReadRequestFromQueue(this, readRequest);
            return;
          }
          const autoAllocateChunkSize = this._autoAllocateChunkSize;
          if (autoAllocateChunkSize !== void 0) {
            let buffer2;
            try {
              buffer2 = new ArrayBuffer(autoAllocateChunkSize);
            } catch (bufferE) {
              readRequest._errorSteps(bufferE);
              return;
            }
            const pullIntoDescriptor = {
              buffer: buffer2,
              bufferByteLength: autoAllocateChunkSize,
              byteOffset: 0,
              byteLength: autoAllocateChunkSize,
              bytesFilled: 0,
              minimumFill: 1,
              elementSize: 1,
              viewConstructor: Uint8Array,
              readerType: "default"
            };
            this._pendingPullIntos.push(pullIntoDescriptor);
          }
          ReadableStreamAddReadRequest(stream, readRequest);
          ReadableByteStreamControllerCallPullIfNeeded(this);
        }
        /** @internal */
        [ReleaseSteps]() {
          if (this._pendingPullIntos.length > 0) {
            const firstPullInto = this._pendingPullIntos.peek();
            firstPullInto.readerType = "none";
            this._pendingPullIntos = new SimpleQueue();
            this._pendingPullIntos.push(firstPullInto);
          }
        }
      }
      Object.defineProperties(ReadableByteStreamController.prototype, {
        close: { enumerable: true },
        enqueue: { enumerable: true },
        error: { enumerable: true },
        byobRequest: { enumerable: true },
        desiredSize: { enumerable: true }
      });
      setFunctionName(ReadableByteStreamController.prototype.close, "close");
      setFunctionName(ReadableByteStreamController.prototype.enqueue, "enqueue");
      setFunctionName(ReadableByteStreamController.prototype.error, "error");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(ReadableByteStreamController.prototype, Symbol.toStringTag, {
          value: "ReadableByteStreamController",
          configurable: true
        });
      }
      function IsReadableByteStreamController(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_controlledReadableByteStream")) {
          return false;
        }
        return x11 instanceof ReadableByteStreamController;
      }
      function IsReadableStreamBYOBRequest(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_associatedReadableByteStreamController")) {
          return false;
        }
        return x11 instanceof ReadableStreamBYOBRequest;
      }
      function ReadableByteStreamControllerCallPullIfNeeded(controller) {
        const shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
        if (!shouldPull) {
          return;
        }
        if (controller._pulling) {
          controller._pullAgain = true;
          return;
        }
        controller._pulling = true;
        const pullPromise = controller._pullAlgorithm();
        uponPromise(pullPromise, () => {
          controller._pulling = false;
          if (controller._pullAgain) {
            controller._pullAgain = false;
            ReadableByteStreamControllerCallPullIfNeeded(controller);
          }
          return null;
        }, (e6) => {
          ReadableByteStreamControllerError(controller, e6);
          return null;
        });
      }
      function ReadableByteStreamControllerClearPendingPullIntos(controller) {
        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
        controller._pendingPullIntos = new SimpleQueue();
      }
      function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
        let done = false;
        if (stream._state === "closed") {
          done = true;
        }
        const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
        if (pullIntoDescriptor.readerType === "default") {
          ReadableStreamFulfillReadRequest(stream, filledView, done);
        } else {
          ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
        }
      }
      function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
        const bytesFilled = pullIntoDescriptor.bytesFilled;
        const elementSize = pullIntoDescriptor.elementSize;
        return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
      }
      function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer2, byteOffset, byteLength) {
        controller._queue.push({ buffer: buffer2, byteOffset, byteLength });
        controller._queueTotalSize += byteLength;
      }
      function ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, buffer2, byteOffset, byteLength) {
        let clonedChunk;
        try {
          clonedChunk = ArrayBufferSlice(buffer2, byteOffset, byteOffset + byteLength);
        } catch (cloneE) {
          ReadableByteStreamControllerError(controller, cloneE);
          throw cloneE;
        }
        ReadableByteStreamControllerEnqueueChunkToQueue(controller, clonedChunk, 0, byteLength);
      }
      function ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstDescriptor) {
        if (firstDescriptor.bytesFilled > 0) {
          ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, firstDescriptor.buffer, firstDescriptor.byteOffset, firstDescriptor.bytesFilled);
        }
        ReadableByteStreamControllerShiftPendingPullInto(controller);
      }
      function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
        const maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
        const maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
        let totalBytesToCopyRemaining = maxBytesToCopy;
        let ready = false;
        const remainderBytes = maxBytesFilled % pullIntoDescriptor.elementSize;
        const maxAlignedBytes = maxBytesFilled - remainderBytes;
        if (maxAlignedBytes >= pullIntoDescriptor.minimumFill) {
          totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
          ready = true;
        }
        const queue = controller._queue;
        while (totalBytesToCopyRemaining > 0) {
          const headOfQueue = queue.peek();
          const bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
          const destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
          CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
          if (headOfQueue.byteLength === bytesToCopy) {
            queue.shift();
          } else {
            headOfQueue.byteOffset += bytesToCopy;
            headOfQueue.byteLength -= bytesToCopy;
          }
          controller._queueTotalSize -= bytesToCopy;
          ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
          totalBytesToCopyRemaining -= bytesToCopy;
        }
        return ready;
      }
      function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size2, pullIntoDescriptor) {
        pullIntoDescriptor.bytesFilled += size2;
      }
      function ReadableByteStreamControllerHandleQueueDrain(controller) {
        if (controller._queueTotalSize === 0 && controller._closeRequested) {
          ReadableByteStreamControllerClearAlgorithms(controller);
          ReadableStreamClose(controller._controlledReadableByteStream);
        } else {
          ReadableByteStreamControllerCallPullIfNeeded(controller);
        }
      }
      function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
        if (controller._byobRequest === null) {
          return;
        }
        controller._byobRequest._associatedReadableByteStreamController = void 0;
        controller._byobRequest._view = null;
        controller._byobRequest = null;
      }
      function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
        while (controller._pendingPullIntos.length > 0) {
          if (controller._queueTotalSize === 0) {
            return;
          }
          const pullIntoDescriptor = controller._pendingPullIntos.peek();
          if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
            ReadableByteStreamControllerShiftPendingPullInto(controller);
            ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
          }
        }
      }
      function ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller) {
        const reader = controller._controlledReadableByteStream._reader;
        while (reader._readRequests.length > 0) {
          if (controller._queueTotalSize === 0) {
            return;
          }
          const readRequest = reader._readRequests.shift();
          ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest);
        }
      }
      function ReadableByteStreamControllerPullInto(controller, view5, min2, readIntoRequest) {
        const stream = controller._controlledReadableByteStream;
        const ctor = view5.constructor;
        const elementSize = arrayBufferViewElementSize(ctor);
        const { byteOffset, byteLength } = view5;
        const minimumFill = min2 * elementSize;
        let buffer2;
        try {
          buffer2 = TransferArrayBuffer(view5.buffer);
        } catch (e6) {
          readIntoRequest._errorSteps(e6);
          return;
        }
        const pullIntoDescriptor = {
          buffer: buffer2,
          bufferByteLength: buffer2.byteLength,
          byteOffset,
          byteLength,
          bytesFilled: 0,
          minimumFill,
          elementSize,
          viewConstructor: ctor,
          readerType: "byob"
        };
        if (controller._pendingPullIntos.length > 0) {
          controller._pendingPullIntos.push(pullIntoDescriptor);
          ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
          return;
        }
        if (stream._state === "closed") {
          const emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
          readIntoRequest._closeSteps(emptyView);
          return;
        }
        if (controller._queueTotalSize > 0) {
          if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
            const filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
            ReadableByteStreamControllerHandleQueueDrain(controller);
            readIntoRequest._chunkSteps(filledView);
            return;
          }
          if (controller._closeRequested) {
            const e6 = new TypeError("Insufficient bytes to fill elements in the given buffer");
            ReadableByteStreamControllerError(controller, e6);
            readIntoRequest._errorSteps(e6);
            return;
          }
        }
        controller._pendingPullIntos.push(pullIntoDescriptor);
        ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
        ReadableByteStreamControllerCallPullIfNeeded(controller);
      }
      function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
        if (firstDescriptor.readerType === "none") {
          ReadableByteStreamControllerShiftPendingPullInto(controller);
        }
        const stream = controller._controlledReadableByteStream;
        if (ReadableStreamHasBYOBReader(stream)) {
          while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
            const pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
            ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
          }
        }
      }
      function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
        ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
        if (pullIntoDescriptor.readerType === "none") {
          ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, pullIntoDescriptor);
          ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
          return;
        }
        if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.minimumFill) {
          return;
        }
        ReadableByteStreamControllerShiftPendingPullInto(controller);
        const remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
        if (remainderSize > 0) {
          const end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
          ReadableByteStreamControllerEnqueueClonedChunkToQueue(controller, pullIntoDescriptor.buffer, end - remainderSize, remainderSize);
        }
        pullIntoDescriptor.bytesFilled -= remainderSize;
        ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
        ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
      }
      function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
        const firstDescriptor = controller._pendingPullIntos.peek();
        ReadableByteStreamControllerInvalidateBYOBRequest(controller);
        const state2 = controller._controlledReadableByteStream._state;
        if (state2 === "closed") {
          ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
        } else {
          ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
        }
        ReadableByteStreamControllerCallPullIfNeeded(controller);
      }
      function ReadableByteStreamControllerShiftPendingPullInto(controller) {
        const descriptor = controller._pendingPullIntos.shift();
        return descriptor;
      }
      function ReadableByteStreamControllerShouldCallPull(controller) {
        const stream = controller._controlledReadableByteStream;
        if (stream._state !== "readable") {
          return false;
        }
        if (controller._closeRequested) {
          return false;
        }
        if (!controller._started) {
          return false;
        }
        if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
          return true;
        }
        if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
          return true;
        }
        const desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);
        if (desiredSize > 0) {
          return true;
        }
        return false;
      }
      function ReadableByteStreamControllerClearAlgorithms(controller) {
        controller._pullAlgorithm = void 0;
        controller._cancelAlgorithm = void 0;
      }
      function ReadableByteStreamControllerClose(controller) {
        const stream = controller._controlledReadableByteStream;
        if (controller._closeRequested || stream._state !== "readable") {
          return;
        }
        if (controller._queueTotalSize > 0) {
          controller._closeRequested = true;
          return;
        }
        if (controller._pendingPullIntos.length > 0) {
          const firstPendingPullInto = controller._pendingPullIntos.peek();
          if (firstPendingPullInto.bytesFilled % firstPendingPullInto.elementSize !== 0) {
            const e6 = new TypeError("Insufficient bytes to fill elements in the given buffer");
            ReadableByteStreamControllerError(controller, e6);
            throw e6;
          }
        }
        ReadableByteStreamControllerClearAlgorithms(controller);
        ReadableStreamClose(stream);
      }
      function ReadableByteStreamControllerEnqueue(controller, chunk) {
        const stream = controller._controlledReadableByteStream;
        if (controller._closeRequested || stream._state !== "readable") {
          return;
        }
        const { buffer: buffer2, byteOffset, byteLength } = chunk;
        if (IsDetachedBuffer(buffer2)) {
          throw new TypeError("chunk's buffer is detached and so cannot be enqueued");
        }
        const transferredBuffer = TransferArrayBuffer(buffer2);
        if (controller._pendingPullIntos.length > 0) {
          const firstPendingPullInto = controller._pendingPullIntos.peek();
          if (IsDetachedBuffer(firstPendingPullInto.buffer)) {
            throw new TypeError("The BYOB request's buffer has been detached and so cannot be filled with an enqueued chunk");
          }
          ReadableByteStreamControllerInvalidateBYOBRequest(controller);
          firstPendingPullInto.buffer = TransferArrayBuffer(firstPendingPullInto.buffer);
          if (firstPendingPullInto.readerType === "none") {
            ReadableByteStreamControllerEnqueueDetachedPullIntoToQueue(controller, firstPendingPullInto);
          }
        }
        if (ReadableStreamHasDefaultReader(stream)) {
          ReadableByteStreamControllerProcessReadRequestsUsingQueue(controller);
          if (ReadableStreamGetNumReadRequests(stream) === 0) {
            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
          } else {
            if (controller._pendingPullIntos.length > 0) {
              ReadableByteStreamControllerShiftPendingPullInto(controller);
            }
            const transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
            ReadableStreamFulfillReadRequest(stream, transferredView, false);
          }
        } else if (ReadableStreamHasBYOBReader(stream)) {
          ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
          ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
        } else {
          ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
        }
        ReadableByteStreamControllerCallPullIfNeeded(controller);
      }
      function ReadableByteStreamControllerError(controller, e6) {
        const stream = controller._controlledReadableByteStream;
        if (stream._state !== "readable") {
          return;
        }
        ReadableByteStreamControllerClearPendingPullIntos(controller);
        ResetQueue(controller);
        ReadableByteStreamControllerClearAlgorithms(controller);
        ReadableStreamError(stream, e6);
      }
      function ReadableByteStreamControllerFillReadRequestFromQueue(controller, readRequest) {
        const entry = controller._queue.shift();
        controller._queueTotalSize -= entry.byteLength;
        ReadableByteStreamControllerHandleQueueDrain(controller);
        const view5 = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
        readRequest._chunkSteps(view5);
      }
      function ReadableByteStreamControllerGetBYOBRequest(controller) {
        if (controller._byobRequest === null && controller._pendingPullIntos.length > 0) {
          const firstDescriptor = controller._pendingPullIntos.peek();
          const view5 = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
          const byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
          SetUpReadableStreamBYOBRequest(byobRequest, controller, view5);
          controller._byobRequest = byobRequest;
        }
        return controller._byobRequest;
      }
      function ReadableByteStreamControllerGetDesiredSize(controller) {
        const state2 = controller._controlledReadableByteStream._state;
        if (state2 === "errored") {
          return null;
        }
        if (state2 === "closed") {
          return 0;
        }
        return controller._strategyHWM - controller._queueTotalSize;
      }
      function ReadableByteStreamControllerRespond(controller, bytesWritten) {
        const firstDescriptor = controller._pendingPullIntos.peek();
        const state2 = controller._controlledReadableByteStream._state;
        if (state2 === "closed") {
          if (bytesWritten !== 0) {
            throw new TypeError("bytesWritten must be 0 when calling respond() on a closed stream");
          }
        } else {
          if (bytesWritten === 0) {
            throw new TypeError("bytesWritten must be greater than 0 when calling respond() on a readable stream");
          }
          if (firstDescriptor.bytesFilled + bytesWritten > firstDescriptor.byteLength) {
            throw new RangeError("bytesWritten out of range");
          }
        }
        firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
        ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
      }
      function ReadableByteStreamControllerRespondWithNewView(controller, view5) {
        const firstDescriptor = controller._pendingPullIntos.peek();
        const state2 = controller._controlledReadableByteStream._state;
        if (state2 === "closed") {
          if (view5.byteLength !== 0) {
            throw new TypeError("The view's length must be 0 when calling respondWithNewView() on a closed stream");
          }
        } else {
          if (view5.byteLength === 0) {
            throw new TypeError("The view's length must be greater than 0 when calling respondWithNewView() on a readable stream");
          }
        }
        if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view5.byteOffset) {
          throw new RangeError("The region specified by view does not match byobRequest");
        }
        if (firstDescriptor.bufferByteLength !== view5.buffer.byteLength) {
          throw new RangeError("The buffer of view has different capacity than byobRequest");
        }
        if (firstDescriptor.bytesFilled + view5.byteLength > firstDescriptor.byteLength) {
          throw new RangeError("The region specified by view is larger than byobRequest");
        }
        const viewByteLength = view5.byteLength;
        firstDescriptor.buffer = TransferArrayBuffer(view5.buffer);
        ReadableByteStreamControllerRespondInternal(controller, viewByteLength);
      }
      function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
        controller._controlledReadableByteStream = stream;
        controller._pullAgain = false;
        controller._pulling = false;
        controller._byobRequest = null;
        controller._queue = controller._queueTotalSize = void 0;
        ResetQueue(controller);
        controller._closeRequested = false;
        controller._started = false;
        controller._strategyHWM = highWaterMark;
        controller._pullAlgorithm = pullAlgorithm;
        controller._cancelAlgorithm = cancelAlgorithm;
        controller._autoAllocateChunkSize = autoAllocateChunkSize;
        controller._pendingPullIntos = new SimpleQueue();
        stream._readableStreamController = controller;
        const startResult = startAlgorithm();
        uponPromise(promiseResolvedWith(startResult), () => {
          controller._started = true;
          ReadableByteStreamControllerCallPullIfNeeded(controller);
          return null;
        }, (r6) => {
          ReadableByteStreamControllerError(controller, r6);
          return null;
        });
      }
      function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
        const controller = Object.create(ReadableByteStreamController.prototype);
        let startAlgorithm;
        let pullAlgorithm;
        let cancelAlgorithm;
        if (underlyingByteSource.start !== void 0) {
          startAlgorithm = () => underlyingByteSource.start(controller);
        } else {
          startAlgorithm = () => void 0;
        }
        if (underlyingByteSource.pull !== void 0) {
          pullAlgorithm = () => underlyingByteSource.pull(controller);
        } else {
          pullAlgorithm = () => promiseResolvedWith(void 0);
        }
        if (underlyingByteSource.cancel !== void 0) {
          cancelAlgorithm = (reason) => underlyingByteSource.cancel(reason);
        } else {
          cancelAlgorithm = () => promiseResolvedWith(void 0);
        }
        const autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
        if (autoAllocateChunkSize === 0) {
          throw new TypeError("autoAllocateChunkSize must be greater than 0");
        }
        SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
      }
      function SetUpReadableStreamBYOBRequest(request2, controller, view5) {
        request2._associatedReadableByteStreamController = controller;
        request2._view = view5;
      }
      function byobRequestBrandCheckException(name3) {
        return new TypeError(`ReadableStreamBYOBRequest.prototype.${name3} can only be used on a ReadableStreamBYOBRequest`);
      }
      function byteStreamControllerBrandCheckException(name3) {
        return new TypeError(`ReadableByteStreamController.prototype.${name3} can only be used on a ReadableByteStreamController`);
      }
      function convertReaderOptions(options, context) {
        assertDictionary(options, context);
        const mode = options === null || options === void 0 ? void 0 : options.mode;
        return {
          mode: mode === void 0 ? void 0 : convertReadableStreamReaderMode(mode, `${context} has member 'mode' that`)
        };
      }
      function convertReadableStreamReaderMode(mode, context) {
        mode = `${mode}`;
        if (mode !== "byob") {
          throw new TypeError(`${context} '${mode}' is not a valid enumeration value for ReadableStreamReaderMode`);
        }
        return mode;
      }
      function convertByobReadOptions(options, context) {
        var _a507;
        assertDictionary(options, context);
        const min2 = (_a507 = options === null || options === void 0 ? void 0 : options.min) !== null && _a507 !== void 0 ? _a507 : 1;
        return {
          min: convertUnsignedLongLongWithEnforceRange(min2, `${context} has member 'min' that`)
        };
      }
      function AcquireReadableStreamBYOBReader(stream) {
        return new ReadableStreamBYOBReader(stream);
      }
      function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) {
        stream._reader._readIntoRequests.push(readIntoRequest);
      }
      function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
        const reader = stream._reader;
        const readIntoRequest = reader._readIntoRequests.shift();
        if (done) {
          readIntoRequest._closeSteps(chunk);
        } else {
          readIntoRequest._chunkSteps(chunk);
        }
      }
      function ReadableStreamGetNumReadIntoRequests(stream) {
        return stream._reader._readIntoRequests.length;
      }
      function ReadableStreamHasBYOBReader(stream) {
        const reader = stream._reader;
        if (reader === void 0) {
          return false;
        }
        if (!IsReadableStreamBYOBReader(reader)) {
          return false;
        }
        return true;
      }
      class ReadableStreamBYOBReader {
        constructor(stream) {
          assertRequiredArgument(stream, 1, "ReadableStreamBYOBReader");
          assertReadableStream(stream, "First parameter");
          if (IsReadableStreamLocked(stream)) {
            throw new TypeError("This stream has already been locked for exclusive reading by another reader");
          }
          if (!IsReadableByteStreamController(stream._readableStreamController)) {
            throw new TypeError("Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte source");
          }
          ReadableStreamReaderGenericInitialize(this, stream);
          this._readIntoRequests = new SimpleQueue();
        }
        /**
         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
         * the reader's lock is released before the stream finishes closing.
         */
        get closed() {
          if (!IsReadableStreamBYOBReader(this)) {
            return promiseRejectedWith(byobReaderBrandCheckException("closed"));
          }
          return this._closedPromise;
        }
        /**
         * If the reader is active, behaves the same as {@link ReadableStream.cancel | stream.cancel(reason)}.
         */
        cancel(reason = void 0) {
          if (!IsReadableStreamBYOBReader(this)) {
            return promiseRejectedWith(byobReaderBrandCheckException("cancel"));
          }
          if (this._ownerReadableStream === void 0) {
            return promiseRejectedWith(readerLockException("cancel"));
          }
          return ReadableStreamReaderGenericCancel(this, reason);
        }
        read(view5, rawOptions = {}) {
          if (!IsReadableStreamBYOBReader(this)) {
            return promiseRejectedWith(byobReaderBrandCheckException("read"));
          }
          if (!ArrayBuffer.isView(view5)) {
            return promiseRejectedWith(new TypeError("view must be an array buffer view"));
          }
          if (view5.byteLength === 0) {
            return promiseRejectedWith(new TypeError("view must have non-zero byteLength"));
          }
          if (view5.buffer.byteLength === 0) {
            return promiseRejectedWith(new TypeError(`view's buffer must have non-zero byteLength`));
          }
          if (IsDetachedBuffer(view5.buffer)) {
            return promiseRejectedWith(new TypeError("view's buffer has been detached"));
          }
          let options;
          try {
            options = convertByobReadOptions(rawOptions, "options");
          } catch (e6) {
            return promiseRejectedWith(e6);
          }
          const min2 = options.min;
          if (min2 === 0) {
            return promiseRejectedWith(new TypeError("options.min must be greater than 0"));
          }
          if (!isDataView(view5)) {
            if (min2 > view5.length) {
              return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's length"));
            }
          } else if (min2 > view5.byteLength) {
            return promiseRejectedWith(new RangeError("options.min must be less than or equal to view's byteLength"));
          }
          if (this._ownerReadableStream === void 0) {
            return promiseRejectedWith(readerLockException("read from"));
          }
          let resolvePromise;
          let rejectPromise;
          const promise = newPromise((resolve2, reject) => {
            resolvePromise = resolve2;
            rejectPromise = reject;
          });
          const readIntoRequest = {
            _chunkSteps: (chunk) => resolvePromise({ value: chunk, done: false }),
            _closeSteps: (chunk) => resolvePromise({ value: chunk, done: true }),
            _errorSteps: (e6) => rejectPromise(e6)
          };
          ReadableStreamBYOBReaderRead(this, view5, min2, readIntoRequest);
          return promise;
        }
        /**
         * Releases the reader's lock on the corresponding stream. After the lock is released, the reader is no longer active.
         * If the associated stream is errored when the lock is released, the reader will appear errored in the same way
         * from now on; otherwise, the reader will appear closed.
         *
         * A reader's lock cannot be released while it still has a pending read request, i.e., if a promise returned by
         * the reader's {@link ReadableStreamBYOBReader.read | read()} method has not yet been settled. Attempting to
         * do so will throw a `TypeError` and leave the reader locked to the stream.
         */
        releaseLock() {
          if (!IsReadableStreamBYOBReader(this)) {
            throw byobReaderBrandCheckException("releaseLock");
          }
          if (this._ownerReadableStream === void 0) {
            return;
          }
          ReadableStreamBYOBReaderRelease(this);
        }
      }
      Object.defineProperties(ReadableStreamBYOBReader.prototype, {
        cancel: { enumerable: true },
        read: { enumerable: true },
        releaseLock: { enumerable: true },
        closed: { enumerable: true }
      });
      setFunctionName(ReadableStreamBYOBReader.prototype.cancel, "cancel");
      setFunctionName(ReadableStreamBYOBReader.prototype.read, "read");
      setFunctionName(ReadableStreamBYOBReader.prototype.releaseLock, "releaseLock");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(ReadableStreamBYOBReader.prototype, Symbol.toStringTag, {
          value: "ReadableStreamBYOBReader",
          configurable: true
        });
      }
      function IsReadableStreamBYOBReader(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_readIntoRequests")) {
          return false;
        }
        return x11 instanceof ReadableStreamBYOBReader;
      }
      function ReadableStreamBYOBReaderRead(reader, view5, min2, readIntoRequest) {
        const stream = reader._ownerReadableStream;
        stream._disturbed = true;
        if (stream._state === "errored") {
          readIntoRequest._errorSteps(stream._storedError);
        } else {
          ReadableByteStreamControllerPullInto(stream._readableStreamController, view5, min2, readIntoRequest);
        }
      }
      function ReadableStreamBYOBReaderRelease(reader) {
        ReadableStreamReaderGenericRelease(reader);
        const e6 = new TypeError("Reader was released");
        ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e6);
      }
      function ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e6) {
        const readIntoRequests = reader._readIntoRequests;
        reader._readIntoRequests = new SimpleQueue();
        readIntoRequests.forEach((readIntoRequest) => {
          readIntoRequest._errorSteps(e6);
        });
      }
      function byobReaderBrandCheckException(name3) {
        return new TypeError(`ReadableStreamBYOBReader.prototype.${name3} can only be used on a ReadableStreamBYOBReader`);
      }
      function ExtractHighWaterMark(strategy, defaultHWM) {
        const { highWaterMark } = strategy;
        if (highWaterMark === void 0) {
          return defaultHWM;
        }
        if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {
          throw new RangeError("Invalid highWaterMark");
        }
        return highWaterMark;
      }
      function ExtractSizeAlgorithm(strategy) {
        const { size: size2 } = strategy;
        if (!size2) {
          return () => 1;
        }
        return size2;
      }
      function convertQueuingStrategy(init3, context) {
        assertDictionary(init3, context);
        const highWaterMark = init3 === null || init3 === void 0 ? void 0 : init3.highWaterMark;
        const size2 = init3 === null || init3 === void 0 ? void 0 : init3.size;
        return {
          highWaterMark: highWaterMark === void 0 ? void 0 : convertUnrestrictedDouble(highWaterMark),
          size: size2 === void 0 ? void 0 : convertQueuingStrategySize(size2, `${context} has member 'size' that`)
        };
      }
      function convertQueuingStrategySize(fn3, context) {
        assertFunction(fn3, context);
        return (chunk) => convertUnrestrictedDouble(fn3(chunk));
      }
      function convertUnderlyingSink(original, context) {
        assertDictionary(original, context);
        const abort2 = original === null || original === void 0 ? void 0 : original.abort;
        const close = original === null || original === void 0 ? void 0 : original.close;
        const start2 = original === null || original === void 0 ? void 0 : original.start;
        const type = original === null || original === void 0 ? void 0 : original.type;
        const write = original === null || original === void 0 ? void 0 : original.write;
        return {
          abort: abort2 === void 0 ? void 0 : convertUnderlyingSinkAbortCallback(abort2, original, `${context} has member 'abort' that`),
          close: close === void 0 ? void 0 : convertUnderlyingSinkCloseCallback(close, original, `${context} has member 'close' that`),
          start: start2 === void 0 ? void 0 : convertUnderlyingSinkStartCallback(start2, original, `${context} has member 'start' that`),
          write: write === void 0 ? void 0 : convertUnderlyingSinkWriteCallback(write, original, `${context} has member 'write' that`),
          type
        };
      }
      function convertUnderlyingSinkAbortCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (reason) => promiseCall(fn3, original, [reason]);
      }
      function convertUnderlyingSinkCloseCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return () => promiseCall(fn3, original, []);
      }
      function convertUnderlyingSinkStartCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (controller) => reflectCall(fn3, original, [controller]);
      }
      function convertUnderlyingSinkWriteCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (chunk, controller) => promiseCall(fn3, original, [chunk, controller]);
      }
      function assertWritableStream(x11, context) {
        if (!IsWritableStream(x11)) {
          throw new TypeError(`${context} is not a WritableStream.`);
        }
      }
      function isAbortSignal2(value) {
        if (typeof value !== "object" || value === null) {
          return false;
        }
        try {
          return typeof value.aborted === "boolean";
        } catch (_a507) {
          return false;
        }
      }
      const supportsAbortController = typeof AbortController === "function";
      function createAbortController() {
        if (supportsAbortController) {
          return new AbortController();
        }
        return void 0;
      }
      class WritableStream {
        constructor(rawUnderlyingSink = {}, rawStrategy = {}) {
          if (rawUnderlyingSink === void 0) {
            rawUnderlyingSink = null;
          } else {
            assertObject(rawUnderlyingSink, "First parameter");
          }
          const strategy = convertQueuingStrategy(rawStrategy, "Second parameter");
          const underlyingSink = convertUnderlyingSink(rawUnderlyingSink, "First parameter");
          InitializeWritableStream(this);
          const type = underlyingSink.type;
          if (type !== void 0) {
            throw new RangeError("Invalid type is specified");
          }
          const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
          const highWaterMark = ExtractHighWaterMark(strategy, 1);
          SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
        }
        /**
         * Returns whether or not the writable stream is locked to a writer.
         */
        get locked() {
          if (!IsWritableStream(this)) {
            throw streamBrandCheckException$2("locked");
          }
          return IsWritableStreamLocked(this);
        }
        /**
         * Aborts the stream, signaling that the producer can no longer successfully write to the stream and it is to be
         * immediately moved to an errored state, with any queued-up writes discarded. This will also execute any abort
         * mechanism of the underlying sink.
         *
         * The returned promise will fulfill if the stream shuts down successfully, or reject if the underlying sink signaled
         * that there was an error doing so. Additionally, it will reject with a `TypeError` (without attempting to cancel
         * the stream) if the stream is currently locked.
         */
        abort(reason = void 0) {
          if (!IsWritableStream(this)) {
            return promiseRejectedWith(streamBrandCheckException$2("abort"));
          }
          if (IsWritableStreamLocked(this)) {
            return promiseRejectedWith(new TypeError("Cannot abort a stream that already has a writer"));
          }
          return WritableStreamAbort(this, reason);
        }
        /**
         * Closes the stream. The underlying sink will finish processing any previously-written chunks, before invoking its
         * close behavior. During this time any further attempts to write will fail (without erroring the stream).
         *
         * The method returns a promise that will fulfill if all remaining chunks are successfully written and the stream
         * successfully closes, or rejects if an error is encountered during this process. Additionally, it will reject with
         * a `TypeError` (without attempting to cancel the stream) if the stream is currently locked.
         */
        close() {
          if (!IsWritableStream(this)) {
            return promiseRejectedWith(streamBrandCheckException$2("close"));
          }
          if (IsWritableStreamLocked(this)) {
            return promiseRejectedWith(new TypeError("Cannot close a stream that already has a writer"));
          }
          if (WritableStreamCloseQueuedOrInFlight(this)) {
            return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
          }
          return WritableStreamClose(this);
        }
        /**
         * Creates a {@link WritableStreamDefaultWriter | writer} and locks the stream to the new writer. While the stream
         * is locked, no other writer can be acquired until this one is released.
         *
         * This functionality is especially useful for creating abstractions that desire the ability to write to a stream
         * without interruption or interleaving. By getting a writer for the stream, you can ensure nobody else can write at
         * the same time, which would cause the resulting written data to be unpredictable and probably useless.
         */
        getWriter() {
          if (!IsWritableStream(this)) {
            throw streamBrandCheckException$2("getWriter");
          }
          return AcquireWritableStreamDefaultWriter(this);
        }
      }
      Object.defineProperties(WritableStream.prototype, {
        abort: { enumerable: true },
        close: { enumerable: true },
        getWriter: { enumerable: true },
        locked: { enumerable: true }
      });
      setFunctionName(WritableStream.prototype.abort, "abort");
      setFunctionName(WritableStream.prototype.close, "close");
      setFunctionName(WritableStream.prototype.getWriter, "getWriter");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(WritableStream.prototype, Symbol.toStringTag, {
          value: "WritableStream",
          configurable: true
        });
      }
      function AcquireWritableStreamDefaultWriter(stream) {
        return new WritableStreamDefaultWriter(stream);
      }
      function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
        const stream = Object.create(WritableStream.prototype);
        InitializeWritableStream(stream);
        const controller = Object.create(WritableStreamDefaultController.prototype);
        SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
        return stream;
      }
      function InitializeWritableStream(stream) {
        stream._state = "writable";
        stream._storedError = void 0;
        stream._writer = void 0;
        stream._writableStreamController = void 0;
        stream._writeRequests = new SimpleQueue();
        stream._inFlightWriteRequest = void 0;
        stream._closeRequest = void 0;
        stream._inFlightCloseRequest = void 0;
        stream._pendingAbortRequest = void 0;
        stream._backpressure = false;
      }
      function IsWritableStream(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_writableStreamController")) {
          return false;
        }
        return x11 instanceof WritableStream;
      }
      function IsWritableStreamLocked(stream) {
        if (stream._writer === void 0) {
          return false;
        }
        return true;
      }
      function WritableStreamAbort(stream, reason) {
        var _a507;
        if (stream._state === "closed" || stream._state === "errored") {
          return promiseResolvedWith(void 0);
        }
        stream._writableStreamController._abortReason = reason;
        (_a507 = stream._writableStreamController._abortController) === null || _a507 === void 0 ? void 0 : _a507.abort(reason);
        const state2 = stream._state;
        if (state2 === "closed" || state2 === "errored") {
          return promiseResolvedWith(void 0);
        }
        if (stream._pendingAbortRequest !== void 0) {
          return stream._pendingAbortRequest._promise;
        }
        let wasAlreadyErroring = false;
        if (state2 === "erroring") {
          wasAlreadyErroring = true;
          reason = void 0;
        }
        const promise = newPromise((resolve2, reject) => {
          stream._pendingAbortRequest = {
            _promise: void 0,
            _resolve: resolve2,
            _reject: reject,
            _reason: reason,
            _wasAlreadyErroring: wasAlreadyErroring
          };
        });
        stream._pendingAbortRequest._promise = promise;
        if (!wasAlreadyErroring) {
          WritableStreamStartErroring(stream, reason);
        }
        return promise;
      }
      function WritableStreamClose(stream) {
        const state2 = stream._state;
        if (state2 === "closed" || state2 === "errored") {
          return promiseRejectedWith(new TypeError(`The stream (in ${state2} state) is not in the writable state and cannot be closed`));
        }
        const promise = newPromise((resolve2, reject) => {
          const closeRequest = {
            _resolve: resolve2,
            _reject: reject
          };
          stream._closeRequest = closeRequest;
        });
        const writer = stream._writer;
        if (writer !== void 0 && stream._backpressure && state2 === "writable") {
          defaultWriterReadyPromiseResolve(writer);
        }
        WritableStreamDefaultControllerClose(stream._writableStreamController);
        return promise;
      }
      function WritableStreamAddWriteRequest(stream) {
        const promise = newPromise((resolve2, reject) => {
          const writeRequest = {
            _resolve: resolve2,
            _reject: reject
          };
          stream._writeRequests.push(writeRequest);
        });
        return promise;
      }
      function WritableStreamDealWithRejection(stream, error2) {
        const state2 = stream._state;
        if (state2 === "writable") {
          WritableStreamStartErroring(stream, error2);
          return;
        }
        WritableStreamFinishErroring(stream);
      }
      function WritableStreamStartErroring(stream, reason) {
        const controller = stream._writableStreamController;
        stream._state = "erroring";
        stream._storedError = reason;
        const writer = stream._writer;
        if (writer !== void 0) {
          WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
        }
        if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) {
          WritableStreamFinishErroring(stream);
        }
      }
      function WritableStreamFinishErroring(stream) {
        stream._state = "errored";
        stream._writableStreamController[ErrorSteps]();
        const storedError = stream._storedError;
        stream._writeRequests.forEach((writeRequest) => {
          writeRequest._reject(storedError);
        });
        stream._writeRequests = new SimpleQueue();
        if (stream._pendingAbortRequest === void 0) {
          WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
          return;
        }
        const abortRequest = stream._pendingAbortRequest;
        stream._pendingAbortRequest = void 0;
        if (abortRequest._wasAlreadyErroring) {
          abortRequest._reject(storedError);
          WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
          return;
        }
        const promise = stream._writableStreamController[AbortSteps](abortRequest._reason);
        uponPromise(promise, () => {
          abortRequest._resolve();
          WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
          return null;
        }, (reason) => {
          abortRequest._reject(reason);
          WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
          return null;
        });
      }
      function WritableStreamFinishInFlightWrite(stream) {
        stream._inFlightWriteRequest._resolve(void 0);
        stream._inFlightWriteRequest = void 0;
      }
      function WritableStreamFinishInFlightWriteWithError(stream, error2) {
        stream._inFlightWriteRequest._reject(error2);
        stream._inFlightWriteRequest = void 0;
        WritableStreamDealWithRejection(stream, error2);
      }
      function WritableStreamFinishInFlightClose(stream) {
        stream._inFlightCloseRequest._resolve(void 0);
        stream._inFlightCloseRequest = void 0;
        const state2 = stream._state;
        if (state2 === "erroring") {
          stream._storedError = void 0;
          if (stream._pendingAbortRequest !== void 0) {
            stream._pendingAbortRequest._resolve();
            stream._pendingAbortRequest = void 0;
          }
        }
        stream._state = "closed";
        const writer = stream._writer;
        if (writer !== void 0) {
          defaultWriterClosedPromiseResolve(writer);
        }
      }
      function WritableStreamFinishInFlightCloseWithError(stream, error2) {
        stream._inFlightCloseRequest._reject(error2);
        stream._inFlightCloseRequest = void 0;
        if (stream._pendingAbortRequest !== void 0) {
          stream._pendingAbortRequest._reject(error2);
          stream._pendingAbortRequest = void 0;
        }
        WritableStreamDealWithRejection(stream, error2);
      }
      function WritableStreamCloseQueuedOrInFlight(stream) {
        if (stream._closeRequest === void 0 && stream._inFlightCloseRequest === void 0) {
          return false;
        }
        return true;
      }
      function WritableStreamHasOperationMarkedInFlight(stream) {
        if (stream._inFlightWriteRequest === void 0 && stream._inFlightCloseRequest === void 0) {
          return false;
        }
        return true;
      }
      function WritableStreamMarkCloseRequestInFlight(stream) {
        stream._inFlightCloseRequest = stream._closeRequest;
        stream._closeRequest = void 0;
      }
      function WritableStreamMarkFirstWriteRequestInFlight(stream) {
        stream._inFlightWriteRequest = stream._writeRequests.shift();
      }
      function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
        if (stream._closeRequest !== void 0) {
          stream._closeRequest._reject(stream._storedError);
          stream._closeRequest = void 0;
        }
        const writer = stream._writer;
        if (writer !== void 0) {
          defaultWriterClosedPromiseReject(writer, stream._storedError);
        }
      }
      function WritableStreamUpdateBackpressure(stream, backpressure) {
        const writer = stream._writer;
        if (writer !== void 0 && backpressure !== stream._backpressure) {
          if (backpressure) {
            defaultWriterReadyPromiseReset(writer);
          } else {
            defaultWriterReadyPromiseResolve(writer);
          }
        }
        stream._backpressure = backpressure;
      }
      class WritableStreamDefaultWriter {
        constructor(stream) {
          assertRequiredArgument(stream, 1, "WritableStreamDefaultWriter");
          assertWritableStream(stream, "First parameter");
          if (IsWritableStreamLocked(stream)) {
            throw new TypeError("This stream has already been locked for exclusive writing by another writer");
          }
          this._ownerWritableStream = stream;
          stream._writer = this;
          const state2 = stream._state;
          if (state2 === "writable") {
            if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) {
              defaultWriterReadyPromiseInitialize(this);
            } else {
              defaultWriterReadyPromiseInitializeAsResolved(this);
            }
            defaultWriterClosedPromiseInitialize(this);
          } else if (state2 === "erroring") {
            defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
            defaultWriterClosedPromiseInitialize(this);
          } else if (state2 === "closed") {
            defaultWriterReadyPromiseInitializeAsResolved(this);
            defaultWriterClosedPromiseInitializeAsResolved(this);
          } else {
            const storedError = stream._storedError;
            defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
            defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
          }
        }
        /**
         * Returns a promise that will be fulfilled when the stream becomes closed, or rejected if the stream ever errors or
         * the writer’s lock is released before the stream finishes closing.
         */
        get closed() {
          if (!IsWritableStreamDefaultWriter(this)) {
            return promiseRejectedWith(defaultWriterBrandCheckException("closed"));
          }
          return this._closedPromise;
        }
        /**
         * Returns the desired size to fill the stream’s internal queue. It can be negative, if the queue is over-full.
         * A producer can use this information to determine the right amount of data to write.
         *
         * It will be `null` if the stream cannot be successfully written to (due to either being errored, or having an abort
         * queued up). It will return zero if the stream is closed. And the getter will throw an exception if invoked when
         * the writer’s lock is released.
         */
        get desiredSize() {
          if (!IsWritableStreamDefaultWriter(this)) {
            throw defaultWriterBrandCheckException("desiredSize");
          }
          if (this._ownerWritableStream === void 0) {
            throw defaultWriterLockException("desiredSize");
          }
          return WritableStreamDefaultWriterGetDesiredSize(this);
        }
        /**
         * Returns a promise that will be fulfilled when the desired size to fill the stream’s internal queue transitions
         * from non-positive to positive, signaling that it is no longer applying backpressure. Once the desired size dips
         * back to zero or below, the getter will return a new promise that stays pending until the next transition.
         *
         * If the stream becomes errored or aborted, or the writer’s lock is released, the returned promise will become
         * rejected.
         */
        get ready() {
          if (!IsWritableStreamDefaultWriter(this)) {
            return promiseRejectedWith(defaultWriterBrandCheckException("ready"));
          }
          return this._readyPromise;
        }
        /**
         * If the reader is active, behaves the same as {@link WritableStream.abort | stream.abort(reason)}.
         */
        abort(reason = void 0) {
          if (!IsWritableStreamDefaultWriter(this)) {
            return promiseRejectedWith(defaultWriterBrandCheckException("abort"));
          }
          if (this._ownerWritableStream === void 0) {
            return promiseRejectedWith(defaultWriterLockException("abort"));
          }
          return WritableStreamDefaultWriterAbort(this, reason);
        }
        /**
         * If the reader is active, behaves the same as {@link WritableStream.close | stream.close()}.
         */
        close() {
          if (!IsWritableStreamDefaultWriter(this)) {
            return promiseRejectedWith(defaultWriterBrandCheckException("close"));
          }
          const stream = this._ownerWritableStream;
          if (stream === void 0) {
            return promiseRejectedWith(defaultWriterLockException("close"));
          }
          if (WritableStreamCloseQueuedOrInFlight(stream)) {
            return promiseRejectedWith(new TypeError("Cannot close an already-closing stream"));
          }
          return WritableStreamDefaultWriterClose(this);
        }
        /**
         * Releases the writer’s lock on the corresponding stream. After the lock is released, the writer is no longer active.
         * If the associated stream is errored when the lock is released, the writer will appear errored in the same way from
         * now on; otherwise, the writer will appear closed.
         *
         * Note that the lock can still be released even if some ongoing writes have not yet finished (i.e. even if the
         * promises returned from previous calls to {@link WritableStreamDefaultWriter.write | write()} have not yet settled).
         * It’s not necessary to hold the lock on the writer for the duration of the write; the lock instead simply prevents
         * other producers from writing in an interleaved manner.
         */
        releaseLock() {
          if (!IsWritableStreamDefaultWriter(this)) {
            throw defaultWriterBrandCheckException("releaseLock");
          }
          const stream = this._ownerWritableStream;
          if (stream === void 0) {
            return;
          }
          WritableStreamDefaultWriterRelease(this);
        }
        write(chunk = void 0) {
          if (!IsWritableStreamDefaultWriter(this)) {
            return promiseRejectedWith(defaultWriterBrandCheckException("write"));
          }
          if (this._ownerWritableStream === void 0) {
            return promiseRejectedWith(defaultWriterLockException("write to"));
          }
          return WritableStreamDefaultWriterWrite(this, chunk);
        }
      }
      Object.defineProperties(WritableStreamDefaultWriter.prototype, {
        abort: { enumerable: true },
        close: { enumerable: true },
        releaseLock: { enumerable: true },
        write: { enumerable: true },
        closed: { enumerable: true },
        desiredSize: { enumerable: true },
        ready: { enumerable: true }
      });
      setFunctionName(WritableStreamDefaultWriter.prototype.abort, "abort");
      setFunctionName(WritableStreamDefaultWriter.prototype.close, "close");
      setFunctionName(WritableStreamDefaultWriter.prototype.releaseLock, "releaseLock");
      setFunctionName(WritableStreamDefaultWriter.prototype.write, "write");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(WritableStreamDefaultWriter.prototype, Symbol.toStringTag, {
          value: "WritableStreamDefaultWriter",
          configurable: true
        });
      }
      function IsWritableStreamDefaultWriter(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_ownerWritableStream")) {
          return false;
        }
        return x11 instanceof WritableStreamDefaultWriter;
      }
      function WritableStreamDefaultWriterAbort(writer, reason) {
        const stream = writer._ownerWritableStream;
        return WritableStreamAbort(stream, reason);
      }
      function WritableStreamDefaultWriterClose(writer) {
        const stream = writer._ownerWritableStream;
        return WritableStreamClose(stream);
      }
      function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
        const stream = writer._ownerWritableStream;
        const state2 = stream._state;
        if (WritableStreamCloseQueuedOrInFlight(stream) || state2 === "closed") {
          return promiseResolvedWith(void 0);
        }
        if (state2 === "errored") {
          return promiseRejectedWith(stream._storedError);
        }
        return WritableStreamDefaultWriterClose(writer);
      }
      function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error2) {
        if (writer._closedPromiseState === "pending") {
          defaultWriterClosedPromiseReject(writer, error2);
        } else {
          defaultWriterClosedPromiseResetToRejected(writer, error2);
        }
      }
      function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error2) {
        if (writer._readyPromiseState === "pending") {
          defaultWriterReadyPromiseReject(writer, error2);
        } else {
          defaultWriterReadyPromiseResetToRejected(writer, error2);
        }
      }
      function WritableStreamDefaultWriterGetDesiredSize(writer) {
        const stream = writer._ownerWritableStream;
        const state2 = stream._state;
        if (state2 === "errored" || state2 === "erroring") {
          return null;
        }
        if (state2 === "closed") {
          return 0;
        }
        return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
      }
      function WritableStreamDefaultWriterRelease(writer) {
        const stream = writer._ownerWritableStream;
        const releasedError = new TypeError(`Writer was released and can no longer be used to monitor the stream's closedness`);
        WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
        WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
        stream._writer = void 0;
        writer._ownerWritableStream = void 0;
      }
      function WritableStreamDefaultWriterWrite(writer, chunk) {
        const stream = writer._ownerWritableStream;
        const controller = stream._writableStreamController;
        const chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
        if (stream !== writer._ownerWritableStream) {
          return promiseRejectedWith(defaultWriterLockException("write to"));
        }
        const state2 = stream._state;
        if (state2 === "errored") {
          return promiseRejectedWith(stream._storedError);
        }
        if (WritableStreamCloseQueuedOrInFlight(stream) || state2 === "closed") {
          return promiseRejectedWith(new TypeError("The stream is closing or closed and cannot be written to"));
        }
        if (state2 === "erroring") {
          return promiseRejectedWith(stream._storedError);
        }
        const promise = WritableStreamAddWriteRequest(stream);
        WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
        return promise;
      }
      const closeSentinel = {};
      class WritableStreamDefaultController {
        constructor() {
          throw new TypeError("Illegal constructor");
        }
        /**
         * The reason which was passed to `WritableStream.abort(reason)` when the stream was aborted.
         *
         * @deprecated
         *  This property has been removed from the specification, see https://github.com/whatwg/streams/pull/1177.
         *  Use {@link WritableStreamDefaultController.signal}'s `reason` instead.
         */
        get abortReason() {
          if (!IsWritableStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException$2("abortReason");
          }
          return this._abortReason;
        }
        /**
         * An `AbortSignal` that can be used to abort the pending write or close operation when the stream is aborted.
         */
        get signal() {
          if (!IsWritableStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException$2("signal");
          }
          if (this._abortController === void 0) {
            throw new TypeError("WritableStreamDefaultController.prototype.signal is not supported");
          }
          return this._abortController.signal;
        }
        /**
         * Closes the controlled writable stream, making all future interactions with it fail with the given error `e`.
         *
         * This method is rarely used, since usually it suffices to return a rejected promise from one of the underlying
         * sink's methods. However, it can be useful for suddenly shutting down a stream in response to an event outside the
         * normal lifecycle of interactions with the underlying sink.
         */
        error(e6 = void 0) {
          if (!IsWritableStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException$2("error");
          }
          const state2 = this._controlledWritableStream._state;
          if (state2 !== "writable") {
            return;
          }
          WritableStreamDefaultControllerError(this, e6);
        }
        /** @internal */
        [AbortSteps](reason) {
          const result = this._abortAlgorithm(reason);
          WritableStreamDefaultControllerClearAlgorithms(this);
          return result;
        }
        /** @internal */
        [ErrorSteps]() {
          ResetQueue(this);
        }
      }
      Object.defineProperties(WritableStreamDefaultController.prototype, {
        abortReason: { enumerable: true },
        signal: { enumerable: true },
        error: { enumerable: true }
      });
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(WritableStreamDefaultController.prototype, Symbol.toStringTag, {
          value: "WritableStreamDefaultController",
          configurable: true
        });
      }
      function IsWritableStreamDefaultController(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_controlledWritableStream")) {
          return false;
        }
        return x11 instanceof WritableStreamDefaultController;
      }
      function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
        controller._controlledWritableStream = stream;
        stream._writableStreamController = controller;
        controller._queue = void 0;
        controller._queueTotalSize = void 0;
        ResetQueue(controller);
        controller._abortReason = void 0;
        controller._abortController = createAbortController();
        controller._started = false;
        controller._strategySizeAlgorithm = sizeAlgorithm;
        controller._strategyHWM = highWaterMark;
        controller._writeAlgorithm = writeAlgorithm;
        controller._closeAlgorithm = closeAlgorithm;
        controller._abortAlgorithm = abortAlgorithm;
        const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
        WritableStreamUpdateBackpressure(stream, backpressure);
        const startResult = startAlgorithm();
        const startPromise = promiseResolvedWith(startResult);
        uponPromise(startPromise, () => {
          controller._started = true;
          WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
          return null;
        }, (r6) => {
          controller._started = true;
          WritableStreamDealWithRejection(stream, r6);
          return null;
        });
      }
      function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
        const controller = Object.create(WritableStreamDefaultController.prototype);
        let startAlgorithm;
        let writeAlgorithm;
        let closeAlgorithm;
        let abortAlgorithm;
        if (underlyingSink.start !== void 0) {
          startAlgorithm = () => underlyingSink.start(controller);
        } else {
          startAlgorithm = () => void 0;
        }
        if (underlyingSink.write !== void 0) {
          writeAlgorithm = (chunk) => underlyingSink.write(chunk, controller);
        } else {
          writeAlgorithm = () => promiseResolvedWith(void 0);
        }
        if (underlyingSink.close !== void 0) {
          closeAlgorithm = () => underlyingSink.close();
        } else {
          closeAlgorithm = () => promiseResolvedWith(void 0);
        }
        if (underlyingSink.abort !== void 0) {
          abortAlgorithm = (reason) => underlyingSink.abort(reason);
        } else {
          abortAlgorithm = () => promiseResolvedWith(void 0);
        }
        SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
      }
      function WritableStreamDefaultControllerClearAlgorithms(controller) {
        controller._writeAlgorithm = void 0;
        controller._closeAlgorithm = void 0;
        controller._abortAlgorithm = void 0;
        controller._strategySizeAlgorithm = void 0;
      }
      function WritableStreamDefaultControllerClose(controller) {
        EnqueueValueWithSize(controller, closeSentinel, 0);
        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
      }
      function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
        try {
          return controller._strategySizeAlgorithm(chunk);
        } catch (chunkSizeE) {
          WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
          return 1;
        }
      }
      function WritableStreamDefaultControllerGetDesiredSize(controller) {
        return controller._strategyHWM - controller._queueTotalSize;
      }
      function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
        try {
          EnqueueValueWithSize(controller, chunk, chunkSize);
        } catch (enqueueE) {
          WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
          return;
        }
        const stream = controller._controlledWritableStream;
        if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === "writable") {
          const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
          WritableStreamUpdateBackpressure(stream, backpressure);
        }
        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
      }
      function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
        const stream = controller._controlledWritableStream;
        if (!controller._started) {
          return;
        }
        if (stream._inFlightWriteRequest !== void 0) {
          return;
        }
        const state2 = stream._state;
        if (state2 === "erroring") {
          WritableStreamFinishErroring(stream);
          return;
        }
        if (controller._queue.length === 0) {
          return;
        }
        const value = PeekQueueValue(controller);
        if (value === closeSentinel) {
          WritableStreamDefaultControllerProcessClose(controller);
        } else {
          WritableStreamDefaultControllerProcessWrite(controller, value);
        }
      }
      function WritableStreamDefaultControllerErrorIfNeeded(controller, error2) {
        if (controller._controlledWritableStream._state === "writable") {
          WritableStreamDefaultControllerError(controller, error2);
        }
      }
      function WritableStreamDefaultControllerProcessClose(controller) {
        const stream = controller._controlledWritableStream;
        WritableStreamMarkCloseRequestInFlight(stream);
        DequeueValue(controller);
        const sinkClosePromise = controller._closeAlgorithm();
        WritableStreamDefaultControllerClearAlgorithms(controller);
        uponPromise(sinkClosePromise, () => {
          WritableStreamFinishInFlightClose(stream);
          return null;
        }, (reason) => {
          WritableStreamFinishInFlightCloseWithError(stream, reason);
          return null;
        });
      }
      function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
        const stream = controller._controlledWritableStream;
        WritableStreamMarkFirstWriteRequestInFlight(stream);
        const sinkWritePromise = controller._writeAlgorithm(chunk);
        uponPromise(sinkWritePromise, () => {
          WritableStreamFinishInFlightWrite(stream);
          const state2 = stream._state;
          DequeueValue(controller);
          if (!WritableStreamCloseQueuedOrInFlight(stream) && state2 === "writable") {
            const backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
            WritableStreamUpdateBackpressure(stream, backpressure);
          }
          WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
          return null;
        }, (reason) => {
          if (stream._state === "writable") {
            WritableStreamDefaultControllerClearAlgorithms(controller);
          }
          WritableStreamFinishInFlightWriteWithError(stream, reason);
          return null;
        });
      }
      function WritableStreamDefaultControllerGetBackpressure(controller) {
        const desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
        return desiredSize <= 0;
      }
      function WritableStreamDefaultControllerError(controller, error2) {
        const stream = controller._controlledWritableStream;
        WritableStreamDefaultControllerClearAlgorithms(controller);
        WritableStreamStartErroring(stream, error2);
      }
      function streamBrandCheckException$2(name3) {
        return new TypeError(`WritableStream.prototype.${name3} can only be used on a WritableStream`);
      }
      function defaultControllerBrandCheckException$2(name3) {
        return new TypeError(`WritableStreamDefaultController.prototype.${name3} can only be used on a WritableStreamDefaultController`);
      }
      function defaultWriterBrandCheckException(name3) {
        return new TypeError(`WritableStreamDefaultWriter.prototype.${name3} can only be used on a WritableStreamDefaultWriter`);
      }
      function defaultWriterLockException(name3) {
        return new TypeError("Cannot " + name3 + " a stream using a released writer");
      }
      function defaultWriterClosedPromiseInitialize(writer) {
        writer._closedPromise = newPromise((resolve2, reject) => {
          writer._closedPromise_resolve = resolve2;
          writer._closedPromise_reject = reject;
          writer._closedPromiseState = "pending";
        });
      }
      function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
        defaultWriterClosedPromiseInitialize(writer);
        defaultWriterClosedPromiseReject(writer, reason);
      }
      function defaultWriterClosedPromiseInitializeAsResolved(writer) {
        defaultWriterClosedPromiseInitialize(writer);
        defaultWriterClosedPromiseResolve(writer);
      }
      function defaultWriterClosedPromiseReject(writer, reason) {
        if (writer._closedPromise_reject === void 0) {
          return;
        }
        setPromiseIsHandledToTrue(writer._closedPromise);
        writer._closedPromise_reject(reason);
        writer._closedPromise_resolve = void 0;
        writer._closedPromise_reject = void 0;
        writer._closedPromiseState = "rejected";
      }
      function defaultWriterClosedPromiseResetToRejected(writer, reason) {
        defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
      }
      function defaultWriterClosedPromiseResolve(writer) {
        if (writer._closedPromise_resolve === void 0) {
          return;
        }
        writer._closedPromise_resolve(void 0);
        writer._closedPromise_resolve = void 0;
        writer._closedPromise_reject = void 0;
        writer._closedPromiseState = "resolved";
      }
      function defaultWriterReadyPromiseInitialize(writer) {
        writer._readyPromise = newPromise((resolve2, reject) => {
          writer._readyPromise_resolve = resolve2;
          writer._readyPromise_reject = reject;
        });
        writer._readyPromiseState = "pending";
      }
      function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
        defaultWriterReadyPromiseInitialize(writer);
        defaultWriterReadyPromiseReject(writer, reason);
      }
      function defaultWriterReadyPromiseInitializeAsResolved(writer) {
        defaultWriterReadyPromiseInitialize(writer);
        defaultWriterReadyPromiseResolve(writer);
      }
      function defaultWriterReadyPromiseReject(writer, reason) {
        if (writer._readyPromise_reject === void 0) {
          return;
        }
        setPromiseIsHandledToTrue(writer._readyPromise);
        writer._readyPromise_reject(reason);
        writer._readyPromise_resolve = void 0;
        writer._readyPromise_reject = void 0;
        writer._readyPromiseState = "rejected";
      }
      function defaultWriterReadyPromiseReset(writer) {
        defaultWriterReadyPromiseInitialize(writer);
      }
      function defaultWriterReadyPromiseResetToRejected(writer, reason) {
        defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
      }
      function defaultWriterReadyPromiseResolve(writer) {
        if (writer._readyPromise_resolve === void 0) {
          return;
        }
        writer._readyPromise_resolve(void 0);
        writer._readyPromise_resolve = void 0;
        writer._readyPromise_reject = void 0;
        writer._readyPromiseState = "fulfilled";
      }
      function getGlobals() {
        if (typeof globalThis !== "undefined") {
          return globalThis;
        } else if (typeof self !== "undefined") {
          return self;
        } else if (typeof global !== "undefined") {
          return global;
        }
        return void 0;
      }
      const globals = getGlobals();
      function isDOMExceptionConstructor(ctor) {
        if (!(typeof ctor === "function" || typeof ctor === "object")) {
          return false;
        }
        if (ctor.name !== "DOMException") {
          return false;
        }
        try {
          new ctor();
          return true;
        } catch (_a507) {
          return false;
        }
      }
      function getFromGlobal() {
        const ctor = globals === null || globals === void 0 ? void 0 : globals.DOMException;
        return isDOMExceptionConstructor(ctor) ? ctor : void 0;
      }
      function createPolyfill() {
        const ctor = function DOMException3(message, name3) {
          this.message = message || "";
          this.name = name3 || "Error";
          if (Error.captureStackTrace) {
            Error.captureStackTrace(this, this.constructor);
          }
        };
        setFunctionName(ctor, "DOMException");
        ctor.prototype = Object.create(Error.prototype);
        Object.defineProperty(ctor.prototype, "constructor", { value: ctor, writable: true, configurable: true });
        return ctor;
      }
      const DOMException2 = getFromGlobal() || createPolyfill();
      function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
        const reader = AcquireReadableStreamDefaultReader(source);
        const writer = AcquireWritableStreamDefaultWriter(dest);
        source._disturbed = true;
        let shuttingDown = false;
        let currentWrite = promiseResolvedWith(void 0);
        return newPromise((resolve2, reject) => {
          let abortAlgorithm;
          if (signal !== void 0) {
            abortAlgorithm = () => {
              const error2 = signal.reason !== void 0 ? signal.reason : new DOMException2("Aborted", "AbortError");
              const actions = [];
              if (!preventAbort) {
                actions.push(() => {
                  if (dest._state === "writable") {
                    return WritableStreamAbort(dest, error2);
                  }
                  return promiseResolvedWith(void 0);
                });
              }
              if (!preventCancel) {
                actions.push(() => {
                  if (source._state === "readable") {
                    return ReadableStreamCancel(source, error2);
                  }
                  return promiseResolvedWith(void 0);
                });
              }
              shutdownWithAction(() => Promise.all(actions.map((action) => action())), true, error2);
            };
            if (signal.aborted) {
              abortAlgorithm();
              return;
            }
            signal.addEventListener("abort", abortAlgorithm);
          }
          function pipeLoop() {
            return newPromise((resolveLoop, rejectLoop) => {
              function next(done) {
                if (done) {
                  resolveLoop();
                } else {
                  PerformPromiseThen(pipeStep(), next, rejectLoop);
                }
              }
              next(false);
            });
          }
          function pipeStep() {
            if (shuttingDown) {
              return promiseResolvedWith(true);
            }
            return PerformPromiseThen(writer._readyPromise, () => {
              return newPromise((resolveRead, rejectRead) => {
                ReadableStreamDefaultReaderRead(reader, {
                  _chunkSteps: (chunk) => {
                    currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), void 0, noop4);
                    resolveRead(false);
                  },
                  _closeSteps: () => resolveRead(true),
                  _errorSteps: rejectRead
                });
              });
            });
          }
          isOrBecomesErrored(source, reader._closedPromise, (storedError) => {
            if (!preventAbort) {
              shutdownWithAction(() => WritableStreamAbort(dest, storedError), true, storedError);
            } else {
              shutdown(true, storedError);
            }
            return null;
          });
          isOrBecomesErrored(dest, writer._closedPromise, (storedError) => {
            if (!preventCancel) {
              shutdownWithAction(() => ReadableStreamCancel(source, storedError), true, storedError);
            } else {
              shutdown(true, storedError);
            }
            return null;
          });
          isOrBecomesClosed(source, reader._closedPromise, () => {
            if (!preventClose) {
              shutdownWithAction(() => WritableStreamDefaultWriterCloseWithErrorPropagation(writer));
            } else {
              shutdown();
            }
            return null;
          });
          if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === "closed") {
            const destClosed = new TypeError("the destination writable stream closed before all data could be piped to it");
            if (!preventCancel) {
              shutdownWithAction(() => ReadableStreamCancel(source, destClosed), true, destClosed);
            } else {
              shutdown(true, destClosed);
            }
          }
          setPromiseIsHandledToTrue(pipeLoop());
          function waitForWritesToFinish() {
            const oldCurrentWrite = currentWrite;
            return PerformPromiseThen(currentWrite, () => oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : void 0);
          }
          function isOrBecomesErrored(stream, promise, action) {
            if (stream._state === "errored") {
              action(stream._storedError);
            } else {
              uponRejection(promise, action);
            }
          }
          function isOrBecomesClosed(stream, promise, action) {
            if (stream._state === "closed") {
              action();
            } else {
              uponFulfillment(promise, action);
            }
          }
          function shutdownWithAction(action, originalIsError, originalError) {
            if (shuttingDown) {
              return;
            }
            shuttingDown = true;
            if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) {
              uponFulfillment(waitForWritesToFinish(), doTheRest);
            } else {
              doTheRest();
            }
            function doTheRest() {
              uponPromise(action(), () => finalize(originalIsError, originalError), (newError) => finalize(true, newError));
              return null;
            }
          }
          function shutdown(isError, error2) {
            if (shuttingDown) {
              return;
            }
            shuttingDown = true;
            if (dest._state === "writable" && !WritableStreamCloseQueuedOrInFlight(dest)) {
              uponFulfillment(waitForWritesToFinish(), () => finalize(isError, error2));
            } else {
              finalize(isError, error2);
            }
          }
          function finalize(isError, error2) {
            WritableStreamDefaultWriterRelease(writer);
            ReadableStreamReaderGenericRelease(reader);
            if (signal !== void 0) {
              signal.removeEventListener("abort", abortAlgorithm);
            }
            if (isError) {
              reject(error2);
            } else {
              resolve2(void 0);
            }
            return null;
          }
        });
      }
      class ReadableStreamDefaultController {
        constructor() {
          throw new TypeError("Illegal constructor");
        }
        /**
         * Returns the desired size to fill the controlled stream's internal queue. It can be negative, if the queue is
         * over-full. An underlying source ought to use this information to determine when and how to apply backpressure.
         */
        get desiredSize() {
          if (!IsReadableStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException$1("desiredSize");
          }
          return ReadableStreamDefaultControllerGetDesiredSize(this);
        }
        /**
         * Closes the controlled readable stream. Consumers will still be able to read any previously-enqueued chunks from
         * the stream, but once those are read, the stream will become closed.
         */
        close() {
          if (!IsReadableStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException$1("close");
          }
          if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
            throw new TypeError("The stream is not in a state that permits close");
          }
          ReadableStreamDefaultControllerClose(this);
        }
        enqueue(chunk = void 0) {
          if (!IsReadableStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException$1("enqueue");
          }
          if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
            throw new TypeError("The stream is not in a state that permits enqueue");
          }
          return ReadableStreamDefaultControllerEnqueue(this, chunk);
        }
        /**
         * Errors the controlled readable stream, making all future interactions with it fail with the given error `e`.
         */
        error(e6 = void 0) {
          if (!IsReadableStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException$1("error");
          }
          ReadableStreamDefaultControllerError(this, e6);
        }
        /** @internal */
        [CancelSteps](reason) {
          ResetQueue(this);
          const result = this._cancelAlgorithm(reason);
          ReadableStreamDefaultControllerClearAlgorithms(this);
          return result;
        }
        /** @internal */
        [PullSteps](readRequest) {
          const stream = this._controlledReadableStream;
          if (this._queue.length > 0) {
            const chunk = DequeueValue(this);
            if (this._closeRequested && this._queue.length === 0) {
              ReadableStreamDefaultControllerClearAlgorithms(this);
              ReadableStreamClose(stream);
            } else {
              ReadableStreamDefaultControllerCallPullIfNeeded(this);
            }
            readRequest._chunkSteps(chunk);
          } else {
            ReadableStreamAddReadRequest(stream, readRequest);
            ReadableStreamDefaultControllerCallPullIfNeeded(this);
          }
        }
        /** @internal */
        [ReleaseSteps]() {
        }
      }
      Object.defineProperties(ReadableStreamDefaultController.prototype, {
        close: { enumerable: true },
        enqueue: { enumerable: true },
        error: { enumerable: true },
        desiredSize: { enumerable: true }
      });
      setFunctionName(ReadableStreamDefaultController.prototype.close, "close");
      setFunctionName(ReadableStreamDefaultController.prototype.enqueue, "enqueue");
      setFunctionName(ReadableStreamDefaultController.prototype.error, "error");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(ReadableStreamDefaultController.prototype, Symbol.toStringTag, {
          value: "ReadableStreamDefaultController",
          configurable: true
        });
      }
      function IsReadableStreamDefaultController(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_controlledReadableStream")) {
          return false;
        }
        return x11 instanceof ReadableStreamDefaultController;
      }
      function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
        const shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
        if (!shouldPull) {
          return;
        }
        if (controller._pulling) {
          controller._pullAgain = true;
          return;
        }
        controller._pulling = true;
        const pullPromise = controller._pullAlgorithm();
        uponPromise(pullPromise, () => {
          controller._pulling = false;
          if (controller._pullAgain) {
            controller._pullAgain = false;
            ReadableStreamDefaultControllerCallPullIfNeeded(controller);
          }
          return null;
        }, (e6) => {
          ReadableStreamDefaultControllerError(controller, e6);
          return null;
        });
      }
      function ReadableStreamDefaultControllerShouldCallPull(controller) {
        const stream = controller._controlledReadableStream;
        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
          return false;
        }
        if (!controller._started) {
          return false;
        }
        if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
          return true;
        }
        const desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
        if (desiredSize > 0) {
          return true;
        }
        return false;
      }
      function ReadableStreamDefaultControllerClearAlgorithms(controller) {
        controller._pullAlgorithm = void 0;
        controller._cancelAlgorithm = void 0;
        controller._strategySizeAlgorithm = void 0;
      }
      function ReadableStreamDefaultControllerClose(controller) {
        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
          return;
        }
        const stream = controller._controlledReadableStream;
        controller._closeRequested = true;
        if (controller._queue.length === 0) {
          ReadableStreamDefaultControllerClearAlgorithms(controller);
          ReadableStreamClose(stream);
        }
      }
      function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
          return;
        }
        const stream = controller._controlledReadableStream;
        if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
          ReadableStreamFulfillReadRequest(stream, chunk, false);
        } else {
          let chunkSize;
          try {
            chunkSize = controller._strategySizeAlgorithm(chunk);
          } catch (chunkSizeE) {
            ReadableStreamDefaultControllerError(controller, chunkSizeE);
            throw chunkSizeE;
          }
          try {
            EnqueueValueWithSize(controller, chunk, chunkSize);
          } catch (enqueueE) {
            ReadableStreamDefaultControllerError(controller, enqueueE);
            throw enqueueE;
          }
        }
        ReadableStreamDefaultControllerCallPullIfNeeded(controller);
      }
      function ReadableStreamDefaultControllerError(controller, e6) {
        const stream = controller._controlledReadableStream;
        if (stream._state !== "readable") {
          return;
        }
        ResetQueue(controller);
        ReadableStreamDefaultControllerClearAlgorithms(controller);
        ReadableStreamError(stream, e6);
      }
      function ReadableStreamDefaultControllerGetDesiredSize(controller) {
        const state2 = controller._controlledReadableStream._state;
        if (state2 === "errored") {
          return null;
        }
        if (state2 === "closed") {
          return 0;
        }
        return controller._strategyHWM - controller._queueTotalSize;
      }
      function ReadableStreamDefaultControllerHasBackpressure(controller) {
        if (ReadableStreamDefaultControllerShouldCallPull(controller)) {
          return false;
        }
        return true;
      }
      function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
        const state2 = controller._controlledReadableStream._state;
        if (!controller._closeRequested && state2 === "readable") {
          return true;
        }
        return false;
      }
      function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
        controller._controlledReadableStream = stream;
        controller._queue = void 0;
        controller._queueTotalSize = void 0;
        ResetQueue(controller);
        controller._started = false;
        controller._closeRequested = false;
        controller._pullAgain = false;
        controller._pulling = false;
        controller._strategySizeAlgorithm = sizeAlgorithm;
        controller._strategyHWM = highWaterMark;
        controller._pullAlgorithm = pullAlgorithm;
        controller._cancelAlgorithm = cancelAlgorithm;
        stream._readableStreamController = controller;
        const startResult = startAlgorithm();
        uponPromise(promiseResolvedWith(startResult), () => {
          controller._started = true;
          ReadableStreamDefaultControllerCallPullIfNeeded(controller);
          return null;
        }, (r6) => {
          ReadableStreamDefaultControllerError(controller, r6);
          return null;
        });
      }
      function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
        const controller = Object.create(ReadableStreamDefaultController.prototype);
        let startAlgorithm;
        let pullAlgorithm;
        let cancelAlgorithm;
        if (underlyingSource.start !== void 0) {
          startAlgorithm = () => underlyingSource.start(controller);
        } else {
          startAlgorithm = () => void 0;
        }
        if (underlyingSource.pull !== void 0) {
          pullAlgorithm = () => underlyingSource.pull(controller);
        } else {
          pullAlgorithm = () => promiseResolvedWith(void 0);
        }
        if (underlyingSource.cancel !== void 0) {
          cancelAlgorithm = (reason) => underlyingSource.cancel(reason);
        } else {
          cancelAlgorithm = () => promiseResolvedWith(void 0);
        }
        SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
      }
      function defaultControllerBrandCheckException$1(name3) {
        return new TypeError(`ReadableStreamDefaultController.prototype.${name3} can only be used on a ReadableStreamDefaultController`);
      }
      function ReadableStreamTee(stream, cloneForBranch2) {
        if (IsReadableByteStreamController(stream._readableStreamController)) {
          return ReadableByteStreamTee(stream);
        }
        return ReadableStreamDefaultTee(stream);
      }
      function ReadableStreamDefaultTee(stream, cloneForBranch2) {
        const reader = AcquireReadableStreamDefaultReader(stream);
        let reading = false;
        let readAgain = false;
        let canceled1 = false;
        let canceled2 = false;
        let reason1;
        let reason2;
        let branch1;
        let branch2;
        let resolveCancelPromise;
        const cancelPromise = newPromise((resolve2) => {
          resolveCancelPromise = resolve2;
        });
        function pullAlgorithm() {
          if (reading) {
            readAgain = true;
            return promiseResolvedWith(void 0);
          }
          reading = true;
          const readRequest = {
            _chunkSteps: (chunk) => {
              _queueMicrotask2(() => {
                readAgain = false;
                const chunk1 = chunk;
                const chunk2 = chunk;
                if (!canceled1) {
                  ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, chunk1);
                }
                if (!canceled2) {
                  ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, chunk2);
                }
                reading = false;
                if (readAgain) {
                  pullAlgorithm();
                }
              });
            },
            _closeSteps: () => {
              reading = false;
              if (!canceled1) {
                ReadableStreamDefaultControllerClose(branch1._readableStreamController);
              }
              if (!canceled2) {
                ReadableStreamDefaultControllerClose(branch2._readableStreamController);
              }
              if (!canceled1 || !canceled2) {
                resolveCancelPromise(void 0);
              }
            },
            _errorSteps: () => {
              reading = false;
            }
          };
          ReadableStreamDefaultReaderRead(reader, readRequest);
          return promiseResolvedWith(void 0);
        }
        function cancel1Algorithm(reason) {
          canceled1 = true;
          reason1 = reason;
          if (canceled2) {
            const compositeReason = CreateArrayFromList([reason1, reason2]);
            const cancelResult = ReadableStreamCancel(stream, compositeReason);
            resolveCancelPromise(cancelResult);
          }
          return cancelPromise;
        }
        function cancel2Algorithm(reason) {
          canceled2 = true;
          reason2 = reason;
          if (canceled1) {
            const compositeReason = CreateArrayFromList([reason1, reason2]);
            const cancelResult = ReadableStreamCancel(stream, compositeReason);
            resolveCancelPromise(cancelResult);
          }
          return cancelPromise;
        }
        function startAlgorithm() {
        }
        branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
        branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
        uponRejection(reader._closedPromise, (r6) => {
          ReadableStreamDefaultControllerError(branch1._readableStreamController, r6);
          ReadableStreamDefaultControllerError(branch2._readableStreamController, r6);
          if (!canceled1 || !canceled2) {
            resolveCancelPromise(void 0);
          }
          return null;
        });
        return [branch1, branch2];
      }
      function ReadableByteStreamTee(stream) {
        let reader = AcquireReadableStreamDefaultReader(stream);
        let reading = false;
        let readAgainForBranch1 = false;
        let readAgainForBranch2 = false;
        let canceled1 = false;
        let canceled2 = false;
        let reason1;
        let reason2;
        let branch1;
        let branch2;
        let resolveCancelPromise;
        const cancelPromise = newPromise((resolve2) => {
          resolveCancelPromise = resolve2;
        });
        function forwardReaderError(thisReader) {
          uponRejection(thisReader._closedPromise, (r6) => {
            if (thisReader !== reader) {
              return null;
            }
            ReadableByteStreamControllerError(branch1._readableStreamController, r6);
            ReadableByteStreamControllerError(branch2._readableStreamController, r6);
            if (!canceled1 || !canceled2) {
              resolveCancelPromise(void 0);
            }
            return null;
          });
        }
        function pullWithDefaultReader() {
          if (IsReadableStreamBYOBReader(reader)) {
            ReadableStreamReaderGenericRelease(reader);
            reader = AcquireReadableStreamDefaultReader(stream);
            forwardReaderError(reader);
          }
          const readRequest = {
            _chunkSteps: (chunk) => {
              _queueMicrotask2(() => {
                readAgainForBranch1 = false;
                readAgainForBranch2 = false;
                const chunk1 = chunk;
                let chunk2 = chunk;
                if (!canceled1 && !canceled2) {
                  try {
                    chunk2 = CloneAsUint8Array(chunk);
                  } catch (cloneE) {
                    ReadableByteStreamControllerError(branch1._readableStreamController, cloneE);
                    ReadableByteStreamControllerError(branch2._readableStreamController, cloneE);
                    resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
                    return;
                  }
                }
                if (!canceled1) {
                  ReadableByteStreamControllerEnqueue(branch1._readableStreamController, chunk1);
                }
                if (!canceled2) {
                  ReadableByteStreamControllerEnqueue(branch2._readableStreamController, chunk2);
                }
                reading = false;
                if (readAgainForBranch1) {
                  pull1Algorithm();
                } else if (readAgainForBranch2) {
                  pull2Algorithm();
                }
              });
            },
            _closeSteps: () => {
              reading = false;
              if (!canceled1) {
                ReadableByteStreamControllerClose(branch1._readableStreamController);
              }
              if (!canceled2) {
                ReadableByteStreamControllerClose(branch2._readableStreamController);
              }
              if (branch1._readableStreamController._pendingPullIntos.length > 0) {
                ReadableByteStreamControllerRespond(branch1._readableStreamController, 0);
              }
              if (branch2._readableStreamController._pendingPullIntos.length > 0) {
                ReadableByteStreamControllerRespond(branch2._readableStreamController, 0);
              }
              if (!canceled1 || !canceled2) {
                resolveCancelPromise(void 0);
              }
            },
            _errorSteps: () => {
              reading = false;
            }
          };
          ReadableStreamDefaultReaderRead(reader, readRequest);
        }
        function pullWithBYOBReader(view5, forBranch2) {
          if (IsReadableStreamDefaultReader(reader)) {
            ReadableStreamReaderGenericRelease(reader);
            reader = AcquireReadableStreamBYOBReader(stream);
            forwardReaderError(reader);
          }
          const byobBranch = forBranch2 ? branch2 : branch1;
          const otherBranch = forBranch2 ? branch1 : branch2;
          const readIntoRequest = {
            _chunkSteps: (chunk) => {
              _queueMicrotask2(() => {
                readAgainForBranch1 = false;
                readAgainForBranch2 = false;
                const byobCanceled = forBranch2 ? canceled2 : canceled1;
                const otherCanceled = forBranch2 ? canceled1 : canceled2;
                if (!otherCanceled) {
                  let clonedChunk;
                  try {
                    clonedChunk = CloneAsUint8Array(chunk);
                  } catch (cloneE) {
                    ReadableByteStreamControllerError(byobBranch._readableStreamController, cloneE);
                    ReadableByteStreamControllerError(otherBranch._readableStreamController, cloneE);
                    resolveCancelPromise(ReadableStreamCancel(stream, cloneE));
                    return;
                  }
                  if (!byobCanceled) {
                    ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
                  }
                  ReadableByteStreamControllerEnqueue(otherBranch._readableStreamController, clonedChunk);
                } else if (!byobCanceled) {
                  ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
                }
                reading = false;
                if (readAgainForBranch1) {
                  pull1Algorithm();
                } else if (readAgainForBranch2) {
                  pull2Algorithm();
                }
              });
            },
            _closeSteps: (chunk) => {
              reading = false;
              const byobCanceled = forBranch2 ? canceled2 : canceled1;
              const otherCanceled = forBranch2 ? canceled1 : canceled2;
              if (!byobCanceled) {
                ReadableByteStreamControllerClose(byobBranch._readableStreamController);
              }
              if (!otherCanceled) {
                ReadableByteStreamControllerClose(otherBranch._readableStreamController);
              }
              if (chunk !== void 0) {
                if (!byobCanceled) {
                  ReadableByteStreamControllerRespondWithNewView(byobBranch._readableStreamController, chunk);
                }
                if (!otherCanceled && otherBranch._readableStreamController._pendingPullIntos.length > 0) {
                  ReadableByteStreamControllerRespond(otherBranch._readableStreamController, 0);
                }
              }
              if (!byobCanceled || !otherCanceled) {
                resolveCancelPromise(void 0);
              }
            },
            _errorSteps: () => {
              reading = false;
            }
          };
          ReadableStreamBYOBReaderRead(reader, view5, 1, readIntoRequest);
        }
        function pull1Algorithm() {
          if (reading) {
            readAgainForBranch1 = true;
            return promiseResolvedWith(void 0);
          }
          reading = true;
          const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch1._readableStreamController);
          if (byobRequest === null) {
            pullWithDefaultReader();
          } else {
            pullWithBYOBReader(byobRequest._view, false);
          }
          return promiseResolvedWith(void 0);
        }
        function pull2Algorithm() {
          if (reading) {
            readAgainForBranch2 = true;
            return promiseResolvedWith(void 0);
          }
          reading = true;
          const byobRequest = ReadableByteStreamControllerGetBYOBRequest(branch2._readableStreamController);
          if (byobRequest === null) {
            pullWithDefaultReader();
          } else {
            pullWithBYOBReader(byobRequest._view, true);
          }
          return promiseResolvedWith(void 0);
        }
        function cancel1Algorithm(reason) {
          canceled1 = true;
          reason1 = reason;
          if (canceled2) {
            const compositeReason = CreateArrayFromList([reason1, reason2]);
            const cancelResult = ReadableStreamCancel(stream, compositeReason);
            resolveCancelPromise(cancelResult);
          }
          return cancelPromise;
        }
        function cancel2Algorithm(reason) {
          canceled2 = true;
          reason2 = reason;
          if (canceled1) {
            const compositeReason = CreateArrayFromList([reason1, reason2]);
            const cancelResult = ReadableStreamCancel(stream, compositeReason);
            resolveCancelPromise(cancelResult);
          }
          return cancelPromise;
        }
        function startAlgorithm() {
          return;
        }
        branch1 = CreateReadableByteStream(startAlgorithm, pull1Algorithm, cancel1Algorithm);
        branch2 = CreateReadableByteStream(startAlgorithm, pull2Algorithm, cancel2Algorithm);
        forwardReaderError(reader);
        return [branch1, branch2];
      }
      function isReadableStreamLike(stream) {
        return typeIsObject(stream) && typeof stream.getReader !== "undefined";
      }
      function ReadableStreamFrom(source) {
        if (isReadableStreamLike(source)) {
          return ReadableStreamFromDefaultReader(source.getReader());
        }
        return ReadableStreamFromIterable(source);
      }
      function ReadableStreamFromIterable(asyncIterable) {
        let stream;
        const iteratorRecord = GetIterator(asyncIterable, "async");
        const startAlgorithm = noop4;
        function pullAlgorithm() {
          let nextResult;
          try {
            nextResult = IteratorNext(iteratorRecord);
          } catch (e6) {
            return promiseRejectedWith(e6);
          }
          const nextPromise = promiseResolvedWith(nextResult);
          return transformPromiseWith(nextPromise, (iterResult) => {
            if (!typeIsObject(iterResult)) {
              throw new TypeError("The promise returned by the iterator.next() method must fulfill with an object");
            }
            const done = IteratorComplete(iterResult);
            if (done) {
              ReadableStreamDefaultControllerClose(stream._readableStreamController);
            } else {
              const value = IteratorValue(iterResult);
              ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
            }
          });
        }
        function cancelAlgorithm(reason) {
          const iterator = iteratorRecord.iterator;
          let returnMethod;
          try {
            returnMethod = GetMethod(iterator, "return");
          } catch (e6) {
            return promiseRejectedWith(e6);
          }
          if (returnMethod === void 0) {
            return promiseResolvedWith(void 0);
          }
          let returnResult;
          try {
            returnResult = reflectCall(returnMethod, iterator, [reason]);
          } catch (e6) {
            return promiseRejectedWith(e6);
          }
          const returnPromise = promiseResolvedWith(returnResult);
          return transformPromiseWith(returnPromise, (iterResult) => {
            if (!typeIsObject(iterResult)) {
              throw new TypeError("The promise returned by the iterator.return() method must fulfill with an object");
            }
            return void 0;
          });
        }
        stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
        return stream;
      }
      function ReadableStreamFromDefaultReader(reader) {
        let stream;
        const startAlgorithm = noop4;
        function pullAlgorithm() {
          let readPromise;
          try {
            readPromise = reader.read();
          } catch (e6) {
            return promiseRejectedWith(e6);
          }
          return transformPromiseWith(readPromise, (readResult) => {
            if (!typeIsObject(readResult)) {
              throw new TypeError("The promise returned by the reader.read() method must fulfill with an object");
            }
            if (readResult.done) {
              ReadableStreamDefaultControllerClose(stream._readableStreamController);
            } else {
              const value = readResult.value;
              ReadableStreamDefaultControllerEnqueue(stream._readableStreamController, value);
            }
          });
        }
        function cancelAlgorithm(reason) {
          try {
            return promiseResolvedWith(reader.cancel(reason));
          } catch (e6) {
            return promiseRejectedWith(e6);
          }
        }
        stream = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, 0);
        return stream;
      }
      function convertUnderlyingDefaultOrByteSource(source, context) {
        assertDictionary(source, context);
        const original = source;
        const autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize;
        const cancel = original === null || original === void 0 ? void 0 : original.cancel;
        const pull = original === null || original === void 0 ? void 0 : original.pull;
        const start2 = original === null || original === void 0 ? void 0 : original.start;
        const type = original === null || original === void 0 ? void 0 : original.type;
        return {
          autoAllocateChunkSize: autoAllocateChunkSize === void 0 ? void 0 : convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, `${context} has member 'autoAllocateChunkSize' that`),
          cancel: cancel === void 0 ? void 0 : convertUnderlyingSourceCancelCallback(cancel, original, `${context} has member 'cancel' that`),
          pull: pull === void 0 ? void 0 : convertUnderlyingSourcePullCallback(pull, original, `${context} has member 'pull' that`),
          start: start2 === void 0 ? void 0 : convertUnderlyingSourceStartCallback(start2, original, `${context} has member 'start' that`),
          type: type === void 0 ? void 0 : convertReadableStreamType(type, `${context} has member 'type' that`)
        };
      }
      function convertUnderlyingSourceCancelCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (reason) => promiseCall(fn3, original, [reason]);
      }
      function convertUnderlyingSourcePullCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (controller) => promiseCall(fn3, original, [controller]);
      }
      function convertUnderlyingSourceStartCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (controller) => reflectCall(fn3, original, [controller]);
      }
      function convertReadableStreamType(type, context) {
        type = `${type}`;
        if (type !== "bytes") {
          throw new TypeError(`${context} '${type}' is not a valid enumeration value for ReadableStreamType`);
        }
        return type;
      }
      function convertIteratorOptions(options, context) {
        assertDictionary(options, context);
        const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
        return { preventCancel: Boolean(preventCancel) };
      }
      function convertPipeOptions(options, context) {
        assertDictionary(options, context);
        const preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort;
        const preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
        const preventClose = options === null || options === void 0 ? void 0 : options.preventClose;
        const signal = options === null || options === void 0 ? void 0 : options.signal;
        if (signal !== void 0) {
          assertAbortSignal(signal, `${context} has member 'signal' that`);
        }
        return {
          preventAbort: Boolean(preventAbort),
          preventCancel: Boolean(preventCancel),
          preventClose: Boolean(preventClose),
          signal
        };
      }
      function assertAbortSignal(signal, context) {
        if (!isAbortSignal2(signal)) {
          throw new TypeError(`${context} is not an AbortSignal.`);
        }
      }
      function convertReadableWritablePair(pair, context) {
        assertDictionary(pair, context);
        const readable = pair === null || pair === void 0 ? void 0 : pair.readable;
        assertRequiredField(readable, "readable", "ReadableWritablePair");
        assertReadableStream(readable, `${context} has member 'readable' that`);
        const writable = pair === null || pair === void 0 ? void 0 : pair.writable;
        assertRequiredField(writable, "writable", "ReadableWritablePair");
        assertWritableStream(writable, `${context} has member 'writable' that`);
        return { readable, writable };
      }
      class ReadableStream2 {
        constructor(rawUnderlyingSource = {}, rawStrategy = {}) {
          if (rawUnderlyingSource === void 0) {
            rawUnderlyingSource = null;
          } else {
            assertObject(rawUnderlyingSource, "First parameter");
          }
          const strategy = convertQueuingStrategy(rawStrategy, "Second parameter");
          const underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, "First parameter");
          InitializeReadableStream(this);
          if (underlyingSource.type === "bytes") {
            if (strategy.size !== void 0) {
              throw new RangeError("The strategy for a byte stream cannot have a size function");
            }
            const highWaterMark = ExtractHighWaterMark(strategy, 0);
            SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);
          } else {
            const sizeAlgorithm = ExtractSizeAlgorithm(strategy);
            const highWaterMark = ExtractHighWaterMark(strategy, 1);
            SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
          }
        }
        /**
         * Whether or not the readable stream is locked to a {@link ReadableStreamDefaultReader | reader}.
         */
        get locked() {
          if (!IsReadableStream(this)) {
            throw streamBrandCheckException$1("locked");
          }
          return IsReadableStreamLocked(this);
        }
        /**
         * Cancels the stream, signaling a loss of interest in the stream by a consumer.
         *
         * The supplied `reason` argument will be given to the underlying source's {@link UnderlyingSource.cancel | cancel()}
         * method, which might or might not use it.
         */
        cancel(reason = void 0) {
          if (!IsReadableStream(this)) {
            return promiseRejectedWith(streamBrandCheckException$1("cancel"));
          }
          if (IsReadableStreamLocked(this)) {
            return promiseRejectedWith(new TypeError("Cannot cancel a stream that already has a reader"));
          }
          return ReadableStreamCancel(this, reason);
        }
        getReader(rawOptions = void 0) {
          if (!IsReadableStream(this)) {
            throw streamBrandCheckException$1("getReader");
          }
          const options = convertReaderOptions(rawOptions, "First parameter");
          if (options.mode === void 0) {
            return AcquireReadableStreamDefaultReader(this);
          }
          return AcquireReadableStreamBYOBReader(this);
        }
        pipeThrough(rawTransform, rawOptions = {}) {
          if (!IsReadableStream(this)) {
            throw streamBrandCheckException$1("pipeThrough");
          }
          assertRequiredArgument(rawTransform, 1, "pipeThrough");
          const transform = convertReadableWritablePair(rawTransform, "First parameter");
          const options = convertPipeOptions(rawOptions, "Second parameter");
          if (IsReadableStreamLocked(this)) {
            throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream");
          }
          if (IsWritableStreamLocked(transform.writable)) {
            throw new TypeError("ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream");
          }
          const promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
          setPromiseIsHandledToTrue(promise);
          return transform.readable;
        }
        pipeTo(destination, rawOptions = {}) {
          if (!IsReadableStream(this)) {
            return promiseRejectedWith(streamBrandCheckException$1("pipeTo"));
          }
          if (destination === void 0) {
            return promiseRejectedWith(`Parameter 1 is required in 'pipeTo'.`);
          }
          if (!IsWritableStream(destination)) {
            return promiseRejectedWith(new TypeError(`ReadableStream.prototype.pipeTo's first argument must be a WritableStream`));
          }
          let options;
          try {
            options = convertPipeOptions(rawOptions, "Second parameter");
          } catch (e6) {
            return promiseRejectedWith(e6);
          }
          if (IsReadableStreamLocked(this)) {
            return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream"));
          }
          if (IsWritableStreamLocked(destination)) {
            return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream"));
          }
          return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
        }
        /**
         * Tees this readable stream, returning a two-element array containing the two resulting branches as
         * new {@link ReadableStream} instances.
         *
         * Teeing a stream will lock it, preventing any other consumer from acquiring a reader.
         * To cancel the stream, cancel both of the resulting branches; a composite cancellation reason will then be
         * propagated to the stream's underlying source.
         *
         * Note that the chunks seen in each branch will be the same object. If the chunks are not immutable,
         * this could allow interference between the two branches.
         */
        tee() {
          if (!IsReadableStream(this)) {
            throw streamBrandCheckException$1("tee");
          }
          const branches = ReadableStreamTee(this);
          return CreateArrayFromList(branches);
        }
        values(rawOptions = void 0) {
          if (!IsReadableStream(this)) {
            throw streamBrandCheckException$1("values");
          }
          const options = convertIteratorOptions(rawOptions, "First parameter");
          return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
        }
        [SymbolAsyncIterator](options) {
          return this.values(options);
        }
        /**
         * Creates a new ReadableStream wrapping the provided iterable or async iterable.
         *
         * This can be used to adapt various kinds of objects into a readable stream,
         * such as an array, an async generator, or a Node.js readable stream.
         */
        static from(asyncIterable) {
          return ReadableStreamFrom(asyncIterable);
        }
      }
      Object.defineProperties(ReadableStream2, {
        from: { enumerable: true }
      });
      Object.defineProperties(ReadableStream2.prototype, {
        cancel: { enumerable: true },
        getReader: { enumerable: true },
        pipeThrough: { enumerable: true },
        pipeTo: { enumerable: true },
        tee: { enumerable: true },
        values: { enumerable: true },
        locked: { enumerable: true }
      });
      setFunctionName(ReadableStream2.from, "from");
      setFunctionName(ReadableStream2.prototype.cancel, "cancel");
      setFunctionName(ReadableStream2.prototype.getReader, "getReader");
      setFunctionName(ReadableStream2.prototype.pipeThrough, "pipeThrough");
      setFunctionName(ReadableStream2.prototype.pipeTo, "pipeTo");
      setFunctionName(ReadableStream2.prototype.tee, "tee");
      setFunctionName(ReadableStream2.prototype.values, "values");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(ReadableStream2.prototype, Symbol.toStringTag, {
          value: "ReadableStream",
          configurable: true
        });
      }
      Object.defineProperty(ReadableStream2.prototype, SymbolAsyncIterator, {
        value: ReadableStream2.prototype.values,
        writable: true,
        configurable: true
      });
      function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark = 1, sizeAlgorithm = () => 1) {
        const stream = Object.create(ReadableStream2.prototype);
        InitializeReadableStream(stream);
        const controller = Object.create(ReadableStreamDefaultController.prototype);
        SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
        return stream;
      }
      function CreateReadableByteStream(startAlgorithm, pullAlgorithm, cancelAlgorithm) {
        const stream = Object.create(ReadableStream2.prototype);
        InitializeReadableStream(stream);
        const controller = Object.create(ReadableByteStreamController.prototype);
        SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, 0, void 0);
        return stream;
      }
      function InitializeReadableStream(stream) {
        stream._state = "readable";
        stream._reader = void 0;
        stream._storedError = void 0;
        stream._disturbed = false;
      }
      function IsReadableStream(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_readableStreamController")) {
          return false;
        }
        return x11 instanceof ReadableStream2;
      }
      function IsReadableStreamLocked(stream) {
        if (stream._reader === void 0) {
          return false;
        }
        return true;
      }
      function ReadableStreamCancel(stream, reason) {
        stream._disturbed = true;
        if (stream._state === "closed") {
          return promiseResolvedWith(void 0);
        }
        if (stream._state === "errored") {
          return promiseRejectedWith(stream._storedError);
        }
        ReadableStreamClose(stream);
        const reader = stream._reader;
        if (reader !== void 0 && IsReadableStreamBYOBReader(reader)) {
          const readIntoRequests = reader._readIntoRequests;
          reader._readIntoRequests = new SimpleQueue();
          readIntoRequests.forEach((readIntoRequest) => {
            readIntoRequest._closeSteps(void 0);
          });
        }
        const sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
        return transformPromiseWith(sourceCancelPromise, noop4);
      }
      function ReadableStreamClose(stream) {
        stream._state = "closed";
        const reader = stream._reader;
        if (reader === void 0) {
          return;
        }
        defaultReaderClosedPromiseResolve(reader);
        if (IsReadableStreamDefaultReader(reader)) {
          const readRequests = reader._readRequests;
          reader._readRequests = new SimpleQueue();
          readRequests.forEach((readRequest) => {
            readRequest._closeSteps();
          });
        }
      }
      function ReadableStreamError(stream, e6) {
        stream._state = "errored";
        stream._storedError = e6;
        const reader = stream._reader;
        if (reader === void 0) {
          return;
        }
        defaultReaderClosedPromiseReject(reader, e6);
        if (IsReadableStreamDefaultReader(reader)) {
          ReadableStreamDefaultReaderErrorReadRequests(reader, e6);
        } else {
          ReadableStreamBYOBReaderErrorReadIntoRequests(reader, e6);
        }
      }
      function streamBrandCheckException$1(name3) {
        return new TypeError(`ReadableStream.prototype.${name3} can only be used on a ReadableStream`);
      }
      function convertQueuingStrategyInit(init3, context) {
        assertDictionary(init3, context);
        const highWaterMark = init3 === null || init3 === void 0 ? void 0 : init3.highWaterMark;
        assertRequiredField(highWaterMark, "highWaterMark", "QueuingStrategyInit");
        return {
          highWaterMark: convertUnrestrictedDouble(highWaterMark)
        };
      }
      const byteLengthSizeFunction = (chunk) => {
        return chunk.byteLength;
      };
      setFunctionName(byteLengthSizeFunction, "size");
      class ByteLengthQueuingStrategy {
        constructor(options) {
          assertRequiredArgument(options, 1, "ByteLengthQueuingStrategy");
          options = convertQueuingStrategyInit(options, "First parameter");
          this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
        }
        /**
         * Returns the high water mark provided to the constructor.
         */
        get highWaterMark() {
          if (!IsByteLengthQueuingStrategy(this)) {
            throw byteLengthBrandCheckException("highWaterMark");
          }
          return this._byteLengthQueuingStrategyHighWaterMark;
        }
        /**
         * Measures the size of `chunk` by returning the value of its `byteLength` property.
         */
        get size() {
          if (!IsByteLengthQueuingStrategy(this)) {
            throw byteLengthBrandCheckException("size");
          }
          return byteLengthSizeFunction;
        }
      }
      Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
        highWaterMark: { enumerable: true },
        size: { enumerable: true }
      });
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(ByteLengthQueuingStrategy.prototype, Symbol.toStringTag, {
          value: "ByteLengthQueuingStrategy",
          configurable: true
        });
      }
      function byteLengthBrandCheckException(name3) {
        return new TypeError(`ByteLengthQueuingStrategy.prototype.${name3} can only be used on a ByteLengthQueuingStrategy`);
      }
      function IsByteLengthQueuingStrategy(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_byteLengthQueuingStrategyHighWaterMark")) {
          return false;
        }
        return x11 instanceof ByteLengthQueuingStrategy;
      }
      const countSizeFunction = () => {
        return 1;
      };
      setFunctionName(countSizeFunction, "size");
      class CountQueuingStrategy {
        constructor(options) {
          assertRequiredArgument(options, 1, "CountQueuingStrategy");
          options = convertQueuingStrategyInit(options, "First parameter");
          this._countQueuingStrategyHighWaterMark = options.highWaterMark;
        }
        /**
         * Returns the high water mark provided to the constructor.
         */
        get highWaterMark() {
          if (!IsCountQueuingStrategy(this)) {
            throw countBrandCheckException("highWaterMark");
          }
          return this._countQueuingStrategyHighWaterMark;
        }
        /**
         * Measures the size of `chunk` by always returning 1.
         * This ensures that the total queue size is a count of the number of chunks in the queue.
         */
        get size() {
          if (!IsCountQueuingStrategy(this)) {
            throw countBrandCheckException("size");
          }
          return countSizeFunction;
        }
      }
      Object.defineProperties(CountQueuingStrategy.prototype, {
        highWaterMark: { enumerable: true },
        size: { enumerable: true }
      });
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(CountQueuingStrategy.prototype, Symbol.toStringTag, {
          value: "CountQueuingStrategy",
          configurable: true
        });
      }
      function countBrandCheckException(name3) {
        return new TypeError(`CountQueuingStrategy.prototype.${name3} can only be used on a CountQueuingStrategy`);
      }
      function IsCountQueuingStrategy(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_countQueuingStrategyHighWaterMark")) {
          return false;
        }
        return x11 instanceof CountQueuingStrategy;
      }
      function convertTransformer(original, context) {
        assertDictionary(original, context);
        const cancel = original === null || original === void 0 ? void 0 : original.cancel;
        const flush2 = original === null || original === void 0 ? void 0 : original.flush;
        const readableType = original === null || original === void 0 ? void 0 : original.readableType;
        const start2 = original === null || original === void 0 ? void 0 : original.start;
        const transform = original === null || original === void 0 ? void 0 : original.transform;
        const writableType = original === null || original === void 0 ? void 0 : original.writableType;
        return {
          cancel: cancel === void 0 ? void 0 : convertTransformerCancelCallback(cancel, original, `${context} has member 'cancel' that`),
          flush: flush2 === void 0 ? void 0 : convertTransformerFlushCallback(flush2, original, `${context} has member 'flush' that`),
          readableType,
          start: start2 === void 0 ? void 0 : convertTransformerStartCallback(start2, original, `${context} has member 'start' that`),
          transform: transform === void 0 ? void 0 : convertTransformerTransformCallback(transform, original, `${context} has member 'transform' that`),
          writableType
        };
      }
      function convertTransformerFlushCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (controller) => promiseCall(fn3, original, [controller]);
      }
      function convertTransformerStartCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (controller) => reflectCall(fn3, original, [controller]);
      }
      function convertTransformerTransformCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (chunk, controller) => promiseCall(fn3, original, [chunk, controller]);
      }
      function convertTransformerCancelCallback(fn3, original, context) {
        assertFunction(fn3, context);
        return (reason) => promiseCall(fn3, original, [reason]);
      }
      class TransformStream2 {
        constructor(rawTransformer = {}, rawWritableStrategy = {}, rawReadableStrategy = {}) {
          if (rawTransformer === void 0) {
            rawTransformer = null;
          }
          const writableStrategy = convertQueuingStrategy(rawWritableStrategy, "Second parameter");
          const readableStrategy = convertQueuingStrategy(rawReadableStrategy, "Third parameter");
          const transformer = convertTransformer(rawTransformer, "First parameter");
          if (transformer.readableType !== void 0) {
            throw new RangeError("Invalid readableType specified");
          }
          if (transformer.writableType !== void 0) {
            throw new RangeError("Invalid writableType specified");
          }
          const readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);
          const readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);
          const writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
          const writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
          let startPromise_resolve;
          const startPromise = newPromise((resolve2) => {
            startPromise_resolve = resolve2;
          });
          InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
          SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
          if (transformer.start !== void 0) {
            startPromise_resolve(transformer.start(this._transformStreamController));
          } else {
            startPromise_resolve(void 0);
          }
        }
        /**
         * The readable side of the transform stream.
         */
        get readable() {
          if (!IsTransformStream(this)) {
            throw streamBrandCheckException("readable");
          }
          return this._readable;
        }
        /**
         * The writable side of the transform stream.
         */
        get writable() {
          if (!IsTransformStream(this)) {
            throw streamBrandCheckException("writable");
          }
          return this._writable;
        }
      }
      Object.defineProperties(TransformStream2.prototype, {
        readable: { enumerable: true },
        writable: { enumerable: true }
      });
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(TransformStream2.prototype, Symbol.toStringTag, {
          value: "TransformStream",
          configurable: true
        });
      }
      function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
        function startAlgorithm() {
          return startPromise;
        }
        function writeAlgorithm(chunk) {
          return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
        }
        function abortAlgorithm(reason) {
          return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
        }
        function closeAlgorithm() {
          return TransformStreamDefaultSinkCloseAlgorithm(stream);
        }
        stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
        function pullAlgorithm() {
          return TransformStreamDefaultSourcePullAlgorithm(stream);
        }
        function cancelAlgorithm(reason) {
          return TransformStreamDefaultSourceCancelAlgorithm(stream, reason);
        }
        stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
        stream._backpressure = void 0;
        stream._backpressureChangePromise = void 0;
        stream._backpressureChangePromise_resolve = void 0;
        TransformStreamSetBackpressure(stream, true);
        stream._transformStreamController = void 0;
      }
      function IsTransformStream(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_transformStreamController")) {
          return false;
        }
        return x11 instanceof TransformStream2;
      }
      function TransformStreamError(stream, e6) {
        ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e6);
        TransformStreamErrorWritableAndUnblockWrite(stream, e6);
      }
      function TransformStreamErrorWritableAndUnblockWrite(stream, e6) {
        TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
        WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e6);
        TransformStreamUnblockWrite(stream);
      }
      function TransformStreamUnblockWrite(stream) {
        if (stream._backpressure) {
          TransformStreamSetBackpressure(stream, false);
        }
      }
      function TransformStreamSetBackpressure(stream, backpressure) {
        if (stream._backpressureChangePromise !== void 0) {
          stream._backpressureChangePromise_resolve();
        }
        stream._backpressureChangePromise = newPromise((resolve2) => {
          stream._backpressureChangePromise_resolve = resolve2;
        });
        stream._backpressure = backpressure;
      }
      class TransformStreamDefaultController {
        constructor() {
          throw new TypeError("Illegal constructor");
        }
        /**
         * Returns the desired size to fill the readable side’s internal queue. It can be negative, if the queue is over-full.
         */
        get desiredSize() {
          if (!IsTransformStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException("desiredSize");
          }
          const readableController = this._controlledTransformStream._readable._readableStreamController;
          return ReadableStreamDefaultControllerGetDesiredSize(readableController);
        }
        enqueue(chunk = void 0) {
          if (!IsTransformStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException("enqueue");
          }
          TransformStreamDefaultControllerEnqueue(this, chunk);
        }
        /**
         * Errors both the readable side and the writable side of the controlled transform stream, making all future
         * interactions with it fail with the given error `e`. Any chunks queued for transformation will be discarded.
         */
        error(reason = void 0) {
          if (!IsTransformStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException("error");
          }
          TransformStreamDefaultControllerError(this, reason);
        }
        /**
         * Closes the readable side and errors the writable side of the controlled transform stream. This is useful when the
         * transformer only needs to consume a portion of the chunks written to the writable side.
         */
        terminate() {
          if (!IsTransformStreamDefaultController(this)) {
            throw defaultControllerBrandCheckException("terminate");
          }
          TransformStreamDefaultControllerTerminate(this);
        }
      }
      Object.defineProperties(TransformStreamDefaultController.prototype, {
        enqueue: { enumerable: true },
        error: { enumerable: true },
        terminate: { enumerable: true },
        desiredSize: { enumerable: true }
      });
      setFunctionName(TransformStreamDefaultController.prototype.enqueue, "enqueue");
      setFunctionName(TransformStreamDefaultController.prototype.error, "error");
      setFunctionName(TransformStreamDefaultController.prototype.terminate, "terminate");
      if (typeof Symbol.toStringTag === "symbol") {
        Object.defineProperty(TransformStreamDefaultController.prototype, Symbol.toStringTag, {
          value: "TransformStreamDefaultController",
          configurable: true
        });
      }
      function IsTransformStreamDefaultController(x11) {
        if (!typeIsObject(x11)) {
          return false;
        }
        if (!Object.prototype.hasOwnProperty.call(x11, "_controlledTransformStream")) {
          return false;
        }
        return x11 instanceof TransformStreamDefaultController;
      }
      function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm) {
        controller._controlledTransformStream = stream;
        stream._transformStreamController = controller;
        controller._transformAlgorithm = transformAlgorithm;
        controller._flushAlgorithm = flushAlgorithm;
        controller._cancelAlgorithm = cancelAlgorithm;
        controller._finishPromise = void 0;
        controller._finishPromise_resolve = void 0;
        controller._finishPromise_reject = void 0;
      }
      function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
        const controller = Object.create(TransformStreamDefaultController.prototype);
        let transformAlgorithm;
        let flushAlgorithm;
        let cancelAlgorithm;
        if (transformer.transform !== void 0) {
          transformAlgorithm = (chunk) => transformer.transform(chunk, controller);
        } else {
          transformAlgorithm = (chunk) => {
            try {
              TransformStreamDefaultControllerEnqueue(controller, chunk);
              return promiseResolvedWith(void 0);
            } catch (transformResultE) {
              return promiseRejectedWith(transformResultE);
            }
          };
        }
        if (transformer.flush !== void 0) {
          flushAlgorithm = () => transformer.flush(controller);
        } else {
          flushAlgorithm = () => promiseResolvedWith(void 0);
        }
        if (transformer.cancel !== void 0) {
          cancelAlgorithm = (reason) => transformer.cancel(reason);
        } else {
          cancelAlgorithm = () => promiseResolvedWith(void 0);
        }
        SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm, cancelAlgorithm);
      }
      function TransformStreamDefaultControllerClearAlgorithms(controller) {
        controller._transformAlgorithm = void 0;
        controller._flushAlgorithm = void 0;
        controller._cancelAlgorithm = void 0;
      }
      function TransformStreamDefaultControllerEnqueue(controller, chunk) {
        const stream = controller._controlledTransformStream;
        const readableController = stream._readable._readableStreamController;
        if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
          throw new TypeError("Readable side is not in a state that permits enqueue");
        }
        try {
          ReadableStreamDefaultControllerEnqueue(readableController, chunk);
        } catch (e6) {
          TransformStreamErrorWritableAndUnblockWrite(stream, e6);
          throw stream._readable._storedError;
        }
        const backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
        if (backpressure !== stream._backpressure) {
          TransformStreamSetBackpressure(stream, true);
        }
      }
      function TransformStreamDefaultControllerError(controller, e6) {
        TransformStreamError(controller._controlledTransformStream, e6);
      }
      function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
        const transformPromise = controller._transformAlgorithm(chunk);
        return transformPromiseWith(transformPromise, void 0, (r6) => {
          TransformStreamError(controller._controlledTransformStream, r6);
          throw r6;
        });
      }
      function TransformStreamDefaultControllerTerminate(controller) {
        const stream = controller._controlledTransformStream;
        const readableController = stream._readable._readableStreamController;
        ReadableStreamDefaultControllerClose(readableController);
        const error2 = new TypeError("TransformStream terminated");
        TransformStreamErrorWritableAndUnblockWrite(stream, error2);
      }
      function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
        const controller = stream._transformStreamController;
        if (stream._backpressure) {
          const backpressureChangePromise = stream._backpressureChangePromise;
          return transformPromiseWith(backpressureChangePromise, () => {
            const writable = stream._writable;
            const state2 = writable._state;
            if (state2 === "erroring") {
              throw writable._storedError;
            }
            return TransformStreamDefaultControllerPerformTransform(controller, chunk);
          });
        }
        return TransformStreamDefaultControllerPerformTransform(controller, chunk);
      }
      function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
        const controller = stream._transformStreamController;
        if (controller._finishPromise !== void 0) {
          return controller._finishPromise;
        }
        const readable = stream._readable;
        controller._finishPromise = newPromise((resolve2, reject) => {
          controller._finishPromise_resolve = resolve2;
          controller._finishPromise_reject = reject;
        });
        const cancelPromise = controller._cancelAlgorithm(reason);
        TransformStreamDefaultControllerClearAlgorithms(controller);
        uponPromise(cancelPromise, () => {
          if (readable._state === "errored") {
            defaultControllerFinishPromiseReject(controller, readable._storedError);
          } else {
            ReadableStreamDefaultControllerError(readable._readableStreamController, reason);
            defaultControllerFinishPromiseResolve(controller);
          }
          return null;
        }, (r6) => {
          ReadableStreamDefaultControllerError(readable._readableStreamController, r6);
          defaultControllerFinishPromiseReject(controller, r6);
          return null;
        });
        return controller._finishPromise;
      }
      function TransformStreamDefaultSinkCloseAlgorithm(stream) {
        const controller = stream._transformStreamController;
        if (controller._finishPromise !== void 0) {
          return controller._finishPromise;
        }
        const readable = stream._readable;
        controller._finishPromise = newPromise((resolve2, reject) => {
          controller._finishPromise_resolve = resolve2;
          controller._finishPromise_reject = reject;
        });
        const flushPromise = controller._flushAlgorithm();
        TransformStreamDefaultControllerClearAlgorithms(controller);
        uponPromise(flushPromise, () => {
          if (readable._state === "errored") {
            defaultControllerFinishPromiseReject(controller, readable._storedError);
          } else {
            ReadableStreamDefaultControllerClose(readable._readableStreamController);
            defaultControllerFinishPromiseResolve(controller);
          }
          return null;
        }, (r6) => {
          ReadableStreamDefaultControllerError(readable._readableStreamController, r6);
          defaultControllerFinishPromiseReject(controller, r6);
          return null;
        });
        return controller._finishPromise;
      }
      function TransformStreamDefaultSourcePullAlgorithm(stream) {
        TransformStreamSetBackpressure(stream, false);
        return stream._backpressureChangePromise;
      }
      function TransformStreamDefaultSourceCancelAlgorithm(stream, reason) {
        const controller = stream._transformStreamController;
        if (controller._finishPromise !== void 0) {
          return controller._finishPromise;
        }
        const writable = stream._writable;
        controller._finishPromise = newPromise((resolve2, reject) => {
          controller._finishPromise_resolve = resolve2;
          controller._finishPromise_reject = reject;
        });
        const cancelPromise = controller._cancelAlgorithm(reason);
        TransformStreamDefaultControllerClearAlgorithms(controller);
        uponPromise(cancelPromise, () => {
          if (writable._state === "errored") {
            defaultControllerFinishPromiseReject(controller, writable._storedError);
          } else {
            WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, reason);
            TransformStreamUnblockWrite(stream);
            defaultControllerFinishPromiseResolve(controller);
          }
          return null;
        }, (r6) => {
          WritableStreamDefaultControllerErrorIfNeeded(writable._writableStreamController, r6);
          TransformStreamUnblockWrite(stream);
          defaultControllerFinishPromiseReject(controller, r6);
          return null;
        });
        return controller._finishPromise;
      }
      function defaultControllerBrandCheckException(name3) {
        return new TypeError(`TransformStreamDefaultController.prototype.${name3} can only be used on a TransformStreamDefaultController`);
      }
      function defaultControllerFinishPromiseResolve(controller) {
        if (controller._finishPromise_resolve === void 0) {
          return;
        }
        controller._finishPromise_resolve();
        controller._finishPromise_resolve = void 0;
        controller._finishPromise_reject = void 0;
      }
      function defaultControllerFinishPromiseReject(controller, reason) {
        if (controller._finishPromise_reject === void 0) {
          return;
        }
        setPromiseIsHandledToTrue(controller._finishPromise);
        controller._finishPromise_reject(reason);
        controller._finishPromise_resolve = void 0;
        controller._finishPromise_reject = void 0;
      }
      function streamBrandCheckException(name3) {
        return new TypeError(`TransformStream.prototype.${name3} can only be used on a TransformStream`);
      }
      exports3.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
      exports3.CountQueuingStrategy = CountQueuingStrategy;
      exports3.ReadableByteStreamController = ReadableByteStreamController;
      exports3.ReadableStream = ReadableStream2;
      exports3.ReadableStreamBYOBReader = ReadableStreamBYOBReader;
      exports3.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
      exports3.ReadableStreamDefaultController = ReadableStreamDefaultController;
      exports3.ReadableStreamDefaultReader = ReadableStreamDefaultReader;
      exports3.TransformStream = TransformStream2;
      exports3.TransformStreamDefaultController = TransformStreamDefaultController;
      exports3.WritableStream = WritableStream;
      exports3.WritableStreamDefaultController = WritableStreamDefaultController;
      exports3.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
    });
  }
});

// ../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/streams.cjs
var require_streams = __commonJS({
  "../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/streams.cjs"() {
    "use strict";
    var POOL_SIZE2 = 65536;
    if (!globalThis.ReadableStream) {
      try {
        const process4 = require("process");
        const { emitWarning } = process4;
        try {
          process4.emitWarning = () => {
          };
          Object.assign(globalThis, require("stream/web"));
          process4.emitWarning = emitWarning;
        } catch (error2) {
          process4.emitWarning = emitWarning;
          throw error2;
        }
      } catch (error2) {
        Object.assign(globalThis, require_ponyfill_es2018());
      }
    }
    try {
      const { Blob: Blob3 } = require("buffer");
      if (Blob3 && !Blob3.prototype.stream) {
        Blob3.prototype.stream = function name3(params) {
          let position = 0;
          const blob2 = this;
          return new ReadableStream({
            type: "bytes",
            async pull(ctrl) {
              const chunk = blob2.slice(position, Math.min(blob2.size, position + POOL_SIZE2));
              const buffer2 = await chunk.arrayBuffer();
              position += buffer2.byteLength;
              ctrl.enqueue(new Uint8Array(buffer2));
              if (position === blob2.size) {
                ctrl.close();
              }
            }
          });
        };
      }
    } catch (error2) {
    }
  }
});

// ../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/index.js
async function* toIterator(parts2, clone2 = true) {
  for (const part of parts2) {
    if ("stream" in part) {
      yield* (
        /** @type {AsyncIterableIterator<Uint8Array>} */
        part.stream()
      );
    } else if (ArrayBuffer.isView(part)) {
      if (clone2) {
        let position = part.byteOffset;
        const end = part.byteOffset + part.byteLength;
        while (position !== end) {
          const size2 = Math.min(end - position, POOL_SIZE);
          const chunk = part.buffer.slice(position, position + size2);
          position += chunk.byteLength;
          yield new Uint8Array(chunk);
        }
      } else {
        yield part;
      }
    } else {
      let position = 0, b9 = (
        /** @type {Blob} */
        part
      );
      while (position !== b9.size) {
        const chunk = b9.slice(position, Math.min(b9.size, position + POOL_SIZE));
        const buffer2 = await chunk.arrayBuffer();
        position += buffer2.byteLength;
        yield new Uint8Array(buffer2);
      }
    }
  }
}
var import_streams, POOL_SIZE, _parts, _type, _size, _endings, _a447, _Blob, Blob2, fetch_blob_default;
var init_fetch_blob = __esm({
  "../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/index.js"() {
    "use strict";
    import_streams = __toESM(require_streams(), 1);
    POOL_SIZE = 65536;
    _Blob = (_a447 = class {
      /**
       * The Blob() constructor returns a new Blob object. The content
       * of the blob consists of the concatenation of the values given
       * in the parameter array.
       *
       * @param {*} blobParts
       * @param {{ type?: string, endings?: string }} [options]
       */
      constructor(blobParts = [], options = {}) {
        /** @type {Array.<(Blob|Uint8Array)>} */
        __privateAdd(this, _parts, []);
        __privateAdd(this, _type, "");
        __privateAdd(this, _size, 0);
        __privateAdd(this, _endings, "transparent");
        if (typeof blobParts !== "object" || blobParts === null) {
          throw new TypeError("Failed to construct 'Blob': The provided value cannot be converted to a sequence.");
        }
        if (typeof blobParts[Symbol.iterator] !== "function") {
          throw new TypeError("Failed to construct 'Blob': The object must have a callable @@iterator property.");
        }
        if (typeof options !== "object" && typeof options !== "function") {
          throw new TypeError("Failed to construct 'Blob': parameter 2 cannot convert to dictionary.");
        }
        if (options === null) options = {};
        const encoder = new TextEncoder();
        for (const element of blobParts) {
          let part;
          if (ArrayBuffer.isView(element)) {
            part = new Uint8Array(element.buffer.slice(element.byteOffset, element.byteOffset + element.byteLength));
          } else if (element instanceof ArrayBuffer) {
            part = new Uint8Array(element.slice(0));
          } else if (element instanceof _a447) {
            part = element;
          } else {
            part = encoder.encode(`${element}`);
          }
          __privateSet(this, _size, __privateGet(this, _size) + (ArrayBuffer.isView(part) ? part.byteLength : part.size));
          __privateGet(this, _parts).push(part);
        }
        __privateSet(this, _endings, `${options.endings === void 0 ? "transparent" : options.endings}`);
        const type = options.type === void 0 ? "" : String(options.type);
        __privateSet(this, _type, /^[\x20-\x7E]*$/.test(type) ? type : "");
      }
      /**
       * The Blob interface's size property returns the
       * size of the Blob in bytes.
       */
      get size() {
        return __privateGet(this, _size);
      }
      /**
       * The type property of a Blob object returns the MIME type of the file.
       */
      get type() {
        return __privateGet(this, _type);
      }
      /**
       * The text() method in the Blob interface returns a Promise
       * that resolves with a string containing the contents of
       * the blob, interpreted as UTF-8.
       *
       * @return {Promise<string>}
       */
      async text() {
        const decoder2 = new TextDecoder();
        let str = "";
        for await (const part of toIterator(__privateGet(this, _parts), false)) {
          str += decoder2.decode(part, { stream: true });
        }
        str += decoder2.decode();
        return str;
      }
      /**
       * The arrayBuffer() method in the Blob interface returns a
       * Promise that resolves with the contents of the blob as
       * binary data contained in an ArrayBuffer.
       *
       * @return {Promise<ArrayBuffer>}
       */
      async arrayBuffer() {
        const data = new Uint8Array(this.size);
        let offset = 0;
        for await (const chunk of toIterator(__privateGet(this, _parts), false)) {
          data.set(chunk, offset);
          offset += chunk.length;
        }
        return data.buffer;
      }
      stream() {
        const it2 = toIterator(__privateGet(this, _parts), true);
        return new globalThis.ReadableStream({
          // @ts-ignore
          type: "bytes",
          async pull(ctrl) {
            const chunk = await it2.next();
            chunk.done ? ctrl.close() : ctrl.enqueue(chunk.value);
          },
          async cancel() {
            await it2.return();
          }
        });
      }
      /**
       * The Blob interface's slice() method creates and returns a
       * new Blob object which contains data from a subset of the
       * blob on which it's called.
       *
       * @param {number} [start]
       * @param {number} [end]
       * @param {string} [type]
       */
      slice(start2 = 0, end = this.size, type = "") {
        const { size: size2 } = this;
        let relativeStart = start2 < 0 ? Math.max(size2 + start2, 0) : Math.min(start2, size2);
        let relativeEnd = end < 0 ? Math.max(size2 + end, 0) : Math.min(end, size2);
        const span = Math.max(relativeEnd - relativeStart, 0);
        const parts2 = __privateGet(this, _parts);
        const blobParts = [];
        let added = 0;
        for (const part of parts2) {
          if (added >= span) {
            break;
          }
          const size3 = ArrayBuffer.isView(part) ? part.byteLength : part.size;
          if (relativeStart && size3 <= relativeStart) {
            relativeStart -= size3;
            relativeEnd -= size3;
          } else {
            let chunk;
            if (ArrayBuffer.isView(part)) {
              chunk = part.subarray(relativeStart, Math.min(size3, relativeEnd));
              added += chunk.byteLength;
            } else {
              chunk = part.slice(relativeStart, Math.min(size3, relativeEnd));
              added += chunk.size;
            }
            relativeEnd -= size3;
            blobParts.push(chunk);
            relativeStart = 0;
          }
        }
        const blob2 = new _a447([], { type: String(type).toLowerCase() });
        __privateSet(blob2, _size, span);
        __privateSet(blob2, _parts, blobParts);
        return blob2;
      }
      get [Symbol.toStringTag]() {
        return "Blob";
      }
      static [Symbol.hasInstance](object2) {
        return object2 && typeof object2 === "object" && typeof object2.constructor === "function" && (typeof object2.stream === "function" || typeof object2.arrayBuffer === "function") && /^(Blob|File)$/.test(object2[Symbol.toStringTag]);
      }
    }, _parts = new WeakMap(), _type = new WeakMap(), _size = new WeakMap(), _endings = new WeakMap(), _a447);
    Object.defineProperties(_Blob.prototype, {
      size: { enumerable: true },
      type: { enumerable: true },
      slice: { enumerable: true }
    });
    Blob2 = _Blob;
    fetch_blob_default = Blob2;
  }
});

// ../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/file.js
var _lastModified, _name, _a448, _File, File2, file_default;
var init_file = __esm({
  "../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/file.js"() {
    "use strict";
    init_fetch_blob();
    _File = (_a448 = class extends fetch_blob_default {
      /**
       * @param {*[]} fileBits
       * @param {string} fileName
       * @param {{lastModified?: number, type?: string}} options
       */
      // @ts-ignore
      constructor(fileBits, fileName, options = {}) {
        if (arguments.length < 2) {
          throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`);
        }
        super(fileBits, options);
        __privateAdd(this, _lastModified, 0);
        __privateAdd(this, _name, "");
        if (options === null) options = {};
        const lastModified = options.lastModified === void 0 ? Date.now() : Number(options.lastModified);
        if (!Number.isNaN(lastModified)) {
          __privateSet(this, _lastModified, lastModified);
        }
        __privateSet(this, _name, String(fileName));
      }
      get name() {
        return __privateGet(this, _name);
      }
      get lastModified() {
        return __privateGet(this, _lastModified);
      }
      get [Symbol.toStringTag]() {
        return "File";
      }
      static [Symbol.hasInstance](object2) {
        return !!object2 && object2 instanceof fetch_blob_default && /^(File)$/.test(object2[Symbol.toStringTag]);
      }
    }, _lastModified = new WeakMap(), _name = new WeakMap(), _a448);
    File2 = _File;
    file_default = File2;
  }
});

// ../node_modules/.pnpm/formdata-polyfill@4.0.10/node_modules/formdata-polyfill/esm.min.js
function formDataToBlob(F6, B3 = fetch_blob_default) {
  var b9 = `${r()}${r()}`.replace(/\./g, "").slice(-28).padStart(32, "-"), c6 = [], p11 = `--${b9}\r
Content-Disposition: form-data; name="`;
  F6.forEach((v11, n7) => typeof v11 == "string" ? c6.push(p11 + e(n7) + `"\r
\r
${v11.replace(/\r(?!\n)|(?<!\r)\n/g, "\r\n")}\r
`) : c6.push(p11 + e(n7) + `"; filename="${e(v11.name, 1)}"\r
Content-Type: ${v11.type || "application/octet-stream"}\r
\r
`, v11, "\r\n"));
  c6.push(`--${b9}--`);
  return new B3(c6, { type: "multipart/form-data; boundary=" + b9 });
}
var t, i2, h, r, m, f, e, x, _d6, _a449, FormData;
var init_esm_min = __esm({
  "../node_modules/.pnpm/formdata-polyfill@4.0.10/node_modules/formdata-polyfill/esm.min.js"() {
    "use strict";
    init_fetch_blob();
    init_file();
    ({ toStringTag: t, iterator: i2, hasInstance: h } = Symbol);
    r = Math.random;
    m = "append,set,get,getAll,delete,keys,values,entries,forEach,constructor".split(",");
    f = (a9, b9, c6) => (a9 += "", /^(Blob|File)$/.test(b9 && b9[t]) ? [(c6 = c6 !== void 0 ? c6 + "" : b9[t] == "File" ? b9.name : "blob", a9), b9.name !== c6 || b9[t] == "blob" ? new file_default([b9], c6, b9) : b9] : [a9, b9 + ""]);
    e = (c6, f9) => (f9 ? c6 : c6.replace(/\r?\n|\r/g, "\r\n")).replace(/\n/g, "%0A").replace(/\r/g, "%0D").replace(/"/g, "%22");
    x = (n7, a9, e6) => {
      if (a9.length < e6) {
        throw new TypeError(`Failed to execute '${n7}' on 'FormData': ${e6} arguments required, but only ${a9.length} present.`);
      }
    };
    FormData = (_a449 = class {
      constructor(...a9) {
        __privateAdd(this, _d6, []);
        if (a9.length) throw new TypeError(`Failed to construct 'FormData': parameter 1 is not of type 'HTMLFormElement'.`);
      }
      get [t]() {
        return "FormData";
      }
      [i2]() {
        return this.entries();
      }
      static [h](o9) {
        return o9 && typeof o9 === "object" && o9[t] === "FormData" && !m.some((m12) => typeof o9[m12] != "function");
      }
      append(...a9) {
        x("append", arguments, 2);
        __privateGet(this, _d6).push(f(...a9));
      }
      delete(a9) {
        x("delete", arguments, 1);
        a9 += "";
        __privateSet(this, _d6, __privateGet(this, _d6).filter(([b9]) => b9 !== a9));
      }
      get(a9) {
        x("get", arguments, 1);
        a9 += "";
        for (var b9 = __privateGet(this, _d6), l7 = b9.length, c6 = 0; c6 < l7; c6++) if (b9[c6][0] === a9) return b9[c6][1];
        return null;
      }
      getAll(a9, b9) {
        x("getAll", arguments, 1);
        b9 = [];
        a9 += "";
        __privateGet(this, _d6).forEach((c6) => c6[0] === a9 && b9.push(c6[1]));
        return b9;
      }
      has(a9) {
        x("has", arguments, 1);
        a9 += "";
        return __privateGet(this, _d6).some((b9) => b9[0] === a9);
      }
      forEach(a9, b9) {
        x("forEach", arguments, 1);
        for (var [c6, d7] of this) a9.call(b9, d7, c6, this);
      }
      set(...a9) {
        x("set", arguments, 2);
        var b9 = [], c6 = true;
        a9 = f(...a9);
        __privateGet(this, _d6).forEach((d7) => {
          d7[0] === a9[0] ? c6 && (c6 = !b9.push(a9)) : b9.push(d7);
        });
        c6 && b9.push(a9);
        __privateSet(this, _d6, b9);
      }
      *entries() {
        yield* __privateGet(this, _d6);
      }
      *keys() {
        for (var [a9] of this) yield a9;
      }
      *values() {
        for (var [, a9] of this) yield a9;
      }
    }, _d6 = new WeakMap(), _a449);
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/errors/base.js
var FetchBaseError;
var init_base = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/errors/base.js"() {
    "use strict";
    FetchBaseError = class extends Error {
      constructor(message, type) {
        super(message);
        Error.captureStackTrace(this, this.constructor);
        this.type = type;
      }
      get name() {
        return this.constructor.name;
      }
      get [Symbol.toStringTag]() {
        return this.constructor.name;
      }
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/errors/fetch-error.js
var FetchError;
var init_fetch_error = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/errors/fetch-error.js"() {
    "use strict";
    init_base();
    FetchError = class extends FetchBaseError {
      /**
       * @param  {string} message -      Error message for human
       * @param  {string} [type] -        Error type for machine
       * @param  {SystemError} [systemError] - For Node.js system error
       */
      constructor(message, type, systemError) {
        super(message, type);
        if (systemError) {
          this.code = this.errno = systemError.code;
          this.erroredSysCall = systemError.syscall;
        }
      }
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/is.js
var NAME, isURLSearchParameters, isBlob, isAbortSignal, isDomainOrSubdomain, isSameProtocol;
var init_is = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/is.js"() {
    "use strict";
    NAME = Symbol.toStringTag;
    isURLSearchParameters = (object2) => {
      return typeof object2 === "object" && typeof object2.append === "function" && typeof object2.delete === "function" && typeof object2.get === "function" && typeof object2.getAll === "function" && typeof object2.has === "function" && typeof object2.set === "function" && typeof object2.sort === "function" && object2[NAME] === "URLSearchParams";
    };
    isBlob = (object2) => {
      return object2 && typeof object2 === "object" && typeof object2.arrayBuffer === "function" && typeof object2.type === "string" && typeof object2.stream === "function" && typeof object2.constructor === "function" && /^(Blob|File)$/.test(object2[NAME]);
    };
    isAbortSignal = (object2) => {
      return typeof object2 === "object" && (object2[NAME] === "AbortSignal" || object2[NAME] === "EventTarget");
    };
    isDomainOrSubdomain = (destination, original) => {
      const orig = new URL(original).hostname;
      const dest = new URL(destination).hostname;
      return orig === dest || orig.endsWith(`.${dest}`);
    };
    isSameProtocol = (destination, original) => {
      const orig = new URL(original).protocol;
      const dest = new URL(destination).protocol;
      return orig === dest;
    };
  }
});

// ../node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js
var require_node_domexception = __commonJS({
  "../node_modules/.pnpm/node-domexception@1.0.0/node_modules/node-domexception/index.js"(exports2, module2) {
    "use strict";
    if (!globalThis.DOMException) {
      try {
        const { MessageChannel } = require("worker_threads"), port = new MessageChannel().port1, ab = new ArrayBuffer();
        port.postMessage(ab, [ab, ab]);
      } catch (err3) {
        err3.constructor.name === "DOMException" && (globalThis.DOMException = err3.constructor);
      }
    }
    module2.exports = globalThis.DOMException;
  }
});

// ../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/from.js
var import_node_fs, import_node_path2, import_node_domexception, stat;
var init_from = __esm({
  "../node_modules/.pnpm/fetch-blob@3.2.0/node_modules/fetch-blob/from.js"() {
    "use strict";
    import_node_fs = require("fs");
    import_node_path2 = require("path");
    import_node_domexception = __toESM(require_node_domexception(), 1);
    init_file();
    init_fetch_blob();
    ({ stat } = import_node_fs.promises);
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/multipart-parser.js
var multipart_parser_exports = {};
__export(multipart_parser_exports, {
  toFormData: () => toFormData
});
function _fileName(headerValue) {
  const m12 = headerValue.match(/\bfilename=("(.*?)"|([^()<>@,;:\\"/[\]?={}\s\t]+))($|;\s)/i);
  if (!m12) {
    return;
  }
  const match2 = m12[2] || m12[3] || "";
  let filename = match2.slice(match2.lastIndexOf("\\") + 1);
  filename = filename.replace(/%22/g, '"');
  filename = filename.replace(/&#(\d{4});/g, (m13, code) => {
    return String.fromCharCode(code);
  });
  return filename;
}
async function toFormData(Body2, ct2) {
  if (!/multipart/i.test(ct2)) {
    throw new TypeError("Failed to fetch");
  }
  const m12 = ct2.match(/boundary=(?:"([^"]+)"|([^;]+))/i);
  if (!m12) {
    throw new TypeError("no or bad content-type header, no multipart boundary");
  }
  const parser = new MultipartParser(m12[1] || m12[2]);
  let headerField;
  let headerValue;
  let entryValue;
  let entryName;
  let contentType;
  let filename;
  const entryChunks = [];
  const formData = new FormData();
  const onPartData = (ui8a) => {
    entryValue += decoder2.decode(ui8a, { stream: true });
  };
  const appendToFile = (ui8a) => {
    entryChunks.push(ui8a);
  };
  const appendFileToFormData = () => {
    const file = new file_default(entryChunks, filename, { type: contentType });
    formData.append(entryName, file);
  };
  const appendEntryToFormData = () => {
    formData.append(entryName, entryValue);
  };
  const decoder2 = new TextDecoder("utf-8");
  decoder2.decode();
  parser.onPartBegin = function() {
    parser.onPartData = onPartData;
    parser.onPartEnd = appendEntryToFormData;
    headerField = "";
    headerValue = "";
    entryValue = "";
    entryName = "";
    contentType = "";
    filename = null;
    entryChunks.length = 0;
  };
  parser.onHeaderField = function(ui8a) {
    headerField += decoder2.decode(ui8a, { stream: true });
  };
  parser.onHeaderValue = function(ui8a) {
    headerValue += decoder2.decode(ui8a, { stream: true });
  };
  parser.onHeaderEnd = function() {
    headerValue += decoder2.decode();
    headerField = headerField.toLowerCase();
    if (headerField === "content-disposition") {
      const m13 = headerValue.match(/\bname=("([^"]*)"|([^()<>@,;:\\"/[\]?={}\s\t]+))/i);
      if (m13) {
        entryName = m13[2] || m13[3] || "";
      }
      filename = _fileName(headerValue);
      if (filename) {
        parser.onPartData = appendToFile;
        parser.onPartEnd = appendFileToFormData;
      }
    } else if (headerField === "content-type") {
      contentType = headerValue;
    }
    headerValue = "";
    headerField = "";
  };
  for await (const chunk of Body2) {
    parser.write(chunk);
  }
  parser.end();
  return formData;
}
var s, S, f2, F, LF, CR, SPACE, HYPHEN, COLON, A, Z, lower, noop, MultipartParser;
var init_multipart_parser = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/multipart-parser.js"() {
    "use strict";
    init_from();
    init_esm_min();
    s = 0;
    S = {
      START_BOUNDARY: s++,
      HEADER_FIELD_START: s++,
      HEADER_FIELD: s++,
      HEADER_VALUE_START: s++,
      HEADER_VALUE: s++,
      HEADER_VALUE_ALMOST_DONE: s++,
      HEADERS_ALMOST_DONE: s++,
      PART_DATA_START: s++,
      PART_DATA: s++,
      END: s++
    };
    f2 = 1;
    F = {
      PART_BOUNDARY: f2,
      LAST_BOUNDARY: f2 *= 2
    };
    LF = 10;
    CR = 13;
    SPACE = 32;
    HYPHEN = 45;
    COLON = 58;
    A = 97;
    Z = 122;
    lower = (c6) => c6 | 32;
    noop = () => {
    };
    MultipartParser = class {
      /**
       * @param {string} boundary
       */
      constructor(boundary) {
        this.index = 0;
        this.flags = 0;
        this.onHeaderEnd = noop;
        this.onHeaderField = noop;
        this.onHeadersEnd = noop;
        this.onHeaderValue = noop;
        this.onPartBegin = noop;
        this.onPartData = noop;
        this.onPartEnd = noop;
        this.boundaryChars = {};
        boundary = "\r\n--" + boundary;
        const ui8a = new Uint8Array(boundary.length);
        for (let i8 = 0; i8 < boundary.length; i8++) {
          ui8a[i8] = boundary.charCodeAt(i8);
          this.boundaryChars[ui8a[i8]] = true;
        }
        this.boundary = ui8a;
        this.lookbehind = new Uint8Array(this.boundary.length + 8);
        this.state = S.START_BOUNDARY;
      }
      /**
       * @param {Uint8Array} data
       */
      write(data) {
        let i8 = 0;
        const length_ = data.length;
        let previousIndex = this.index;
        let { lookbehind, boundary, boundaryChars, index: index7, state: state2, flags: flags2 } = this;
        const boundaryLength = this.boundary.length;
        const boundaryEnd = boundaryLength - 1;
        const bufferLength = data.length;
        let c6;
        let cl;
        const mark = (name3) => {
          this[name3 + "Mark"] = i8;
        };
        const clear = (name3) => {
          delete this[name3 + "Mark"];
        };
        const callback = (callbackSymbol, start2, end, ui8a) => {
          if (start2 === void 0 || start2 !== end) {
            this[callbackSymbol](ui8a && ui8a.subarray(start2, end));
          }
        };
        const dataCallback = (name3, clear2) => {
          const markSymbol = name3 + "Mark";
          if (!(markSymbol in this)) {
            return;
          }
          if (clear2) {
            callback(name3, this[markSymbol], i8, data);
            delete this[markSymbol];
          } else {
            callback(name3, this[markSymbol], data.length, data);
            this[markSymbol] = 0;
          }
        };
        for (i8 = 0; i8 < length_; i8++) {
          c6 = data[i8];
          switch (state2) {
            case S.START_BOUNDARY:
              if (index7 === boundary.length - 2) {
                if (c6 === HYPHEN) {
                  flags2 |= F.LAST_BOUNDARY;
                } else if (c6 !== CR) {
                  return;
                }
                index7++;
                break;
              } else if (index7 - 1 === boundary.length - 2) {
                if (flags2 & F.LAST_BOUNDARY && c6 === HYPHEN) {
                  state2 = S.END;
                  flags2 = 0;
                } else if (!(flags2 & F.LAST_BOUNDARY) && c6 === LF) {
                  index7 = 0;
                  callback("onPartBegin");
                  state2 = S.HEADER_FIELD_START;
                } else {
                  return;
                }
                break;
              }
              if (c6 !== boundary[index7 + 2]) {
                index7 = -2;
              }
              if (c6 === boundary[index7 + 2]) {
                index7++;
              }
              break;
            case S.HEADER_FIELD_START:
              state2 = S.HEADER_FIELD;
              mark("onHeaderField");
              index7 = 0;
            // falls through
            case S.HEADER_FIELD:
              if (c6 === CR) {
                clear("onHeaderField");
                state2 = S.HEADERS_ALMOST_DONE;
                break;
              }
              index7++;
              if (c6 === HYPHEN) {
                break;
              }
              if (c6 === COLON) {
                if (index7 === 1) {
                  return;
                }
                dataCallback("onHeaderField", true);
                state2 = S.HEADER_VALUE_START;
                break;
              }
              cl = lower(c6);
              if (cl < A || cl > Z) {
                return;
              }
              break;
            case S.HEADER_VALUE_START:
              if (c6 === SPACE) {
                break;
              }
              mark("onHeaderValue");
              state2 = S.HEADER_VALUE;
            // falls through
            case S.HEADER_VALUE:
              if (c6 === CR) {
                dataCallback("onHeaderValue", true);
                callback("onHeaderEnd");
                state2 = S.HEADER_VALUE_ALMOST_DONE;
              }
              break;
            case S.HEADER_VALUE_ALMOST_DONE:
              if (c6 !== LF) {
                return;
              }
              state2 = S.HEADER_FIELD_START;
              break;
            case S.HEADERS_ALMOST_DONE:
              if (c6 !== LF) {
                return;
              }
              callback("onHeadersEnd");
              state2 = S.PART_DATA_START;
              break;
            case S.PART_DATA_START:
              state2 = S.PART_DATA;
              mark("onPartData");
            // falls through
            case S.PART_DATA:
              previousIndex = index7;
              if (index7 === 0) {
                i8 += boundaryEnd;
                while (i8 < bufferLength && !(data[i8] in boundaryChars)) {
                  i8 += boundaryLength;
                }
                i8 -= boundaryEnd;
                c6 = data[i8];
              }
              if (index7 < boundary.length) {
                if (boundary[index7] === c6) {
                  if (index7 === 0) {
                    dataCallback("onPartData", true);
                  }
                  index7++;
                } else {
                  index7 = 0;
                }
              } else if (index7 === boundary.length) {
                index7++;
                if (c6 === CR) {
                  flags2 |= F.PART_BOUNDARY;
                } else if (c6 === HYPHEN) {
                  flags2 |= F.LAST_BOUNDARY;
                } else {
                  index7 = 0;
                }
              } else if (index7 - 1 === boundary.length) {
                if (flags2 & F.PART_BOUNDARY) {
                  index7 = 0;
                  if (c6 === LF) {
                    flags2 &= ~F.PART_BOUNDARY;
                    callback("onPartEnd");
                    callback("onPartBegin");
                    state2 = S.HEADER_FIELD_START;
                    break;
                  }
                } else if (flags2 & F.LAST_BOUNDARY) {
                  if (c6 === HYPHEN) {
                    callback("onPartEnd");
                    state2 = S.END;
                    flags2 = 0;
                  } else {
                    index7 = 0;
                  }
                } else {
                  index7 = 0;
                }
              }
              if (index7 > 0) {
                lookbehind[index7 - 1] = c6;
              } else if (previousIndex > 0) {
                const _lookbehind = new Uint8Array(lookbehind.buffer, lookbehind.byteOffset, lookbehind.byteLength);
                callback("onPartData", 0, previousIndex, _lookbehind);
                previousIndex = 0;
                mark("onPartData");
                i8--;
              }
              break;
            case S.END:
              break;
            default:
              throw new Error(`Unexpected state entered: ${state2}`);
          }
        }
        dataCallback("onHeaderField");
        dataCallback("onHeaderValue");
        dataCallback("onPartData");
        this.index = index7;
        this.state = state2;
        this.flags = flags2;
      }
      end() {
        if (this.state === S.HEADER_FIELD_START && this.index === 0 || this.state === S.PART_DATA && this.index === this.boundary.length) {
          this.onPartEnd();
        } else if (this.state !== S.END) {
          throw new Error("MultipartParser.end(): stream ended unexpectedly");
        }
      }
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/body.js
async function consumeBody(data) {
  if (data[INTERNALS].disturbed) {
    throw new TypeError(`body used already for: ${data.url}`);
  }
  data[INTERNALS].disturbed = true;
  if (data[INTERNALS].error) {
    throw data[INTERNALS].error;
  }
  const { body: body2 } = data;
  if (body2 === null) {
    return import_node_buffer.Buffer.alloc(0);
  }
  if (!(body2 instanceof import_node_stream.default)) {
    return import_node_buffer.Buffer.alloc(0);
  }
  const accum = [];
  let accumBytes = 0;
  try {
    for await (const chunk of body2) {
      if (data.size > 0 && accumBytes + chunk.length > data.size) {
        const error2 = new FetchError(`content size at ${data.url} over limit: ${data.size}`, "max-size");
        body2.destroy(error2);
        throw error2;
      }
      accumBytes += chunk.length;
      accum.push(chunk);
    }
  } catch (error2) {
    const error_ = error2 instanceof FetchBaseError ? error2 : new FetchError(`Invalid response body while trying to fetch ${data.url}: ${error2.message}`, "system", error2);
    throw error_;
  }
  if (body2.readableEnded === true || body2._readableState.ended === true) {
    try {
      if (accum.every((c6) => typeof c6 === "string")) {
        return import_node_buffer.Buffer.from(accum.join(""));
      }
      return import_node_buffer.Buffer.concat(accum, accumBytes);
    } catch (error2) {
      throw new FetchError(`Could not create Buffer from response body for ${data.url}: ${error2.message}`, "system", error2);
    }
  } else {
    throw new FetchError(`Premature close of server response while trying to fetch ${data.url}`);
  }
}
var import_node_stream, import_node_util, import_node_buffer, pipeline, INTERNALS, Body, clone, getNonSpecFormDataBoundary, extractContentType, getTotalBytes, writeToStream;
var init_body2 = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/body.js"() {
    "use strict";
    import_node_stream = __toESM(require("stream"), 1);
    import_node_util = require("util");
    import_node_buffer = require("buffer");
    init_fetch_blob();
    init_esm_min();
    init_fetch_error();
    init_base();
    init_is();
    pipeline = (0, import_node_util.promisify)(import_node_stream.default.pipeline);
    INTERNALS = Symbol("Body internals");
    Body = class {
      constructor(body2, {
        size: size2 = 0
      } = {}) {
        let boundary = null;
        if (body2 === null) {
          body2 = null;
        } else if (isURLSearchParameters(body2)) {
          body2 = import_node_buffer.Buffer.from(body2.toString());
        } else if (isBlob(body2)) {
        } else if (import_node_buffer.Buffer.isBuffer(body2)) {
        } else if (import_node_util.types.isAnyArrayBuffer(body2)) {
          body2 = import_node_buffer.Buffer.from(body2);
        } else if (ArrayBuffer.isView(body2)) {
          body2 = import_node_buffer.Buffer.from(body2.buffer, body2.byteOffset, body2.byteLength);
        } else if (body2 instanceof import_node_stream.default) {
        } else if (body2 instanceof FormData) {
          body2 = formDataToBlob(body2);
          boundary = body2.type.split("=")[1];
        } else {
          body2 = import_node_buffer.Buffer.from(String(body2));
        }
        let stream = body2;
        if (import_node_buffer.Buffer.isBuffer(body2)) {
          stream = import_node_stream.default.Readable.from(body2);
        } else if (isBlob(body2)) {
          stream = import_node_stream.default.Readable.from(body2.stream());
        }
        this[INTERNALS] = {
          body: body2,
          stream,
          boundary,
          disturbed: false,
          error: null
        };
        this.size = size2;
        if (body2 instanceof import_node_stream.default) {
          body2.on("error", (error_) => {
            const error2 = error_ instanceof FetchBaseError ? error_ : new FetchError(`Invalid response body while trying to fetch ${this.url}: ${error_.message}`, "system", error_);
            this[INTERNALS].error = error2;
          });
        }
      }
      get body() {
        return this[INTERNALS].stream;
      }
      get bodyUsed() {
        return this[INTERNALS].disturbed;
      }
      /**
       * Decode response as ArrayBuffer
       *
       * @return  Promise
       */
      async arrayBuffer() {
        const { buffer: buffer2, byteOffset, byteLength } = await consumeBody(this);
        return buffer2.slice(byteOffset, byteOffset + byteLength);
      }
      async formData() {
        const ct2 = this.headers.get("content-type");
        if (ct2.startsWith("application/x-www-form-urlencoded")) {
          const formData = new FormData();
          const parameters = new URLSearchParams(await this.text());
          for (const [name3, value] of parameters) {
            formData.append(name3, value);
          }
          return formData;
        }
        const { toFormData: toFormData2 } = await Promise.resolve().then(() => (init_multipart_parser(), multipart_parser_exports));
        return toFormData2(this.body, ct2);
      }
      /**
       * Return raw response as Blob
       *
       * @return Promise
       */
      async blob() {
        const ct2 = this.headers && this.headers.get("content-type") || this[INTERNALS].body && this[INTERNALS].body.type || "";
        const buf = await this.arrayBuffer();
        return new fetch_blob_default([buf], {
          type: ct2
        });
      }
      /**
       * Decode response as json
       *
       * @return  Promise
       */
      async json() {
        const text5 = await this.text();
        return JSON.parse(text5);
      }
      /**
       * Decode response as text
       *
       * @return  Promise
       */
      async text() {
        const buffer2 = await consumeBody(this);
        return new TextDecoder().decode(buffer2);
      }
      /**
       * Decode response as buffer (non-spec api)
       *
       * @return  Promise
       */
      buffer() {
        return consumeBody(this);
      }
    };
    Body.prototype.buffer = (0, import_node_util.deprecate)(Body.prototype.buffer, "Please use 'response.arrayBuffer()' instead of 'response.buffer()'", "node-fetch#buffer");
    Object.defineProperties(Body.prototype, {
      body: { enumerable: true },
      bodyUsed: { enumerable: true },
      arrayBuffer: { enumerable: true },
      blob: { enumerable: true },
      json: { enumerable: true },
      text: { enumerable: true },
      data: { get: (0, import_node_util.deprecate)(
        () => {
        },
        "data doesn't exist, use json(), text(), arrayBuffer(), or body instead",
        "https://github.com/node-fetch/node-fetch/issues/1000 (response)"
      ) }
    });
    clone = (instance2, highWaterMark) => {
      let p1;
      let p22;
      let { body: body2 } = instance2[INTERNALS];
      if (instance2.bodyUsed) {
        throw new Error("cannot clone body after it is used");
      }
      if (body2 instanceof import_node_stream.default && typeof body2.getBoundary !== "function") {
        p1 = new import_node_stream.PassThrough({ highWaterMark });
        p22 = new import_node_stream.PassThrough({ highWaterMark });
        body2.pipe(p1);
        body2.pipe(p22);
        instance2[INTERNALS].stream = p1;
        body2 = p22;
      }
      return body2;
    };
    getNonSpecFormDataBoundary = (0, import_node_util.deprecate)(
      (body2) => body2.getBoundary(),
      "form-data doesn't follow the spec and requires special treatment. Use alternative package",
      "https://github.com/node-fetch/node-fetch/issues/1167"
    );
    extractContentType = (body2, request2) => {
      if (body2 === null) {
        return null;
      }
      if (typeof body2 === "string") {
        return "text/plain;charset=UTF-8";
      }
      if (isURLSearchParameters(body2)) {
        return "application/x-www-form-urlencoded;charset=UTF-8";
      }
      if (isBlob(body2)) {
        return body2.type || null;
      }
      if (import_node_buffer.Buffer.isBuffer(body2) || import_node_util.types.isAnyArrayBuffer(body2) || ArrayBuffer.isView(body2)) {
        return null;
      }
      if (body2 instanceof FormData) {
        return `multipart/form-data; boundary=${request2[INTERNALS].boundary}`;
      }
      if (body2 && typeof body2.getBoundary === "function") {
        return `multipart/form-data;boundary=${getNonSpecFormDataBoundary(body2)}`;
      }
      if (body2 instanceof import_node_stream.default) {
        return null;
      }
      return "text/plain;charset=UTF-8";
    };
    getTotalBytes = (request2) => {
      const { body: body2 } = request2[INTERNALS];
      if (body2 === null) {
        return 0;
      }
      if (isBlob(body2)) {
        return body2.size;
      }
      if (import_node_buffer.Buffer.isBuffer(body2)) {
        return body2.length;
      }
      if (body2 && typeof body2.getLengthSync === "function") {
        return body2.hasKnownLength && body2.hasKnownLength() ? body2.getLengthSync() : null;
      }
      return null;
    };
    writeToStream = async (dest, { body: body2 }) => {
      if (body2 === null) {
        dest.end();
      } else {
        await pipeline(body2, dest);
      }
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/headers.js
function fromRawHeaders(headers = []) {
  return new Headers2(
    headers.reduce((result, value, index7, array3) => {
      if (index7 % 2 === 0) {
        result.push(array3.slice(index7, index7 + 2));
      }
      return result;
    }, []).filter(([name3, value]) => {
      try {
        validateHeaderName(name3);
        validateHeaderValue(name3, String(value));
        return true;
      } catch {
        return false;
      }
    })
  );
}
var import_node_util2, import_node_http, validateHeaderName, validateHeaderValue, Headers2;
var init_headers = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/headers.js"() {
    "use strict";
    import_node_util2 = require("util");
    import_node_http = __toESM(require("http"), 1);
    validateHeaderName = typeof import_node_http.default.validateHeaderName === "function" ? import_node_http.default.validateHeaderName : (name3) => {
      if (!/^[\^`\-\w!#$%&'*+.|~]+$/.test(name3)) {
        const error2 = new TypeError(`Header name must be a valid HTTP token [${name3}]`);
        Object.defineProperty(error2, "code", { value: "ERR_INVALID_HTTP_TOKEN" });
        throw error2;
      }
    };
    validateHeaderValue = typeof import_node_http.default.validateHeaderValue === "function" ? import_node_http.default.validateHeaderValue : (name3, value) => {
      if (/[^\t\u0020-\u007E\u0080-\u00FF]/.test(value)) {
        const error2 = new TypeError(`Invalid character in header content ["${name3}"]`);
        Object.defineProperty(error2, "code", { value: "ERR_INVALID_CHAR" });
        throw error2;
      }
    };
    Headers2 = class _Headers2 extends URLSearchParams {
      /**
       * Headers class
       *
       * @constructor
       * @param {HeadersInit} [init] - Response headers
       */
      constructor(init3) {
        let result = [];
        if (init3 instanceof _Headers2) {
          const raw2 = init3.raw();
          for (const [name3, values2] of Object.entries(raw2)) {
            result.push(...values2.map((value) => [name3, value]));
          }
        } else if (init3 == null) {
        } else if (typeof init3 === "object" && !import_node_util2.types.isBoxedPrimitive(init3)) {
          const method = init3[Symbol.iterator];
          if (method == null) {
            result.push(...Object.entries(init3));
          } else {
            if (typeof method !== "function") {
              throw new TypeError("Header pairs must be iterable");
            }
            result = [...init3].map((pair) => {
              if (typeof pair !== "object" || import_node_util2.types.isBoxedPrimitive(pair)) {
                throw new TypeError("Each header pair must be an iterable object");
              }
              return [...pair];
            }).map((pair) => {
              if (pair.length !== 2) {
                throw new TypeError("Each header pair must be a name/value tuple");
              }
              return [...pair];
            });
          }
        } else {
          throw new TypeError("Failed to construct 'Headers': The provided value is not of type '(sequence<sequence<ByteString>> or record<ByteString, ByteString>)");
        }
        result = result.length > 0 ? result.map(([name3, value]) => {
          validateHeaderName(name3);
          validateHeaderValue(name3, String(value));
          return [String(name3).toLowerCase(), String(value)];
        }) : void 0;
        super(result);
        return new Proxy(this, {
          get(target, p11, receiver) {
            switch (p11) {
              case "append":
              case "set":
                return (name3, value) => {
                  validateHeaderName(name3);
                  validateHeaderValue(name3, String(value));
                  return URLSearchParams.prototype[p11].call(
                    target,
                    String(name3).toLowerCase(),
                    String(value)
                  );
                };
              case "delete":
              case "has":
              case "getAll":
                return (name3) => {
                  validateHeaderName(name3);
                  return URLSearchParams.prototype[p11].call(
                    target,
                    String(name3).toLowerCase()
                  );
                };
              case "keys":
                return () => {
                  target.sort();
                  return new Set(URLSearchParams.prototype.keys.call(target)).keys();
                };
              default:
                return Reflect.get(target, p11, receiver);
            }
          }
        });
      }
      get [Symbol.toStringTag]() {
        return this.constructor.name;
      }
      toString() {
        return Object.prototype.toString.call(this);
      }
      get(name3) {
        const values2 = this.getAll(name3);
        if (values2.length === 0) {
          return null;
        }
        let value = values2.join(", ");
        if (/^content-encoding$/i.test(name3)) {
          value = value.toLowerCase();
        }
        return value;
      }
      forEach(callback, thisArg = void 0) {
        for (const name3 of this.keys()) {
          Reflect.apply(callback, thisArg, [this.get(name3), name3, this]);
        }
      }
      *values() {
        for (const name3 of this.keys()) {
          yield this.get(name3);
        }
      }
      /**
       * @type {() => IterableIterator<[string, string]>}
       */
      *entries() {
        for (const name3 of this.keys()) {
          yield [name3, this.get(name3)];
        }
      }
      [Symbol.iterator]() {
        return this.entries();
      }
      /**
       * Node-fetch non-spec method
       * returning all headers and their values as array
       * @returns {Record<string, string[]>}
       */
      raw() {
        return [...this.keys()].reduce((result, key) => {
          result[key] = this.getAll(key);
          return result;
        }, {});
      }
      /**
       * For better console.log(headers) and also to convert Headers into Node.js Request compatible format
       */
      [Symbol.for("nodejs.util.inspect.custom")]() {
        return [...this.keys()].reduce((result, key) => {
          const values2 = this.getAll(key);
          if (key === "host") {
            result[key] = values2[0];
          } else {
            result[key] = values2.length > 1 ? values2 : values2[0];
          }
          return result;
        }, {});
      }
    };
    Object.defineProperties(
      Headers2.prototype,
      ["get", "entries", "forEach", "values"].reduce((result, property) => {
        result[property] = { enumerable: true };
        return result;
      }, {})
    );
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/is-redirect.js
var redirectStatus, isRedirect;
var init_is_redirect = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/is-redirect.js"() {
    "use strict";
    redirectStatus = /* @__PURE__ */ new Set([301, 302, 303, 307, 308]);
    isRedirect = (code) => {
      return redirectStatus.has(code);
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/response.js
var INTERNALS2, Response3;
var init_response = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/response.js"() {
    "use strict";
    init_headers();
    init_body2();
    init_is_redirect();
    INTERNALS2 = Symbol("Response internals");
    Response3 = class _Response extends Body {
      constructor(body2 = null, options = {}) {
        super(body2, options);
        const status = options.status != null ? options.status : 200;
        const headers = new Headers2(options.headers);
        if (body2 !== null && !headers.has("Content-Type")) {
          const contentType = extractContentType(body2, this);
          if (contentType) {
            headers.append("Content-Type", contentType);
          }
        }
        this[INTERNALS2] = {
          type: "default",
          url: options.url,
          status,
          statusText: options.statusText || "",
          headers,
          counter: options.counter,
          highWaterMark: options.highWaterMark
        };
      }
      get type() {
        return this[INTERNALS2].type;
      }
      get url() {
        return this[INTERNALS2].url || "";
      }
      get status() {
        return this[INTERNALS2].status;
      }
      /**
       * Convenience property representing if the request ended normally
       */
      get ok() {
        return this[INTERNALS2].status >= 200 && this[INTERNALS2].status < 300;
      }
      get redirected() {
        return this[INTERNALS2].counter > 0;
      }
      get statusText() {
        return this[INTERNALS2].statusText;
      }
      get headers() {
        return this[INTERNALS2].headers;
      }
      get highWaterMark() {
        return this[INTERNALS2].highWaterMark;
      }
      /**
       * Clone this response
       *
       * @return  Response
       */
      clone() {
        return new _Response(clone(this, this.highWaterMark), {
          type: this.type,
          url: this.url,
          status: this.status,
          statusText: this.statusText,
          headers: this.headers,
          ok: this.ok,
          redirected: this.redirected,
          size: this.size,
          highWaterMark: this.highWaterMark
        });
      }
      /**
       * @param {string} url    The URL that the new response is to originate from.
       * @param {number} status An optional status code for the response (e.g., 302.)
       * @returns {Response}    A Response object.
       */
      static redirect(url, status = 302) {
        if (!isRedirect(status)) {
          throw new RangeError('Failed to execute "redirect" on "response": Invalid status code');
        }
        return new _Response(null, {
          headers: {
            location: new URL(url).toString()
          },
          status
        });
      }
      static error() {
        const response = new _Response(null, { status: 0, statusText: "" });
        response[INTERNALS2].type = "error";
        return response;
      }
      static json(data = void 0, init3 = {}) {
        const body2 = JSON.stringify(data);
        if (body2 === void 0) {
          throw new TypeError("data is not JSON serializable");
        }
        const headers = new Headers2(init3 && init3.headers);
        if (!headers.has("content-type")) {
          headers.set("content-type", "application/json");
        }
        return new _Response(body2, {
          ...init3,
          headers
        });
      }
      get [Symbol.toStringTag]() {
        return "Response";
      }
    };
    Object.defineProperties(Response3.prototype, {
      type: { enumerable: true },
      url: { enumerable: true },
      status: { enumerable: true },
      ok: { enumerable: true },
      redirected: { enumerable: true },
      statusText: { enumerable: true },
      headers: { enumerable: true },
      clone: { enumerable: true }
    });
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/get-search.js
var getSearch;
var init_get_search = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/get-search.js"() {
    "use strict";
    getSearch = (parsedURL) => {
      if (parsedURL.search) {
        return parsedURL.search;
      }
      const lastOffset = parsedURL.href.length - 1;
      const hash = parsedURL.hash || (parsedURL.href[lastOffset] === "#" ? "#" : "");
      return parsedURL.href[lastOffset - hash.length] === "?" ? "?" : "";
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/referrer.js
function stripURLForUseAsAReferrer(url, originOnly = false) {
  if (url == null) {
    return "no-referrer";
  }
  url = new URL(url);
  if (/^(about|blob|data):$/.test(url.protocol)) {
    return "no-referrer";
  }
  url.username = "";
  url.password = "";
  url.hash = "";
  if (originOnly) {
    url.pathname = "";
    url.search = "";
  }
  return url;
}
function validateReferrerPolicy(referrerPolicy) {
  if (!ReferrerPolicy.has(referrerPolicy)) {
    throw new TypeError(`Invalid referrerPolicy: ${referrerPolicy}`);
  }
  return referrerPolicy;
}
function isOriginPotentiallyTrustworthy(url) {
  if (/^(http|ws)s:$/.test(url.protocol)) {
    return true;
  }
  const hostIp = url.host.replace(/(^\[)|(]$)/g, "");
  const hostIPVersion = (0, import_node_net.isIP)(hostIp);
  if (hostIPVersion === 4 && /^127\./.test(hostIp)) {
    return true;
  }
  if (hostIPVersion === 6 && /^(((0+:){7})|(::(0+:){0,6}))0*1$/.test(hostIp)) {
    return true;
  }
  if (url.host === "localhost" || url.host.endsWith(".localhost")) {
    return false;
  }
  if (url.protocol === "file:") {
    return true;
  }
  return false;
}
function isUrlPotentiallyTrustworthy(url) {
  if (/^about:(blank|srcdoc)$/.test(url)) {
    return true;
  }
  if (url.protocol === "data:") {
    return true;
  }
  if (/^(blob|filesystem):$/.test(url.protocol)) {
    return true;
  }
  return isOriginPotentiallyTrustworthy(url);
}
function determineRequestsReferrer(request2, { referrerURLCallback, referrerOriginCallback } = {}) {
  if (request2.referrer === "no-referrer" || request2.referrerPolicy === "") {
    return null;
  }
  const policy5 = request2.referrerPolicy;
  if (request2.referrer === "about:client") {
    return "no-referrer";
  }
  const referrerSource = request2.referrer;
  let referrerURL = stripURLForUseAsAReferrer(referrerSource);
  let referrerOrigin = stripURLForUseAsAReferrer(referrerSource, true);
  if (referrerURL.toString().length > 4096) {
    referrerURL = referrerOrigin;
  }
  if (referrerURLCallback) {
    referrerURL = referrerURLCallback(referrerURL);
  }
  if (referrerOriginCallback) {
    referrerOrigin = referrerOriginCallback(referrerOrigin);
  }
  const currentURL = new URL(request2.url);
  switch (policy5) {
    case "no-referrer":
      return "no-referrer";
    case "origin":
      return referrerOrigin;
    case "unsafe-url":
      return referrerURL;
    case "strict-origin":
      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
        return "no-referrer";
      }
      return referrerOrigin.toString();
    case "strict-origin-when-cross-origin":
      if (referrerURL.origin === currentURL.origin) {
        return referrerURL;
      }
      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
        return "no-referrer";
      }
      return referrerOrigin;
    case "same-origin":
      if (referrerURL.origin === currentURL.origin) {
        return referrerURL;
      }
      return "no-referrer";
    case "origin-when-cross-origin":
      if (referrerURL.origin === currentURL.origin) {
        return referrerURL;
      }
      return referrerOrigin;
    case "no-referrer-when-downgrade":
      if (isUrlPotentiallyTrustworthy(referrerURL) && !isUrlPotentiallyTrustworthy(currentURL)) {
        return "no-referrer";
      }
      return referrerURL;
    default:
      throw new TypeError(`Invalid referrerPolicy: ${policy5}`);
  }
}
function parseReferrerPolicyFromHeader(headers) {
  const policyTokens = (headers.get("referrer-policy") || "").split(/[,\s]+/);
  let policy5 = "";
  for (const token of policyTokens) {
    if (token && ReferrerPolicy.has(token)) {
      policy5 = token;
    }
  }
  return policy5;
}
var import_node_net, ReferrerPolicy, DEFAULT_REFERRER_POLICY;
var init_referrer = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/utils/referrer.js"() {
    "use strict";
    import_node_net = require("net");
    ReferrerPolicy = /* @__PURE__ */ new Set([
      "",
      "no-referrer",
      "no-referrer-when-downgrade",
      "same-origin",
      "origin",
      "strict-origin",
      "origin-when-cross-origin",
      "strict-origin-when-cross-origin",
      "unsafe-url"
    ]);
    DEFAULT_REFERRER_POLICY = "strict-origin-when-cross-origin";
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/request.js
var import_node_url, import_node_util3, INTERNALS3, isRequest, doBadDataWarn, Request3, getNodeRequestOptions;
var init_request2 = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/request.js"() {
    "use strict";
    import_node_url = require("url");
    import_node_util3 = require("util");
    init_headers();
    init_body2();
    init_is();
    init_get_search();
    init_referrer();
    INTERNALS3 = Symbol("Request internals");
    isRequest = (object2) => {
      return typeof object2 === "object" && typeof object2[INTERNALS3] === "object";
    };
    doBadDataWarn = (0, import_node_util3.deprecate)(
      () => {
      },
      ".data is not a valid RequestInit property, use .body instead",
      "https://github.com/node-fetch/node-fetch/issues/1000 (request)"
    );
    Request3 = class _Request2 extends Body {
      constructor(input, init3 = {}) {
        let parsedURL;
        if (isRequest(input)) {
          parsedURL = new URL(input.url);
        } else {
          parsedURL = new URL(input);
          input = {};
        }
        if (parsedURL.username !== "" || parsedURL.password !== "") {
          throw new TypeError(`${parsedURL} is an url with embedded credentials.`);
        }
        let method = init3.method || input.method || "GET";
        if (/^(delete|get|head|options|post|put)$/i.test(method)) {
          method = method.toUpperCase();
        }
        if (!isRequest(init3) && "data" in init3) {
          doBadDataWarn();
        }
        if ((init3.body != null || isRequest(input) && input.body !== null) && (method === "GET" || method === "HEAD")) {
          throw new TypeError("Request with GET/HEAD method cannot have body");
        }
        const inputBody = init3.body ? init3.body : isRequest(input) && input.body !== null ? clone(input) : null;
        super(inputBody, {
          size: init3.size || input.size || 0
        });
        const headers = new Headers2(init3.headers || input.headers || {});
        if (inputBody !== null && !headers.has("Content-Type")) {
          const contentType = extractContentType(inputBody, this);
          if (contentType) {
            headers.set("Content-Type", contentType);
          }
        }
        let signal = isRequest(input) ? input.signal : null;
        if ("signal" in init3) {
          signal = init3.signal;
        }
        if (signal != null && !isAbortSignal(signal)) {
          throw new TypeError("Expected signal to be an instanceof AbortSignal or EventTarget");
        }
        let referrer = init3.referrer == null ? input.referrer : init3.referrer;
        if (referrer === "") {
          referrer = "no-referrer";
        } else if (referrer) {
          const parsedReferrer = new URL(referrer);
          referrer = /^about:(\/\/)?client$/.test(parsedReferrer) ? "client" : parsedReferrer;
        } else {
          referrer = void 0;
        }
        this[INTERNALS3] = {
          method,
          redirect: init3.redirect || input.redirect || "follow",
          headers,
          parsedURL,
          signal,
          referrer
        };
        this.follow = init3.follow === void 0 ? input.follow === void 0 ? 20 : input.follow : init3.follow;
        this.compress = init3.compress === void 0 ? input.compress === void 0 ? true : input.compress : init3.compress;
        this.counter = init3.counter || input.counter || 0;
        this.agent = init3.agent || input.agent;
        this.highWaterMark = init3.highWaterMark || input.highWaterMark || 16384;
        this.insecureHTTPParser = init3.insecureHTTPParser || input.insecureHTTPParser || false;
        this.referrerPolicy = init3.referrerPolicy || input.referrerPolicy || "";
      }
      /** @returns {string} */
      get method() {
        return this[INTERNALS3].method;
      }
      /** @returns {string} */
      get url() {
        return (0, import_node_url.format)(this[INTERNALS3].parsedURL);
      }
      /** @returns {Headers} */
      get headers() {
        return this[INTERNALS3].headers;
      }
      get redirect() {
        return this[INTERNALS3].redirect;
      }
      /** @returns {AbortSignal} */
      get signal() {
        return this[INTERNALS3].signal;
      }
      // https://fetch.spec.whatwg.org/#dom-request-referrer
      get referrer() {
        if (this[INTERNALS3].referrer === "no-referrer") {
          return "";
        }
        if (this[INTERNALS3].referrer === "client") {
          return "about:client";
        }
        if (this[INTERNALS3].referrer) {
          return this[INTERNALS3].referrer.toString();
        }
        return void 0;
      }
      get referrerPolicy() {
        return this[INTERNALS3].referrerPolicy;
      }
      set referrerPolicy(referrerPolicy) {
        this[INTERNALS3].referrerPolicy = validateReferrerPolicy(referrerPolicy);
      }
      /**
       * Clone this request
       *
       * @return  Request
       */
      clone() {
        return new _Request2(this);
      }
      get [Symbol.toStringTag]() {
        return "Request";
      }
    };
    Object.defineProperties(Request3.prototype, {
      method: { enumerable: true },
      url: { enumerable: true },
      headers: { enumerable: true },
      redirect: { enumerable: true },
      clone: { enumerable: true },
      signal: { enumerable: true },
      referrer: { enumerable: true },
      referrerPolicy: { enumerable: true }
    });
    getNodeRequestOptions = (request2) => {
      const { parsedURL } = request2[INTERNALS3];
      const headers = new Headers2(request2[INTERNALS3].headers);
      if (!headers.has("Accept")) {
        headers.set("Accept", "*/*");
      }
      let contentLengthValue = null;
      if (request2.body === null && /^(post|put)$/i.test(request2.method)) {
        contentLengthValue = "0";
      }
      if (request2.body !== null) {
        const totalBytes = getTotalBytes(request2);
        if (typeof totalBytes === "number" && !Number.isNaN(totalBytes)) {
          contentLengthValue = String(totalBytes);
        }
      }
      if (contentLengthValue) {
        headers.set("Content-Length", contentLengthValue);
      }
      if (request2.referrerPolicy === "") {
        request2.referrerPolicy = DEFAULT_REFERRER_POLICY;
      }
      if (request2.referrer && request2.referrer !== "no-referrer") {
        request2[INTERNALS3].referrer = determineRequestsReferrer(request2);
      } else {
        request2[INTERNALS3].referrer = "no-referrer";
      }
      if (request2[INTERNALS3].referrer instanceof URL) {
        headers.set("Referer", request2.referrer);
      }
      if (!headers.has("User-Agent")) {
        headers.set("User-Agent", "node-fetch");
      }
      if (request2.compress && !headers.has("Accept-Encoding")) {
        headers.set("Accept-Encoding", "gzip, deflate, br");
      }
      let { agent } = request2;
      if (typeof agent === "function") {
        agent = agent(parsedURL);
      }
      const search = getSearch(parsedURL);
      const options = {
        // Overwrite search to retain trailing ? (issue #776)
        path: parsedURL.pathname + search,
        // The following options are not expressed in the URL
        method: request2.method,
        headers: headers[Symbol.for("nodejs.util.inspect.custom")](),
        insecureHTTPParser: request2.insecureHTTPParser,
        agent
      };
      return {
        /** @type {URL} */
        parsedURL,
        options
      };
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/errors/abort-error.js
var AbortError;
var init_abort_error = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/errors/abort-error.js"() {
    "use strict";
    init_base();
    AbortError = class extends FetchBaseError {
      constructor(message, type = "aborted") {
        super(message, type);
      }
    };
  }
});

// ../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/index.js
async function fetch2(url, options_) {
  return new Promise((resolve2, reject) => {
    const request2 = new Request3(url, options_);
    const { parsedURL, options } = getNodeRequestOptions(request2);
    if (!supportedSchemas.has(parsedURL.protocol)) {
      throw new TypeError(`node-fetch cannot load ${url}. URL scheme "${parsedURL.protocol.replace(/:$/, "")}" is not supported.`);
    }
    if (parsedURL.protocol === "data:") {
      const data = dist_default(request2.url);
      const response2 = new Response3(data, { headers: { "Content-Type": data.typeFull } });
      resolve2(response2);
      return;
    }
    const send = (parsedURL.protocol === "https:" ? import_node_https.default : import_node_http2.default).request;
    const { signal } = request2;
    let response = null;
    const abort2 = () => {
      const error2 = new AbortError("The operation was aborted.");
      reject(error2);
      if (request2.body && request2.body instanceof import_node_stream2.default.Readable) {
        request2.body.destroy(error2);
      }
      if (!response || !response.body) {
        return;
      }
      response.body.emit("error", error2);
    };
    if (signal && signal.aborted) {
      abort2();
      return;
    }
    const abortAndFinalize = () => {
      abort2();
      finalize();
    };
    const request_ = send(parsedURL.toString(), options);
    if (signal) {
      signal.addEventListener("abort", abortAndFinalize);
    }
    const finalize = () => {
      request_.abort();
      if (signal) {
        signal.removeEventListener("abort", abortAndFinalize);
      }
    };
    request_.on("error", (error2) => {
      reject(new FetchError(`request to ${request2.url} failed, reason: ${error2.message}`, "system", error2));
      finalize();
    });
    fixResponseChunkedTransferBadEnding(request_, (error2) => {
      if (response && response.body) {
        response.body.destroy(error2);
      }
    });
    if (process.version < "v14") {
      request_.on("socket", (s10) => {
        let endedWithEventsCount;
        s10.prependListener("end", () => {
          endedWithEventsCount = s10._eventsCount;
        });
        s10.prependListener("close", (hadError) => {
          if (response && endedWithEventsCount < s10._eventsCount && !hadError) {
            const error2 = new Error("Premature close");
            error2.code = "ERR_STREAM_PREMATURE_CLOSE";
            response.body.emit("error", error2);
          }
        });
      });
    }
    request_.on("response", (response_) => {
      request_.setTimeout(0);
      const headers = fromRawHeaders(response_.rawHeaders);
      if (isRedirect(response_.statusCode)) {
        const location2 = headers.get("Location");
        let locationURL = null;
        try {
          locationURL = location2 === null ? null : new URL(location2, request2.url);
        } catch {
          if (request2.redirect !== "manual") {
            reject(new FetchError(`uri requested responds with an invalid redirect URL: ${location2}`, "invalid-redirect"));
            finalize();
            return;
          }
        }
        switch (request2.redirect) {
          case "error":
            reject(new FetchError(`uri requested responds with a redirect, redirect mode is set to error: ${request2.url}`, "no-redirect"));
            finalize();
            return;
          case "manual":
            break;
          case "follow": {
            if (locationURL === null) {
              break;
            }
            if (request2.counter >= request2.follow) {
              reject(new FetchError(`maximum redirect reached at: ${request2.url}`, "max-redirect"));
              finalize();
              return;
            }
            const requestOptions = {
              headers: new Headers2(request2.headers),
              follow: request2.follow,
              counter: request2.counter + 1,
              agent: request2.agent,
              compress: request2.compress,
              method: request2.method,
              body: clone(request2),
              signal: request2.signal,
              size: request2.size,
              referrer: request2.referrer,
              referrerPolicy: request2.referrerPolicy
            };
            if (!isDomainOrSubdomain(request2.url, locationURL) || !isSameProtocol(request2.url, locationURL)) {
              for (const name3 of ["authorization", "www-authenticate", "cookie", "cookie2"]) {
                requestOptions.headers.delete(name3);
              }
            }
            if (response_.statusCode !== 303 && request2.body && options_.body instanceof import_node_stream2.default.Readable) {
              reject(new FetchError("Cannot follow redirect with body being a readable stream", "unsupported-redirect"));
              finalize();
              return;
            }
            if (response_.statusCode === 303 || (response_.statusCode === 301 || response_.statusCode === 302) && request2.method === "POST") {
              requestOptions.method = "GET";
              requestOptions.body = void 0;
              requestOptions.headers.delete("content-length");
            }
            const responseReferrerPolicy = parseReferrerPolicyFromHeader(headers);
            if (responseReferrerPolicy) {
              requestOptions.referrerPolicy = responseReferrerPolicy;
            }
            resolve2(fetch2(new Request3(locationURL, requestOptions)));
            finalize();
            return;
          }
          default:
            return reject(new TypeError(`Redirect option '${request2.redirect}' is not a valid value of RequestRedirect`));
        }
      }
      if (signal) {
        response_.once("end", () => {
          signal.removeEventListener("abort", abortAndFinalize);
        });
      }
      let body2 = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error2) => {
        if (error2) {
          reject(error2);
        }
      });
      if (process.version < "v12.10") {
        response_.on("aborted", abortAndFinalize);
      }
      const responseOptions = {
        url: request2.url,
        status: response_.statusCode,
        statusText: response_.statusMessage,
        headers,
        size: request2.size,
        counter: request2.counter,
        highWaterMark: request2.highWaterMark
      };
      const codings = headers.get("Content-Encoding");
      if (!request2.compress || request2.method === "HEAD" || codings === null || response_.statusCode === 204 || response_.statusCode === 304) {
        response = new Response3(body2, responseOptions);
        resolve2(response);
        return;
      }
      const zlibOptions = {
        flush: import_node_zlib.default.Z_SYNC_FLUSH,
        finishFlush: import_node_zlib.default.Z_SYNC_FLUSH
      };
      if (codings === "gzip" || codings === "x-gzip") {
        body2 = (0, import_node_stream2.pipeline)(body2, import_node_zlib.default.createGunzip(zlibOptions), (error2) => {
          if (error2) {
            reject(error2);
          }
        });
        response = new Response3(body2, responseOptions);
        resolve2(response);
        return;
      }
      if (codings === "deflate" || codings === "x-deflate") {
        const raw2 = (0, import_node_stream2.pipeline)(response_, new import_node_stream2.PassThrough(), (error2) => {
          if (error2) {
            reject(error2);
          }
        });
        raw2.once("data", (chunk) => {
          if ((chunk[0] & 15) === 8) {
            body2 = (0, import_node_stream2.pipeline)(body2, import_node_zlib.default.createInflate(), (error2) => {
              if (error2) {
                reject(error2);
              }
            });
          } else {
            body2 = (0, import_node_stream2.pipeline)(body2, import_node_zlib.default.createInflateRaw(), (error2) => {
              if (error2) {
                reject(error2);
              }
            });
          }
          response = new Response3(body2, responseOptions);
          resolve2(response);
        });
        raw2.once("end", () => {
          if (!response) {
            response = new Response3(body2, responseOptions);
            resolve2(response);
          }
        });
        return;
      }
      if (codings === "br") {
        body2 = (0, import_node_stream2.pipeline)(body2, import_node_zlib.default.createBrotliDecompress(), (error2) => {
          if (error2) {
            reject(error2);
          }
        });
        response = new Response3(body2, responseOptions);
        resolve2(response);
        return;
      }
      response = new Response3(body2, responseOptions);
      resolve2(response);
    });
    writeToStream(request_, request2).catch(reject);
  });
}
function fixResponseChunkedTransferBadEnding(request2, errorCallback) {
  const LAST_CHUNK = import_node_buffer2.Buffer.from("0\r\n\r\n");
  let isChunkedTransfer = false;
  let properLastChunkReceived = false;
  let previousChunk;
  request2.on("response", (response) => {
    const { headers } = response;
    isChunkedTransfer = headers["transfer-encoding"] === "chunked" && !headers["content-length"];
  });
  request2.on("socket", (socket) => {
    const onSocketClose = () => {
      if (isChunkedTransfer && !properLastChunkReceived) {
        const error2 = new Error("Premature close");
        error2.code = "ERR_STREAM_PREMATURE_CLOSE";
        errorCallback(error2);
      }
    };
    const onData = (buf) => {
      properLastChunkReceived = import_node_buffer2.Buffer.compare(buf.slice(-5), LAST_CHUNK) === 0;
      if (!properLastChunkReceived && previousChunk) {
        properLastChunkReceived = import_node_buffer2.Buffer.compare(previousChunk.slice(-3), LAST_CHUNK.slice(0, 3)) === 0 && import_node_buffer2.Buffer.compare(buf.slice(-2), LAST_CHUNK.slice(3)) === 0;
      }
      previousChunk = buf;
    };
    socket.prependListener("close", onSocketClose);
    socket.on("data", onData);
    request2.on("close", () => {
      socket.removeListener("close", onSocketClose);
      socket.removeListener("data", onData);
    });
  });
}
var import_node_http2, import_node_https, import_node_zlib, import_node_stream2, import_node_buffer2, supportedSchemas;
var init_src = __esm({
  "../node_modules/.pnpm/node-fetch@3.3.2/node_modules/node-fetch/src/index.js"() {
    "use strict";
    import_node_http2 = __toESM(require("http"), 1);
    import_node_https = __toESM(require("https"), 1);
    import_node_zlib = __toESM(require("zlib"), 1);
    import_node_stream2 = __toESM(require("stream"), 1);
    import_node_buffer2 = require("buffer");
    init_dist4();
    init_body2();
    init_response();
    init_headers();
    init_request2();
    init_fetch_error();
    init_abort_error();
    init_is_redirect();
    init_esm_min();
    init_is();
    init_referrer();
    init_from();
    supportedSchemas = /* @__PURE__ */ new Set(["data:", "http:", "https:"]);
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/constants.js
var require_constants = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/constants.js"(exports2, module2) {
    "use strict";
    var BINARY_TYPES = ["nodebuffer", "arraybuffer", "fragments"];
    var hasBlob = typeof Blob !== "undefined";
    if (hasBlob) BINARY_TYPES.push("blob");
    module2.exports = {
      BINARY_TYPES,
      EMPTY_BUFFER: Buffer.alloc(0),
      GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
      hasBlob,
      kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
      kListener: Symbol("kListener"),
      kStatusCode: Symbol("status-code"),
      kWebSocket: Symbol("websocket"),
      NOOP: () => {
      }
    };
  }
});

// ../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js
var require_node_gyp_build = __commonJS({
  "../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/node-gyp-build.js"(exports2, module2) {
    "use strict";
    var fs9 = require("fs");
    var path3 = require("path");
    var os4 = require("os");
    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
    var vars = process.config && process.config.variables || {};
    var prebuildsOnly = !!process.env.PREBUILDS_ONLY;
    var abi = process.versions.modules;
    var runtime = isElectron() ? "electron" : isNwjs() ? "node-webkit" : "node";
    var arch = process.env.npm_config_arch || os4.arch();
    var platform2 = process.env.npm_config_platform || os4.platform();
    var libc = process.env.LIBC || (isAlpine(platform2) ? "musl" : "glibc");
    var armv = process.env.ARM_VERSION || (arch === "arm64" ? "8" : vars.arm_version) || "";
    var uv = (process.versions.uv || "").split(".")[0];
    module2.exports = load;
    function load(dir) {
      return runtimeRequire(load.resolve(dir));
    }
    load.resolve = load.path = function(dir) {
      dir = path3.resolve(dir || ".");
      try {
        var name3 = runtimeRequire(path3.join(dir, "package.json")).name.toUpperCase().replace(/-/g, "_");
        if (process.env[name3 + "_PREBUILD"]) dir = process.env[name3 + "_PREBUILD"];
      } catch (err3) {
      }
      if (!prebuildsOnly) {
        var release2 = getFirst(path3.join(dir, "build/Release"), matchBuild);
        if (release2) return release2;
        var debug = getFirst(path3.join(dir, "build/Debug"), matchBuild);
        if (debug) return debug;
      }
      var prebuild = resolve2(dir);
      if (prebuild) return prebuild;
      var nearby = resolve2(path3.dirname(process.execPath));
      if (nearby) return nearby;
      var target = [
        "platform=" + platform2,
        "arch=" + arch,
        "runtime=" + runtime,
        "abi=" + abi,
        "uv=" + uv,
        armv ? "armv=" + armv : "",
        "libc=" + libc,
        "node=" + process.versions.node,
        process.versions.electron ? "electron=" + process.versions.electron : "",
        typeof __webpack_require__ === "function" ? "webpack=true" : ""
        // eslint-disable-line
      ].filter(Boolean).join(" ");
      throw new Error("No native build was found for " + target + "\n    loaded from: " + dir + "\n");
      function resolve2(dir2) {
        var tuples2 = readdirSync(path3.join(dir2, "prebuilds")).map(parseTuple);
        var tuple = tuples2.filter(matchTuple(platform2, arch)).sort(compareTuples)[0];
        if (!tuple) return;
        var prebuilds = path3.join(dir2, "prebuilds", tuple.name);
        var parsed = readdirSync(prebuilds).map(parseTags);
        var candidates = parsed.filter(matchTags(runtime, abi));
        var winner = candidates.sort(compareTags(runtime))[0];
        if (winner) return path3.join(prebuilds, winner.file);
      }
    };
    function readdirSync(dir) {
      try {
        return fs9.readdirSync(dir);
      } catch (err3) {
        return [];
      }
    }
    function getFirst(dir, filter2) {
      var files = readdirSync(dir).filter(filter2);
      return files[0] && path3.join(dir, files[0]);
    }
    function matchBuild(name3) {
      return /\.node$/.test(name3);
    }
    function parseTuple(name3) {
      var arr = name3.split("-");
      if (arr.length !== 2) return;
      var platform3 = arr[0];
      var architectures = arr[1].split("+");
      if (!platform3) return;
      if (!architectures.length) return;
      if (!architectures.every(Boolean)) return;
      return { name: name3, platform: platform3, architectures };
    }
    function matchTuple(platform3, arch2) {
      return function(tuple) {
        if (tuple == null) return false;
        if (tuple.platform !== platform3) return false;
        return tuple.architectures.includes(arch2);
      };
    }
    function compareTuples(a9, b9) {
      return a9.architectures.length - b9.architectures.length;
    }
    function parseTags(file) {
      var arr = file.split(".");
      var extension = arr.pop();
      var tags = { file, specificity: 0 };
      if (extension !== "node") return;
      for (var i8 = 0; i8 < arr.length; i8++) {
        var tag = arr[i8];
        if (tag === "node" || tag === "electron" || tag === "node-webkit") {
          tags.runtime = tag;
        } else if (tag === "napi") {
          tags.napi = true;
        } else if (tag.slice(0, 3) === "abi") {
          tags.abi = tag.slice(3);
        } else if (tag.slice(0, 2) === "uv") {
          tags.uv = tag.slice(2);
        } else if (tag.slice(0, 4) === "armv") {
          tags.armv = tag.slice(4);
        } else if (tag === "glibc" || tag === "musl") {
          tags.libc = tag;
        } else {
          continue;
        }
        tags.specificity++;
      }
      return tags;
    }
    function matchTags(runtime2, abi2) {
      return function(tags) {
        if (tags == null) return false;
        if (tags.runtime && tags.runtime !== runtime2 && !runtimeAgnostic(tags)) return false;
        if (tags.abi && tags.abi !== abi2 && !tags.napi) return false;
        if (tags.uv && tags.uv !== uv) return false;
        if (tags.armv && tags.armv !== armv) return false;
        if (tags.libc && tags.libc !== libc) return false;
        return true;
      };
    }
    function runtimeAgnostic(tags) {
      return tags.runtime === "node" && tags.napi;
    }
    function compareTags(runtime2) {
      return function(a9, b9) {
        if (a9.runtime !== b9.runtime) {
          return a9.runtime === runtime2 ? -1 : 1;
        } else if (a9.abi !== b9.abi) {
          return a9.abi ? -1 : 1;
        } else if (a9.specificity !== b9.specificity) {
          return a9.specificity > b9.specificity ? -1 : 1;
        } else {
          return 0;
        }
      };
    }
    function isNwjs() {
      return !!(process.versions && process.versions.nw);
    }
    function isElectron() {
      if (process.versions && process.versions.electron) return true;
      if (process.env.ELECTRON_RUN_AS_NODE) return true;
      return typeof window !== "undefined" && window.process && window.process.type === "renderer";
    }
    function isAlpine(platform3) {
      return platform3 === "linux" && fs9.existsSync("/etc/alpine-release");
    }
    load.parseTags = parseTags;
    load.matchTags = matchTags;
    load.compareTags = compareTags;
    load.parseTuple = parseTuple;
    load.matchTuple = matchTuple;
    load.compareTuples = compareTuples;
  }
});

// ../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/index.js
var require_node_gyp_build2 = __commonJS({
  "../node_modules/.pnpm/node-gyp-build@4.8.4/node_modules/node-gyp-build/index.js"(exports2, module2) {
    "use strict";
    var runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
    if (typeof runtimeRequire.addon === "function") {
      module2.exports = runtimeRequire.addon.bind(runtimeRequire);
    } else {
      module2.exports = require_node_gyp_build();
    }
  }
});

// ../node_modules/.pnpm/bufferutil@4.0.8/node_modules/bufferutil/fallback.js
var require_fallback = __commonJS({
  "../node_modules/.pnpm/bufferutil@4.0.8/node_modules/bufferutil/fallback.js"(exports2, module2) {
    "use strict";
    var mask = (source, mask2, output, offset, length) => {
      for (var i8 = 0; i8 < length; i8++) {
        output[offset + i8] = source[i8] ^ mask2[i8 & 3];
      }
    };
    var unmask = (buffer2, mask2) => {
      const length = buffer2.length;
      for (var i8 = 0; i8 < length; i8++) {
        buffer2[i8] ^= mask2[i8 & 3];
      }
    };
    module2.exports = { mask, unmask };
  }
});

// ../node_modules/.pnpm/bufferutil@4.0.8/node_modules/bufferutil/index.js
var require_bufferutil = __commonJS({
  "../node_modules/.pnpm/bufferutil@4.0.8/node_modules/bufferutil/index.js"(exports2, module2) {
    "use strict";
    try {
      module2.exports = require_node_gyp_build2()(__dirname);
    } catch (e6) {
      module2.exports = require_fallback();
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/buffer-util.js
var require_buffer_util = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/buffer-util.js"(exports2, module2) {
    "use strict";
    var { EMPTY_BUFFER } = require_constants();
    var FastBuffer = Buffer[Symbol.species];
    function concat(list, totalLength) {
      if (list.length === 0) return EMPTY_BUFFER;
      if (list.length === 1) return list[0];
      const target = Buffer.allocUnsafe(totalLength);
      let offset = 0;
      for (let i8 = 0; i8 < list.length; i8++) {
        const buf = list[i8];
        target.set(buf, offset);
        offset += buf.length;
      }
      if (offset < totalLength) {
        return new FastBuffer(target.buffer, target.byteOffset, offset);
      }
      return target;
    }
    function _mask(source, mask, output, offset, length) {
      for (let i8 = 0; i8 < length; i8++) {
        output[offset + i8] = source[i8] ^ mask[i8 & 3];
      }
    }
    function _unmask(buffer2, mask) {
      for (let i8 = 0; i8 < buffer2.length; i8++) {
        buffer2[i8] ^= mask[i8 & 3];
      }
    }
    function toArrayBuffer(buf) {
      if (buf.length === buf.buffer.byteLength) {
        return buf.buffer;
      }
      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
    }
    function toBuffer(data) {
      toBuffer.readOnly = true;
      if (Buffer.isBuffer(data)) return data;
      let buf;
      if (data instanceof ArrayBuffer) {
        buf = new FastBuffer(data);
      } else if (ArrayBuffer.isView(data)) {
        buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
      } else {
        buf = Buffer.from(data);
        toBuffer.readOnly = false;
      }
      return buf;
    }
    module2.exports = {
      concat,
      mask: _mask,
      toArrayBuffer,
      toBuffer,
      unmask: _unmask
    };
    if (!process.env.WS_NO_BUFFER_UTIL) {
      try {
        const bufferUtil = require_bufferutil();
        module2.exports.mask = function(source, mask, output, offset, length) {
          if (length < 48) _mask(source, mask, output, offset, length);
          else bufferUtil.mask(source, mask, output, offset, length);
        };
        module2.exports.unmask = function(buffer2, mask) {
          if (buffer2.length < 32) _unmask(buffer2, mask);
          else bufferUtil.unmask(buffer2, mask);
        };
      } catch (e6) {
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/limiter.js
var require_limiter = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/limiter.js"(exports2, module2) {
    "use strict";
    var kDone = Symbol("kDone");
    var kRun = Symbol("kRun");
    var Limiter = class {
      /**
       * Creates a new `Limiter`.
       *
       * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
       *     to run concurrently
       */
      constructor(concurrency) {
        this[kDone] = () => {
          this.pending--;
          this[kRun]();
        };
        this.concurrency = concurrency || Infinity;
        this.jobs = [];
        this.pending = 0;
      }
      /**
       * Adds a job to the queue.
       *
       * @param {Function} job The job to run
       * @public
       */
      add(job) {
        this.jobs.push(job);
        this[kRun]();
      }
      /**
       * Removes a job from the queue and runs it if possible.
       *
       * @private
       */
      [kRun]() {
        if (this.pending === this.concurrency) return;
        if (this.jobs.length) {
          const job = this.jobs.shift();
          this.pending++;
          job(this[kDone]);
        }
      }
    };
    module2.exports = Limiter;
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/permessage-deflate.js
var require_permessage_deflate = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
    "use strict";
    var zlib2 = require("zlib");
    var bufferUtil = require_buffer_util();
    var Limiter = require_limiter();
    var { kStatusCode } = require_constants();
    var FastBuffer = Buffer[Symbol.species];
    var TRAILER = Buffer.from([0, 0, 255, 255]);
    var kPerMessageDeflate = Symbol("permessage-deflate");
    var kTotalLength = Symbol("total-length");
    var kCallback = Symbol("callback");
    var kBuffers = Symbol("buffers");
    var kError = Symbol("error");
    var zlibLimiter;
    var PerMessageDeflate = class {
      /**
       * Creates a PerMessageDeflate instance.
       *
       * @param {Object} [options] Configuration options
       * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
       *     for, or request, a custom client window size
       * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
       *     acknowledge disabling of client context takeover
       * @param {Number} [options.concurrencyLimit=10] The number of concurrent
       *     calls to zlib
       * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
       *     use of a custom server window size
       * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
       *     disabling of server context takeover
       * @param {Number} [options.threshold=1024] Size (in bytes) below which
       *     messages should not be compressed if context takeover is disabled
       * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
       *     deflate
       * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
       *     inflate
       * @param {Boolean} [isServer=false] Create the instance in either server or
       *     client mode
       * @param {Number} [maxPayload=0] The maximum allowed message length
       */
      constructor(options, isServer, maxPayload) {
        this._maxPayload = maxPayload | 0;
        this._options = options || {};
        this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
        this._isServer = !!isServer;
        this._deflate = null;
        this._inflate = null;
        this.params = null;
        if (!zlibLimiter) {
          const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
          zlibLimiter = new Limiter(concurrency);
        }
      }
      /**
       * @type {String}
       */
      static get extensionName() {
        return "permessage-deflate";
      }
      /**
       * Create an extension negotiation offer.
       *
       * @return {Object} Extension parameters
       * @public
       */
      offer() {
        const params = {};
        if (this._options.serverNoContextTakeover) {
          params.server_no_context_takeover = true;
        }
        if (this._options.clientNoContextTakeover) {
          params.client_no_context_takeover = true;
        }
        if (this._options.serverMaxWindowBits) {
          params.server_max_window_bits = this._options.serverMaxWindowBits;
        }
        if (this._options.clientMaxWindowBits) {
          params.client_max_window_bits = this._options.clientMaxWindowBits;
        } else if (this._options.clientMaxWindowBits == null) {
          params.client_max_window_bits = true;
        }
        return params;
      }
      /**
       * Accept an extension negotiation offer/response.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Object} Accepted configuration
       * @public
       */
      accept(configurations) {
        configurations = this.normalizeParams(configurations);
        this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
        return this.params;
      }
      /**
       * Releases all resources used by the extension.
       *
       * @public
       */
      cleanup() {
        if (this._inflate) {
          this._inflate.close();
          this._inflate = null;
        }
        if (this._deflate) {
          const callback = this._deflate[kCallback];
          this._deflate.close();
          this._deflate = null;
          if (callback) {
            callback(
              new Error(
                "The deflate stream was closed while data was being processed"
              )
            );
          }
        }
      }
      /**
       *  Accept an extension negotiation offer.
       *
       * @param {Array} offers The extension negotiation offers
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsServer(offers) {
        const opts = this._options;
        const accepted = offers.find((params) => {
          if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
            return false;
          }
          return true;
        });
        if (!accepted) {
          throw new Error("None of the extension offers can be accepted");
        }
        if (opts.serverNoContextTakeover) {
          accepted.server_no_context_takeover = true;
        }
        if (opts.clientNoContextTakeover) {
          accepted.client_no_context_takeover = true;
        }
        if (typeof opts.serverMaxWindowBits === "number") {
          accepted.server_max_window_bits = opts.serverMaxWindowBits;
        }
        if (typeof opts.clientMaxWindowBits === "number") {
          accepted.client_max_window_bits = opts.clientMaxWindowBits;
        } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
          delete accepted.client_max_window_bits;
        }
        return accepted;
      }
      /**
       * Accept the extension negotiation response.
       *
       * @param {Array} response The extension negotiation response
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsClient(response) {
        const params = response[0];
        if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
          throw new Error('Unexpected parameter "client_no_context_takeover"');
        }
        if (!params.client_max_window_bits) {
          if (typeof this._options.clientMaxWindowBits === "number") {
            params.client_max_window_bits = this._options.clientMaxWindowBits;
          }
        } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
          throw new Error(
            'Unexpected or invalid parameter "client_max_window_bits"'
          );
        }
        return params;
      }
      /**
       * Normalize parameters.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Array} The offers/response with normalized parameters
       * @private
       */
      normalizeParams(configurations) {
        configurations.forEach((params) => {
          Object.keys(params).forEach((key) => {
            let value = params[key];
            if (value.length > 1) {
              throw new Error(`Parameter "${key}" must have only a single value`);
            }
            value = value[0];
            if (key === "client_max_window_bits") {
              if (value !== true) {
                const num = +value;
                if (!Number.isInteger(num) || num < 8 || num > 15) {
                  throw new TypeError(
                    `Invalid value for parameter "${key}": ${value}`
                  );
                }
                value = num;
              } else if (!this._isServer) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else if (key === "server_max_window_bits") {
              const num = +value;
              if (!Number.isInteger(num) || num < 8 || num > 15) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
              value = num;
            } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
              if (value !== true) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else {
              throw new Error(`Unknown parameter "${key}"`);
            }
            params[key] = value;
          });
        });
        return configurations;
      }
      /**
       * Decompress data. Concurrency limited.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      decompress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._decompress(data, fin, (err3, result) => {
            done();
            callback(err3, result);
          });
        });
      }
      /**
       * Compress data. Concurrency limited.
       *
       * @param {(Buffer|String)} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      compress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._compress(data, fin, (err3, result) => {
            done();
            callback(err3, result);
          });
        });
      }
      /**
       * Decompress data.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _decompress(data, fin, callback) {
        const endpoint = this._isServer ? "client" : "server";
        if (!this._inflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._inflate = zlib2.createInflateRaw({
            ...this._options.zlibInflateOptions,
            windowBits
          });
          this._inflate[kPerMessageDeflate] = this;
          this._inflate[kTotalLength] = 0;
          this._inflate[kBuffers] = [];
          this._inflate.on("error", inflateOnError);
          this._inflate.on("data", inflateOnData);
        }
        this._inflate[kCallback] = callback;
        this._inflate.write(data);
        if (fin) this._inflate.write(TRAILER);
        this._inflate.flush(() => {
          const err3 = this._inflate[kError];
          if (err3) {
            this._inflate.close();
            this._inflate = null;
            callback(err3);
            return;
          }
          const data2 = bufferUtil.concat(
            this._inflate[kBuffers],
            this._inflate[kTotalLength]
          );
          if (this._inflate._readableState.endEmitted) {
            this._inflate.close();
            this._inflate = null;
          } else {
            this._inflate[kTotalLength] = 0;
            this._inflate[kBuffers] = [];
            if (fin && this.params[`${endpoint}_no_context_takeover`]) {
              this._inflate.reset();
            }
          }
          callback(null, data2);
        });
      }
      /**
       * Compress data.
       *
       * @param {(Buffer|String)} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _compress(data, fin, callback) {
        const endpoint = this._isServer ? "server" : "client";
        if (!this._deflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._deflate = zlib2.createDeflateRaw({
            ...this._options.zlibDeflateOptions,
            windowBits
          });
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          this._deflate.on("data", deflateOnData);
        }
        this._deflate[kCallback] = callback;
        this._deflate.write(data);
        this._deflate.flush(zlib2.Z_SYNC_FLUSH, () => {
          if (!this._deflate) {
            return;
          }
          let data2 = bufferUtil.concat(
            this._deflate[kBuffers],
            this._deflate[kTotalLength]
          );
          if (fin) {
            data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
          }
          this._deflate[kCallback] = null;
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          if (fin && this.params[`${endpoint}_no_context_takeover`]) {
            this._deflate.reset();
          }
          callback(null, data2);
        });
      }
    };
    module2.exports = PerMessageDeflate;
    function deflateOnData(chunk) {
      this[kBuffers].push(chunk);
      this[kTotalLength] += chunk.length;
    }
    function inflateOnData(chunk) {
      this[kTotalLength] += chunk.length;
      if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
        this[kBuffers].push(chunk);
        return;
      }
      this[kError] = new RangeError("Max payload size exceeded");
      this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
      this[kError][kStatusCode] = 1009;
      this.removeListener("data", inflateOnData);
      this.reset();
    }
    function inflateOnError(err3) {
      this[kPerMessageDeflate]._inflate = null;
      if (this[kError]) {
        this[kCallback](this[kError]);
        return;
      }
      err3[kStatusCode] = 1007;
      this[kCallback](err3);
    }
  }
});

// ../node_modules/.pnpm/utf-8-validate@6.0.3/node_modules/utf-8-validate/fallback.js
var require_fallback2 = __commonJS({
  "../node_modules/.pnpm/utf-8-validate@6.0.3/node_modules/utf-8-validate/fallback.js"(exports2, module2) {
    "use strict";
    function isValidUTF8(buf) {
      const len = buf.length;
      let i8 = 0;
      while (i8 < len) {
        if ((buf[i8] & 128) === 0) {
          i8++;
        } else if ((buf[i8] & 224) === 192) {
          if (i8 + 1 === len || (buf[i8 + 1] & 192) !== 128 || (buf[i8] & 254) === 192) {
            return false;
          }
          i8 += 2;
        } else if ((buf[i8] & 240) === 224) {
          if (i8 + 2 >= len || (buf[i8 + 1] & 192) !== 128 || (buf[i8 + 2] & 192) !== 128 || buf[i8] === 224 && (buf[i8 + 1] & 224) === 128 || // overlong
          buf[i8] === 237 && (buf[i8 + 1] & 224) === 160) {
            return false;
          }
          i8 += 3;
        } else if ((buf[i8] & 248) === 240) {
          if (i8 + 3 >= len || (buf[i8 + 1] & 192) !== 128 || (buf[i8 + 2] & 192) !== 128 || (buf[i8 + 3] & 192) !== 128 || buf[i8] === 240 && (buf[i8 + 1] & 240) === 128 || // overlong
          buf[i8] === 244 && buf[i8 + 1] > 143 || buf[i8] > 244) {
            return false;
          }
          i8 += 4;
        } else {
          return false;
        }
      }
      return true;
    }
    module2.exports = isValidUTF8;
  }
});

// ../node_modules/.pnpm/utf-8-validate@6.0.3/node_modules/utf-8-validate/index.js
var require_utf_8_validate = __commonJS({
  "../node_modules/.pnpm/utf-8-validate@6.0.3/node_modules/utf-8-validate/index.js"(exports2, module2) {
    "use strict";
    try {
      module2.exports = require_node_gyp_build2()(__dirname);
    } catch (e6) {
      module2.exports = require_fallback2();
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/validation.js
var require_validation = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/validation.js"(exports2, module2) {
    "use strict";
    var { isUtf8 } = require("buffer");
    var { hasBlob } = require_constants();
    var tokenChars = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 0 - 15
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 16 - 31
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      0,
      // 32 - 47
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      // 48 - 63
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 64 - 79
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      // 80 - 95
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 96 - 111
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      0,
      1,
      0
      // 112 - 127
    ];
    function isValidStatusCode(code) {
      return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
    }
    function _isValidUTF8(buf) {
      const len = buf.length;
      let i8 = 0;
      while (i8 < len) {
        if ((buf[i8] & 128) === 0) {
          i8++;
        } else if ((buf[i8] & 224) === 192) {
          if (i8 + 1 === len || (buf[i8 + 1] & 192) !== 128 || (buf[i8] & 254) === 192) {
            return false;
          }
          i8 += 2;
        } else if ((buf[i8] & 240) === 224) {
          if (i8 + 2 >= len || (buf[i8 + 1] & 192) !== 128 || (buf[i8 + 2] & 192) !== 128 || buf[i8] === 224 && (buf[i8 + 1] & 224) === 128 || // Overlong
          buf[i8] === 237 && (buf[i8 + 1] & 224) === 160) {
            return false;
          }
          i8 += 3;
        } else if ((buf[i8] & 248) === 240) {
          if (i8 + 3 >= len || (buf[i8 + 1] & 192) !== 128 || (buf[i8 + 2] & 192) !== 128 || (buf[i8 + 3] & 192) !== 128 || buf[i8] === 240 && (buf[i8 + 1] & 240) === 128 || // Overlong
          buf[i8] === 244 && buf[i8 + 1] > 143 || buf[i8] > 244) {
            return false;
          }
          i8 += 4;
        } else {
          return false;
        }
      }
      return true;
    }
    function isBlob3(value) {
      return hasBlob && typeof value === "object" && typeof value.arrayBuffer === "function" && typeof value.type === "string" && typeof value.stream === "function" && (value[Symbol.toStringTag] === "Blob" || value[Symbol.toStringTag] === "File");
    }
    module2.exports = {
      isBlob: isBlob3,
      isValidStatusCode,
      isValidUTF8: _isValidUTF8,
      tokenChars
    };
    if (isUtf8) {
      module2.exports.isValidUTF8 = function(buf) {
        return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
      };
    } else if (!process.env.WS_NO_UTF_8_VALIDATE) {
      try {
        const isValidUTF8 = require_utf_8_validate();
        module2.exports.isValidUTF8 = function(buf) {
          return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
        };
      } catch (e6) {
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/receiver.js
var require_receiver = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/receiver.js"(exports2, module2) {
    "use strict";
    var { Writable: Writable2 } = require("stream");
    var PerMessageDeflate = require_permessage_deflate();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      kStatusCode,
      kWebSocket
    } = require_constants();
    var { concat, toArrayBuffer, unmask } = require_buffer_util();
    var { isValidStatusCode, isValidUTF8 } = require_validation();
    var FastBuffer = Buffer[Symbol.species];
    var GET_INFO = 0;
    var GET_PAYLOAD_LENGTH_16 = 1;
    var GET_PAYLOAD_LENGTH_64 = 2;
    var GET_MASK = 3;
    var GET_DATA = 4;
    var INFLATING = 5;
    var DEFER_EVENT = 6;
    var Receiver3 = class extends Writable2 {
      /**
       * Creates a Receiver instance.
       *
       * @param {Object} [options] Options object
       * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
       *     multiple times in the same tick
       * @param {String} [options.binaryType=nodebuffer] The type for binary data
       * @param {Object} [options.extensions] An object containing the negotiated
       *     extensions
       * @param {Boolean} [options.isServer=false] Specifies whether to operate in
       *     client or server mode
       * @param {Number} [options.maxPayload=0] The maximum allowed message length
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       */
      constructor(options = {}) {
        super();
        this._allowSynchronousEvents = options.allowSynchronousEvents !== void 0 ? options.allowSynchronousEvents : true;
        this._binaryType = options.binaryType || BINARY_TYPES[0];
        this._extensions = options.extensions || {};
        this._isServer = !!options.isServer;
        this._maxPayload = options.maxPayload | 0;
        this._skipUTF8Validation = !!options.skipUTF8Validation;
        this[kWebSocket] = void 0;
        this._bufferedBytes = 0;
        this._buffers = [];
        this._compressed = false;
        this._payloadLength = 0;
        this._mask = void 0;
        this._fragmented = 0;
        this._masked = false;
        this._fin = false;
        this._opcode = 0;
        this._totalPayloadLength = 0;
        this._messageLength = 0;
        this._fragments = [];
        this._errored = false;
        this._loop = false;
        this._state = GET_INFO;
      }
      /**
       * Implements `Writable.prototype._write()`.
       *
       * @param {Buffer} chunk The chunk of data to write
       * @param {String} encoding The character encoding of `chunk`
       * @param {Function} cb Callback
       * @private
       */
      _write(chunk, encoding, cb) {
        if (this._opcode === 8 && this._state == GET_INFO) return cb();
        this._bufferedBytes += chunk.length;
        this._buffers.push(chunk);
        this.startLoop(cb);
      }
      /**
       * Consumes `n` bytes from the buffered data.
       *
       * @param {Number} n The number of bytes to consume
       * @return {Buffer} The consumed bytes
       * @private
       */
      consume(n7) {
        this._bufferedBytes -= n7;
        if (n7 === this._buffers[0].length) return this._buffers.shift();
        if (n7 < this._buffers[0].length) {
          const buf = this._buffers[0];
          this._buffers[0] = new FastBuffer(
            buf.buffer,
            buf.byteOffset + n7,
            buf.length - n7
          );
          return new FastBuffer(buf.buffer, buf.byteOffset, n7);
        }
        const dst = Buffer.allocUnsafe(n7);
        do {
          const buf = this._buffers[0];
          const offset = dst.length - n7;
          if (n7 >= buf.length) {
            dst.set(this._buffers.shift(), offset);
          } else {
            dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n7), offset);
            this._buffers[0] = new FastBuffer(
              buf.buffer,
              buf.byteOffset + n7,
              buf.length - n7
            );
          }
          n7 -= buf.length;
        } while (n7 > 0);
        return dst;
      }
      /**
       * Starts the parsing loop.
       *
       * @param {Function} cb Callback
       * @private
       */
      startLoop(cb) {
        this._loop = true;
        do {
          switch (this._state) {
            case GET_INFO:
              this.getInfo(cb);
              break;
            case GET_PAYLOAD_LENGTH_16:
              this.getPayloadLength16(cb);
              break;
            case GET_PAYLOAD_LENGTH_64:
              this.getPayloadLength64(cb);
              break;
            case GET_MASK:
              this.getMask();
              break;
            case GET_DATA:
              this.getData(cb);
              break;
            case INFLATING:
            case DEFER_EVENT:
              this._loop = false;
              return;
          }
        } while (this._loop);
        if (!this._errored) cb();
      }
      /**
       * Reads the first two bytes of a frame.
       *
       * @param {Function} cb Callback
       * @private
       */
      getInfo(cb) {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        const buf = this.consume(2);
        if ((buf[0] & 48) !== 0) {
          const error2 = this.createError(
            RangeError,
            "RSV2 and RSV3 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_2_3"
          );
          cb(error2);
          return;
        }
        const compressed = (buf[0] & 64) === 64;
        if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
          const error2 = this.createError(
            RangeError,
            "RSV1 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_1"
          );
          cb(error2);
          return;
        }
        this._fin = (buf[0] & 128) === 128;
        this._opcode = buf[0] & 15;
        this._payloadLength = buf[1] & 127;
        if (this._opcode === 0) {
          if (compressed) {
            const error2 = this.createError(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
            cb(error2);
            return;
          }
          if (!this._fragmented) {
            const error2 = this.createError(
              RangeError,
              "invalid opcode 0",
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
            cb(error2);
            return;
          }
          this._opcode = this._fragmented;
        } else if (this._opcode === 1 || this._opcode === 2) {
          if (this._fragmented) {
            const error2 = this.createError(
              RangeError,
              `invalid opcode ${this._opcode}`,
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
            cb(error2);
            return;
          }
          this._compressed = compressed;
        } else if (this._opcode > 7 && this._opcode < 11) {
          if (!this._fin) {
            const error2 = this.createError(
              RangeError,
              "FIN must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_FIN"
            );
            cb(error2);
            return;
          }
          if (compressed) {
            const error2 = this.createError(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
            cb(error2);
            return;
          }
          if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
            const error2 = this.createError(
              RangeError,
              `invalid payload length ${this._payloadLength}`,
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
            cb(error2);
            return;
          }
        } else {
          const error2 = this.createError(
            RangeError,
            `invalid opcode ${this._opcode}`,
            true,
            1002,
            "WS_ERR_INVALID_OPCODE"
          );
          cb(error2);
          return;
        }
        if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
        this._masked = (buf[1] & 128) === 128;
        if (this._isServer) {
          if (!this._masked) {
            const error2 = this.createError(
              RangeError,
              "MASK must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_MASK"
            );
            cb(error2);
            return;
          }
        } else if (this._masked) {
          const error2 = this.createError(
            RangeError,
            "MASK must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_MASK"
          );
          cb(error2);
          return;
        }
        if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
        else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
        else this.haveLength(cb);
      }
      /**
       * Gets extended payload length (7+16).
       *
       * @param {Function} cb Callback
       * @private
       */
      getPayloadLength16(cb) {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        this._payloadLength = this.consume(2).readUInt16BE(0);
        this.haveLength(cb);
      }
      /**
       * Gets extended payload length (7+64).
       *
       * @param {Function} cb Callback
       * @private
       */
      getPayloadLength64(cb) {
        if (this._bufferedBytes < 8) {
          this._loop = false;
          return;
        }
        const buf = this.consume(8);
        const num = buf.readUInt32BE(0);
        if (num > Math.pow(2, 53 - 32) - 1) {
          const error2 = this.createError(
            RangeError,
            "Unsupported WebSocket frame: payload length > 2^53 - 1",
            false,
            1009,
            "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
          );
          cb(error2);
          return;
        }
        this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
        this.haveLength(cb);
      }
      /**
       * Payload length has been read.
       *
       * @param {Function} cb Callback
       * @private
       */
      haveLength(cb) {
        if (this._payloadLength && this._opcode < 8) {
          this._totalPayloadLength += this._payloadLength;
          if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
            const error2 = this.createError(
              RangeError,
              "Max payload size exceeded",
              false,
              1009,
              "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
            );
            cb(error2);
            return;
          }
        }
        if (this._masked) this._state = GET_MASK;
        else this._state = GET_DATA;
      }
      /**
       * Reads mask bytes.
       *
       * @private
       */
      getMask() {
        if (this._bufferedBytes < 4) {
          this._loop = false;
          return;
        }
        this._mask = this.consume(4);
        this._state = GET_DATA;
      }
      /**
       * Reads data bytes.
       *
       * @param {Function} cb Callback
       * @private
       */
      getData(cb) {
        let data = EMPTY_BUFFER;
        if (this._payloadLength) {
          if (this._bufferedBytes < this._payloadLength) {
            this._loop = false;
            return;
          }
          data = this.consume(this._payloadLength);
          if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
            unmask(data, this._mask);
          }
        }
        if (this._opcode > 7) {
          this.controlMessage(data, cb);
          return;
        }
        if (this._compressed) {
          this._state = INFLATING;
          this.decompress(data, cb);
          return;
        }
        if (data.length) {
          this._messageLength = this._totalPayloadLength;
          this._fragments.push(data);
        }
        this.dataMessage(cb);
      }
      /**
       * Decompresses data.
       *
       * @param {Buffer} data Compressed data
       * @param {Function} cb Callback
       * @private
       */
      decompress(data, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        perMessageDeflate.decompress(data, this._fin, (err3, buf) => {
          if (err3) return cb(err3);
          if (buf.length) {
            this._messageLength += buf.length;
            if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
              const error2 = this.createError(
                RangeError,
                "Max payload size exceeded",
                false,
                1009,
                "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
              );
              cb(error2);
              return;
            }
            this._fragments.push(buf);
          }
          this.dataMessage(cb);
          if (this._state === GET_INFO) this.startLoop(cb);
        });
      }
      /**
       * Handles a data message.
       *
       * @param {Function} cb Callback
       * @private
       */
      dataMessage(cb) {
        if (!this._fin) {
          this._state = GET_INFO;
          return;
        }
        const messageLength = this._messageLength;
        const fragments = this._fragments;
        this._totalPayloadLength = 0;
        this._messageLength = 0;
        this._fragmented = 0;
        this._fragments = [];
        if (this._opcode === 2) {
          let data;
          if (this._binaryType === "nodebuffer") {
            data = concat(fragments, messageLength);
          } else if (this._binaryType === "arraybuffer") {
            data = toArrayBuffer(concat(fragments, messageLength));
          } else if (this._binaryType === "blob") {
            data = new Blob(fragments);
          } else {
            data = fragments;
          }
          if (this._allowSynchronousEvents) {
            this.emit("message", data, true);
            this._state = GET_INFO;
          } else {
            this._state = DEFER_EVENT;
            setImmediate(() => {
              this.emit("message", data, true);
              this._state = GET_INFO;
              this.startLoop(cb);
            });
          }
        } else {
          const buf = concat(fragments, messageLength);
          if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
            const error2 = this.createError(
              Error,
              "invalid UTF-8 sequence",
              true,
              1007,
              "WS_ERR_INVALID_UTF8"
            );
            cb(error2);
            return;
          }
          if (this._state === INFLATING || this._allowSynchronousEvents) {
            this.emit("message", buf, false);
            this._state = GET_INFO;
          } else {
            this._state = DEFER_EVENT;
            setImmediate(() => {
              this.emit("message", buf, false);
              this._state = GET_INFO;
              this.startLoop(cb);
            });
          }
        }
      }
      /**
       * Handles a control message.
       *
       * @param {Buffer} data Data to handle
       * @return {(Error|RangeError|undefined)} A possible error
       * @private
       */
      controlMessage(data, cb) {
        if (this._opcode === 8) {
          if (data.length === 0) {
            this._loop = false;
            this.emit("conclude", 1005, EMPTY_BUFFER);
            this.end();
          } else {
            const code = data.readUInt16BE(0);
            if (!isValidStatusCode(code)) {
              const error2 = this.createError(
                RangeError,
                `invalid status code ${code}`,
                true,
                1002,
                "WS_ERR_INVALID_CLOSE_CODE"
              );
              cb(error2);
              return;
            }
            const buf = new FastBuffer(
              data.buffer,
              data.byteOffset + 2,
              data.length - 2
            );
            if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
              const error2 = this.createError(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
              cb(error2);
              return;
            }
            this._loop = false;
            this.emit("conclude", code, buf);
            this.end();
          }
          this._state = GET_INFO;
          return;
        }
        if (this._allowSynchronousEvents) {
          this.emit(this._opcode === 9 ? "ping" : "pong", data);
          this._state = GET_INFO;
        } else {
          this._state = DEFER_EVENT;
          setImmediate(() => {
            this.emit(this._opcode === 9 ? "ping" : "pong", data);
            this._state = GET_INFO;
            this.startLoop(cb);
          });
        }
      }
      /**
       * Builds an error object.
       *
       * @param {function(new:Error|RangeError)} ErrorCtor The error constructor
       * @param {String} message The error message
       * @param {Boolean} prefix Specifies whether or not to add a default prefix to
       *     `message`
       * @param {Number} statusCode The status code
       * @param {String} errorCode The exposed error code
       * @return {(Error|RangeError)} The error
       * @private
       */
      createError(ErrorCtor, message, prefix2, statusCode, errorCode) {
        this._loop = false;
        this._errored = true;
        const err3 = new ErrorCtor(
          prefix2 ? `Invalid WebSocket frame: ${message}` : message
        );
        Error.captureStackTrace(err3, this.createError);
        err3.code = errorCode;
        err3[kStatusCode] = statusCode;
        return err3;
      }
    };
    module2.exports = Receiver3;
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/sender.js
var require_sender = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/sender.js"(exports2, module2) {
    "use strict";
    var { Duplex } = require("stream");
    var { randomFillSync } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate();
    var { EMPTY_BUFFER, kWebSocket, NOOP } = require_constants();
    var { isBlob: isBlob3, isValidStatusCode } = require_validation();
    var { mask: applyMask, toBuffer } = require_buffer_util();
    var kByteLength = Symbol("kByteLength");
    var maskBuffer = Buffer.alloc(4);
    var RANDOM_POOL_SIZE = 8 * 1024;
    var randomPool;
    var randomPoolPointer = RANDOM_POOL_SIZE;
    var DEFAULT = 0;
    var DEFLATING = 1;
    var GET_BLOB_DATA = 2;
    var Sender3 = class _Sender {
      /**
       * Creates a Sender instance.
       *
       * @param {Duplex} socket The connection socket
       * @param {Object} [extensions] An object containing the negotiated extensions
       * @param {Function} [generateMask] The function used to generate the masking
       *     key
       */
      constructor(socket, extensions, generateMask) {
        this._extensions = extensions || {};
        if (generateMask) {
          this._generateMask = generateMask;
          this._maskBuffer = Buffer.alloc(4);
        }
        this._socket = socket;
        this._firstFragment = true;
        this._compress = false;
        this._bufferedBytes = 0;
        this._queue = [];
        this._state = DEFAULT;
        this.onerror = NOOP;
        this[kWebSocket] = void 0;
      }
      /**
       * Frames a piece of data according to the HyBi WebSocket protocol.
       *
       * @param {(Buffer|String)} data The data to frame
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @return {(Buffer|String)[]} The framed data
       * @public
       */
      static frame(data, options) {
        let mask;
        let merge2 = false;
        let offset = 2;
        let skipMasking = false;
        if (options.mask) {
          mask = options.maskBuffer || maskBuffer;
          if (options.generateMask) {
            options.generateMask(mask);
          } else {
            if (randomPoolPointer === RANDOM_POOL_SIZE) {
              if (randomPool === void 0) {
                randomPool = Buffer.alloc(RANDOM_POOL_SIZE);
              }
              randomFillSync(randomPool, 0, RANDOM_POOL_SIZE);
              randomPoolPointer = 0;
            }
            mask[0] = randomPool[randomPoolPointer++];
            mask[1] = randomPool[randomPoolPointer++];
            mask[2] = randomPool[randomPoolPointer++];
            mask[3] = randomPool[randomPoolPointer++];
          }
          skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
          offset = 6;
        }
        let dataLength;
        if (typeof data === "string") {
          if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) {
            dataLength = options[kByteLength];
          } else {
            data = Buffer.from(data);
            dataLength = data.length;
          }
        } else {
          dataLength = data.length;
          merge2 = options.mask && options.readOnly && !skipMasking;
        }
        let payloadLength = dataLength;
        if (dataLength >= 65536) {
          offset += 8;
          payloadLength = 127;
        } else if (dataLength > 125) {
          offset += 2;
          payloadLength = 126;
        }
        const target = Buffer.allocUnsafe(merge2 ? dataLength + offset : offset);
        target[0] = options.fin ? options.opcode | 128 : options.opcode;
        if (options.rsv1) target[0] |= 64;
        target[1] = payloadLength;
        if (payloadLength === 126) {
          target.writeUInt16BE(dataLength, 2);
        } else if (payloadLength === 127) {
          target[2] = target[3] = 0;
          target.writeUIntBE(dataLength, 4, 6);
        }
        if (!options.mask) return [target, data];
        target[1] |= 128;
        target[offset - 4] = mask[0];
        target[offset - 3] = mask[1];
        target[offset - 2] = mask[2];
        target[offset - 1] = mask[3];
        if (skipMasking) return [target, data];
        if (merge2) {
          applyMask(data, mask, target, offset, dataLength);
          return [target];
        }
        applyMask(data, mask, data, 0, dataLength);
        return [target, data];
      }
      /**
       * Sends a close message to the other peer.
       *
       * @param {Number} [code] The status code component of the body
       * @param {(String|Buffer)} [data] The message component of the body
       * @param {Boolean} [mask=false] Specifies whether or not to mask the message
       * @param {Function} [cb] Callback
       * @public
       */
      close(code, data, mask, cb) {
        let buf;
        if (code === void 0) {
          buf = EMPTY_BUFFER;
        } else if (typeof code !== "number" || !isValidStatusCode(code)) {
          throw new TypeError("First argument must be a valid error code number");
        } else if (data === void 0 || !data.length) {
          buf = Buffer.allocUnsafe(2);
          buf.writeUInt16BE(code, 0);
        } else {
          const length = Buffer.byteLength(data);
          if (length > 123) {
            throw new RangeError("The message must not be greater than 123 bytes");
          }
          buf = Buffer.allocUnsafe(2 + length);
          buf.writeUInt16BE(code, 0);
          if (typeof data === "string") {
            buf.write(data, 2);
          } else {
            buf.set(data, 2);
          }
        }
        const options = {
          [kByteLength]: buf.length,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 8,
          readOnly: false,
          rsv1: false
        };
        if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, buf, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(buf, options), cb);
        }
      }
      /**
       * Sends a ping message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      ping(data, mask, cb) {
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else if (isBlob3(data)) {
          byteLength = data.size;
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (byteLength > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        const options = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 9,
          readOnly,
          rsv1: false
        };
        if (isBlob3(data)) {
          if (this._state !== DEFAULT) {
            this.enqueue([this.getBlobData, data, false, options, cb]);
          } else {
            this.getBlobData(data, false, options, cb);
          }
        } else if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, data, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(data, options), cb);
        }
      }
      /**
       * Sends a pong message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      pong(data, mask, cb) {
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else if (isBlob3(data)) {
          byteLength = data.size;
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (byteLength > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        const options = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 10,
          readOnly,
          rsv1: false
        };
        if (isBlob3(data)) {
          if (this._state !== DEFAULT) {
            this.enqueue([this.getBlobData, data, false, options, cb]);
          } else {
            this.getBlobData(data, false, options, cb);
          }
        } else if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, data, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(data, options), cb);
        }
      }
      /**
       * Sends a data message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Object} options Options object
       * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
       *     or text
       * @param {Boolean} [options.compress=false] Specifies whether or not to
       *     compress `data`
       * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Function} [cb] Callback
       * @public
       */
      send(data, options, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        let opcode = options.binary ? 2 : 1;
        let rsv1 = options.compress;
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else if (isBlob3(data)) {
          byteLength = data.size;
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (this._firstFragment) {
          this._firstFragment = false;
          if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
            rsv1 = byteLength >= perMessageDeflate._threshold;
          }
          this._compress = rsv1;
        } else {
          rsv1 = false;
          opcode = 0;
        }
        if (options.fin) this._firstFragment = true;
        const opts = {
          [kByteLength]: byteLength,
          fin: options.fin,
          generateMask: this._generateMask,
          mask: options.mask,
          maskBuffer: this._maskBuffer,
          opcode,
          readOnly,
          rsv1
        };
        if (isBlob3(data)) {
          if (this._state !== DEFAULT) {
            this.enqueue([this.getBlobData, data, this._compress, opts, cb]);
          } else {
            this.getBlobData(data, this._compress, opts, cb);
          }
        } else if (this._state !== DEFAULT) {
          this.enqueue([this.dispatch, data, this._compress, opts, cb]);
        } else {
          this.dispatch(data, this._compress, opts, cb);
        }
      }
      /**
       * Gets the contents of a blob as binary data.
       *
       * @param {Blob} blob The blob
       * @param {Boolean} [compress=false] Specifies whether or not to compress
       *     the data
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @param {Function} [cb] Callback
       * @private
       */
      getBlobData(blob2, compress2, options, cb) {
        this._bufferedBytes += options[kByteLength];
        this._state = GET_BLOB_DATA;
        blob2.arrayBuffer().then((arrayBuffer) => {
          if (this._socket.destroyed) {
            const err3 = new Error(
              "The socket was closed while the blob was being read"
            );
            process.nextTick(callCallbacks, this, err3, cb);
            return;
          }
          this._bufferedBytes -= options[kByteLength];
          const data = toBuffer(arrayBuffer);
          if (!compress2) {
            this._state = DEFAULT;
            this.sendFrame(_Sender.frame(data, options), cb);
            this.dequeue();
          } else {
            this.dispatch(data, compress2, options, cb);
          }
        }).catch((err3) => {
          process.nextTick(onError, this, err3, cb);
        });
      }
      /**
       * Dispatches a message.
       *
       * @param {(Buffer|String)} data The message to send
       * @param {Boolean} [compress=false] Specifies whether or not to compress
       *     `data`
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @param {Function} [cb] Callback
       * @private
       */
      dispatch(data, compress2, options, cb) {
        if (!compress2) {
          this.sendFrame(_Sender.frame(data, options), cb);
          return;
        }
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        this._bufferedBytes += options[kByteLength];
        this._state = DEFLATING;
        perMessageDeflate.compress(data, options.fin, (_7, buf) => {
          if (this._socket.destroyed) {
            const err3 = new Error(
              "The socket was closed while data was being compressed"
            );
            callCallbacks(this, err3, cb);
            return;
          }
          this._bufferedBytes -= options[kByteLength];
          this._state = DEFAULT;
          options.readOnly = false;
          this.sendFrame(_Sender.frame(buf, options), cb);
          this.dequeue();
        });
      }
      /**
       * Executes queued send operations.
       *
       * @private
       */
      dequeue() {
        while (this._state === DEFAULT && this._queue.length) {
          const params = this._queue.shift();
          this._bufferedBytes -= params[3][kByteLength];
          Reflect.apply(params[0], this, params.slice(1));
        }
      }
      /**
       * Enqueues a send operation.
       *
       * @param {Array} params Send operation parameters.
       * @private
       */
      enqueue(params) {
        this._bufferedBytes += params[3][kByteLength];
        this._queue.push(params);
      }
      /**
       * Sends a frame.
       *
       * @param {(Buffer | String)[]} list The frame to send
       * @param {Function} [cb] Callback
       * @private
       */
      sendFrame(list, cb) {
        if (list.length === 2) {
          this._socket.cork();
          this._socket.write(list[0]);
          this._socket.write(list[1], cb);
          this._socket.uncork();
        } else {
          this._socket.write(list[0], cb);
        }
      }
    };
    module2.exports = Sender3;
    function callCallbacks(sender, err3, cb) {
      if (typeof cb === "function") cb(err3);
      for (let i8 = 0; i8 < sender._queue.length; i8++) {
        const params = sender._queue[i8];
        const callback = params[params.length - 1];
        if (typeof callback === "function") callback(err3);
      }
    }
    function onError(sender, err3, cb) {
      callCallbacks(sender, err3, cb);
      sender.onerror(err3);
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/event-target.js
var require_event_target = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/event-target.js"(exports2, module2) {
    "use strict";
    var { kForOnEventAttribute, kListener } = require_constants();
    var kCode = Symbol("kCode");
    var kData = Symbol("kData");
    var kError = Symbol("kError");
    var kMessage = Symbol("kMessage");
    var kReason = Symbol("kReason");
    var kTarget = Symbol("kTarget");
    var kType = Symbol("kType");
    var kWasClean = Symbol("kWasClean");
    var Event = class {
      /**
       * Create a new `Event`.
       *
       * @param {String} type The name of the event
       * @throws {TypeError} If the `type` argument is not specified
       */
      constructor(type) {
        this[kTarget] = null;
        this[kType] = type;
      }
      /**
       * @type {*}
       */
      get target() {
        return this[kTarget];
      }
      /**
       * @type {String}
       */
      get type() {
        return this[kType];
      }
    };
    Object.defineProperty(Event.prototype, "target", { enumerable: true });
    Object.defineProperty(Event.prototype, "type", { enumerable: true });
    var CloseEvent = class extends Event {
      /**
       * Create a new `CloseEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {Number} [options.code=0] The status code explaining why the
       *     connection was closed
       * @param {String} [options.reason=''] A human-readable string explaining why
       *     the connection was closed
       * @param {Boolean} [options.wasClean=false] Indicates whether or not the
       *     connection was cleanly closed
       */
      constructor(type, options = {}) {
        super(type);
        this[kCode] = options.code === void 0 ? 0 : options.code;
        this[kReason] = options.reason === void 0 ? "" : options.reason;
        this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean;
      }
      /**
       * @type {Number}
       */
      get code() {
        return this[kCode];
      }
      /**
       * @type {String}
       */
      get reason() {
        return this[kReason];
      }
      /**
       * @type {Boolean}
       */
      get wasClean() {
        return this[kWasClean];
      }
    };
    Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
    var ErrorEvent = class extends Event {
      /**
       * Create a new `ErrorEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {*} [options.error=null] The error that generated this event
       * @param {String} [options.message=''] The error message
       */
      constructor(type, options = {}) {
        super(type);
        this[kError] = options.error === void 0 ? null : options.error;
        this[kMessage] = options.message === void 0 ? "" : options.message;
      }
      /**
       * @type {*}
       */
      get error() {
        return this[kError];
      }
      /**
       * @type {String}
       */
      get message() {
        return this[kMessage];
      }
    };
    Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
    Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
    var MessageEvent = class extends Event {
      /**
       * Create a new `MessageEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {*} [options.data=null] The message content
       */
      constructor(type, options = {}) {
        super(type);
        this[kData] = options.data === void 0 ? null : options.data;
      }
      /**
       * @type {*}
       */
      get data() {
        return this[kData];
      }
    };
    Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
    var EventTarget = {
      /**
       * Register an event listener.
       *
       * @param {String} type A string representing the event type to listen for
       * @param {(Function|Object)} handler The listener to add
       * @param {Object} [options] An options object specifies characteristics about
       *     the event listener
       * @param {Boolean} [options.once=false] A `Boolean` indicating that the
       *     listener should be invoked at most once after being added. If `true`,
       *     the listener would be automatically removed when invoked.
       * @public
       */
      addEventListener(type, handler, options = {}) {
        for (const listener of this.listeners(type)) {
          if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
            return;
          }
        }
        let wrapper;
        if (type === "message") {
          wrapper = function onMessage(data, isBinary2) {
            const event = new MessageEvent("message", {
              data: isBinary2 ? data : data.toString()
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "close") {
          wrapper = function onClose(code, message) {
            const event = new CloseEvent("close", {
              code,
              reason: message.toString(),
              wasClean: this._closeFrameReceived && this._closeFrameSent
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "error") {
          wrapper = function onError(error2) {
            const event = new ErrorEvent("error", {
              error: error2,
              message: error2.message
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "open") {
          wrapper = function onOpen() {
            const event = new Event("open");
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else {
          return;
        }
        wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
        wrapper[kListener] = handler;
        if (options.once) {
          this.once(type, wrapper);
        } else {
          this.on(type, wrapper);
        }
      },
      /**
       * Remove an event listener.
       *
       * @param {String} type A string representing the event type to remove
       * @param {(Function|Object)} handler The listener to remove
       * @public
       */
      removeEventListener(type, handler) {
        for (const listener of this.listeners(type)) {
          if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
            this.removeListener(type, listener);
            break;
          }
        }
      }
    };
    module2.exports = {
      CloseEvent,
      ErrorEvent,
      Event,
      EventTarget,
      MessageEvent
    };
    function callListener(listener, thisArg, event) {
      if (typeof listener === "object" && listener.handleEvent) {
        listener.handleEvent.call(listener, event);
      } else {
        listener.call(thisArg, event);
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/extension.js
var require_extension = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/extension.js"(exports2, module2) {
    "use strict";
    var { tokenChars } = require_validation();
    function push(dest, name3, elem) {
      if (dest[name3] === void 0) dest[name3] = [elem];
      else dest[name3].push(elem);
    }
    function parse6(header) {
      const offers = /* @__PURE__ */ Object.create(null);
      let params = /* @__PURE__ */ Object.create(null);
      let mustUnescape = false;
      let isEscaping = false;
      let inQuotes = false;
      let extensionName;
      let paramName;
      let start2 = -1;
      let code = -1;
      let end = -1;
      let i8 = 0;
      for (; i8 < header.length; i8++) {
        code = header.charCodeAt(i8);
        if (extensionName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start2 === -1) start2 = i8;
          } else if (i8 !== 0 && (code === 32 || code === 9)) {
            if (end === -1 && start2 !== -1) end = i8;
          } else if (code === 59 || code === 44) {
            if (start2 === -1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (end === -1) end = i8;
            const name3 = header.slice(start2, end);
            if (code === 44) {
              push(offers, name3, params);
              params = /* @__PURE__ */ Object.create(null);
            } else {
              extensionName = name3;
            }
            start2 = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
        } else if (paramName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start2 === -1) start2 = i8;
          } else if (code === 32 || code === 9) {
            if (end === -1 && start2 !== -1) end = i8;
          } else if (code === 59 || code === 44) {
            if (start2 === -1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (end === -1) end = i8;
            push(params, header.slice(start2, end), true);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            start2 = end = -1;
          } else if (code === 61 && start2 !== -1 && end === -1) {
            paramName = header.slice(start2, i8);
            start2 = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
        } else {
          if (isEscaping) {
            if (tokenChars[code] !== 1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (start2 === -1) start2 = i8;
            else if (!mustUnescape) mustUnescape = true;
            isEscaping = false;
          } else if (inQuotes) {
            if (tokenChars[code] === 1) {
              if (start2 === -1) start2 = i8;
            } else if (code === 34 && start2 !== -1) {
              inQuotes = false;
              end = i8;
            } else if (code === 92) {
              isEscaping = true;
            } else {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
          } else if (code === 34 && header.charCodeAt(i8 - 1) === 61) {
            inQuotes = true;
          } else if (end === -1 && tokenChars[code] === 1) {
            if (start2 === -1) start2 = i8;
          } else if (start2 !== -1 && (code === 32 || code === 9)) {
            if (end === -1) end = i8;
          } else if (code === 59 || code === 44) {
            if (start2 === -1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (end === -1) end = i8;
            let value = header.slice(start2, end);
            if (mustUnescape) {
              value = value.replace(/\\/g, "");
              mustUnescape = false;
            }
            push(params, paramName, value);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            paramName = void 0;
            start2 = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
        }
      }
      if (start2 === -1 || inQuotes || code === 32 || code === 9) {
        throw new SyntaxError("Unexpected end of input");
      }
      if (end === -1) end = i8;
      const token = header.slice(start2, end);
      if (extensionName === void 0) {
        push(offers, token, params);
      } else {
        if (paramName === void 0) {
          push(params, token, true);
        } else if (mustUnescape) {
          push(params, paramName, token.replace(/\\/g, ""));
        } else {
          push(params, paramName, token);
        }
        push(offers, extensionName, params);
      }
      return offers;
    }
    function format2(extensions) {
      return Object.keys(extensions).map((extension) => {
        let configurations = extensions[extension];
        if (!Array.isArray(configurations)) configurations = [configurations];
        return configurations.map((params) => {
          return [extension].concat(
            Object.keys(params).map((k9) => {
              let values2 = params[k9];
              if (!Array.isArray(values2)) values2 = [values2];
              return values2.map((v11) => v11 === true ? k9 : `${k9}=${v11}`).join("; ");
            })
          ).join("; ");
        }).join(", ");
      }).join(", ");
    }
    module2.exports = { format: format2, parse: parse6 };
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/websocket.js
var require_websocket = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/websocket.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events");
    var https3 = require("https");
    var http4 = require("http");
    var net2 = require("net");
    var tls2 = require("tls");
    var { randomBytes, createHash: createHash4 } = require("crypto");
    var { Duplex, Readable: Readable6 } = require("stream");
    var { URL: URL2 } = require("url");
    var PerMessageDeflate = require_permessage_deflate();
    var Receiver3 = require_receiver();
    var Sender3 = require_sender();
    var { isBlob: isBlob3 } = require_validation();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      GUID,
      kForOnEventAttribute,
      kListener,
      kStatusCode,
      kWebSocket,
      NOOP
    } = require_constants();
    var {
      EventTarget: { addEventListener: addEventListener2, removeEventListener }
    } = require_event_target();
    var { format: format2, parse: parse6 } = require_extension();
    var { toBuffer } = require_buffer_util();
    var closeTimeout = 30 * 1e3;
    var kAborted = Symbol("kAborted");
    var protocolVersions = [8, 13];
    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
    var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
    var WebSocket4 = class _WebSocket extends EventEmitter {
      /**
       * Create a new `WebSocket`.
       *
       * @param {(String|URL)} address The URL to which to connect
       * @param {(String|String[])} [protocols] The subprotocols
       * @param {Object} [options] Connection options
       */
      constructor(address, protocols, options) {
        super();
        this._binaryType = BINARY_TYPES[0];
        this._closeCode = 1006;
        this._closeFrameReceived = false;
        this._closeFrameSent = false;
        this._closeMessage = EMPTY_BUFFER;
        this._closeTimer = null;
        this._errorEmitted = false;
        this._extensions = {};
        this._paused = false;
        this._protocol = "";
        this._readyState = _WebSocket.CONNECTING;
        this._receiver = null;
        this._sender = null;
        this._socket = null;
        if (address !== null) {
          this._bufferedAmount = 0;
          this._isServer = false;
          this._redirects = 0;
          if (protocols === void 0) {
            protocols = [];
          } else if (!Array.isArray(protocols)) {
            if (typeof protocols === "object" && protocols !== null) {
              options = protocols;
              protocols = [];
            } else {
              protocols = [protocols];
            }
          }
          initAsClient(this, address, protocols, options);
        } else {
          this._autoPong = options.autoPong;
          this._isServer = true;
        }
      }
      /**
       * For historical reasons, the custom "nodebuffer" type is used by the default
       * instead of "blob".
       *
       * @type {String}
       */
      get binaryType() {
        return this._binaryType;
      }
      set binaryType(type) {
        if (!BINARY_TYPES.includes(type)) return;
        this._binaryType = type;
        if (this._receiver) this._receiver._binaryType = type;
      }
      /**
       * @type {Number}
       */
      get bufferedAmount() {
        if (!this._socket) return this._bufferedAmount;
        return this._socket._writableState.length + this._sender._bufferedBytes;
      }
      /**
       * @type {String}
       */
      get extensions() {
        return Object.keys(this._extensions).join();
      }
      /**
       * @type {Boolean}
       */
      get isPaused() {
        return this._paused;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onclose() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onerror() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onopen() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onmessage() {
        return null;
      }
      /**
       * @type {String}
       */
      get protocol() {
        return this._protocol;
      }
      /**
       * @type {Number}
       */
      get readyState() {
        return this._readyState;
      }
      /**
       * @type {String}
       */
      get url() {
        return this._url;
      }
      /**
       * Set up the socket and the internal resources.
       *
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Object} options Options object
       * @param {Boolean} [options.allowSynchronousEvents=false] Specifies whether
       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
       *     multiple times in the same tick
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Number} [options.maxPayload=0] The maximum allowed message size
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       * @private
       */
      setSocket(socket, head, options) {
        const receiver = new Receiver3({
          allowSynchronousEvents: options.allowSynchronousEvents,
          binaryType: this.binaryType,
          extensions: this._extensions,
          isServer: this._isServer,
          maxPayload: options.maxPayload,
          skipUTF8Validation: options.skipUTF8Validation
        });
        const sender = new Sender3(socket, this._extensions, options.generateMask);
        this._receiver = receiver;
        this._sender = sender;
        this._socket = socket;
        receiver[kWebSocket] = this;
        sender[kWebSocket] = this;
        socket[kWebSocket] = this;
        receiver.on("conclude", receiverOnConclude);
        receiver.on("drain", receiverOnDrain);
        receiver.on("error", receiverOnError);
        receiver.on("message", receiverOnMessage);
        receiver.on("ping", receiverOnPing);
        receiver.on("pong", receiverOnPong);
        sender.onerror = senderOnError;
        if (socket.setTimeout) socket.setTimeout(0);
        if (socket.setNoDelay) socket.setNoDelay();
        if (head.length > 0) socket.unshift(head);
        socket.on("close", socketOnClose);
        socket.on("data", socketOnData);
        socket.on("end", socketOnEnd);
        socket.on("error", socketOnError);
        this._readyState = _WebSocket.OPEN;
        this.emit("open");
      }
      /**
       * Emit the `'close'` event.
       *
       * @private
       */
      emitClose() {
        if (!this._socket) {
          this._readyState = _WebSocket.CLOSED;
          this.emit("close", this._closeCode, this._closeMessage);
          return;
        }
        if (this._extensions[PerMessageDeflate.extensionName]) {
          this._extensions[PerMessageDeflate.extensionName].cleanup();
        }
        this._receiver.removeAllListeners();
        this._readyState = _WebSocket.CLOSED;
        this.emit("close", this._closeCode, this._closeMessage);
      }
      /**
       * Start a closing handshake.
       *
       *          +----------+   +-----------+   +----------+
       *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
       *    |     +----------+   +-----------+   +----------+     |
       *          +----------+   +-----------+         |
       * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
       *          +----------+   +-----------+   |
       *    |           |                        |   +---+        |
       *                +------------------------+-->|fin| - - - -
       *    |         +---+                      |   +---+
       *     - - - - -|fin|<---------------------+
       *              +---+
       *
       * @param {Number} [code] Status code explaining why the connection is closing
       * @param {(String|Buffer)} [data] The reason why the connection is
       *     closing
       * @public
       */
      close(code, data) {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          abortHandshake(this, this._req, msg);
          return;
        }
        if (this.readyState === _WebSocket.CLOSING) {
          if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
            this._socket.end();
          }
          return;
        }
        this._readyState = _WebSocket.CLOSING;
        this._sender.close(code, data, !this._isServer, (err3) => {
          if (err3) return;
          this._closeFrameSent = true;
          if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
            this._socket.end();
          }
        });
        setCloseTimer(this);
      }
      /**
       * Pause the socket.
       *
       * @public
       */
      pause() {
        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
          return;
        }
        this._paused = true;
        this._socket.pause();
      }
      /**
       * Send a ping.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the ping is sent
       * @public
       */
      ping(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.ping(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Send a pong.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the pong is sent
       * @public
       */
      pong(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.pong(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Resume the socket.
       *
       * @public
       */
      resume() {
        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
          return;
        }
        this._paused = false;
        if (!this._receiver._writableState.needDrain) this._socket.resume();
      }
      /**
       * Send a data message.
       *
       * @param {*} data The message to send
       * @param {Object} [options] Options object
       * @param {Boolean} [options.binary] Specifies whether `data` is binary or
       *     text
       * @param {Boolean} [options.compress] Specifies whether or not to compress
       *     `data`
       * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when data is written out
       * @public
       */
      send(data, options, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof options === "function") {
          cb = options;
          options = {};
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        const opts = {
          binary: typeof data !== "string",
          mask: !this._isServer,
          compress: true,
          fin: true,
          ...options
        };
        if (!this._extensions[PerMessageDeflate.extensionName]) {
          opts.compress = false;
        }
        this._sender.send(data || EMPTY_BUFFER, opts, cb);
      }
      /**
       * Forcibly close the connection.
       *
       * @public
       */
      terminate() {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          abortHandshake(this, this._req, msg);
          return;
        }
        if (this._socket) {
          this._readyState = _WebSocket.CLOSING;
          this._socket.destroy();
        }
      }
    };
    Object.defineProperty(WebSocket4, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket4.prototype, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket4, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket4.prototype, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket4, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket4.prototype, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket4, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    Object.defineProperty(WebSocket4.prototype, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    [
      "binaryType",
      "bufferedAmount",
      "extensions",
      "isPaused",
      "protocol",
      "readyState",
      "url"
    ].forEach((property) => {
      Object.defineProperty(WebSocket4.prototype, property, { enumerable: true });
    });
    ["open", "error", "close", "message"].forEach((method) => {
      Object.defineProperty(WebSocket4.prototype, `on${method}`, {
        enumerable: true,
        get() {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute]) return listener[kListener];
          }
          return null;
        },
        set(handler) {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute]) {
              this.removeListener(method, listener);
              break;
            }
          }
          if (typeof handler !== "function") return;
          this.addEventListener(method, handler, {
            [kForOnEventAttribute]: true
          });
        }
      });
    });
    WebSocket4.prototype.addEventListener = addEventListener2;
    WebSocket4.prototype.removeEventListener = removeEventListener;
    module2.exports = WebSocket4;
    function initAsClient(websocket, address, protocols, options) {
      const opts = {
        allowSynchronousEvents: true,
        autoPong: true,
        protocolVersion: protocolVersions[1],
        maxPayload: 100 * 1024 * 1024,
        skipUTF8Validation: false,
        perMessageDeflate: true,
        followRedirects: false,
        maxRedirects: 10,
        ...options,
        socketPath: void 0,
        hostname: void 0,
        protocol: void 0,
        timeout: void 0,
        method: "GET",
        host: void 0,
        path: void 0,
        port: void 0
      };
      websocket._autoPong = opts.autoPong;
      if (!protocolVersions.includes(opts.protocolVersion)) {
        throw new RangeError(
          `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
        );
      }
      let parsedUrl;
      if (address instanceof URL2) {
        parsedUrl = address;
      } else {
        try {
          parsedUrl = new URL2(address);
        } catch (e6) {
          throw new SyntaxError(`Invalid URL: ${address}`);
        }
      }
      if (parsedUrl.protocol === "http:") {
        parsedUrl.protocol = "ws:";
      } else if (parsedUrl.protocol === "https:") {
        parsedUrl.protocol = "wss:";
      }
      websocket._url = parsedUrl.href;
      const isSecure = parsedUrl.protocol === "wss:";
      const isIpcUrl = parsedUrl.protocol === "ws+unix:";
      let invalidUrlMessage;
      if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
        invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https:", or "ws+unix:"`;
      } else if (isIpcUrl && !parsedUrl.pathname) {
        invalidUrlMessage = "The URL's pathname is empty";
      } else if (parsedUrl.hash) {
        invalidUrlMessage = "The URL contains a fragment identifier";
      }
      if (invalidUrlMessage) {
        const err3 = new SyntaxError(invalidUrlMessage);
        if (websocket._redirects === 0) {
          throw err3;
        } else {
          emitErrorAndClose(websocket, err3);
          return;
        }
      }
      const defaultPort = isSecure ? 443 : 80;
      const key = randomBytes(16).toString("base64");
      const request2 = isSecure ? https3.request : http4.request;
      const protocolSet = /* @__PURE__ */ new Set();
      let perMessageDeflate;
      opts.createConnection = opts.createConnection || (isSecure ? tlsConnect : netConnect);
      opts.defaultPort = opts.defaultPort || defaultPort;
      opts.port = parsedUrl.port || defaultPort;
      opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
      opts.headers = {
        ...opts.headers,
        "Sec-WebSocket-Version": opts.protocolVersion,
        "Sec-WebSocket-Key": key,
        Connection: "Upgrade",
        Upgrade: "websocket"
      };
      opts.path = parsedUrl.pathname + parsedUrl.search;
      opts.timeout = opts.handshakeTimeout;
      if (opts.perMessageDeflate) {
        perMessageDeflate = new PerMessageDeflate(
          opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
          false,
          opts.maxPayload
        );
        opts.headers["Sec-WebSocket-Extensions"] = format2({
          [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
        });
      }
      if (protocols.length) {
        for (const protocol2 of protocols) {
          if (typeof protocol2 !== "string" || !subprotocolRegex.test(protocol2) || protocolSet.has(protocol2)) {
            throw new SyntaxError(
              "An invalid or duplicated subprotocol was specified"
            );
          }
          protocolSet.add(protocol2);
        }
        opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
      }
      if (opts.origin) {
        if (opts.protocolVersion < 13) {
          opts.headers["Sec-WebSocket-Origin"] = opts.origin;
        } else {
          opts.headers.Origin = opts.origin;
        }
      }
      if (parsedUrl.username || parsedUrl.password) {
        opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
      }
      if (isIpcUrl) {
        const parts2 = opts.path.split(":");
        opts.socketPath = parts2[0];
        opts.path = parts2[1];
      }
      let req;
      if (opts.followRedirects) {
        if (websocket._redirects === 0) {
          websocket._originalIpc = isIpcUrl;
          websocket._originalSecure = isSecure;
          websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
          const headers = options && options.headers;
          options = { ...options, headers: {} };
          if (headers) {
            for (const [key2, value] of Object.entries(headers)) {
              options.headers[key2.toLowerCase()] = value;
            }
          }
        } else if (websocket.listenerCount("redirect") === 0) {
          const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
          if (!isSameHost || websocket._originalSecure && !isSecure) {
            delete opts.headers.authorization;
            delete opts.headers.cookie;
            if (!isSameHost) delete opts.headers.host;
            opts.auth = void 0;
          }
        }
        if (opts.auth && !options.headers.authorization) {
          options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
        }
        req = websocket._req = request2(opts);
        if (websocket._redirects) {
          websocket.emit("redirect", websocket.url, req);
        }
      } else {
        req = websocket._req = request2(opts);
      }
      if (opts.timeout) {
        req.on("timeout", () => {
          abortHandshake(websocket, req, "Opening handshake has timed out");
        });
      }
      req.on("error", (err3) => {
        if (req === null || req[kAborted]) return;
        req = websocket._req = null;
        emitErrorAndClose(websocket, err3);
      });
      req.on("response", (res) => {
        const location2 = res.headers.location;
        const statusCode = res.statusCode;
        if (location2 && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
          if (++websocket._redirects > opts.maxRedirects) {
            abortHandshake(websocket, req, "Maximum redirects exceeded");
            return;
          }
          req.abort();
          let addr2;
          try {
            addr2 = new URL2(location2, address);
          } catch (e6) {
            const err3 = new SyntaxError(`Invalid URL: ${location2}`);
            emitErrorAndClose(websocket, err3);
            return;
          }
          initAsClient(websocket, addr2, protocols, options);
        } else if (!websocket.emit("unexpected-response", req, res)) {
          abortHandshake(
            websocket,
            req,
            `Unexpected server response: ${res.statusCode}`
          );
        }
      });
      req.on("upgrade", (res, socket, head) => {
        websocket.emit("upgrade", res);
        if (websocket.readyState !== WebSocket4.CONNECTING) return;
        req = websocket._req = null;
        const upgrade = res.headers.upgrade;
        if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
          abortHandshake(websocket, socket, "Invalid Upgrade header");
          return;
        }
        const digest = createHash4("sha1").update(key + GUID).digest("base64");
        if (res.headers["sec-websocket-accept"] !== digest) {
          abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
          return;
        }
        const serverProt = res.headers["sec-websocket-protocol"];
        let protError;
        if (serverProt !== void 0) {
          if (!protocolSet.size) {
            protError = "Server sent a subprotocol but none was requested";
          } else if (!protocolSet.has(serverProt)) {
            protError = "Server sent an invalid subprotocol";
          }
        } else if (protocolSet.size) {
          protError = "Server sent no subprotocol";
        }
        if (protError) {
          abortHandshake(websocket, socket, protError);
          return;
        }
        if (serverProt) websocket._protocol = serverProt;
        const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
        if (secWebSocketExtensions !== void 0) {
          if (!perMessageDeflate) {
            const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
            abortHandshake(websocket, socket, message);
            return;
          }
          let extensions;
          try {
            extensions = parse6(secWebSocketExtensions);
          } catch (err3) {
            const message = "Invalid Sec-WebSocket-Extensions header";
            abortHandshake(websocket, socket, message);
            return;
          }
          const extensionNames = Object.keys(extensions);
          if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
            const message = "Server indicated an extension that was not requested";
            abortHandshake(websocket, socket, message);
            return;
          }
          try {
            perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
          } catch (err3) {
            const message = "Invalid Sec-WebSocket-Extensions header";
            abortHandshake(websocket, socket, message);
            return;
          }
          websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
        }
        websocket.setSocket(socket, head, {
          allowSynchronousEvents: opts.allowSynchronousEvents,
          generateMask: opts.generateMask,
          maxPayload: opts.maxPayload,
          skipUTF8Validation: opts.skipUTF8Validation
        });
      });
      if (opts.finishRequest) {
        opts.finishRequest(req, websocket);
      } else {
        req.end();
      }
    }
    function emitErrorAndClose(websocket, err3) {
      websocket._readyState = WebSocket4.CLOSING;
      websocket._errorEmitted = true;
      websocket.emit("error", err3);
      websocket.emitClose();
    }
    function netConnect(options) {
      options.path = options.socketPath;
      return net2.connect(options);
    }
    function tlsConnect(options) {
      options.path = void 0;
      if (!options.servername && options.servername !== "") {
        options.servername = net2.isIP(options.host) ? "" : options.host;
      }
      return tls2.connect(options);
    }
    function abortHandshake(websocket, stream, message) {
      websocket._readyState = WebSocket4.CLOSING;
      const err3 = new Error(message);
      Error.captureStackTrace(err3, abortHandshake);
      if (stream.setHeader) {
        stream[kAborted] = true;
        stream.abort();
        if (stream.socket && !stream.socket.destroyed) {
          stream.socket.destroy();
        }
        process.nextTick(emitErrorAndClose, websocket, err3);
      } else {
        stream.destroy(err3);
        stream.once("error", websocket.emit.bind(websocket, "error"));
        stream.once("close", websocket.emitClose.bind(websocket));
      }
    }
    function sendAfterClose(websocket, data, cb) {
      if (data) {
        const length = isBlob3(data) ? data.size : toBuffer(data).length;
        if (websocket._socket) websocket._sender._bufferedBytes += length;
        else websocket._bufferedAmount += length;
      }
      if (cb) {
        const err3 = new Error(
          `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
        );
        process.nextTick(cb, err3);
      }
    }
    function receiverOnConclude(code, reason) {
      const websocket = this[kWebSocket];
      websocket._closeFrameReceived = true;
      websocket._closeMessage = reason;
      websocket._closeCode = code;
      if (websocket._socket[kWebSocket] === void 0) return;
      websocket._socket.removeListener("data", socketOnData);
      process.nextTick(resume, websocket._socket);
      if (code === 1005) websocket.close();
      else websocket.close(code, reason);
    }
    function receiverOnDrain() {
      const websocket = this[kWebSocket];
      if (!websocket.isPaused) websocket._socket.resume();
    }
    function receiverOnError(err3) {
      const websocket = this[kWebSocket];
      if (websocket._socket[kWebSocket] !== void 0) {
        websocket._socket.removeListener("data", socketOnData);
        process.nextTick(resume, websocket._socket);
        websocket.close(err3[kStatusCode]);
      }
      if (!websocket._errorEmitted) {
        websocket._errorEmitted = true;
        websocket.emit("error", err3);
      }
    }
    function receiverOnFinish() {
      this[kWebSocket].emitClose();
    }
    function receiverOnMessage(data, isBinary2) {
      this[kWebSocket].emit("message", data, isBinary2);
    }
    function receiverOnPing(data) {
      const websocket = this[kWebSocket];
      if (websocket._autoPong) websocket.pong(data, !this._isServer, NOOP);
      websocket.emit("ping", data);
    }
    function receiverOnPong(data) {
      this[kWebSocket].emit("pong", data);
    }
    function resume(stream) {
      stream.resume();
    }
    function senderOnError(err3) {
      const websocket = this[kWebSocket];
      if (websocket.readyState === WebSocket4.CLOSED) return;
      if (websocket.readyState === WebSocket4.OPEN) {
        websocket._readyState = WebSocket4.CLOSING;
        setCloseTimer(websocket);
      }
      this._socket.end();
      if (!websocket._errorEmitted) {
        websocket._errorEmitted = true;
        websocket.emit("error", err3);
      }
    }
    function setCloseTimer(websocket) {
      websocket._closeTimer = setTimeout(
        websocket._socket.destroy.bind(websocket._socket),
        closeTimeout
      );
    }
    function socketOnClose() {
      const websocket = this[kWebSocket];
      this.removeListener("close", socketOnClose);
      this.removeListener("data", socketOnData);
      this.removeListener("end", socketOnEnd);
      websocket._readyState = WebSocket4.CLOSING;
      let chunk;
      if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
        websocket._receiver.write(chunk);
      }
      websocket._receiver.end();
      this[kWebSocket] = void 0;
      clearTimeout(websocket._closeTimer);
      if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
        websocket.emitClose();
      } else {
        websocket._receiver.on("error", receiverOnFinish);
        websocket._receiver.on("finish", receiverOnFinish);
      }
    }
    function socketOnData(chunk) {
      if (!this[kWebSocket]._receiver.write(chunk)) {
        this.pause();
      }
    }
    function socketOnEnd() {
      const websocket = this[kWebSocket];
      websocket._readyState = WebSocket4.CLOSING;
      websocket._receiver.end();
      this.end();
    }
    function socketOnError() {
      const websocket = this[kWebSocket];
      this.removeListener("error", socketOnError);
      this.on("error", NOOP);
      if (websocket) {
        websocket._readyState = WebSocket4.CLOSING;
        this.destroy();
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/stream.js
var require_stream = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/stream.js"(exports2, module2) {
    "use strict";
    var WebSocket4 = require_websocket();
    var { Duplex } = require("stream");
    function emitClose(stream) {
      stream.emit("close");
    }
    function duplexOnEnd() {
      if (!this.destroyed && this._writableState.finished) {
        this.destroy();
      }
    }
    function duplexOnError(err3) {
      this.removeListener("error", duplexOnError);
      this.destroy();
      if (this.listenerCount("error") === 0) {
        this.emit("error", err3);
      }
    }
    function createWebSocketStream3(ws4, options) {
      let terminateOnDestroy = true;
      const duplex = new Duplex({
        ...options,
        autoDestroy: false,
        emitClose: false,
        objectMode: false,
        writableObjectMode: false
      });
      ws4.on("message", function message(msg, isBinary2) {
        const data = !isBinary2 && duplex._readableState.objectMode ? msg.toString() : msg;
        if (!duplex.push(data)) ws4.pause();
      });
      ws4.once("error", function error2(err3) {
        if (duplex.destroyed) return;
        terminateOnDestroy = false;
        duplex.destroy(err3);
      });
      ws4.once("close", function close() {
        if (duplex.destroyed) return;
        duplex.push(null);
      });
      duplex._destroy = function(err3, callback) {
        if (ws4.readyState === ws4.CLOSED) {
          callback(err3);
          process.nextTick(emitClose, duplex);
          return;
        }
        let called = false;
        ws4.once("error", function error2(err4) {
          called = true;
          callback(err4);
        });
        ws4.once("close", function close() {
          if (!called) callback(err3);
          process.nextTick(emitClose, duplex);
        });
        if (terminateOnDestroy) ws4.terminate();
      };
      duplex._final = function(callback) {
        if (ws4.readyState === ws4.CONNECTING) {
          ws4.once("open", function open() {
            duplex._final(callback);
          });
          return;
        }
        if (ws4._socket === null) return;
        if (ws4._socket._writableState.finished) {
          callback();
          if (duplex._readableState.endEmitted) duplex.destroy();
        } else {
          ws4._socket.once("finish", function finish() {
            callback();
          });
          ws4.close();
        }
      };
      duplex._read = function() {
        if (ws4.isPaused) ws4.resume();
      };
      duplex._write = function(chunk, encoding, callback) {
        if (ws4.readyState === ws4.CONNECTING) {
          ws4.once("open", function open() {
            duplex._write(chunk, encoding, callback);
          });
          return;
        }
        ws4.send(chunk, callback);
      };
      duplex.on("end", duplexOnEnd);
      duplex.on("error", duplexOnError);
      return duplex;
    }
    module2.exports = createWebSocketStream3;
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/subprotocol.js
var require_subprotocol = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/subprotocol.js"(exports2, module2) {
    "use strict";
    var { tokenChars } = require_validation();
    function parse6(header) {
      const protocols = /* @__PURE__ */ new Set();
      let start2 = -1;
      let end = -1;
      let i8 = 0;
      for (i8; i8 < header.length; i8++) {
        const code = header.charCodeAt(i8);
        if (end === -1 && tokenChars[code] === 1) {
          if (start2 === -1) start2 = i8;
        } else if (i8 !== 0 && (code === 32 || code === 9)) {
          if (end === -1 && start2 !== -1) end = i8;
        } else if (code === 44) {
          if (start2 === -1) {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
          if (end === -1) end = i8;
          const protocol3 = header.slice(start2, end);
          if (protocols.has(protocol3)) {
            throw new SyntaxError(`The "${protocol3}" subprotocol is duplicated`);
          }
          protocols.add(protocol3);
          start2 = end = -1;
        } else {
          throw new SyntaxError(`Unexpected character at index ${i8}`);
        }
      }
      if (start2 === -1 || end !== -1) {
        throw new SyntaxError("Unexpected end of input");
      }
      const protocol2 = header.slice(start2, i8);
      if (protocols.has(protocol2)) {
        throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
      }
      protocols.add(protocol2);
      return protocols;
    }
    module2.exports = { parse: parse6 };
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/websocket-server.js
var require_websocket_server = __commonJS({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/lib/websocket-server.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events");
    var http4 = require("http");
    var { Duplex } = require("stream");
    var { createHash: createHash4 } = require("crypto");
    var extension = require_extension();
    var PerMessageDeflate = require_permessage_deflate();
    var subprotocol = require_subprotocol();
    var WebSocket4 = require_websocket();
    var { GUID, kWebSocket } = require_constants();
    var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
    var RUNNING = 0;
    var CLOSING = 1;
    var CLOSED = 2;
    var WebSocketServer3 = class extends EventEmitter {
      /**
       * Create a `WebSocketServer` instance.
       *
       * @param {Object} options Configuration options
       * @param {Boolean} [options.allowSynchronousEvents=true] Specifies whether
       *     any of the `'message'`, `'ping'`, and `'pong'` events can be emitted
       *     multiple times in the same tick
       * @param {Boolean} [options.autoPong=true] Specifies whether or not to
       *     automatically send a pong in response to a ping
       * @param {Number} [options.backlog=511] The maximum length of the queue of
       *     pending connections
       * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
       *     track clients
       * @param {Function} [options.handleProtocols] A hook to handle protocols
       * @param {String} [options.host] The hostname where to bind the server
       * @param {Number} [options.maxPayload=104857600] The maximum allowed message
       *     size
       * @param {Boolean} [options.noServer=false] Enable no server mode
       * @param {String} [options.path] Accept only connections matching this path
       * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
       *     permessage-deflate
       * @param {Number} [options.port] The port where to bind the server
       * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
       *     server to use
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       * @param {Function} [options.verifyClient] A hook to reject connections
       * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
       *     class to use. It must be the `WebSocket` class or class that extends it
       * @param {Function} [callback] A listener for the `listening` event
       */
      constructor(options, callback) {
        super();
        options = {
          allowSynchronousEvents: true,
          autoPong: true,
          maxPayload: 100 * 1024 * 1024,
          skipUTF8Validation: false,
          perMessageDeflate: false,
          handleProtocols: null,
          clientTracking: true,
          verifyClient: null,
          noServer: false,
          backlog: null,
          // use default (511 as implemented in net.js)
          server: null,
          host: null,
          path: null,
          port: null,
          WebSocket: WebSocket4,
          ...options
        };
        if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
          throw new TypeError(
            'One and only one of the "port", "server", or "noServer" options must be specified'
          );
        }
        if (options.port != null) {
          this._server = http4.createServer((req, res) => {
            const body2 = http4.STATUS_CODES[426];
            res.writeHead(426, {
              "Content-Length": body2.length,
              "Content-Type": "text/plain"
            });
            res.end(body2);
          });
          this._server.listen(
            options.port,
            options.host,
            options.backlog,
            callback
          );
        } else if (options.server) {
          this._server = options.server;
        }
        if (this._server) {
          const emitConnection = this.emit.bind(this, "connection");
          this._removeListeners = addListeners(this._server, {
            listening: this.emit.bind(this, "listening"),
            error: this.emit.bind(this, "error"),
            upgrade: (req, socket, head) => {
              this.handleUpgrade(req, socket, head, emitConnection);
            }
          });
        }
        if (options.perMessageDeflate === true) options.perMessageDeflate = {};
        if (options.clientTracking) {
          this.clients = /* @__PURE__ */ new Set();
          this._shouldEmitClose = false;
        }
        this.options = options;
        this._state = RUNNING;
      }
      /**
       * Returns the bound address, the address family name, and port of the server
       * as reported by the operating system if listening on an IP socket.
       * If the server is listening on a pipe or UNIX domain socket, the name is
       * returned as a string.
       *
       * @return {(Object|String|null)} The address of the server
       * @public
       */
      address() {
        if (this.options.noServer) {
          throw new Error('The server is operating in "noServer" mode');
        }
        if (!this._server) return null;
        return this._server.address();
      }
      /**
       * Stop the server from accepting new connections and emit the `'close'` event
       * when all existing connections are closed.
       *
       * @param {Function} [cb] A one-time listener for the `'close'` event
       * @public
       */
      close(cb) {
        if (this._state === CLOSED) {
          if (cb) {
            this.once("close", () => {
              cb(new Error("The server is not running"));
            });
          }
          process.nextTick(emitClose, this);
          return;
        }
        if (cb) this.once("close", cb);
        if (this._state === CLOSING) return;
        this._state = CLOSING;
        if (this.options.noServer || this.options.server) {
          if (this._server) {
            this._removeListeners();
            this._removeListeners = this._server = null;
          }
          if (this.clients) {
            if (!this.clients.size) {
              process.nextTick(emitClose, this);
            } else {
              this._shouldEmitClose = true;
            }
          } else {
            process.nextTick(emitClose, this);
          }
        } else {
          const server = this._server;
          this._removeListeners();
          this._removeListeners = this._server = null;
          server.close(() => {
            emitClose(this);
          });
        }
      }
      /**
       * See if a given request should be handled by this server instance.
       *
       * @param {http.IncomingMessage} req Request object to inspect
       * @return {Boolean} `true` if the request is valid, else `false`
       * @public
       */
      shouldHandle(req) {
        if (this.options.path) {
          const index7 = req.url.indexOf("?");
          const pathname = index7 !== -1 ? req.url.slice(0, index7) : req.url;
          if (pathname !== this.options.path) return false;
        }
        return true;
      }
      /**
       * Handle a HTTP Upgrade request.
       *
       * @param {http.IncomingMessage} req The request object
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @public
       */
      handleUpgrade(req, socket, head, cb) {
        socket.on("error", socketOnError);
        const key = req.headers["sec-websocket-key"];
        const upgrade = req.headers.upgrade;
        const version3 = +req.headers["sec-websocket-version"];
        if (req.method !== "GET") {
          const message = "Invalid HTTP method";
          abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
          return;
        }
        if (upgrade === void 0 || upgrade.toLowerCase() !== "websocket") {
          const message = "Invalid Upgrade header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (key === void 0 || !keyRegex.test(key)) {
          const message = "Missing or invalid Sec-WebSocket-Key header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (version3 !== 8 && version3 !== 13) {
          const message = "Missing or invalid Sec-WebSocket-Version header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (!this.shouldHandle(req)) {
          abortHandshake(socket, 400);
          return;
        }
        const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
        let protocols = /* @__PURE__ */ new Set();
        if (secWebSocketProtocol !== void 0) {
          try {
            protocols = subprotocol.parse(secWebSocketProtocol);
          } catch (err3) {
            const message = "Invalid Sec-WebSocket-Protocol header";
            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
            return;
          }
        }
        const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
        const extensions = {};
        if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
          const perMessageDeflate = new PerMessageDeflate(
            this.options.perMessageDeflate,
            true,
            this.options.maxPayload
          );
          try {
            const offers = extension.parse(secWebSocketExtensions);
            if (offers[PerMessageDeflate.extensionName]) {
              perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
              extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
            }
          } catch (err3) {
            const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
            return;
          }
        }
        if (this.options.verifyClient) {
          const info3 = {
            origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
            secure: !!(req.socket.authorized || req.socket.encrypted),
            req
          };
          if (this.options.verifyClient.length === 2) {
            this.options.verifyClient(info3, (verified, code, message, headers) => {
              if (!verified) {
                return abortHandshake(socket, code || 401, message, headers);
              }
              this.completeUpgrade(
                extensions,
                key,
                protocols,
                req,
                socket,
                head,
                cb
              );
            });
            return;
          }
          if (!this.options.verifyClient(info3)) return abortHandshake(socket, 401);
        }
        this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
      }
      /**
       * Upgrade the connection to WebSocket.
       *
       * @param {Object} extensions The accepted extensions
       * @param {String} key The value of the `Sec-WebSocket-Key` header
       * @param {Set} protocols The subprotocols
       * @param {http.IncomingMessage} req The request object
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @throws {Error} If called more than once with the same socket
       * @private
       */
      completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
        if (!socket.readable || !socket.writable) return socket.destroy();
        if (socket[kWebSocket]) {
          throw new Error(
            "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
          );
        }
        if (this._state > RUNNING) return abortHandshake(socket, 503);
        const digest = createHash4("sha1").update(key + GUID).digest("base64");
        const headers = [
          "HTTP/1.1 101 Switching Protocols",
          "Upgrade: websocket",
          "Connection: Upgrade",
          `Sec-WebSocket-Accept: ${digest}`
        ];
        const ws4 = new this.options.WebSocket(null, void 0, this.options);
        if (protocols.size) {
          const protocol2 = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
          if (protocol2) {
            headers.push(`Sec-WebSocket-Protocol: ${protocol2}`);
            ws4._protocol = protocol2;
          }
        }
        if (extensions[PerMessageDeflate.extensionName]) {
          const params = extensions[PerMessageDeflate.extensionName].params;
          const value = extension.format({
            [PerMessageDeflate.extensionName]: [params]
          });
          headers.push(`Sec-WebSocket-Extensions: ${value}`);
          ws4._extensions = extensions;
        }
        this.emit("headers", headers, req);
        socket.write(headers.concat("\r\n").join("\r\n"));
        socket.removeListener("error", socketOnError);
        ws4.setSocket(socket, head, {
          allowSynchronousEvents: this.options.allowSynchronousEvents,
          maxPayload: this.options.maxPayload,
          skipUTF8Validation: this.options.skipUTF8Validation
        });
        if (this.clients) {
          this.clients.add(ws4);
          ws4.on("close", () => {
            this.clients.delete(ws4);
            if (this._shouldEmitClose && !this.clients.size) {
              process.nextTick(emitClose, this);
            }
          });
        }
        cb(ws4, req);
      }
    };
    module2.exports = WebSocketServer3;
    function addListeners(server, map2) {
      for (const event of Object.keys(map2)) server.on(event, map2[event]);
      return function removeListeners() {
        for (const event of Object.keys(map2)) {
          server.removeListener(event, map2[event]);
        }
      };
    }
    function emitClose(server) {
      server._state = CLOSED;
      server.emit("close");
    }
    function socketOnError() {
      this.destroy();
    }
    function abortHandshake(socket, code, message, headers) {
      message = message || http4.STATUS_CODES[code];
      headers = {
        Connection: "close",
        "Content-Type": "text/html",
        "Content-Length": Buffer.byteLength(message),
        ...headers
      };
      socket.once("finish", socket.destroy);
      socket.end(
        `HTTP/1.1 ${code} ${http4.STATUS_CODES[code]}\r
` + Object.keys(headers).map((h8) => `${h8}: ${headers[h8]}`).join("\r\n") + "\r\n\r\n" + message
      );
    }
    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
      if (server.listenerCount("wsClientError")) {
        const err3 = new Error(message);
        Error.captureStackTrace(err3, abortHandshakeOrEmitwsClientError);
        server.emit("wsClientError", err3, socket, req);
      } else {
        abortHandshake(socket, code, message);
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.18.2/node_modules/ws/wrapper.mjs
var import_stream2, import_receiver, import_sender, import_websocket, import_websocket_server, wrapper_default;
var init_wrapper = __esm({
  "../node_modules/.pnpm/ws@8.18.2/node_modules/ws/wrapper.mjs"() {
    "use strict";
    import_stream2 = __toESM(require_stream(), 1);
    import_receiver = __toESM(require_receiver(), 1);
    import_sender = __toESM(require_sender(), 1);
    import_websocket = __toESM(require_websocket(), 1);
    import_websocket_server = __toESM(require_websocket_server(), 1);
    wrapper_default = import_websocket.default;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js
var require_constants2 = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/constants.js"(exports2, module2) {
    "use strict";
    var SEMVER_SPEC_VERSION = "2.0.0";
    var MAX_LENGTH = 256;
    var MAX_SAFE_INTEGER = Number.MAX_SAFE_INTEGER || /* istanbul ignore next */
    9007199254740991;
    var MAX_SAFE_COMPONENT_LENGTH = 16;
    var MAX_SAFE_BUILD_LENGTH = MAX_LENGTH - 6;
    var RELEASE_TYPES = [
      "major",
      "premajor",
      "minor",
      "preminor",
      "patch",
      "prepatch",
      "prerelease"
    ];
    module2.exports = {
      MAX_LENGTH,
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_SAFE_INTEGER,
      RELEASE_TYPES,
      SEMVER_SPEC_VERSION,
      FLAG_INCLUDE_PRERELEASE: 1,
      FLAG_LOOSE: 2
    };
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js
var require_debug = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/debug.js"(exports2, module2) {
    "use strict";
    var debug = typeof process === "object" && process.env && process.env.NODE_DEBUG && /\bsemver\b/i.test(process.env.NODE_DEBUG) ? (...args2) => console.error("SEMVER", ...args2) : () => {
    };
    module2.exports = debug;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js
var require_re = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/re.js"(exports2, module2) {
    "use strict";
    var {
      MAX_SAFE_COMPONENT_LENGTH,
      MAX_SAFE_BUILD_LENGTH,
      MAX_LENGTH
    } = require_constants2();
    var debug = require_debug();
    exports2 = module2.exports = {};
    var re3 = exports2.re = [];
    var safeRe = exports2.safeRe = [];
    var src = exports2.src = [];
    var safeSrc = exports2.safeSrc = [];
    var t6 = exports2.t = {};
    var R5 = 0;
    var LETTERDASHNUMBER = "[a-zA-Z0-9-]";
    var safeRegexReplacements = [
      ["\\s", 1],
      ["\\d", MAX_LENGTH],
      [LETTERDASHNUMBER, MAX_SAFE_BUILD_LENGTH]
    ];
    var makeSafeRegex = (value) => {
      for (const [token, max2] of safeRegexReplacements) {
        value = value.split(`${token}*`).join(`${token}{0,${max2}}`).split(`${token}+`).join(`${token}{1,${max2}}`);
      }
      return value;
    };
    var createToken = (name3, value, isGlobal) => {
      const safe = makeSafeRegex(value);
      const index7 = R5++;
      debug(name3, index7, value);
      t6[name3] = index7;
      src[index7] = value;
      safeSrc[index7] = safe;
      re3[index7] = new RegExp(value, isGlobal ? "g" : void 0);
      safeRe[index7] = new RegExp(safe, isGlobal ? "g" : void 0);
    };
    createToken("NUMERICIDENTIFIER", "0|[1-9]\\d*");
    createToken("NUMERICIDENTIFIERLOOSE", "\\d+");
    createToken("NONNUMERICIDENTIFIER", `\\d*[a-zA-Z-]${LETTERDASHNUMBER}*`);
    createToken("MAINVERSION", `(${src[t6.NUMERICIDENTIFIER]})\\.(${src[t6.NUMERICIDENTIFIER]})\\.(${src[t6.NUMERICIDENTIFIER]})`);
    createToken("MAINVERSIONLOOSE", `(${src[t6.NUMERICIDENTIFIERLOOSE]})\\.(${src[t6.NUMERICIDENTIFIERLOOSE]})\\.(${src[t6.NUMERICIDENTIFIERLOOSE]})`);
    createToken("PRERELEASEIDENTIFIER", `(?:${src[t6.NONNUMERICIDENTIFIER]}|${src[t6.NUMERICIDENTIFIER]})`);
    createToken("PRERELEASEIDENTIFIERLOOSE", `(?:${src[t6.NONNUMERICIDENTIFIER]}|${src[t6.NUMERICIDENTIFIERLOOSE]})`);
    createToken("PRERELEASE", `(?:-(${src[t6.PRERELEASEIDENTIFIER]}(?:\\.${src[t6.PRERELEASEIDENTIFIER]})*))`);
    createToken("PRERELEASELOOSE", `(?:-?(${src[t6.PRERELEASEIDENTIFIERLOOSE]}(?:\\.${src[t6.PRERELEASEIDENTIFIERLOOSE]})*))`);
    createToken("BUILDIDENTIFIER", `${LETTERDASHNUMBER}+`);
    createToken("BUILD", `(?:\\+(${src[t6.BUILDIDENTIFIER]}(?:\\.${src[t6.BUILDIDENTIFIER]})*))`);
    createToken("FULLPLAIN", `v?${src[t6.MAINVERSION]}${src[t6.PRERELEASE]}?${src[t6.BUILD]}?`);
    createToken("FULL", `^${src[t6.FULLPLAIN]}$`);
    createToken("LOOSEPLAIN", `[v=\\s]*${src[t6.MAINVERSIONLOOSE]}${src[t6.PRERELEASELOOSE]}?${src[t6.BUILD]}?`);
    createToken("LOOSE", `^${src[t6.LOOSEPLAIN]}$`);
    createToken("GTLT", "((?:<|>)?=?)");
    createToken("XRANGEIDENTIFIERLOOSE", `${src[t6.NUMERICIDENTIFIERLOOSE]}|x|X|\\*`);
    createToken("XRANGEIDENTIFIER", `${src[t6.NUMERICIDENTIFIER]}|x|X|\\*`);
    createToken("XRANGEPLAIN", `[v=\\s]*(${src[t6.XRANGEIDENTIFIER]})(?:\\.(${src[t6.XRANGEIDENTIFIER]})(?:\\.(${src[t6.XRANGEIDENTIFIER]})(?:${src[t6.PRERELEASE]})?${src[t6.BUILD]}?)?)?`);
    createToken("XRANGEPLAINLOOSE", `[v=\\s]*(${src[t6.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t6.XRANGEIDENTIFIERLOOSE]})(?:\\.(${src[t6.XRANGEIDENTIFIERLOOSE]})(?:${src[t6.PRERELEASELOOSE]})?${src[t6.BUILD]}?)?)?`);
    createToken("XRANGE", `^${src[t6.GTLT]}\\s*${src[t6.XRANGEPLAIN]}$`);
    createToken("XRANGELOOSE", `^${src[t6.GTLT]}\\s*${src[t6.XRANGEPLAINLOOSE]}$`);
    createToken("COERCEPLAIN", `${"(^|[^\\d])(\\d{1,"}${MAX_SAFE_COMPONENT_LENGTH}})(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?(?:\\.(\\d{1,${MAX_SAFE_COMPONENT_LENGTH}}))?`);
    createToken("COERCE", `${src[t6.COERCEPLAIN]}(?:$|[^\\d])`);
    createToken("COERCEFULL", src[t6.COERCEPLAIN] + `(?:${src[t6.PRERELEASE]})?(?:${src[t6.BUILD]})?(?:$|[^\\d])`);
    createToken("COERCERTL", src[t6.COERCE], true);
    createToken("COERCERTLFULL", src[t6.COERCEFULL], true);
    createToken("LONETILDE", "(?:~>?)");
    createToken("TILDETRIM", `(\\s*)${src[t6.LONETILDE]}\\s+`, true);
    exports2.tildeTrimReplace = "$1~";
    createToken("TILDE", `^${src[t6.LONETILDE]}${src[t6.XRANGEPLAIN]}$`);
    createToken("TILDELOOSE", `^${src[t6.LONETILDE]}${src[t6.XRANGEPLAINLOOSE]}$`);
    createToken("LONECARET", "(?:\\^)");
    createToken("CARETTRIM", `(\\s*)${src[t6.LONECARET]}\\s+`, true);
    exports2.caretTrimReplace = "$1^";
    createToken("CARET", `^${src[t6.LONECARET]}${src[t6.XRANGEPLAIN]}$`);
    createToken("CARETLOOSE", `^${src[t6.LONECARET]}${src[t6.XRANGEPLAINLOOSE]}$`);
    createToken("COMPARATORLOOSE", `^${src[t6.GTLT]}\\s*(${src[t6.LOOSEPLAIN]})$|^$`);
    createToken("COMPARATOR", `^${src[t6.GTLT]}\\s*(${src[t6.FULLPLAIN]})$|^$`);
    createToken("COMPARATORTRIM", `(\\s*)${src[t6.GTLT]}\\s*(${src[t6.LOOSEPLAIN]}|${src[t6.XRANGEPLAIN]})`, true);
    exports2.comparatorTrimReplace = "$1$2$3";
    createToken("HYPHENRANGE", `^\\s*(${src[t6.XRANGEPLAIN]})\\s+-\\s+(${src[t6.XRANGEPLAIN]})\\s*$`);
    createToken("HYPHENRANGELOOSE", `^\\s*(${src[t6.XRANGEPLAINLOOSE]})\\s+-\\s+(${src[t6.XRANGEPLAINLOOSE]})\\s*$`);
    createToken("STAR", "(<|>)?=?\\s*\\*");
    createToken("GTE0", "^\\s*>=\\s*0\\.0\\.0\\s*$");
    createToken("GTE0PRE", "^\\s*>=\\s*0\\.0\\.0-0\\s*$");
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js
var require_parse_options = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/parse-options.js"(exports2, module2) {
    "use strict";
    var looseOption = Object.freeze({ loose: true });
    var emptyOpts = Object.freeze({});
    var parseOptions2 = (options) => {
      if (!options) {
        return emptyOpts;
      }
      if (typeof options !== "object") {
        return looseOption;
      }
      return options;
    };
    module2.exports = parseOptions2;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js
var require_identifiers = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/identifiers.js"(exports2, module2) {
    "use strict";
    var numeric3 = /^[0-9]+$/;
    var compareIdentifiers = (a9, b9) => {
      const anum = numeric3.test(a9);
      const bnum = numeric3.test(b9);
      if (anum && bnum) {
        a9 = +a9;
        b9 = +b9;
      }
      return a9 === b9 ? 0 : anum && !bnum ? -1 : bnum && !anum ? 1 : a9 < b9 ? -1 : 1;
    };
    var rcompareIdentifiers = (a9, b9) => compareIdentifiers(b9, a9);
    module2.exports = {
      compareIdentifiers,
      rcompareIdentifiers
    };
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js
var require_semver = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/semver.js"(exports2, module2) {
    "use strict";
    var debug = require_debug();
    var { MAX_LENGTH, MAX_SAFE_INTEGER } = require_constants2();
    var { safeRe: re3, t: t6 } = require_re();
    var parseOptions2 = require_parse_options();
    var { compareIdentifiers } = require_identifiers();
    var SemVer = class _SemVer {
      constructor(version3, options) {
        options = parseOptions2(options);
        if (version3 instanceof _SemVer) {
          if (version3.loose === !!options.loose && version3.includePrerelease === !!options.includePrerelease) {
            return version3;
          } else {
            version3 = version3.version;
          }
        } else if (typeof version3 !== "string") {
          throw new TypeError(`Invalid version. Must be a string. Got type "${typeof version3}".`);
        }
        if (version3.length > MAX_LENGTH) {
          throw new TypeError(
            `version is longer than ${MAX_LENGTH} characters`
          );
        }
        debug("SemVer", version3, options);
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        const m12 = version3.trim().match(options.loose ? re3[t6.LOOSE] : re3[t6.FULL]);
        if (!m12) {
          throw new TypeError(`Invalid Version: ${version3}`);
        }
        this.raw = version3;
        this.major = +m12[1];
        this.minor = +m12[2];
        this.patch = +m12[3];
        if (this.major > MAX_SAFE_INTEGER || this.major < 0) {
          throw new TypeError("Invalid major version");
        }
        if (this.minor > MAX_SAFE_INTEGER || this.minor < 0) {
          throw new TypeError("Invalid minor version");
        }
        if (this.patch > MAX_SAFE_INTEGER || this.patch < 0) {
          throw new TypeError("Invalid patch version");
        }
        if (!m12[4]) {
          this.prerelease = [];
        } else {
          this.prerelease = m12[4].split(".").map((id) => {
            if (/^[0-9]+$/.test(id)) {
              const num = +id;
              if (num >= 0 && num < MAX_SAFE_INTEGER) {
                return num;
              }
            }
            return id;
          });
        }
        this.build = m12[5] ? m12[5].split(".") : [];
        this.format();
      }
      format() {
        this.version = `${this.major}.${this.minor}.${this.patch}`;
        if (this.prerelease.length) {
          this.version += `-${this.prerelease.join(".")}`;
        }
        return this.version;
      }
      toString() {
        return this.version;
      }
      compare(other) {
        debug("SemVer.compare", this.version, this.options, other);
        if (!(other instanceof _SemVer)) {
          if (typeof other === "string" && other === this.version) {
            return 0;
          }
          other = new _SemVer(other, this.options);
        }
        if (other.version === this.version) {
          return 0;
        }
        return this.compareMain(other) || this.comparePre(other);
      }
      compareMain(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        return compareIdentifiers(this.major, other.major) || compareIdentifiers(this.minor, other.minor) || compareIdentifiers(this.patch, other.patch);
      }
      comparePre(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        if (this.prerelease.length && !other.prerelease.length) {
          return -1;
        } else if (!this.prerelease.length && other.prerelease.length) {
          return 1;
        } else if (!this.prerelease.length && !other.prerelease.length) {
          return 0;
        }
        let i8 = 0;
        do {
          const a9 = this.prerelease[i8];
          const b9 = other.prerelease[i8];
          debug("prerelease compare", i8, a9, b9);
          if (a9 === void 0 && b9 === void 0) {
            return 0;
          } else if (b9 === void 0) {
            return 1;
          } else if (a9 === void 0) {
            return -1;
          } else if (a9 === b9) {
            continue;
          } else {
            return compareIdentifiers(a9, b9);
          }
        } while (++i8);
      }
      compareBuild(other) {
        if (!(other instanceof _SemVer)) {
          other = new _SemVer(other, this.options);
        }
        let i8 = 0;
        do {
          const a9 = this.build[i8];
          const b9 = other.build[i8];
          debug("build compare", i8, a9, b9);
          if (a9 === void 0 && b9 === void 0) {
            return 0;
          } else if (b9 === void 0) {
            return 1;
          } else if (a9 === void 0) {
            return -1;
          } else if (a9 === b9) {
            continue;
          } else {
            return compareIdentifiers(a9, b9);
          }
        } while (++i8);
      }
      // preminor will bump the version up to the next minor release, and immediately
      // down to pre-release. premajor and prepatch work the same way.
      inc(release2, identifier, identifierBase) {
        if (release2.startsWith("pre")) {
          if (!identifier && identifierBase === false) {
            throw new Error("invalid increment argument: identifier is empty");
          }
          if (identifier) {
            const match2 = `-${identifier}`.match(this.options.loose ? re3[t6.PRERELEASELOOSE] : re3[t6.PRERELEASE]);
            if (!match2 || match2[1] !== identifier) {
              throw new Error(`invalid identifier: ${identifier}`);
            }
          }
        }
        switch (release2) {
          case "premajor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor = 0;
            this.major++;
            this.inc("pre", identifier, identifierBase);
            break;
          case "preminor":
            this.prerelease.length = 0;
            this.patch = 0;
            this.minor++;
            this.inc("pre", identifier, identifierBase);
            break;
          case "prepatch":
            this.prerelease.length = 0;
            this.inc("patch", identifier, identifierBase);
            this.inc("pre", identifier, identifierBase);
            break;
          // If the input is a non-prerelease version, this acts the same as
          // prepatch.
          case "prerelease":
            if (this.prerelease.length === 0) {
              this.inc("patch", identifier, identifierBase);
            }
            this.inc("pre", identifier, identifierBase);
            break;
          case "release":
            if (this.prerelease.length === 0) {
              throw new Error(`version ${this.raw} is not a prerelease`);
            }
            this.prerelease.length = 0;
            break;
          case "major":
            if (this.minor !== 0 || this.patch !== 0 || this.prerelease.length === 0) {
              this.major++;
            }
            this.minor = 0;
            this.patch = 0;
            this.prerelease = [];
            break;
          case "minor":
            if (this.patch !== 0 || this.prerelease.length === 0) {
              this.minor++;
            }
            this.patch = 0;
            this.prerelease = [];
            break;
          case "patch":
            if (this.prerelease.length === 0) {
              this.patch++;
            }
            this.prerelease = [];
            break;
          // This probably shouldn't be used publicly.
          // 1.0.0 'pre' would become 1.0.0-0 which is the wrong direction.
          case "pre": {
            const base = Number(identifierBase) ? 1 : 0;
            if (this.prerelease.length === 0) {
              this.prerelease = [base];
            } else {
              let i8 = this.prerelease.length;
              while (--i8 >= 0) {
                if (typeof this.prerelease[i8] === "number") {
                  this.prerelease[i8]++;
                  i8 = -2;
                }
              }
              if (i8 === -1) {
                if (identifier === this.prerelease.join(".") && identifierBase === false) {
                  throw new Error("invalid increment argument: identifier already exists");
                }
                this.prerelease.push(base);
              }
            }
            if (identifier) {
              let prerelease = [identifier, base];
              if (identifierBase === false) {
                prerelease = [identifier];
              }
              if (compareIdentifiers(this.prerelease[0], identifier) === 0) {
                if (isNaN(this.prerelease[1])) {
                  this.prerelease = prerelease;
                }
              } else {
                this.prerelease = prerelease;
              }
            }
            break;
          }
          default:
            throw new Error(`invalid increment argument: ${release2}`);
        }
        this.raw = this.format();
        if (this.build.length) {
          this.raw += `+${this.build.join(".")}`;
        }
        return this;
      }
    };
    module2.exports = SemVer;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/parse.js
var require_parse = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/parse.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var parse6 = (version3, options, throwErrors = false) => {
      if (version3 instanceof SemVer) {
        return version3;
      }
      try {
        return new SemVer(version3, options);
      } catch (er3) {
        if (!throwErrors) {
          return null;
        }
        throw er3;
      }
    };
    module2.exports = parse6;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/valid.js
var require_valid = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/valid.js"(exports2, module2) {
    "use strict";
    var parse6 = require_parse();
    var valid = (version3, options) => {
      const v11 = parse6(version3, options);
      return v11 ? v11.version : null;
    };
    module2.exports = valid;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/clean.js
var require_clean = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/clean.js"(exports2, module2) {
    "use strict";
    var parse6 = require_parse();
    var clean = (version3, options) => {
      const s10 = parse6(version3.trim().replace(/^[=v]+/, ""), options);
      return s10 ? s10.version : null;
    };
    module2.exports = clean;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js
var require_inc = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/inc.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var inc = (version3, release2, options, identifier, identifierBase) => {
      if (typeof options === "string") {
        identifierBase = identifier;
        identifier = options;
        options = void 0;
      }
      try {
        return new SemVer(
          version3 instanceof SemVer ? version3.version : version3,
          options
        ).inc(release2, identifier, identifierBase).version;
      } catch (er3) {
        return null;
      }
    };
    module2.exports = inc;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js
var require_diff = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/diff.js"(exports2, module2) {
    "use strict";
    var parse6 = require_parse();
    var diff2 = (version1, version22) => {
      const v1 = parse6(version1, null, true);
      const v22 = parse6(version22, null, true);
      const comparison = v1.compare(v22);
      if (comparison === 0) {
        return null;
      }
      const v1Higher = comparison > 0;
      const highVersion = v1Higher ? v1 : v22;
      const lowVersion = v1Higher ? v22 : v1;
      const highHasPre = !!highVersion.prerelease.length;
      const lowHasPre = !!lowVersion.prerelease.length;
      if (lowHasPre && !highHasPre) {
        if (!lowVersion.patch && !lowVersion.minor) {
          return "major";
        }
        if (lowVersion.compareMain(highVersion) === 0) {
          if (lowVersion.minor && !lowVersion.patch) {
            return "minor";
          }
          return "patch";
        }
      }
      const prefix2 = highHasPre ? "pre" : "";
      if (v1.major !== v22.major) {
        return prefix2 + "major";
      }
      if (v1.minor !== v22.minor) {
        return prefix2 + "minor";
      }
      if (v1.patch !== v22.patch) {
        return prefix2 + "patch";
      }
      return "prerelease";
    };
    module2.exports = diff2;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js
var require_major = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/major.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var major = (a9, loose) => new SemVer(a9, loose).major;
    module2.exports = major;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js
var require_minor = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/minor.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var minor = (a9, loose) => new SemVer(a9, loose).minor;
    module2.exports = minor;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js
var require_patch = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/patch.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var patch = (a9, loose) => new SemVer(a9, loose).patch;
    module2.exports = patch;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js
var require_prerelease = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/prerelease.js"(exports2, module2) {
    "use strict";
    var parse6 = require_parse();
    var prerelease = (version3, options) => {
      const parsed = parse6(version3, options);
      return parsed && parsed.prerelease.length ? parsed.prerelease : null;
    };
    module2.exports = prerelease;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js
var require_compare = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var compare = (a9, b9, loose) => new SemVer(a9, loose).compare(new SemVer(b9, loose));
    module2.exports = compare;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js
var require_rcompare = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rcompare.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var rcompare = (a9, b9, loose) => compare(b9, a9, loose);
    module2.exports = rcompare;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js
var require_compare_loose = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-loose.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var compareLoose = (a9, b9) => compare(a9, b9, true);
    module2.exports = compareLoose;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js
var require_compare_build = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/compare-build.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var compareBuild = (a9, b9, loose) => {
      const versionA = new SemVer(a9, loose);
      const versionB = new SemVer(b9, loose);
      return versionA.compare(versionB) || versionA.compareBuild(versionB);
    };
    module2.exports = compareBuild;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js
var require_sort = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/sort.js"(exports2, module2) {
    "use strict";
    var compareBuild = require_compare_build();
    var sort = (list, loose) => list.sort((a9, b9) => compareBuild(a9, b9, loose));
    module2.exports = sort;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js
var require_rsort = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/rsort.js"(exports2, module2) {
    "use strict";
    var compareBuild = require_compare_build();
    var rsort = (list, loose) => list.sort((a9, b9) => compareBuild(b9, a9, loose));
    module2.exports = rsort;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js
var require_gt = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gt.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var gt6 = (a9, b9, loose) => compare(a9, b9, loose) > 0;
    module2.exports = gt6;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js
var require_lt = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lt.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var lt3 = (a9, b9, loose) => compare(a9, b9, loose) < 0;
    module2.exports = lt3;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js
var require_eq = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/eq.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var eq2 = (a9, b9, loose) => compare(a9, b9, loose) === 0;
    module2.exports = eq2;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js
var require_neq = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/neq.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var neq = (a9, b9, loose) => compare(a9, b9, loose) !== 0;
    module2.exports = neq;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js
var require_gte = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/gte.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var gte2 = (a9, b9, loose) => compare(a9, b9, loose) >= 0;
    module2.exports = gte2;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js
var require_lte = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/lte.js"(exports2, module2) {
    "use strict";
    var compare = require_compare();
    var lte2 = (a9, b9, loose) => compare(a9, b9, loose) <= 0;
    module2.exports = lte2;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js
var require_cmp = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/cmp.js"(exports2, module2) {
    "use strict";
    var eq2 = require_eq();
    var neq = require_neq();
    var gt6 = require_gt();
    var gte2 = require_gte();
    var lt3 = require_lt();
    var lte2 = require_lte();
    var cmp = (a9, op, b9, loose) => {
      switch (op) {
        case "===":
          if (typeof a9 === "object") {
            a9 = a9.version;
          }
          if (typeof b9 === "object") {
            b9 = b9.version;
          }
          return a9 === b9;
        case "!==":
          if (typeof a9 === "object") {
            a9 = a9.version;
          }
          if (typeof b9 === "object") {
            b9 = b9.version;
          }
          return a9 !== b9;
        case "":
        case "=":
        case "==":
          return eq2(a9, b9, loose);
        case "!=":
          return neq(a9, b9, loose);
        case ">":
          return gt6(a9, b9, loose);
        case ">=":
          return gte2(a9, b9, loose);
        case "<":
          return lt3(a9, b9, loose);
        case "<=":
          return lte2(a9, b9, loose);
        default:
          throw new TypeError(`Invalid operator: ${op}`);
      }
    };
    module2.exports = cmp;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js
var require_coerce = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/coerce.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var parse6 = require_parse();
    var { safeRe: re3, t: t6 } = require_re();
    var coerce2 = (version3, options) => {
      if (version3 instanceof SemVer) {
        return version3;
      }
      if (typeof version3 === "number") {
        version3 = String(version3);
      }
      if (typeof version3 !== "string") {
        return null;
      }
      options = options || {};
      let match2 = null;
      if (!options.rtl) {
        match2 = version3.match(options.includePrerelease ? re3[t6.COERCEFULL] : re3[t6.COERCE]);
      } else {
        const coerceRtlRegex = options.includePrerelease ? re3[t6.COERCERTLFULL] : re3[t6.COERCERTL];
        let next;
        while ((next = coerceRtlRegex.exec(version3)) && (!match2 || match2.index + match2[0].length !== version3.length)) {
          if (!match2 || next.index + next[0].length !== match2.index + match2[0].length) {
            match2 = next;
          }
          coerceRtlRegex.lastIndex = next.index + next[1].length + next[2].length;
        }
        coerceRtlRegex.lastIndex = -1;
      }
      if (match2 === null) {
        return null;
      }
      const major = match2[2];
      const minor = match2[3] || "0";
      const patch = match2[4] || "0";
      const prerelease = options.includePrerelease && match2[5] ? `-${match2[5]}` : "";
      const build = options.includePrerelease && match2[6] ? `+${match2[6]}` : "";
      return parse6(`${major}.${minor}.${patch}${prerelease}${build}`, options);
    };
    module2.exports = coerce2;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js
var require_lrucache = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/internal/lrucache.js"(exports2, module2) {
    "use strict";
    var LRUCache = class {
      constructor() {
        this.max = 1e3;
        this.map = /* @__PURE__ */ new Map();
      }
      get(key) {
        const value = this.map.get(key);
        if (value === void 0) {
          return void 0;
        } else {
          this.map.delete(key);
          this.map.set(key, value);
          return value;
        }
      }
      delete(key) {
        return this.map.delete(key);
      }
      set(key, value) {
        const deleted = this.delete(key);
        if (!deleted && value !== void 0) {
          if (this.map.size >= this.max) {
            const firstKey = this.map.keys().next().value;
            this.delete(firstKey);
          }
          this.map.set(key, value);
        }
        return this;
      }
    };
    module2.exports = LRUCache;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js
var require_range = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/range.js"(exports2, module2) {
    "use strict";
    var SPACE_CHARACTERS = /\s+/g;
    var Range = class _Range {
      constructor(range, options) {
        options = parseOptions2(options);
        if (range instanceof _Range) {
          if (range.loose === !!options.loose && range.includePrerelease === !!options.includePrerelease) {
            return range;
          } else {
            return new _Range(range.raw, options);
          }
        }
        if (range instanceof Comparator) {
          this.raw = range.value;
          this.set = [[range]];
          this.formatted = void 0;
          return this;
        }
        this.options = options;
        this.loose = !!options.loose;
        this.includePrerelease = !!options.includePrerelease;
        this.raw = range.trim().replace(SPACE_CHARACTERS, " ");
        this.set = this.raw.split("||").map((r6) => this.parseRange(r6.trim())).filter((c6) => c6.length);
        if (!this.set.length) {
          throw new TypeError(`Invalid SemVer Range: ${this.raw}`);
        }
        if (this.set.length > 1) {
          const first = this.set[0];
          this.set = this.set.filter((c6) => !isNullSet(c6[0]));
          if (this.set.length === 0) {
            this.set = [first];
          } else if (this.set.length > 1) {
            for (const c6 of this.set) {
              if (c6.length === 1 && isAny(c6[0])) {
                this.set = [c6];
                break;
              }
            }
          }
        }
        this.formatted = void 0;
      }
      get range() {
        if (this.formatted === void 0) {
          this.formatted = "";
          for (let i8 = 0; i8 < this.set.length; i8++) {
            if (i8 > 0) {
              this.formatted += "||";
            }
            const comps = this.set[i8];
            for (let k9 = 0; k9 < comps.length; k9++) {
              if (k9 > 0) {
                this.formatted += " ";
              }
              this.formatted += comps[k9].toString().trim();
            }
          }
        }
        return this.formatted;
      }
      format() {
        return this.range;
      }
      toString() {
        return this.range;
      }
      parseRange(range) {
        const memoOpts = (this.options.includePrerelease && FLAG_INCLUDE_PRERELEASE) | (this.options.loose && FLAG_LOOSE);
        const memoKey = memoOpts + ":" + range;
        const cached = cache5.get(memoKey);
        if (cached) {
          return cached;
        }
        const loose = this.options.loose;
        const hr3 = loose ? re3[t6.HYPHENRANGELOOSE] : re3[t6.HYPHENRANGE];
        range = range.replace(hr3, hyphenReplace(this.options.includePrerelease));
        debug("hyphen replace", range);
        range = range.replace(re3[t6.COMPARATORTRIM], comparatorTrimReplace);
        debug("comparator trim", range);
        range = range.replace(re3[t6.TILDETRIM], tildeTrimReplace);
        debug("tilde trim", range);
        range = range.replace(re3[t6.CARETTRIM], caretTrimReplace);
        debug("caret trim", range);
        let rangeList = range.split(" ").map((comp) => parseComparator(comp, this.options)).join(" ").split(/\s+/).map((comp) => replaceGTE0(comp, this.options));
        if (loose) {
          rangeList = rangeList.filter((comp) => {
            debug("loose invalid filter", comp, this.options);
            return !!comp.match(re3[t6.COMPARATORLOOSE]);
          });
        }
        debug("range list", rangeList);
        const rangeMap = /* @__PURE__ */ new Map();
        const comparators = rangeList.map((comp) => new Comparator(comp, this.options));
        for (const comp of comparators) {
          if (isNullSet(comp)) {
            return [comp];
          }
          rangeMap.set(comp.value, comp);
        }
        if (rangeMap.size > 1 && rangeMap.has("")) {
          rangeMap.delete("");
        }
        const result = [...rangeMap.values()];
        cache5.set(memoKey, result);
        return result;
      }
      intersects(range, options) {
        if (!(range instanceof _Range)) {
          throw new TypeError("a Range is required");
        }
        return this.set.some((thisComparators) => {
          return isSatisfiable(thisComparators, options) && range.set.some((rangeComparators) => {
            return isSatisfiable(rangeComparators, options) && thisComparators.every((thisComparator) => {
              return rangeComparators.every((rangeComparator) => {
                return thisComparator.intersects(rangeComparator, options);
              });
            });
          });
        });
      }
      // if ANY of the sets match ALL of its comparators, then pass
      test(version3) {
        if (!version3) {
          return false;
        }
        if (typeof version3 === "string") {
          try {
            version3 = new SemVer(version3, this.options);
          } catch (er3) {
            return false;
          }
        }
        for (let i8 = 0; i8 < this.set.length; i8++) {
          if (testSet(this.set[i8], version3, this.options)) {
            return true;
          }
        }
        return false;
      }
    };
    module2.exports = Range;
    var LRU = require_lrucache();
    var cache5 = new LRU();
    var parseOptions2 = require_parse_options();
    var Comparator = require_comparator();
    var debug = require_debug();
    var SemVer = require_semver();
    var {
      safeRe: re3,
      t: t6,
      comparatorTrimReplace,
      tildeTrimReplace,
      caretTrimReplace
    } = require_re();
    var { FLAG_INCLUDE_PRERELEASE, FLAG_LOOSE } = require_constants2();
    var isNullSet = (c6) => c6.value === "<0.0.0-0";
    var isAny = (c6) => c6.value === "";
    var isSatisfiable = (comparators, options) => {
      let result = true;
      const remainingComparators = comparators.slice();
      let testComparator = remainingComparators.pop();
      while (result && remainingComparators.length) {
        result = remainingComparators.every((otherComparator) => {
          return testComparator.intersects(otherComparator, options);
        });
        testComparator = remainingComparators.pop();
      }
      return result;
    };
    var parseComparator = (comp, options) => {
      debug("comp", comp, options);
      comp = replaceCarets(comp, options);
      debug("caret", comp);
      comp = replaceTildes(comp, options);
      debug("tildes", comp);
      comp = replaceXRanges(comp, options);
      debug("xrange", comp);
      comp = replaceStars(comp, options);
      debug("stars", comp);
      return comp;
    };
    var isX = (id) => !id || id.toLowerCase() === "x" || id === "*";
    var replaceTildes = (comp, options) => {
      return comp.trim().split(/\s+/).map((c6) => replaceTilde(c6, options)).join(" ");
    };
    var replaceTilde = (comp, options) => {
      const r6 = options.loose ? re3[t6.TILDELOOSE] : re3[t6.TILDE];
      return comp.replace(r6, (_7, M3, m12, p11, pr2) => {
        debug("tilde", comp, _7, M3, m12, p11, pr2);
        let ret;
        if (isX(M3)) {
          ret = "";
        } else if (isX(m12)) {
          ret = `>=${M3}.0.0 <${+M3 + 1}.0.0-0`;
        } else if (isX(p11)) {
          ret = `>=${M3}.${m12}.0 <${M3}.${+m12 + 1}.0-0`;
        } else if (pr2) {
          debug("replaceTilde pr", pr2);
          ret = `>=${M3}.${m12}.${p11}-${pr2} <${M3}.${+m12 + 1}.0-0`;
        } else {
          ret = `>=${M3}.${m12}.${p11} <${M3}.${+m12 + 1}.0-0`;
        }
        debug("tilde return", ret);
        return ret;
      });
    };
    var replaceCarets = (comp, options) => {
      return comp.trim().split(/\s+/).map((c6) => replaceCaret(c6, options)).join(" ");
    };
    var replaceCaret = (comp, options) => {
      debug("caret", comp, options);
      const r6 = options.loose ? re3[t6.CARETLOOSE] : re3[t6.CARET];
      const z6 = options.includePrerelease ? "-0" : "";
      return comp.replace(r6, (_7, M3, m12, p11, pr2) => {
        debug("caret", comp, _7, M3, m12, p11, pr2);
        let ret;
        if (isX(M3)) {
          ret = "";
        } else if (isX(m12)) {
          ret = `>=${M3}.0.0${z6} <${+M3 + 1}.0.0-0`;
        } else if (isX(p11)) {
          if (M3 === "0") {
            ret = `>=${M3}.${m12}.0${z6} <${M3}.${+m12 + 1}.0-0`;
          } else {
            ret = `>=${M3}.${m12}.0${z6} <${+M3 + 1}.0.0-0`;
          }
        } else if (pr2) {
          debug("replaceCaret pr", pr2);
          if (M3 === "0") {
            if (m12 === "0") {
              ret = `>=${M3}.${m12}.${p11}-${pr2} <${M3}.${m12}.${+p11 + 1}-0`;
            } else {
              ret = `>=${M3}.${m12}.${p11}-${pr2} <${M3}.${+m12 + 1}.0-0`;
            }
          } else {
            ret = `>=${M3}.${m12}.${p11}-${pr2} <${+M3 + 1}.0.0-0`;
          }
        } else {
          debug("no pr");
          if (M3 === "0") {
            if (m12 === "0") {
              ret = `>=${M3}.${m12}.${p11}${z6} <${M3}.${m12}.${+p11 + 1}-0`;
            } else {
              ret = `>=${M3}.${m12}.${p11}${z6} <${M3}.${+m12 + 1}.0-0`;
            }
          } else {
            ret = `>=${M3}.${m12}.${p11} <${+M3 + 1}.0.0-0`;
          }
        }
        debug("caret return", ret);
        return ret;
      });
    };
    var replaceXRanges = (comp, options) => {
      debug("replaceXRanges", comp, options);
      return comp.split(/\s+/).map((c6) => replaceXRange(c6, options)).join(" ");
    };
    var replaceXRange = (comp, options) => {
      comp = comp.trim();
      const r6 = options.loose ? re3[t6.XRANGELOOSE] : re3[t6.XRANGE];
      return comp.replace(r6, (ret, gtlt, M3, m12, p11, pr2) => {
        debug("xRange", comp, ret, gtlt, M3, m12, p11, pr2);
        const xM = isX(M3);
        const xm = xM || isX(m12);
        const xp = xm || isX(p11);
        const anyX = xp;
        if (gtlt === "=" && anyX) {
          gtlt = "";
        }
        pr2 = options.includePrerelease ? "-0" : "";
        if (xM) {
          if (gtlt === ">" || gtlt === "<") {
            ret = "<0.0.0-0";
          } else {
            ret = "*";
          }
        } else if (gtlt && anyX) {
          if (xm) {
            m12 = 0;
          }
          p11 = 0;
          if (gtlt === ">") {
            gtlt = ">=";
            if (xm) {
              M3 = +M3 + 1;
              m12 = 0;
              p11 = 0;
            } else {
              m12 = +m12 + 1;
              p11 = 0;
            }
          } else if (gtlt === "<=") {
            gtlt = "<";
            if (xm) {
              M3 = +M3 + 1;
            } else {
              m12 = +m12 + 1;
            }
          }
          if (gtlt === "<") {
            pr2 = "-0";
          }
          ret = `${gtlt + M3}.${m12}.${p11}${pr2}`;
        } else if (xm) {
          ret = `>=${M3}.0.0${pr2} <${+M3 + 1}.0.0-0`;
        } else if (xp) {
          ret = `>=${M3}.${m12}.0${pr2} <${M3}.${+m12 + 1}.0-0`;
        }
        debug("xRange return", ret);
        return ret;
      });
    };
    var replaceStars = (comp, options) => {
      debug("replaceStars", comp, options);
      return comp.trim().replace(re3[t6.STAR], "");
    };
    var replaceGTE0 = (comp, options) => {
      debug("replaceGTE0", comp, options);
      return comp.trim().replace(re3[options.includePrerelease ? t6.GTE0PRE : t6.GTE0], "");
    };
    var hyphenReplace = (incPr) => ($0, from, fM, fm, fp, fpr, fb, to3, tM, tm, tp, tpr) => {
      if (isX(fM)) {
        from = "";
      } else if (isX(fm)) {
        from = `>=${fM}.0.0${incPr ? "-0" : ""}`;
      } else if (isX(fp)) {
        from = `>=${fM}.${fm}.0${incPr ? "-0" : ""}`;
      } else if (fpr) {
        from = `>=${from}`;
      } else {
        from = `>=${from}${incPr ? "-0" : ""}`;
      }
      if (isX(tM)) {
        to3 = "";
      } else if (isX(tm)) {
        to3 = `<${+tM + 1}.0.0-0`;
      } else if (isX(tp)) {
        to3 = `<${tM}.${+tm + 1}.0-0`;
      } else if (tpr) {
        to3 = `<=${tM}.${tm}.${tp}-${tpr}`;
      } else if (incPr) {
        to3 = `<${tM}.${tm}.${+tp + 1}-0`;
      } else {
        to3 = `<=${to3}`;
      }
      return `${from} ${to3}`.trim();
    };
    var testSet = (set, version3, options) => {
      for (let i8 = 0; i8 < set.length; i8++) {
        if (!set[i8].test(version3)) {
          return false;
        }
      }
      if (version3.prerelease.length && !options.includePrerelease) {
        for (let i8 = 0; i8 < set.length; i8++) {
          debug(set[i8].semver);
          if (set[i8].semver === Comparator.ANY) {
            continue;
          }
          if (set[i8].semver.prerelease.length > 0) {
            const allowed = set[i8].semver;
            if (allowed.major === version3.major && allowed.minor === version3.minor && allowed.patch === version3.patch) {
              return true;
            }
          }
        }
        return false;
      }
      return true;
    };
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js
var require_comparator = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/classes/comparator.js"(exports2, module2) {
    "use strict";
    var ANY = Symbol("SemVer ANY");
    var Comparator = class _Comparator {
      static get ANY() {
        return ANY;
      }
      constructor(comp, options) {
        options = parseOptions2(options);
        if (comp instanceof _Comparator) {
          if (comp.loose === !!options.loose) {
            return comp;
          } else {
            comp = comp.value;
          }
        }
        comp = comp.trim().split(/\s+/).join(" ");
        debug("comparator", comp, options);
        this.options = options;
        this.loose = !!options.loose;
        this.parse(comp);
        if (this.semver === ANY) {
          this.value = "";
        } else {
          this.value = this.operator + this.semver.version;
        }
        debug("comp", this);
      }
      parse(comp) {
        const r6 = this.options.loose ? re3[t6.COMPARATORLOOSE] : re3[t6.COMPARATOR];
        const m12 = comp.match(r6);
        if (!m12) {
          throw new TypeError(`Invalid comparator: ${comp}`);
        }
        this.operator = m12[1] !== void 0 ? m12[1] : "";
        if (this.operator === "=") {
          this.operator = "";
        }
        if (!m12[2]) {
          this.semver = ANY;
        } else {
          this.semver = new SemVer(m12[2], this.options.loose);
        }
      }
      toString() {
        return this.value;
      }
      test(version3) {
        debug("Comparator.test", version3, this.options.loose);
        if (this.semver === ANY || version3 === ANY) {
          return true;
        }
        if (typeof version3 === "string") {
          try {
            version3 = new SemVer(version3, this.options);
          } catch (er3) {
            return false;
          }
        }
        return cmp(version3, this.operator, this.semver, this.options);
      }
      intersects(comp, options) {
        if (!(comp instanceof _Comparator)) {
          throw new TypeError("a Comparator is required");
        }
        if (this.operator === "") {
          if (this.value === "") {
            return true;
          }
          return new Range(comp.value, options).test(this.value);
        } else if (comp.operator === "") {
          if (comp.value === "") {
            return true;
          }
          return new Range(this.value, options).test(comp.semver);
        }
        options = parseOptions2(options);
        if (options.includePrerelease && (this.value === "<0.0.0-0" || comp.value === "<0.0.0-0")) {
          return false;
        }
        if (!options.includePrerelease && (this.value.startsWith("<0.0.0") || comp.value.startsWith("<0.0.0"))) {
          return false;
        }
        if (this.operator.startsWith(">") && comp.operator.startsWith(">")) {
          return true;
        }
        if (this.operator.startsWith("<") && comp.operator.startsWith("<")) {
          return true;
        }
        if (this.semver.version === comp.semver.version && this.operator.includes("=") && comp.operator.includes("=")) {
          return true;
        }
        if (cmp(this.semver, "<", comp.semver, options) && this.operator.startsWith(">") && comp.operator.startsWith("<")) {
          return true;
        }
        if (cmp(this.semver, ">", comp.semver, options) && this.operator.startsWith("<") && comp.operator.startsWith(">")) {
          return true;
        }
        return false;
      }
    };
    module2.exports = Comparator;
    var parseOptions2 = require_parse_options();
    var { safeRe: re3, t: t6 } = require_re();
    var cmp = require_cmp();
    var debug = require_debug();
    var SemVer = require_semver();
    var Range = require_range();
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js
var require_satisfies = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/functions/satisfies.js"(exports2, module2) {
    "use strict";
    var Range = require_range();
    var satisfies = (version3, range, options) => {
      try {
        range = new Range(range, options);
      } catch (er3) {
        return false;
      }
      return range.test(version3);
    };
    module2.exports = satisfies;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js
var require_to_comparators = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/to-comparators.js"(exports2, module2) {
    "use strict";
    var Range = require_range();
    var toComparators = (range, options) => new Range(range, options).set.map((comp) => comp.map((c6) => c6.value).join(" ").trim().split(" "));
    module2.exports = toComparators;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js
var require_max_satisfying = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/max-satisfying.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range = require_range();
    var maxSatisfying = (versions2, range, options) => {
      let max2 = null;
      let maxSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range(range, options);
      } catch (er3) {
        return null;
      }
      versions2.forEach((v11) => {
        if (rangeObj.test(v11)) {
          if (!max2 || maxSV.compare(v11) === -1) {
            max2 = v11;
            maxSV = new SemVer(max2, options);
          }
        }
      });
      return max2;
    };
    module2.exports = maxSatisfying;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js
var require_min_satisfying = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-satisfying.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range = require_range();
    var minSatisfying = (versions2, range, options) => {
      let min2 = null;
      let minSV = null;
      let rangeObj = null;
      try {
        rangeObj = new Range(range, options);
      } catch (er3) {
        return null;
      }
      versions2.forEach((v11) => {
        if (rangeObj.test(v11)) {
          if (!min2 || minSV.compare(v11) === 1) {
            min2 = v11;
            minSV = new SemVer(min2, options);
          }
        }
      });
      return min2;
    };
    module2.exports = minSatisfying;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js
var require_min_version = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/min-version.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Range = require_range();
    var gt6 = require_gt();
    var minVersion = (range, loose) => {
      range = new Range(range, loose);
      let minver = new SemVer("0.0.0");
      if (range.test(minver)) {
        return minver;
      }
      minver = new SemVer("0.0.0-0");
      if (range.test(minver)) {
        return minver;
      }
      minver = null;
      for (let i8 = 0; i8 < range.set.length; ++i8) {
        const comparators = range.set[i8];
        let setMin = null;
        comparators.forEach((comparator) => {
          const compver = new SemVer(comparator.semver.version);
          switch (comparator.operator) {
            case ">":
              if (compver.prerelease.length === 0) {
                compver.patch++;
              } else {
                compver.prerelease.push(0);
              }
              compver.raw = compver.format();
            /* fallthrough */
            case "":
            case ">=":
              if (!setMin || gt6(compver, setMin)) {
                setMin = compver;
              }
              break;
            case "<":
            case "<=":
              break;
            /* istanbul ignore next */
            default:
              throw new Error(`Unexpected operation: ${comparator.operator}`);
          }
        });
        if (setMin && (!minver || gt6(minver, setMin))) {
          minver = setMin;
        }
      }
      if (minver && range.test(minver)) {
        return minver;
      }
      return null;
    };
    module2.exports = minVersion;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js
var require_valid2 = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/valid.js"(exports2, module2) {
    "use strict";
    var Range = require_range();
    var validRange = (range, options) => {
      try {
        return new Range(range, options).range || "*";
      } catch (er3) {
        return null;
      }
    };
    module2.exports = validRange;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js
var require_outside = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/outside.js"(exports2, module2) {
    "use strict";
    var SemVer = require_semver();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var Range = require_range();
    var satisfies = require_satisfies();
    var gt6 = require_gt();
    var lt3 = require_lt();
    var lte2 = require_lte();
    var gte2 = require_gte();
    var outside = (version3, range, hilo, options) => {
      version3 = new SemVer(version3, options);
      range = new Range(range, options);
      let gtfn, ltefn, ltfn, comp, ecomp;
      switch (hilo) {
        case ">":
          gtfn = gt6;
          ltefn = lte2;
          ltfn = lt3;
          comp = ">";
          ecomp = ">=";
          break;
        case "<":
          gtfn = lt3;
          ltefn = gte2;
          ltfn = gt6;
          comp = "<";
          ecomp = "<=";
          break;
        default:
          throw new TypeError('Must provide a hilo val of "<" or ">"');
      }
      if (satisfies(version3, range, options)) {
        return false;
      }
      for (let i8 = 0; i8 < range.set.length; ++i8) {
        const comparators = range.set[i8];
        let high = null;
        let low = null;
        comparators.forEach((comparator) => {
          if (comparator.semver === ANY) {
            comparator = new Comparator(">=0.0.0");
          }
          high = high || comparator;
          low = low || comparator;
          if (gtfn(comparator.semver, high.semver, options)) {
            high = comparator;
          } else if (ltfn(comparator.semver, low.semver, options)) {
            low = comparator;
          }
        });
        if (high.operator === comp || high.operator === ecomp) {
          return false;
        }
        if ((!low.operator || low.operator === comp) && ltefn(version3, low.semver)) {
          return false;
        } else if (low.operator === ecomp && ltfn(version3, low.semver)) {
          return false;
        }
      }
      return true;
    };
    module2.exports = outside;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js
var require_gtr = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/gtr.js"(exports2, module2) {
    "use strict";
    var outside = require_outside();
    var gtr = (version3, range, options) => outside(version3, range, ">", options);
    module2.exports = gtr;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js
var require_ltr = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/ltr.js"(exports2, module2) {
    "use strict";
    var outside = require_outside();
    var ltr = (version3, range, options) => outside(version3, range, "<", options);
    module2.exports = ltr;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js
var require_intersects = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/intersects.js"(exports2, module2) {
    "use strict";
    var Range = require_range();
    var intersects = (r1, r22, options) => {
      r1 = new Range(r1, options);
      r22 = new Range(r22, options);
      return r1.intersects(r22, options);
    };
    module2.exports = intersects;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js
var require_simplify = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/simplify.js"(exports2, module2) {
    "use strict";
    var satisfies = require_satisfies();
    var compare = require_compare();
    module2.exports = (versions2, range, options) => {
      const set = [];
      let first = null;
      let prev = null;
      const v11 = versions2.sort((a9, b9) => compare(a9, b9, options));
      for (const version3 of v11) {
        const included = satisfies(version3, range, options);
        if (included) {
          prev = version3;
          if (!first) {
            first = version3;
          }
        } else {
          if (prev) {
            set.push([first, prev]);
          }
          prev = null;
          first = null;
        }
      }
      if (first) {
        set.push([first, null]);
      }
      const ranges = [];
      for (const [min2, max2] of set) {
        if (min2 === max2) {
          ranges.push(min2);
        } else if (!max2 && min2 === v11[0]) {
          ranges.push("*");
        } else if (!max2) {
          ranges.push(`>=${min2}`);
        } else if (min2 === v11[0]) {
          ranges.push(`<=${max2}`);
        } else {
          ranges.push(`${min2} - ${max2}`);
        }
      }
      const simplified = ranges.join(" || ");
      const original = typeof range.raw === "string" ? range.raw : String(range);
      return simplified.length < original.length ? simplified : range;
    };
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js
var require_subset = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/ranges/subset.js"(exports2, module2) {
    "use strict";
    var Range = require_range();
    var Comparator = require_comparator();
    var { ANY } = Comparator;
    var satisfies = require_satisfies();
    var compare = require_compare();
    var subset = (sub, dom, options = {}) => {
      if (sub === dom) {
        return true;
      }
      sub = new Range(sub, options);
      dom = new Range(dom, options);
      let sawNonNull = false;
      OUTER: for (const simpleSub of sub.set) {
        for (const simpleDom of dom.set) {
          const isSub = simpleSubset(simpleSub, simpleDom, options);
          sawNonNull = sawNonNull || isSub !== null;
          if (isSub) {
            continue OUTER;
          }
        }
        if (sawNonNull) {
          return false;
        }
      }
      return true;
    };
    var minimumVersionWithPreRelease = [new Comparator(">=0.0.0-0")];
    var minimumVersion = [new Comparator(">=0.0.0")];
    var simpleSubset = (sub, dom, options) => {
      if (sub === dom) {
        return true;
      }
      if (sub.length === 1 && sub[0].semver === ANY) {
        if (dom.length === 1 && dom[0].semver === ANY) {
          return true;
        } else if (options.includePrerelease) {
          sub = minimumVersionWithPreRelease;
        } else {
          sub = minimumVersion;
        }
      }
      if (dom.length === 1 && dom[0].semver === ANY) {
        if (options.includePrerelease) {
          return true;
        } else {
          dom = minimumVersion;
        }
      }
      const eqSet = /* @__PURE__ */ new Set();
      let gt6, lt3;
      for (const c6 of sub) {
        if (c6.operator === ">" || c6.operator === ">=") {
          gt6 = higherGT(gt6, c6, options);
        } else if (c6.operator === "<" || c6.operator === "<=") {
          lt3 = lowerLT(lt3, c6, options);
        } else {
          eqSet.add(c6.semver);
        }
      }
      if (eqSet.size > 1) {
        return null;
      }
      let gtltComp;
      if (gt6 && lt3) {
        gtltComp = compare(gt6.semver, lt3.semver, options);
        if (gtltComp > 0) {
          return null;
        } else if (gtltComp === 0 && (gt6.operator !== ">=" || lt3.operator !== "<=")) {
          return null;
        }
      }
      for (const eq2 of eqSet) {
        if (gt6 && !satisfies(eq2, String(gt6), options)) {
          return null;
        }
        if (lt3 && !satisfies(eq2, String(lt3), options)) {
          return null;
        }
        for (const c6 of dom) {
          if (!satisfies(eq2, String(c6), options)) {
            return false;
          }
        }
        return true;
      }
      let higher, lower2;
      let hasDomLT, hasDomGT;
      let needDomLTPre = lt3 && !options.includePrerelease && lt3.semver.prerelease.length ? lt3.semver : false;
      let needDomGTPre = gt6 && !options.includePrerelease && gt6.semver.prerelease.length ? gt6.semver : false;
      if (needDomLTPre && needDomLTPre.prerelease.length === 1 && lt3.operator === "<" && needDomLTPre.prerelease[0] === 0) {
        needDomLTPre = false;
      }
      for (const c6 of dom) {
        hasDomGT = hasDomGT || c6.operator === ">" || c6.operator === ">=";
        hasDomLT = hasDomLT || c6.operator === "<" || c6.operator === "<=";
        if (gt6) {
          if (needDomGTPre) {
            if (c6.semver.prerelease && c6.semver.prerelease.length && c6.semver.major === needDomGTPre.major && c6.semver.minor === needDomGTPre.minor && c6.semver.patch === needDomGTPre.patch) {
              needDomGTPre = false;
            }
          }
          if (c6.operator === ">" || c6.operator === ">=") {
            higher = higherGT(gt6, c6, options);
            if (higher === c6 && higher !== gt6) {
              return false;
            }
          } else if (gt6.operator === ">=" && !satisfies(gt6.semver, String(c6), options)) {
            return false;
          }
        }
        if (lt3) {
          if (needDomLTPre) {
            if (c6.semver.prerelease && c6.semver.prerelease.length && c6.semver.major === needDomLTPre.major && c6.semver.minor === needDomLTPre.minor && c6.semver.patch === needDomLTPre.patch) {
              needDomLTPre = false;
            }
          }
          if (c6.operator === "<" || c6.operator === "<=") {
            lower2 = lowerLT(lt3, c6, options);
            if (lower2 === c6 && lower2 !== lt3) {
              return false;
            }
          } else if (lt3.operator === "<=" && !satisfies(lt3.semver, String(c6), options)) {
            return false;
          }
        }
        if (!c6.operator && (lt3 || gt6) && gtltComp !== 0) {
          return false;
        }
      }
      if (gt6 && hasDomLT && !lt3 && gtltComp !== 0) {
        return false;
      }
      if (lt3 && hasDomGT && !gt6 && gtltComp !== 0) {
        return false;
      }
      if (needDomGTPre || needDomLTPre) {
        return false;
      }
      return true;
    };
    var higherGT = (a9, b9, options) => {
      if (!a9) {
        return b9;
      }
      const comp = compare(a9.semver, b9.semver, options);
      return comp > 0 ? a9 : comp < 0 ? b9 : b9.operator === ">" && a9.operator === ">=" ? b9 : a9;
    };
    var lowerLT = (a9, b9, options) => {
      if (!a9) {
        return b9;
      }
      const comp = compare(a9.semver, b9.semver, options);
      return comp < 0 ? a9 : comp > 0 ? b9 : b9.operator === "<" && a9.operator === "<=" ? b9 : a9;
    };
    module2.exports = subset;
  }
});

// ../node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js
var require_semver2 = __commonJS({
  "../node_modules/.pnpm/semver@7.7.2/node_modules/semver/index.js"(exports2, module2) {
    "use strict";
    var internalRe = require_re();
    var constants = require_constants2();
    var SemVer = require_semver();
    var identifiers = require_identifiers();
    var parse6 = require_parse();
    var valid = require_valid();
    var clean = require_clean();
    var inc = require_inc();
    var diff2 = require_diff();
    var major = require_major();
    var minor = require_minor();
    var patch = require_patch();
    var prerelease = require_prerelease();
    var compare = require_compare();
    var rcompare = require_rcompare();
    var compareLoose = require_compare_loose();
    var compareBuild = require_compare_build();
    var sort = require_sort();
    var rsort = require_rsort();
    var gt6 = require_gt();
    var lt3 = require_lt();
    var eq2 = require_eq();
    var neq = require_neq();
    var gte2 = require_gte();
    var lte2 = require_lte();
    var cmp = require_cmp();
    var coerce2 = require_coerce();
    var Comparator = require_comparator();
    var Range = require_range();
    var satisfies = require_satisfies();
    var toComparators = require_to_comparators();
    var maxSatisfying = require_max_satisfying();
    var minSatisfying = require_min_satisfying();
    var minVersion = require_min_version();
    var validRange = require_valid2();
    var outside = require_outside();
    var gtr = require_gtr();
    var ltr = require_ltr();
    var intersects = require_intersects();
    var simplifyRange = require_simplify();
    var subset = require_subset();
    module2.exports = {
      parse: parse6,
      valid,
      clean,
      inc,
      diff: diff2,
      major,
      minor,
      patch,
      prerelease,
      compare,
      rcompare,
      compareLoose,
      compareBuild,
      sort,
      rsort,
      gt: gt6,
      lt: lt3,
      eq: eq2,
      neq,
      gte: gte2,
      lte: lte2,
      cmp,
      coerce: coerce2,
      Comparator,
      Range,
      satisfies,
      toComparators,
      maxSatisfying,
      minSatisfying,
      minVersion,
      validRange,
      outside,
      gtr,
      ltr,
      intersects,
      simplifyRange,
      subset,
      SemVer,
      re: internalRe.re,
      src: internalRe.src,
      tokens: internalRe.t,
      SEMVER_SPEC_VERSION: constants.SEMVER_SPEC_VERSION,
      RELEASE_TYPES: constants.RELEASE_TYPES,
      compareIdentifiers: identifiers.compareIdentifiers,
      rcompareIdentifiers: identifiers.rcompareIdentifiers
    };
  }
});

// src/cli/utils.ts
var import_semver, checkPackage, assertPackages;
var init_utils11 = __esm({
  "src/cli/utils.ts"() {
    "use strict";
    import_semver = __toESM(require_semver2());
    init_views();
    checkPackage = async (it2) => {
      try {
        require(it2);
        return true;
      } catch (e6) {
        return false;
      }
    };
    assertPackages = async (...pkgs) => {
      try {
        for (let i8 = 0; i8 < pkgs.length; i8++) {
          const it2 = pkgs[i8];
          require(it2);
        }
      } catch (e6) {
        err2(
          `please install required packages: ${pkgs.map((it2) => `'${it2}'`).join(" ")}`
        );
        process.exit(1);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/extensions/httpExtensionConfiguration.js
var getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig;
var init_httpExtensionConfiguration = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/extensions/httpExtensionConfiguration.js"() {
    "use strict";
    getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
      return {
        setHttpHandler(handler) {
          runtimeConfig.httpHandler = handler;
        },
        httpHandler() {
          return runtimeConfig.httpHandler;
        },
        updateHttpClientConfig(key, value) {
          runtimeConfig.httpHandler?.updateHttpClientConfig(key, value);
        },
        httpHandlerConfigs() {
          return runtimeConfig.httpHandler.httpHandlerConfigs();
        }
      };
    };
    resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
      return {
        httpHandler: httpHandlerExtensionConfiguration.httpHandler()
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/extensions/index.js
var init_extensions = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/extensions/index.js"() {
    "use strict";
    init_httpExtensionConfiguration();
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/abort.js
var init_abort = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/abort.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/auth.js
var HttpAuthLocation;
var init_auth = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/auth.js"() {
    "use strict";
    (function(HttpAuthLocation2) {
      HttpAuthLocation2["HEADER"] = "header";
      HttpAuthLocation2["QUERY"] = "query";
    })(HttpAuthLocation || (HttpAuthLocation = {}));
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpApiKeyAuth.js
var HttpApiKeyAuthLocation;
var init_HttpApiKeyAuth = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpApiKeyAuth.js"() {
    "use strict";
    (function(HttpApiKeyAuthLocation2) {
      HttpApiKeyAuthLocation2["HEADER"] = "header";
      HttpApiKeyAuthLocation2["QUERY"] = "query";
    })(HttpApiKeyAuthLocation || (HttpApiKeyAuthLocation = {}));
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpAuthScheme.js
var init_HttpAuthScheme = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpAuthScheme.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpAuthSchemeProvider.js
var init_HttpAuthSchemeProvider = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpAuthSchemeProvider.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpSigner.js
var init_HttpSigner = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/HttpSigner.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/IdentityProviderConfig.js
var init_IdentityProviderConfig = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/IdentityProviderConfig.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/index.js
var init_auth2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/auth/index.js"() {
    "use strict";
    init_auth();
    init_HttpApiKeyAuth();
    init_HttpAuthScheme();
    init_HttpAuthSchemeProvider();
    init_HttpSigner();
    init_IdentityProviderConfig();
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/blob/blob-payload-input-types.js
var init_blob_payload_input_types = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/blob/blob-payload-input-types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/checksum.js
var init_checksum = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/checksum.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/client.js
var init_client = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/client.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/command.js
var init_command = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/command.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/config.js
var init_config = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/config.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/manager.js
var init_manager = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/manager.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/pool.js
var init_pool = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/pool.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/index.js
var init_connection = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/connection/index.js"() {
    "use strict";
    init_config();
    init_manager();
    init_pool();
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/crypto.js
var init_crypto2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/crypto.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/encode.js
var init_encode = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/encode.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoint.js
var EndpointURLScheme;
var init_endpoint = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoint.js"() {
    "use strict";
    (function(EndpointURLScheme2) {
      EndpointURLScheme2["HTTP"] = "http";
      EndpointURLScheme2["HTTPS"] = "https";
    })(EndpointURLScheme || (EndpointURLScheme = {}));
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/EndpointRuleObject.js
var init_EndpointRuleObject = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/EndpointRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/ErrorRuleObject.js
var init_ErrorRuleObject = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/ErrorRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/RuleSetObject.js
var init_RuleSetObject = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/RuleSetObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/shared.js
var init_shared = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/shared.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/TreeRuleObject.js
var init_TreeRuleObject = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/TreeRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/index.js
var init_endpoints = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/endpoints/index.js"() {
    "use strict";
    init_EndpointRuleObject();
    init_ErrorRuleObject();
    init_RuleSetObject();
    init_shared();
    init_TreeRuleObject();
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/eventStream.js
var init_eventStream = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/eventStream.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/checksum.js
var AlgorithmId;
var init_checksum2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/checksum.js"() {
    "use strict";
    (function(AlgorithmId2) {
      AlgorithmId2["MD5"] = "md5";
      AlgorithmId2["CRC32"] = "crc32";
      AlgorithmId2["CRC32C"] = "crc32c";
      AlgorithmId2["SHA1"] = "sha1";
      AlgorithmId2["SHA256"] = "sha256";
    })(AlgorithmId || (AlgorithmId = {}));
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/defaultClientConfiguration.js
var init_defaultClientConfiguration = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/defaultClientConfiguration.js"() {
    "use strict";
    init_checksum2();
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/defaultExtensionConfiguration.js
var init_defaultExtensionConfiguration = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/defaultExtensionConfiguration.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/index.js
var init_extensions2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/extensions/index.js"() {
    "use strict";
    init_defaultClientConfiguration();
    init_defaultExtensionConfiguration();
    init_checksum2();
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/feature-ids.js
var init_feature_ids = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/feature-ids.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/http.js
var FieldPosition;
var init_http = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/http.js"() {
    "use strict";
    (function(FieldPosition2) {
      FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER";
      FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER";
    })(FieldPosition || (FieldPosition = {}));
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/http/httpHandlerInitialization.js
var init_httpHandlerInitialization = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/http/httpHandlerInitialization.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/apiKeyIdentity.js
var init_apiKeyIdentity = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/apiKeyIdentity.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/awsCredentialIdentity.js
var init_awsCredentialIdentity = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/awsCredentialIdentity.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/identity.js
var init_identity = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/identity.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/tokenIdentity.js
var init_tokenIdentity = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/tokenIdentity.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/index.js
var init_identity2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/identity/index.js"() {
    "use strict";
    init_apiKeyIdentity();
    init_awsCredentialIdentity();
    init_identity();
    init_tokenIdentity();
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/logger.js
var init_logger2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/logger.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/middleware.js
var SMITHY_CONTEXT_KEY;
var init_middleware = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/middleware.js"() {
    "use strict";
    SMITHY_CONTEXT_KEY = "__smithy_context";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/pagination.js
var init_pagination = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/pagination.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/profile.js
var IniSectionType;
var init_profile = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/profile.js"() {
    "use strict";
    (function(IniSectionType2) {
      IniSectionType2["PROFILE"] = "profile";
      IniSectionType2["SSO_SESSION"] = "sso-session";
      IniSectionType2["SERVICES"] = "services";
    })(IniSectionType || (IniSectionType = {}));
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/response.js
var init_response2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/response.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/retry.js
var init_retry = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/retry.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/schema/schema.js
var init_schema4 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/schema/schema.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/schema/sentinels.js
var init_sentinels = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/schema/sentinels.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/serde.js
var init_serde = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/serde.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/shapes.js
var init_shapes = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/shapes.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/signature.js
var init_signature = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/signature.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/stream.js
var init_stream = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/stream.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/streaming-payload/streaming-blob-common-types.js
var init_streaming_blob_common_types = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/streaming-payload/streaming-blob-common-types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/streaming-payload/streaming-blob-payload-input-types.js
var init_streaming_blob_payload_input_types = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/streaming-payload/streaming-blob-payload-input-types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/streaming-payload/streaming-blob-payload-output-types.js
var init_streaming_blob_payload_output_types = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/streaming-payload/streaming-blob-payload-output-types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transfer.js
var RequestHandlerProtocol;
var init_transfer = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transfer.js"() {
    "use strict";
    (function(RequestHandlerProtocol2) {
      RequestHandlerProtocol2["HTTP_0_9"] = "http/0.9";
      RequestHandlerProtocol2["HTTP_1_0"] = "http/1.0";
      RequestHandlerProtocol2["TDS_8_0"] = "tds/8.0";
    })(RequestHandlerProtocol || (RequestHandlerProtocol = {}));
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/client-payload-blob-type-narrow.js
var init_client_payload_blob_type_narrow = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/client-payload-blob-type-narrow.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/mutable.js
var init_mutable = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/mutable.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/no-undefined.js
var init_no_undefined = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/no-undefined.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/type-transform.js
var init_type_transform = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/transform/type-transform.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/uri.js
var init_uri = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/uri.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/util.js
var init_util2 = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/util.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/waiter.js
var init_waiter = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/waiter.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/index.js
var init_dist_es = __esm({
  "../node_modules/.pnpm/@smithy+types@4.3.1/node_modules/@smithy/types/dist-es/index.js"() {
    "use strict";
    init_abort();
    init_auth2();
    init_blob_payload_input_types();
    init_checksum();
    init_client();
    init_command();
    init_connection();
    init_crypto2();
    init_encode();
    init_endpoint();
    init_endpoints();
    init_eventStream();
    init_extensions2();
    init_feature_ids();
    init_http();
    init_httpHandlerInitialization();
    init_identity2();
    init_logger2();
    init_middleware();
    init_pagination();
    init_profile();
    init_response2();
    init_retry();
    init_schema4();
    init_sentinels();
    init_serde();
    init_shapes();
    init_signature();
    init_stream();
    init_streaming_blob_common_types();
    init_streaming_blob_payload_input_types();
    init_streaming_blob_payload_output_types();
    init_transfer();
    init_client_payload_blob_type_narrow();
    init_mutable();
    init_no_undefined();
    init_type_transform();
    init_uri();
    init_util2();
    init_waiter();
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/Field.js
var init_Field = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/Field.js"() {
    "use strict";
    init_dist_es();
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/Fields.js
var init_Fields = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/Fields.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/httpHandler.js
var init_httpHandler = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/httpHandler.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/httpRequest.js
function cloneQuery(query) {
  return Object.keys(query).reduce((carry, paramName) => {
    const param2 = query[paramName];
    return {
      ...carry,
      [paramName]: Array.isArray(param2) ? [...param2] : param2
    };
  }, {});
}
var HttpRequest;
var init_httpRequest = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/httpRequest.js"() {
    "use strict";
    HttpRequest = class _HttpRequest {
      constructor(options) {
        this.method = options.method || "GET";
        this.hostname = options.hostname || "localhost";
        this.port = options.port;
        this.query = options.query || {};
        this.headers = options.headers || {};
        this.body = options.body;
        this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
        this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
        this.username = options.username;
        this.password = options.password;
        this.fragment = options.fragment;
      }
      static clone(request2) {
        const cloned = new _HttpRequest({
          ...request2,
          headers: { ...request2.headers }
        });
        if (cloned.query) {
          cloned.query = cloneQuery(cloned.query);
        }
        return cloned;
      }
      static isInstance(request2) {
        if (!request2) {
          return false;
        }
        const req = request2;
        return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
      }
      clone() {
        return _HttpRequest.clone(this);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/httpResponse.js
var HttpResponse;
var init_httpResponse = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/httpResponse.js"() {
    "use strict";
    HttpResponse = class {
      constructor(options) {
        this.statusCode = options.statusCode;
        this.reason = options.reason;
        this.headers = options.headers || {};
        this.body = options.body;
      }
      static isInstance(response) {
        if (!response)
          return false;
        const resp = response;
        return typeof resp.statusCode === "number" && typeof resp.headers === "object";
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/isValidHostname.js
var init_isValidHostname = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/isValidHostname.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/types.js
var init_types2 = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/index.js
var init_dist_es2 = __esm({
  "../node_modules/.pnpm/@smithy+protocol-http@5.1.2/node_modules/@smithy/protocol-http/dist-es/index.js"() {
    "use strict";
    init_extensions();
    init_Field();
    init_Fields();
    init_httpHandler();
    init_httpRequest();
    init_httpResponse();
    init_isValidHostname();
    init_types2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-host-header@3.804.0/node_modules/@aws-sdk/middleware-host-header/dist-es/index.js
function resolveHostHeaderConfig(input) {
  return input;
}
var hostHeaderMiddleware, hostHeaderMiddlewareOptions, getHostHeaderPlugin;
var init_dist_es3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-host-header@3.804.0/node_modules/@aws-sdk/middleware-host-header/dist-es/index.js"() {
    "use strict";
    init_dist_es2();
    hostHeaderMiddleware = (options) => (next) => async (args2) => {
      if (!HttpRequest.isInstance(args2.request))
        return next(args2);
      const { request: request2 } = args2;
      const { handlerProtocol = "" } = options.requestHandler.metadata || {};
      if (handlerProtocol.indexOf("h2") >= 0 && !request2.headers[":authority"]) {
        delete request2.headers["host"];
        request2.headers[":authority"] = request2.hostname + (request2.port ? ":" + request2.port : "");
      } else if (!request2.headers["host"]) {
        let host = request2.hostname;
        if (request2.port != null)
          host += `:${request2.port}`;
        request2.headers["host"] = host;
      }
      return next(args2);
    };
    hostHeaderMiddlewareOptions = {
      name: "hostHeaderMiddleware",
      step: "build",
      priority: "low",
      tags: ["HOST"],
      override: true
    };
    getHostHeaderPlugin = (options) => ({
      applyToStack: (clientStack) => {
        clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-logger@3.804.0/node_modules/@aws-sdk/middleware-logger/dist-es/loggerMiddleware.js
var loggerMiddleware, loggerMiddlewareOptions, getLoggerPlugin;
var init_loggerMiddleware = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-logger@3.804.0/node_modules/@aws-sdk/middleware-logger/dist-es/loggerMiddleware.js"() {
    "use strict";
    loggerMiddleware = () => (next, context) => async (args2) => {
      try {
        const response = await next(args2);
        const { clientName, commandName, logger: logger2, dynamoDbDocumentClientOptions = {} } = context;
        const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
        const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
        const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
        const { $metadata, ...outputWithoutMetadata } = response.output;
        logger2?.info?.({
          clientName,
          commandName,
          input: inputFilterSensitiveLog(args2.input),
          output: outputFilterSensitiveLog(outputWithoutMetadata),
          metadata: $metadata
        });
        return response;
      } catch (error2) {
        const { clientName, commandName, logger: logger2, dynamoDbDocumentClientOptions = {} } = context;
        const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
        const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
        logger2?.error?.({
          clientName,
          commandName,
          input: inputFilterSensitiveLog(args2.input),
          error: error2,
          metadata: error2.$metadata
        });
        throw error2;
      }
    };
    loggerMiddlewareOptions = {
      name: "loggerMiddleware",
      tags: ["LOGGER"],
      step: "initialize",
      override: true
    };
    getLoggerPlugin = (options) => ({
      applyToStack: (clientStack) => {
        clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-logger@3.804.0/node_modules/@aws-sdk/middleware-logger/dist-es/index.js
var init_dist_es4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-logger@3.804.0/node_modules/@aws-sdk/middleware-logger/dist-es/index.js"() {
    "use strict";
    init_loggerMiddleware();
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-recursion-detection@3.804.0/node_modules/@aws-sdk/middleware-recursion-detection/dist-es/index.js
var TRACE_ID_HEADER_NAME, ENV_LAMBDA_FUNCTION_NAME, ENV_TRACE_ID, recursionDetectionMiddleware, addRecursionDetectionMiddlewareOptions, getRecursionDetectionPlugin;
var init_dist_es5 = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-recursion-detection@3.804.0/node_modules/@aws-sdk/middleware-recursion-detection/dist-es/index.js"() {
    "use strict";
    init_dist_es2();
    TRACE_ID_HEADER_NAME = "X-Amzn-Trace-Id";
    ENV_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
    ENV_TRACE_ID = "_X_AMZN_TRACE_ID";
    recursionDetectionMiddleware = (options) => (next) => async (args2) => {
      const { request: request2 } = args2;
      if (!HttpRequest.isInstance(request2) || options.runtime !== "node") {
        return next(args2);
      }
      const traceIdHeader = Object.keys(request2.headers ?? {}).find((h8) => h8.toLowerCase() === TRACE_ID_HEADER_NAME.toLowerCase()) ?? TRACE_ID_HEADER_NAME;
      if (request2.headers.hasOwnProperty(traceIdHeader)) {
        return next(args2);
      }
      const functionName = process.env[ENV_LAMBDA_FUNCTION_NAME];
      const traceId = process.env[ENV_TRACE_ID];
      const nonEmptyString = (str) => typeof str === "string" && str.length > 0;
      if (nonEmptyString(functionName) && nonEmptyString(traceId)) {
        request2.headers[TRACE_ID_HEADER_NAME] = traceId;
      }
      return next({
        ...args2,
        request: request2
      });
    };
    addRecursionDetectionMiddlewareOptions = {
      step: "build",
      tags: ["RECURSION_DETECTION"],
      name: "recursionDetectionMiddleware",
      override: true,
      priority: "low"
    };
    getRecursionDetectionPlugin = (options) => ({
      applyToStack: (clientStack) => {
        clientStack.add(recursionDetectionMiddleware(options), addRecursionDetectionMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/getSmithyContext.js
var init_getSmithyContext = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/getSmithyContext.js"() {
    "use strict";
    init_dist_es();
  }
});

// ../node_modules/.pnpm/@smithy+util-middleware@4.0.4/node_modules/@smithy/util-middleware/dist-es/getSmithyContext.js
var getSmithyContext;
var init_getSmithyContext2 = __esm({
  "../node_modules/.pnpm/@smithy+util-middleware@4.0.4/node_modules/@smithy/util-middleware/dist-es/getSmithyContext.js"() {
    "use strict";
    init_dist_es();
    getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
  }
});

// ../node_modules/.pnpm/@smithy+util-middleware@4.0.4/node_modules/@smithy/util-middleware/dist-es/normalizeProvider.js
var normalizeProvider;
var init_normalizeProvider = __esm({
  "../node_modules/.pnpm/@smithy+util-middleware@4.0.4/node_modules/@smithy/util-middleware/dist-es/normalizeProvider.js"() {
    "use strict";
    normalizeProvider = (input) => {
      if (typeof input === "function")
        return input;
      const promisified = Promise.resolve(input);
      return () => promisified;
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-middleware@4.0.4/node_modules/@smithy/util-middleware/dist-es/index.js
var init_dist_es6 = __esm({
  "../node_modules/.pnpm/@smithy+util-middleware@4.0.4/node_modules/@smithy/util-middleware/dist-es/index.js"() {
    "use strict";
    init_getSmithyContext2();
    init_normalizeProvider();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/resolveAuthOptions.js
var resolveAuthOptions;
var init_resolveAuthOptions = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/resolveAuthOptions.js"() {
    "use strict";
    resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
      if (!authSchemePreference || authSchemePreference.length === 0) {
        return candidateAuthOptions;
      }
      const preferredAuthOptions = [];
      for (const preferredSchemeName of authSchemePreference) {
        for (const candidateAuthOption of candidateAuthOptions) {
          const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
          if (candidateAuthSchemeName === preferredSchemeName) {
            preferredAuthOptions.push(candidateAuthOption);
          }
        }
      }
      for (const candidateAuthOption of candidateAuthOptions) {
        if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
          preferredAuthOptions.push(candidateAuthOption);
        }
      }
      return preferredAuthOptions;
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js
function convertHttpAuthSchemesToMap(httpAuthSchemes) {
  const map2 = /* @__PURE__ */ new Map();
  for (const scheme of httpAuthSchemes) {
    map2.set(scheme.schemeId, scheme);
  }
  return map2;
}
var httpAuthSchemeMiddleware;
var init_httpAuthSchemeMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/httpAuthSchemeMiddleware.js"() {
    "use strict";
    init_dist_es();
    init_dist_es6();
    init_resolveAuthOptions();
    httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args2) => {
      const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args2.input));
      const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
      const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
      const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
      const smithyContext = getSmithyContext(context);
      const failureReasons = [];
      for (const option of resolvedOptions) {
        const scheme = authSchemes.get(option.schemeId);
        if (!scheme) {
          failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
          continue;
        }
        const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
        if (!identityProvider) {
          failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
          continue;
        }
        const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
        option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
        option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
        smithyContext.selectedHttpAuthScheme = {
          httpAuthOption: option,
          identity: await identityProvider(option.identityProperties),
          signer: scheme.signer
        };
        break;
      }
      if (!smithyContext.selectedHttpAuthScheme) {
        throw new Error(failureReasons.join("\n"));
      }
      return next(args2);
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.js
var httpAuthSchemeEndpointRuleSetMiddlewareOptions, getHttpAuthSchemeEndpointRuleSetPlugin;
var init_getHttpAuthSchemeEndpointRuleSetPlugin = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.js"() {
    "use strict";
    init_httpAuthSchemeMiddleware();
    httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
      step: "serialize",
      tags: ["HTTP_AUTH_SCHEME"],
      name: "httpAuthSchemeMiddleware",
      override: true,
      relation: "before",
      toMiddleware: "endpointV2Middleware"
    };
    getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
      applyToStack: (clientStack) => {
        clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
          httpAuthSchemeParametersProvider,
          identityProviderConfigProvider
        }), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/deserializerMiddleware.js
var deserializerMiddleware, findHeader;
var init_deserializerMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/deserializerMiddleware.js"() {
    "use strict";
    init_dist_es2();
    deserializerMiddleware = (options, deserializer) => (next, context) => async (args2) => {
      const { response } = await next(args2);
      try {
        const parsed = await deserializer(response, options);
        return {
          response,
          output: parsed
        };
      } catch (error2) {
        Object.defineProperty(error2, "$response", {
          value: response
        });
        if (!("$metadata" in error2)) {
          const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
          try {
            error2.message += "\n  " + hint;
          } catch (e6) {
            if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
              console.warn(hint);
            } else {
              context.logger?.warn?.(hint);
            }
          }
          if (typeof error2.$responseBodyText !== "undefined") {
            if (error2.$response) {
              error2.$response.body = error2.$responseBodyText;
            }
          }
          try {
            if (HttpResponse.isInstance(response)) {
              const { headers = {} } = response;
              const headerEntries = Object.entries(headers);
              error2.$metadata = {
                httpStatusCode: response.statusCode,
                requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
                extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
                cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
              };
            }
          } catch (e6) {
          }
        }
        throw error2;
      }
    };
    findHeader = (pattern, headers) => {
      return (headers.find(([k9]) => {
        return k9.match(pattern);
      }) || [void 0, void 0])[1];
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/serializerMiddleware.js
var serializerMiddleware;
var init_serializerMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/serializerMiddleware.js"() {
    "use strict";
    serializerMiddleware = (options, serializer) => (next, context) => async (args2) => {
      const endpointConfig = options;
      const endpoint = context.endpointV2?.url && endpointConfig.urlParser ? async () => endpointConfig.urlParser(context.endpointV2.url) : endpointConfig.endpoint;
      if (!endpoint) {
        throw new Error("No valid endpoint provider available.");
      }
      const request2 = await serializer(args2.input, { ...options, endpoint });
      return next({
        ...args2,
        request: request2
      });
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/serdePlugin.js
function getSerdePlugin(config, serializer, deserializer) {
  return {
    applyToStack: (commandStack) => {
      commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
      commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
    }
  };
}
var deserializerMiddlewareOption, serializerMiddlewareOption;
var init_serdePlugin = __esm({
  "../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/serdePlugin.js"() {
    "use strict";
    init_deserializerMiddleware();
    init_serializerMiddleware();
    deserializerMiddlewareOption = {
      name: "deserializerMiddleware",
      step: "deserialize",
      tags: ["DESERIALIZER"],
      override: true
    };
    serializerMiddlewareOption = {
      name: "serializerMiddleware",
      step: "serialize",
      tags: ["SERIALIZER"],
      override: true
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/index.js
var init_dist_es7 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-serde@4.0.8/node_modules/@smithy/middleware-serde/dist-es/index.js"() {
    "use strict";
    init_deserializerMiddleware();
    init_serdePlugin();
    init_serializerMiddleware();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemePlugin.js
var httpAuthSchemeMiddlewareOptions;
var init_getHttpAuthSchemePlugin = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/getHttpAuthSchemePlugin.js"() {
    "use strict";
    init_dist_es7();
    init_httpAuthSchemeMiddleware();
    httpAuthSchemeMiddlewareOptions = {
      step: "serialize",
      tags: ["HTTP_AUTH_SCHEME"],
      name: "httpAuthSchemeMiddleware",
      override: true,
      relation: "before",
      toMiddleware: serializerMiddlewareOption.name
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/index.js
var init_middleware_http_auth_scheme = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-auth-scheme/index.js"() {
    "use strict";
    init_httpAuthSchemeMiddleware();
    init_getHttpAuthSchemeEndpointRuleSetPlugin();
    init_getHttpAuthSchemePlugin();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js
var defaultErrorHandler, defaultSuccessHandler, httpSigningMiddleware;
var init_httpSigningMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-signing/httpSigningMiddleware.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es();
    init_dist_es6();
    defaultErrorHandler = (signingProperties) => (error2) => {
      throw error2;
    };
    defaultSuccessHandler = (httpResponse, signingProperties) => {
    };
    httpSigningMiddleware = (config) => (next, context) => async (args2) => {
      if (!HttpRequest.isInstance(args2.request)) {
        return next(args2);
      }
      const smithyContext = getSmithyContext(context);
      const scheme = smithyContext.selectedHttpAuthScheme;
      if (!scheme) {
        throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
      }
      const { httpAuthOption: { signingProperties = {} }, identity, signer } = scheme;
      const output = await next({
        ...args2,
        request: await signer.sign(args2.request, identity, signingProperties)
      }).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
      (signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
      return output;
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-signing/getHttpSigningMiddleware.js
var httpSigningMiddlewareOptions, getHttpSigningPlugin;
var init_getHttpSigningMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-signing/getHttpSigningMiddleware.js"() {
    "use strict";
    init_httpSigningMiddleware();
    httpSigningMiddlewareOptions = {
      step: "finalizeRequest",
      tags: ["HTTP_SIGNING"],
      name: "httpSigningMiddleware",
      aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"],
      override: true,
      relation: "after",
      toMiddleware: "retryMiddleware"
    };
    getHttpSigningPlugin = (config) => ({
      applyToStack: (clientStack) => {
        clientStack.addRelativeTo(httpSigningMiddleware(config), httpSigningMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-signing/index.js
var init_middleware_http_signing = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/middleware-http-signing/index.js"() {
    "use strict";
    init_httpSigningMiddleware();
    init_getHttpSigningMiddleware();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/normalizeProvider.js
var normalizeProvider2;
var init_normalizeProvider2 = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/normalizeProvider.js"() {
    "use strict";
    normalizeProvider2 = (input) => {
      if (typeof input === "function")
        return input;
      const promisified = Promise.resolve(input);
      return () => promisified;
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/pagination/createPaginator.js
function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) {
  return async function* paginateOperation(config, input, ...additionalArguments) {
    const _input = input;
    let token = config.startingToken ?? _input[inputTokenName];
    let hasNext = true;
    let page;
    while (hasNext) {
      _input[inputTokenName] = token;
      if (pageSizeTokenName) {
        _input[pageSizeTokenName] = _input[pageSizeTokenName] ?? config.pageSize;
      }
      if (config.client instanceof ClientCtor) {
        page = await makePagedClientRequest(CommandCtor, config.client, input, config.withCommand, ...additionalArguments);
      } else {
        throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`);
      }
      yield page;
      const prevToken = token;
      token = get(page, outputTokenName);
      hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
    }
    return void 0;
  };
}
var makePagedClientRequest, get;
var init_createPaginator = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/pagination/createPaginator.js"() {
    "use strict";
    makePagedClientRequest = async (CommandCtor, client, input, withCommand = (_7) => _7, ...args2) => {
      let command = new CommandCtor(input);
      command = withCommand(command) ?? command;
      return await client.send(command, ...args2);
    };
    get = (fromObject, path3) => {
      let cursor = fromObject;
      const pathComponents = path3.split(".");
      for (const step of pathComponents) {
        if (!cursor || typeof cursor !== "object") {
          return void 0;
        }
        cursor = cursor[step];
      }
      return cursor;
    };
  }
});

// ../node_modules/.pnpm/@smithy+is-array-buffer@4.0.0/node_modules/@smithy/is-array-buffer/dist-es/index.js
var isArrayBuffer;
var init_dist_es8 = __esm({
  "../node_modules/.pnpm/@smithy+is-array-buffer@4.0.0/node_modules/@smithy/is-array-buffer/dist-es/index.js"() {
    "use strict";
    isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
  }
});

// ../node_modules/.pnpm/@smithy+util-buffer-from@4.0.0/node_modules/@smithy/util-buffer-from/dist-es/index.js
var import_buffer2, fromArrayBuffer, fromString;
var init_dist_es9 = __esm({
  "../node_modules/.pnpm/@smithy+util-buffer-from@4.0.0/node_modules/@smithy/util-buffer-from/dist-es/index.js"() {
    "use strict";
    init_dist_es8();
    import_buffer2 = require("buffer");
    fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
      if (!isArrayBuffer(input)) {
        throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
      }
      return import_buffer2.Buffer.from(input, offset, length);
    };
    fromString = (input, encoding) => {
      if (typeof input !== "string") {
        throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
      }
      return encoding ? import_buffer2.Buffer.from(input, encoding) : import_buffer2.Buffer.from(input);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-base64@4.0.0/node_modules/@smithy/util-base64/dist-es/fromBase64.js
var BASE64_REGEX, fromBase64;
var init_fromBase64 = __esm({
  "../node_modules/.pnpm/@smithy+util-base64@4.0.0/node_modules/@smithy/util-base64/dist-es/fromBase64.js"() {
    "use strict";
    init_dist_es9();
    BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
    fromBase64 = (input) => {
      if (input.length * 3 % 4 !== 0) {
        throw new TypeError(`Incorrect padding on base64 string.`);
      }
      if (!BASE64_REGEX.exec(input)) {
        throw new TypeError(`Invalid base64 string.`);
      }
      const buffer2 = fromString(input, "base64");
      return new Uint8Array(buffer2.buffer, buffer2.byteOffset, buffer2.byteLength);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/fromUtf8.js
var fromUtf8;
var init_fromUtf8 = __esm({
  "../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/fromUtf8.js"() {
    "use strict";
    init_dist_es9();
    fromUtf8 = (input) => {
      const buf = fromString(input, "utf8");
      return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/toUint8Array.js
var toUint8Array;
var init_toUint8Array = __esm({
  "../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/toUint8Array.js"() {
    "use strict";
    init_fromUtf8();
    toUint8Array = (data) => {
      if (typeof data === "string") {
        return fromUtf8(data);
      }
      if (ArrayBuffer.isView(data)) {
        return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
      }
      return new Uint8Array(data);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/toUtf8.js
var toUtf8;
var init_toUtf8 = __esm({
  "../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/toUtf8.js"() {
    "use strict";
    init_dist_es9();
    toUtf8 = (input) => {
      if (typeof input === "string") {
        return input;
      }
      if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
        throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
      }
      return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/index.js
var init_dist_es10 = __esm({
  "../node_modules/.pnpm/@smithy+util-utf8@4.0.0/node_modules/@smithy/util-utf8/dist-es/index.js"() {
    "use strict";
    init_fromUtf8();
    init_toUint8Array();
    init_toUtf8();
  }
});

// ../node_modules/.pnpm/@smithy+util-base64@4.0.0/node_modules/@smithy/util-base64/dist-es/toBase64.js
var toBase64;
var init_toBase64 = __esm({
  "../node_modules/.pnpm/@smithy+util-base64@4.0.0/node_modules/@smithy/util-base64/dist-es/toBase64.js"() {
    "use strict";
    init_dist_es9();
    init_dist_es10();
    toBase64 = (_input) => {
      let input;
      if (typeof _input === "string") {
        input = fromUtf8(_input);
      } else {
        input = _input;
      }
      if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
        throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
      }
      return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-base64@4.0.0/node_modules/@smithy/util-base64/dist-es/index.js
var init_dist_es11 = __esm({
  "../node_modules/.pnpm/@smithy+util-base64@4.0.0/node_modules/@smithy/util-base64/dist-es/index.js"() {
    "use strict";
    init_fromBase64();
    init_toBase64();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/blob/transforms.js
function transformToString(payload, encoding = "utf-8") {
  if (encoding === "base64") {
    return toBase64(payload);
  }
  return toUtf8(payload);
}
function transformFromString(str, encoding) {
  if (encoding === "base64") {
    return Uint8ArrayBlobAdapter.mutate(fromBase64(str));
  }
  return Uint8ArrayBlobAdapter.mutate(fromUtf8(str));
}
var init_transforms = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/blob/transforms.js"() {
    "use strict";
    init_dist_es11();
    init_dist_es10();
    init_Uint8ArrayBlobAdapter();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/blob/Uint8ArrayBlobAdapter.js
var Uint8ArrayBlobAdapter;
var init_Uint8ArrayBlobAdapter = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/blob/Uint8ArrayBlobAdapter.js"() {
    "use strict";
    init_transforms();
    Uint8ArrayBlobAdapter = class _Uint8ArrayBlobAdapter extends Uint8Array {
      static fromString(source, encoding = "utf-8") {
        switch (typeof source) {
          case "string":
            return transformFromString(source, encoding);
          default:
            throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
        }
      }
      static mutate(source) {
        Object.setPrototypeOf(source, _Uint8ArrayBlobAdapter.prototype);
        return source;
      }
      transformToString(encoding = "utf-8") {
        return transformToString(this, encoding);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/ChecksumStream.js
var init_ChecksumStream = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/ChecksumStream.js"() {
    "use strict";
    init_dist_es11();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/stream-type-check.js
var isReadableStream;
var init_stream_type_check = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/stream-type-check.js"() {
    "use strict";
    isReadableStream = (stream) => typeof ReadableStream === "function" && (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream);
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/ChecksumStream.browser.js
var init_ChecksumStream_browser = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/ChecksumStream.browser.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/createChecksumStream.browser.js
var init_createChecksumStream_browser = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/createChecksumStream.browser.js"() {
    "use strict";
    init_dist_es11();
    init_stream_type_check();
    init_ChecksumStream_browser();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/createChecksumStream.js
var init_createChecksumStream = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/checksum/createChecksumStream.js"() {
    "use strict";
    init_stream_type_check();
    init_ChecksumStream();
    init_createChecksumStream_browser();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/ByteArrayCollector.js
var init_ByteArrayCollector = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/ByteArrayCollector.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/createBufferedReadableStream.js
var init_createBufferedReadableStream = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/createBufferedReadableStream.js"() {
    "use strict";
    init_ByteArrayCollector();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/createBufferedReadable.js
var import_node_stream3;
var init_createBufferedReadable = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/createBufferedReadable.js"() {
    "use strict";
    import_node_stream3 = require("stream");
    init_ByteArrayCollector();
    init_createBufferedReadableStream();
    init_stream_type_check();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/getAwsChunkedEncodingStream.js
var init_getAwsChunkedEncodingStream = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/getAwsChunkedEncodingStream.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/headStream.browser.js
var init_headStream_browser = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/headStream.browser.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/headStream.js
var init_headStream = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/headStream.js"() {
    "use strict";
    init_headStream_browser();
    init_stream_type_check();
  }
});

// ../node_modules/.pnpm/@smithy+util-uri-escape@4.0.0/node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js
var escapeUri, hexEncode;
var init_escape_uri = __esm({
  "../node_modules/.pnpm/@smithy+util-uri-escape@4.0.0/node_modules/@smithy/util-uri-escape/dist-es/escape-uri.js"() {
    "use strict";
    escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
    hexEncode = (c6) => `%${c6.charCodeAt(0).toString(16).toUpperCase()}`;
  }
});

// ../node_modules/.pnpm/@smithy+util-uri-escape@4.0.0/node_modules/@smithy/util-uri-escape/dist-es/escape-uri-path.js
var init_escape_uri_path = __esm({
  "../node_modules/.pnpm/@smithy+util-uri-escape@4.0.0/node_modules/@smithy/util-uri-escape/dist-es/escape-uri-path.js"() {
    "use strict";
    init_escape_uri();
  }
});

// ../node_modules/.pnpm/@smithy+util-uri-escape@4.0.0/node_modules/@smithy/util-uri-escape/dist-es/index.js
var init_dist_es12 = __esm({
  "../node_modules/.pnpm/@smithy+util-uri-escape@4.0.0/node_modules/@smithy/util-uri-escape/dist-es/index.js"() {
    "use strict";
    init_escape_uri();
    init_escape_uri_path();
  }
});

// ../node_modules/.pnpm/@smithy+querystring-builder@4.0.4/node_modules/@smithy/querystring-builder/dist-es/index.js
function buildQueryString(query) {
  const parts2 = [];
  for (let key of Object.keys(query).sort()) {
    const value = query[key];
    key = escapeUri(key);
    if (Array.isArray(value)) {
      for (let i8 = 0, iLen = value.length; i8 < iLen; i8++) {
        parts2.push(`${key}=${escapeUri(value[i8])}`);
      }
    } else {
      let qsEntry = key;
      if (value || typeof value === "string") {
        qsEntry += `=${escapeUri(value)}`;
      }
      parts2.push(qsEntry);
    }
  }
  return parts2.join("&");
}
var init_dist_es13 = __esm({
  "../node_modules/.pnpm/@smithy+querystring-builder@4.0.4/node_modules/@smithy/querystring-builder/dist-es/index.js"() {
    "use strict";
    init_dist_es12();
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/constants.js
var NODEJS_TIMEOUT_ERROR_CODES;
var init_constants2 = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/constants.js"() {
    "use strict";
    NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/get-transformed-headers.js
var getTransformedHeaders;
var init_get_transformed_headers = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/get-transformed-headers.js"() {
    "use strict";
    getTransformedHeaders = (headers) => {
      const transformedHeaders = {};
      for (const name3 of Object.keys(headers)) {
        const headerValues = headers[name3];
        transformedHeaders[name3] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
      }
      return transformedHeaders;
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/timing.js
var timing;
var init_timing = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/timing.js"() {
    "use strict";
    timing = {
      setTimeout: (cb, ms3) => setTimeout(cb, ms3),
      clearTimeout: (timeoutId) => clearTimeout(timeoutId)
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js
var DEFER_EVENT_LISTENER_TIME, setConnectionTimeout;
var init_set_connection_timeout = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/set-connection-timeout.js"() {
    "use strict";
    init_timing();
    DEFER_EVENT_LISTENER_TIME = 1e3;
    setConnectionTimeout = (request2, reject, timeoutInMs = 0) => {
      if (!timeoutInMs) {
        return -1;
      }
      const registerTimeout = (offset) => {
        const timeoutId = timing.setTimeout(() => {
          request2.destroy();
          reject(Object.assign(new Error(`Socket timed out without establishing a connection within ${timeoutInMs} ms`), {
            name: "TimeoutError"
          }));
        }, timeoutInMs - offset);
        const doWithSocket = (socket) => {
          if (socket?.connecting) {
            socket.on("connect", () => {
              timing.clearTimeout(timeoutId);
            });
          } else {
            timing.clearTimeout(timeoutId);
          }
        };
        if (request2.socket) {
          doWithSocket(request2.socket);
        } else {
          request2.on("socket", doWithSocket);
        }
      };
      if (timeoutInMs < 2e3) {
        registerTimeout(0);
        return 0;
      }
      return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js
var DEFER_EVENT_LISTENER_TIME2, setSocketKeepAlive;
var init_set_socket_keep_alive = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/set-socket-keep-alive.js"() {
    "use strict";
    init_timing();
    DEFER_EVENT_LISTENER_TIME2 = 3e3;
    setSocketKeepAlive = (request2, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME2) => {
      if (keepAlive !== true) {
        return -1;
      }
      const registerListener = () => {
        if (request2.socket) {
          request2.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
        } else {
          request2.on("socket", (socket) => {
            socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
          });
        }
      };
      if (deferTimeMs === 0) {
        registerListener();
        return 0;
      }
      return timing.setTimeout(registerListener, deferTimeMs);
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js
var DEFER_EVENT_LISTENER_TIME3, setSocketTimeout;
var init_set_socket_timeout = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/set-socket-timeout.js"() {
    "use strict";
    init_node_http_handler();
    init_timing();
    DEFER_EVENT_LISTENER_TIME3 = 3e3;
    setSocketTimeout = (request2, reject, timeoutInMs = DEFAULT_REQUEST_TIMEOUT) => {
      const registerTimeout = (offset) => {
        const timeout = timeoutInMs - offset;
        const onTimeout = () => {
          request2.destroy();
          reject(Object.assign(new Error(`Connection timed out after ${timeoutInMs} ms`), { name: "TimeoutError" }));
        };
        if (request2.socket) {
          request2.socket.setTimeout(timeout, onTimeout);
          request2.on("close", () => request2.socket?.removeListener("timeout", onTimeout));
        } else {
          request2.setTimeout(timeout, onTimeout);
        }
      };
      if (0 < timeoutInMs && timeoutInMs < 6e3) {
        registerTimeout(0);
        return 0;
      }
      return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME3), DEFER_EVENT_LISTENER_TIME3);
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/write-request-body.js
async function writeRequestBody(httpRequest2, request2, maxContinueTimeoutMs = MIN_WAIT_TIME) {
  const headers = request2.headers ?? {};
  const expect = headers["Expect"] || headers["expect"];
  let timeoutId = -1;
  let sendBody = true;
  if (expect === "100-continue") {
    sendBody = await Promise.race([
      new Promise((resolve2) => {
        timeoutId = Number(timing.setTimeout(() => resolve2(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
      }),
      new Promise((resolve2) => {
        httpRequest2.on("continue", () => {
          timing.clearTimeout(timeoutId);
          resolve2(true);
        });
        httpRequest2.on("response", () => {
          timing.clearTimeout(timeoutId);
          resolve2(false);
        });
        httpRequest2.on("error", () => {
          timing.clearTimeout(timeoutId);
          resolve2(false);
        });
      })
    ]);
  }
  if (sendBody) {
    writeBody(httpRequest2, request2.body);
  }
}
function writeBody(httpRequest2, body2) {
  if (body2 instanceof import_stream3.Readable) {
    body2.pipe(httpRequest2);
    return;
  }
  if (body2) {
    if (Buffer.isBuffer(body2) || typeof body2 === "string") {
      httpRequest2.end(body2);
      return;
    }
    const uint8 = body2;
    if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
      httpRequest2.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
      return;
    }
    httpRequest2.end(Buffer.from(body2));
    return;
  }
  httpRequest2.end();
}
var import_stream3, MIN_WAIT_TIME;
var init_write_request_body = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/write-request-body.js"() {
    "use strict";
    import_stream3 = require("stream");
    init_timing();
    MIN_WAIT_TIME = 6e3;
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js
var import_http3, import_https, DEFAULT_REQUEST_TIMEOUT, NodeHttpHandler;
var init_node_http_handler = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http-handler.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es13();
    import_http3 = require("http");
    import_https = require("https");
    init_constants2();
    init_get_transformed_headers();
    init_set_connection_timeout();
    init_set_socket_keep_alive();
    init_set_socket_timeout();
    init_timing();
    init_write_request_body();
    DEFAULT_REQUEST_TIMEOUT = 0;
    NodeHttpHandler = class _NodeHttpHandler {
      static create(instanceOrOptions) {
        if (typeof instanceOrOptions?.handle === "function") {
          return instanceOrOptions;
        }
        return new _NodeHttpHandler(instanceOrOptions);
      }
      static checkSocketUsage(agent, socketWarningTimestamp, logger2 = console) {
        const { sockets, requests, maxSockets } = agent;
        if (typeof maxSockets !== "number" || maxSockets === Infinity) {
          return socketWarningTimestamp;
        }
        const interval2 = 15e3;
        if (Date.now() - interval2 < socketWarningTimestamp) {
          return socketWarningTimestamp;
        }
        if (sockets && requests) {
          for (const origin in sockets) {
            const socketsInUse = sockets[origin]?.length ?? 0;
            const requestsEnqueued = requests[origin]?.length ?? 0;
            if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
              logger2?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
              return Date.now();
            }
          }
        }
        return socketWarningTimestamp;
      }
      constructor(options) {
        this.socketWarningTimestamp = 0;
        this.metadata = { handlerProtocol: "http/1.1" };
        this.configProvider = new Promise((resolve2, reject) => {
          if (typeof options === "function") {
            options().then((_options2) => {
              resolve2(this.resolveDefaultConfig(_options2));
            }).catch(reject);
          } else {
            resolve2(this.resolveDefaultConfig(options));
          }
        });
      }
      resolveDefaultConfig(options) {
        const { requestTimeout: requestTimeout2, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent: httpAgent2, httpsAgent: httpsAgent2 } = options || {};
        const keepAlive = true;
        const maxSockets = 50;
        return {
          connectionTimeout,
          requestTimeout: requestTimeout2 ?? socketTimeout,
          socketAcquisitionWarningTimeout,
          httpAgent: (() => {
            if (httpAgent2 instanceof import_http3.Agent || typeof httpAgent2?.destroy === "function") {
              return httpAgent2;
            }
            return new import_http3.Agent({ keepAlive, maxSockets, ...httpAgent2 });
          })(),
          httpsAgent: (() => {
            if (httpsAgent2 instanceof import_https.Agent || typeof httpsAgent2?.destroy === "function") {
              return httpsAgent2;
            }
            return new import_https.Agent({ keepAlive, maxSockets, ...httpsAgent2 });
          })(),
          logger: console
        };
      }
      destroy() {
        this.config?.httpAgent?.destroy();
        this.config?.httpsAgent?.destroy();
      }
      async handle(request2, { abortSignal } = {}) {
        if (!this.config) {
          this.config = await this.configProvider;
        }
        return new Promise((_resolve, _reject) => {
          let writeRequestBodyPromise = void 0;
          const timeouts = [];
          const resolve2 = async (arg) => {
            await writeRequestBodyPromise;
            timeouts.forEach(timing.clearTimeout);
            _resolve(arg);
          };
          const reject = async (arg) => {
            await writeRequestBodyPromise;
            timeouts.forEach(timing.clearTimeout);
            _reject(arg);
          };
          if (!this.config) {
            throw new Error("Node HTTP request handler config is not resolved");
          }
          if (abortSignal?.aborted) {
            const abortError = new Error("Request aborted");
            abortError.name = "AbortError";
            reject(abortError);
            return;
          }
          const isSSL = request2.protocol === "https:";
          const agent = isSSL ? this.config.httpsAgent : this.config.httpAgent;
          timeouts.push(timing.setTimeout(() => {
            this.socketWarningTimestamp = _NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, this.config.logger);
          }, this.config.socketAcquisitionWarningTimeout ?? (this.config.requestTimeout ?? 2e3) + (this.config.connectionTimeout ?? 1e3)));
          const queryString = buildQueryString(request2.query || {});
          let auth = void 0;
          if (request2.username != null || request2.password != null) {
            const username = request2.username ?? "";
            const password = request2.password ?? "";
            auth = `${username}:${password}`;
          }
          let path3 = request2.path;
          if (queryString) {
            path3 += `?${queryString}`;
          }
          if (request2.fragment) {
            path3 += `#${request2.fragment}`;
          }
          let hostname = request2.hostname ?? "";
          if (hostname[0] === "[" && hostname.endsWith("]")) {
            hostname = request2.hostname.slice(1, -1);
          } else {
            hostname = request2.hostname;
          }
          const nodeHttpsOptions = {
            headers: request2.headers,
            host: hostname,
            method: request2.method,
            path: path3,
            port: request2.port,
            agent,
            auth
          };
          const requestFunc = isSSL ? import_https.request : import_http3.request;
          const req = requestFunc(nodeHttpsOptions, (res) => {
            const httpResponse = new HttpResponse({
              statusCode: res.statusCode || -1,
              reason: res.statusMessage,
              headers: getTransformedHeaders(res.headers),
              body: res
            });
            resolve2({ response: httpResponse });
          });
          req.on("error", (err3) => {
            if (NODEJS_TIMEOUT_ERROR_CODES.includes(err3.code)) {
              reject(Object.assign(err3, { name: "TimeoutError" }));
            } else {
              reject(err3);
            }
          });
          if (abortSignal) {
            const onAbort = () => {
              req.destroy();
              const abortError = new Error("Request aborted");
              abortError.name = "AbortError";
              reject(abortError);
            };
            if (typeof abortSignal.addEventListener === "function") {
              const signal = abortSignal;
              signal.addEventListener("abort", onAbort, { once: true });
              req.once("close", () => signal.removeEventListener("abort", onAbort));
            } else {
              abortSignal.onabort = onAbort;
            }
          }
          timeouts.push(setConnectionTimeout(req, reject, this.config.connectionTimeout));
          timeouts.push(setSocketTimeout(req, reject, this.config.requestTimeout));
          const httpAgent2 = nodeHttpsOptions.agent;
          if (typeof httpAgent2 === "object" && "keepAlive" in httpAgent2) {
            timeouts.push(setSocketKeepAlive(req, {
              keepAlive: httpAgent2.keepAlive,
              keepAliveMsecs: httpAgent2.keepAliveMsecs
            }));
          }
          writeRequestBodyPromise = writeRequestBody(req, request2, this.config.requestTimeout).catch((e6) => {
            timeouts.forEach(timing.clearTimeout);
            return _reject(e6);
          });
        });
      }
      updateHttpClientConfig(key, value) {
        this.config = void 0;
        this.configProvider = this.configProvider.then((config) => {
          return {
            ...config,
            [key]: value
          };
        });
      }
      httpHandlerConfigs() {
        return this.config ?? {};
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http2-connection-pool.js
var init_node_http2_connection_pool = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http2-connection-pool.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http2-connection-manager.js
var init_node_http2_connection_manager = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http2-connection-manager.js"() {
    "use strict";
    init_node_http2_connection_pool();
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http2-handler.js
var init_node_http2_handler = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/node-http2-handler.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es13();
    init_get_transformed_headers();
    init_node_http2_connection_manager();
    init_write_request_body();
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/stream-collector/collector.js
var import_stream4, Collector;
var init_collector = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/stream-collector/collector.js"() {
    "use strict";
    import_stream4 = require("stream");
    Collector = class extends import_stream4.Writable {
      constructor() {
        super(...arguments);
        this.bufferedBytes = [];
      }
      _write(chunk, encoding, callback) {
        this.bufferedBytes.push(chunk);
        callback();
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/stream-collector/index.js
async function collectReadableStream(stream) {
  const chunks = [];
  const reader = stream.getReader();
  let isDone = false;
  let length = 0;
  while (!isDone) {
    const { done, value } = await reader.read();
    if (value) {
      chunks.push(value);
      length += value.length;
    }
    isDone = done;
  }
  const collected = new Uint8Array(length);
  let offset = 0;
  for (const chunk of chunks) {
    collected.set(chunk, offset);
    offset += chunk.length;
  }
  return collected;
}
var streamCollector, isReadableStreamInstance;
var init_stream_collector = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/stream-collector/index.js"() {
    "use strict";
    init_collector();
    streamCollector = (stream) => {
      if (isReadableStreamInstance(stream)) {
        return collectReadableStream(stream);
      }
      return new Promise((resolve2, reject) => {
        const collector = new Collector();
        stream.pipe(collector);
        stream.on("error", (err3) => {
          collector.end();
          reject(err3);
        });
        collector.on("error", reject);
        collector.on("finish", function() {
          const bytes2 = new Uint8Array(Buffer.concat(this.bufferedBytes));
          resolve2(bytes2);
        });
      });
    };
    isReadableStreamInstance = (stream) => typeof ReadableStream === "function" && stream instanceof ReadableStream;
  }
});

// ../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/index.js
var init_dist_es14 = __esm({
  "../node_modules/.pnpm/@smithy+node-http-handler@4.0.6/node_modules/@smithy/node-http-handler/dist-es/index.js"() {
    "use strict";
    init_node_http_handler();
    init_node_http2_handler();
    init_stream_collector();
  }
});

// ../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/create-request.js
var init_create_request = __esm({
  "../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/create-request.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/request-timeout.js
var init_request_timeout = __esm({
  "../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/request-timeout.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/fetch-http-handler.js
var init_fetch_http_handler = __esm({
  "../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/fetch-http-handler.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es13();
    init_create_request();
    init_request_timeout();
  }
});

// ../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/stream-collector.js
async function collectBlob(blob2) {
  const base64 = await readToBase64(blob2);
  const arrayBuffer = fromBase64(base64);
  return new Uint8Array(arrayBuffer);
}
async function collectStream(stream) {
  const chunks = [];
  const reader = stream.getReader();
  let isDone = false;
  let length = 0;
  while (!isDone) {
    const { done, value } = await reader.read();
    if (value) {
      chunks.push(value);
      length += value.length;
    }
    isDone = done;
  }
  const collected = new Uint8Array(length);
  let offset = 0;
  for (const chunk of chunks) {
    collected.set(chunk, offset);
    offset += chunk.length;
  }
  return collected;
}
function readToBase64(blob2) {
  return new Promise((resolve2, reject) => {
    const reader = new FileReader();
    reader.onloadend = () => {
      if (reader.readyState !== 2) {
        return reject(new Error("Reader aborted too early"));
      }
      const result = reader.result ?? "";
      const commaIndex = result.indexOf(",");
      const dataOffset = commaIndex > -1 ? commaIndex + 1 : result.length;
      resolve2(result.substring(dataOffset));
    };
    reader.onabort = () => reject(new Error("Read aborted"));
    reader.onerror = () => reject(reader.error);
    reader.readAsDataURL(blob2);
  });
}
var streamCollector2;
var init_stream_collector2 = __esm({
  "../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/stream-collector.js"() {
    "use strict";
    init_dist_es11();
    streamCollector2 = async (stream) => {
      if (typeof Blob === "function" && stream instanceof Blob || stream.constructor?.name === "Blob") {
        if (Blob.prototype.arrayBuffer !== void 0) {
          return new Uint8Array(await stream.arrayBuffer());
        }
        return collectBlob(stream);
      }
      return collectStream(stream);
    };
  }
});

// ../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/index.js
var init_dist_es15 = __esm({
  "../node_modules/.pnpm/@smithy+fetch-http-handler@5.0.4/node_modules/@smithy/fetch-http-handler/dist-es/index.js"() {
    "use strict";
    init_fetch_http_handler();
    init_stream_collector2();
  }
});

// ../node_modules/.pnpm/@smithy+util-hex-encoding@4.0.0/node_modules/@smithy/util-hex-encoding/dist-es/index.js
function fromHex(encoded) {
  if (encoded.length % 2 !== 0) {
    throw new Error("Hex encoded strings must have an even number length");
  }
  const out2 = new Uint8Array(encoded.length / 2);
  for (let i8 = 0; i8 < encoded.length; i8 += 2) {
    const encodedByte = encoded.slice(i8, i8 + 2).toLowerCase();
    if (encodedByte in HEX_TO_SHORT) {
      out2[i8 / 2] = HEX_TO_SHORT[encodedByte];
    } else {
      throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
    }
  }
  return out2;
}
function toHex(bytes2) {
  let out2 = "";
  for (let i8 = 0; i8 < bytes2.byteLength; i8++) {
    out2 += SHORT_TO_HEX[bytes2[i8]];
  }
  return out2;
}
var SHORT_TO_HEX, HEX_TO_SHORT;
var init_dist_es16 = __esm({
  "../node_modules/.pnpm/@smithy+util-hex-encoding@4.0.0/node_modules/@smithy/util-hex-encoding/dist-es/index.js"() {
    "use strict";
    SHORT_TO_HEX = {};
    HEX_TO_SHORT = {};
    for (let i8 = 0; i8 < 256; i8++) {
      let encodedByte = i8.toString(16).toLowerCase();
      if (encodedByte.length === 1) {
        encodedByte = `0${encodedByte}`;
      }
      SHORT_TO_HEX[i8] = encodedByte;
      HEX_TO_SHORT[encodedByte] = i8;
    }
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/sdk-stream-mixin.browser.js
var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED, sdkStreamMixin, isBlobInstance;
var init_sdk_stream_mixin_browser = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/sdk-stream-mixin.browser.js"() {
    "use strict";
    init_dist_es15();
    init_dist_es11();
    init_dist_es16();
    init_dist_es10();
    init_stream_type_check();
    ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
    sdkStreamMixin = (stream) => {
      if (!isBlobInstance(stream) && !isReadableStream(stream)) {
        const name3 = stream?.__proto__?.constructor?.name || stream;
        throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name3}`);
      }
      let transformed = false;
      const transformToByteArray = async () => {
        if (transformed) {
          throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
        }
        transformed = true;
        return await streamCollector2(stream);
      };
      const blobToWebStream = (blob2) => {
        if (typeof blob2.stream !== "function") {
          throw new Error("Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.\nIf you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body");
        }
        return blob2.stream();
      };
      return Object.assign(stream, {
        transformToByteArray,
        transformToString: async (encoding) => {
          const buf = await transformToByteArray();
          if (encoding === "base64") {
            return toBase64(buf);
          } else if (encoding === "hex") {
            return toHex(buf);
          } else if (encoding === void 0 || encoding === "utf8" || encoding === "utf-8") {
            return toUtf8(buf);
          } else if (typeof TextDecoder === "function") {
            return new TextDecoder(encoding).decode(buf);
          } else {
            throw new Error("TextDecoder is not available, please make sure polyfill is provided.");
          }
        },
        transformToWebStream: () => {
          if (transformed) {
            throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
          }
          transformed = true;
          if (isBlobInstance(stream)) {
            return blobToWebStream(stream);
          } else if (isReadableStream(stream)) {
            return stream;
          } else {
            throw new Error(`Cannot transform payload to web stream, got ${stream}`);
          }
        }
      });
    };
    isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/sdk-stream-mixin.js
var import_stream5, ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2, sdkStreamMixin2;
var init_sdk_stream_mixin = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/sdk-stream-mixin.js"() {
    "use strict";
    init_dist_es14();
    init_dist_es9();
    import_stream5 = require("stream");
    init_sdk_stream_mixin_browser();
    ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2 = "The stream has already been transformed.";
    sdkStreamMixin2 = (stream) => {
      if (!(stream instanceof import_stream5.Readable)) {
        try {
          return sdkStreamMixin(stream);
        } catch (e6) {
          const name3 = stream?.__proto__?.constructor?.name || stream;
          throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name3}`);
        }
      }
      let transformed = false;
      const transformToByteArray = async () => {
        if (transformed) {
          throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2);
        }
        transformed = true;
        return await streamCollector(stream);
      };
      return Object.assign(stream, {
        transformToByteArray,
        transformToString: async (encoding) => {
          const buf = await transformToByteArray();
          if (encoding === void 0 || Buffer.isEncoding(encoding)) {
            return fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
          } else {
            const decoder2 = new TextDecoder(encoding);
            return decoder2.decode(buf);
          }
        },
        transformToWebStream: () => {
          if (transformed) {
            throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED2);
          }
          if (stream.readableFlowing !== null) {
            throw new Error("The stream has been consumed by other callbacks.");
          }
          if (typeof import_stream5.Readable.toWeb !== "function") {
            throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
          }
          transformed = true;
          return import_stream5.Readable.toWeb(stream);
        }
      });
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/splitStream.browser.js
var init_splitStream_browser = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/splitStream.browser.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/splitStream.js
var init_splitStream = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/splitStream.js"() {
    "use strict";
    init_splitStream_browser();
    init_stream_type_check();
  }
});

// ../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/index.js
var init_dist_es17 = __esm({
  "../node_modules/.pnpm/@smithy+util-stream@4.2.2/node_modules/@smithy/util-stream/dist-es/index.js"() {
    "use strict";
    init_Uint8ArrayBlobAdapter();
    init_ChecksumStream();
    init_createChecksumStream();
    init_createBufferedReadable();
    init_getAwsChunkedEncodingStream();
    init_headStream();
    init_sdk_stream_mixin();
    init_splitStream();
    init_stream_type_check();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/collect-stream-body.js
var collectBody;
var init_collect_stream_body = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/collect-stream-body.js"() {
    "use strict";
    init_dist_es17();
    collectBody = async (streamBody = new Uint8Array(), context) => {
      if (streamBody instanceof Uint8Array) {
        return Uint8ArrayBlobAdapter.mutate(streamBody);
      }
      if (!streamBody) {
        return Uint8ArrayBlobAdapter.mutate(new Uint8Array());
      }
      const fromContext = context.streamCollector(streamBody);
      return Uint8ArrayBlobAdapter.mutate(await fromContext);
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/extended-encode-uri-component.js
function extendedEncodeURIComponent(str) {
  return encodeURIComponent(str).replace(/[!'()*]/g, function(c6) {
    return "%" + c6.charCodeAt(0).toString(16).toUpperCase();
  });
}
var init_extended_encode_uri_component = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/extended-encode-uri-component.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/deref.js
var init_deref = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/deref.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js
var init_schemaDeserializationMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaDeserializationMiddleware.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es6();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js
var init_schemaSerializationMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/schemaSerializationMiddleware.js"() {
    "use strict";
    init_dist_es6();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js
var init_getSchemaSerdePlugin = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/middleware/getSchemaSerdePlugin.js"() {
    "use strict";
    init_schemaDeserializationMiddleware();
    init_schemaSerializationMiddleware();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js
var TypeRegistry;
var init_TypeRegistry = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/TypeRegistry.js"() {
    "use strict";
    TypeRegistry = class _TypeRegistry {
      constructor(namespace, schemas = /* @__PURE__ */ new Map()) {
        this.namespace = namespace;
        this.schemas = schemas;
      }
      static for(namespace) {
        if (!_TypeRegistry.registries.has(namespace)) {
          _TypeRegistry.registries.set(namespace, new _TypeRegistry(namespace));
        }
        return _TypeRegistry.registries.get(namespace);
      }
      register(shapeId, schema6) {
        const qualifiedName = this.normalizeShapeId(shapeId);
        const registry = _TypeRegistry.for(this.getNamespace(shapeId));
        registry.schemas.set(qualifiedName, schema6);
      }
      getSchema(shapeId) {
        const id = this.normalizeShapeId(shapeId);
        if (!this.schemas.has(id)) {
          throw new Error(`@smithy/core/schema - schema not found for ${id}`);
        }
        return this.schemas.get(id);
      }
      getBaseException() {
        for (const [id, schema6] of this.schemas.entries()) {
          if (id.startsWith("smithyts.client.synthetic.") && id.endsWith("ServiceException")) {
            return schema6;
          }
        }
        return void 0;
      }
      find(predicate) {
        return [...this.schemas.values()].find(predicate);
      }
      destroy() {
        _TypeRegistry.registries.delete(this.namespace);
        this.schemas.clear();
      }
      normalizeShapeId(shapeId) {
        if (shapeId.includes("#")) {
          return shapeId;
        }
        return this.namespace + "#" + shapeId;
      }
      getNamespace(shapeId) {
        return this.normalizeShapeId(shapeId).split("#")[0];
      }
    };
    TypeRegistry.registries = /* @__PURE__ */ new Map();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js
var init_Schema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/Schema.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js
var init_ListSchema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ListSchema.js"() {
    "use strict";
    init_TypeRegistry();
    init_Schema();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js
var init_MapSchema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/MapSchema.js"() {
    "use strict";
    init_TypeRegistry();
    init_Schema();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js
var init_OperationSchema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/OperationSchema.js"() {
    "use strict";
    init_TypeRegistry();
    init_Schema();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js
var init_StructureSchema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/StructureSchema.js"() {
    "use strict";
    init_TypeRegistry();
    init_Schema();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js
var init_ErrorSchema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/ErrorSchema.js"() {
    "use strict";
    init_TypeRegistry();
    init_StructureSchema();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/sentinels.js
var init_sentinels2 = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/sentinels.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js
var init_SimpleSchema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/SimpleSchema.js"() {
    "use strict";
    init_TypeRegistry();
    init_Schema();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js
var init_NormalizedSchema = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/schemas/NormalizedSchema.js"() {
    "use strict";
    init_deref();
    init_ListSchema();
    init_MapSchema();
    init_sentinels2();
    init_SimpleSchema();
    init_StructureSchema();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/index.js
var init_schema5 = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/schema/index.js"() {
    "use strict";
    init_deref();
    init_getSchemaSerdePlugin();
    init_ListSchema();
    init_MapSchema();
    init_OperationSchema();
    init_ErrorSchema();
    init_NormalizedSchema();
    init_Schema();
    init_SimpleSchema();
    init_StructureSchema();
    init_sentinels2();
    init_TypeRegistry();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/copyDocumentWithTransform.js
var init_copyDocumentWithTransform = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/copyDocumentWithTransform.js"() {
    "use strict";
    init_schema5();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js
var expectBoolean, expectNumber, MAX_FLOAT, expectFloat32, expectLong, expectInt32, expectShort, expectByte, expectSizedInt, castInt, expectNonNull, expectObject, expectString, expectUnion, strictParseFloat32, NUMBER_REGEX, parseNumber, limitedParseDouble, limitedParseFloat32, parseFloatString, strictParseInt32, strictParseShort, strictParseByte, stackTraceWarning, logger;
var init_parse_utils = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/parse-utils.js"() {
    "use strict";
    expectBoolean = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "number") {
        if (value === 0 || value === 1) {
          logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
        }
        if (value === 0) {
          return false;
        }
        if (value === 1) {
          return true;
        }
      }
      if (typeof value === "string") {
        const lower2 = value.toLowerCase();
        if (lower2 === "false" || lower2 === "true") {
          logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
        }
        if (lower2 === "false") {
          return false;
        }
        if (lower2 === "true") {
          return true;
        }
      }
      if (typeof value === "boolean") {
        return value;
      }
      throw new TypeError(`Expected boolean, got ${typeof value}: ${value}`);
    };
    expectNumber = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "string") {
        const parsed = parseFloat(value);
        if (!Number.isNaN(parsed)) {
          if (String(parsed) !== String(value)) {
            logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`));
          }
          return parsed;
        }
      }
      if (typeof value === "number") {
        return value;
      }
      throw new TypeError(`Expected number, got ${typeof value}: ${value}`);
    };
    MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
    expectFloat32 = (value) => {
      const expected = expectNumber(value);
      if (expected !== void 0 && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
        if (Math.abs(expected) > MAX_FLOAT) {
          throw new TypeError(`Expected 32-bit float, got ${value}`);
        }
      }
      return expected;
    };
    expectLong = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (Number.isInteger(value) && !Number.isNaN(value)) {
        return value;
      }
      throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
    };
    expectInt32 = (value) => expectSizedInt(value, 32);
    expectShort = (value) => expectSizedInt(value, 16);
    expectByte = (value) => expectSizedInt(value, 8);
    expectSizedInt = (value, size2) => {
      const expected = expectLong(value);
      if (expected !== void 0 && castInt(expected, size2) !== expected) {
        throw new TypeError(`Expected ${size2}-bit integer, got ${value}`);
      }
      return expected;
    };
    castInt = (value, size2) => {
      switch (size2) {
        case 32:
          return Int32Array.of(value)[0];
        case 16:
          return Int16Array.of(value)[0];
        case 8:
          return Int8Array.of(value)[0];
      }
    };
    expectNonNull = (value, location2) => {
      if (value === null || value === void 0) {
        if (location2) {
          throw new TypeError(`Expected a non-null value for ${location2}`);
        }
        throw new TypeError("Expected a non-null value");
      }
      return value;
    };
    expectObject = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "object" && !Array.isArray(value)) {
        return value;
      }
      const receivedType = Array.isArray(value) ? "array" : typeof value;
      throw new TypeError(`Expected object, got ${receivedType}: ${value}`);
    };
    expectString = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value === "string") {
        return value;
      }
      if (["boolean", "number", "bigint"].includes(typeof value)) {
        logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`));
        return String(value);
      }
      throw new TypeError(`Expected string, got ${typeof value}: ${value}`);
    };
    expectUnion = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      const asObject = expectObject(value);
      const setKeys = Object.entries(asObject).filter(([, v11]) => v11 != null).map(([k9]) => k9);
      if (setKeys.length === 0) {
        throw new TypeError(`Unions must have exactly one non-null member. None were found.`);
      }
      if (setKeys.length > 1) {
        throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`);
      }
      return asObject;
    };
    strictParseFloat32 = (value) => {
      if (typeof value == "string") {
        return expectFloat32(parseNumber(value));
      }
      return expectFloat32(value);
    };
    NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
    parseNumber = (value) => {
      const matches = value.match(NUMBER_REGEX);
      if (matches === null || matches[0].length !== value.length) {
        throw new TypeError(`Expected real number, got implicit NaN`);
      }
      return parseFloat(value);
    };
    limitedParseDouble = (value) => {
      if (typeof value == "string") {
        return parseFloatString(value);
      }
      return expectNumber(value);
    };
    limitedParseFloat32 = (value) => {
      if (typeof value == "string") {
        return parseFloatString(value);
      }
      return expectFloat32(value);
    };
    parseFloatString = (value) => {
      switch (value) {
        case "NaN":
          return NaN;
        case "Infinity":
          return Infinity;
        case "-Infinity":
          return -Infinity;
        default:
          throw new Error(`Unable to parse float value: ${value}`);
      }
    };
    strictParseInt32 = (value) => {
      if (typeof value === "string") {
        return expectInt32(parseNumber(value));
      }
      return expectInt32(value);
    };
    strictParseShort = (value) => {
      if (typeof value === "string") {
        return expectShort(parseNumber(value));
      }
      return expectShort(value);
    };
    strictParseByte = (value) => {
      if (typeof value === "string") {
        return expectByte(parseNumber(value));
      }
      return expectByte(value);
    };
    stackTraceWarning = (message) => {
      return String(new TypeError(message).stack || message).split("\n").slice(0, 5).filter((s10) => !s10.includes("stackTraceWarning")).join("\n");
    };
    logger = {
      warn: console.warn
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/date-utils.js
var MONTHS, RFC3339, parseRfc3339DateTime, RFC3339_WITH_OFFSET, parseRfc3339DateTimeWithOffset, IMF_FIXDATE, RFC_850_DATE, ASC_TIME, buildDate, FIFTY_YEARS_IN_MILLIS, DAYS_IN_MONTH, validateDayOfMonth, isLeapYear2, parseDateValue, parseMilliseconds, parseOffsetToMilliseconds, stripLeadingZeroes;
var init_date_utils = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/date-utils.js"() {
    "use strict";
    init_parse_utils();
    MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
    RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
    parseRfc3339DateTime = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value !== "string") {
        throw new TypeError("RFC-3339 date-times must be expressed as strings");
      }
      const match2 = RFC3339.exec(value);
      if (!match2) {
        throw new TypeError("Invalid RFC-3339 date-time value");
      }
      const [_7, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match2;
      const year3 = strictParseShort(stripLeadingZeroes(yearStr));
      const month = parseDateValue(monthStr, "month", 1, 12);
      const day = parseDateValue(dayStr, "day", 1, 31);
      return buildDate(year3, month, day, { hours, minutes, seconds, fractionalMilliseconds });
    };
    RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}\:\d{2})|[zZ])$/);
    parseRfc3339DateTimeWithOffset = (value) => {
      if (value === null || value === void 0) {
        return void 0;
      }
      if (typeof value !== "string") {
        throw new TypeError("RFC-3339 date-times must be expressed as strings");
      }
      const match2 = RFC3339_WITH_OFFSET.exec(value);
      if (!match2) {
        throw new TypeError("Invalid RFC-3339 date-time value");
      }
      const [_7, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match2;
      const year3 = strictParseShort(stripLeadingZeroes(yearStr));
      const month = parseDateValue(monthStr, "month", 1, 12);
      const day = parseDateValue(dayStr, "day", 1, 31);
      const date4 = buildDate(year3, month, day, { hours, minutes, seconds, fractionalMilliseconds });
      if (offsetStr.toUpperCase() != "Z") {
        date4.setTime(date4.getTime() - parseOffsetToMilliseconds(offsetStr));
      }
      return date4;
    };
    IMF_FIXDATE = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
    RFC_850_DATE = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
    ASC_TIME = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
    buildDate = (year3, month, day, time4) => {
      const adjustedMonth = month - 1;
      validateDayOfMonth(year3, adjustedMonth, day);
      return new Date(Date.UTC(year3, adjustedMonth, day, parseDateValue(time4.hours, "hour", 0, 23), parseDateValue(time4.minutes, "minute", 0, 59), parseDateValue(time4.seconds, "seconds", 0, 60), parseMilliseconds(time4.fractionalMilliseconds)));
    };
    FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1e3;
    DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    validateDayOfMonth = (year3, month, day) => {
      let maxDays = DAYS_IN_MONTH[month];
      if (month === 1 && isLeapYear2(year3)) {
        maxDays = 29;
      }
      if (day > maxDays) {
        throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year3}: ${day}`);
      }
    };
    isLeapYear2 = (year3) => {
      return year3 % 4 === 0 && (year3 % 100 !== 0 || year3 % 400 === 0);
    };
    parseDateValue = (value, type, lower2, upper) => {
      const dateVal = strictParseByte(stripLeadingZeroes(value));
      if (dateVal < lower2 || dateVal > upper) {
        throw new TypeError(`${type} must be between ${lower2} and ${upper}, inclusive`);
      }
      return dateVal;
    };
    parseMilliseconds = (value) => {
      if (value === null || value === void 0) {
        return 0;
      }
      return strictParseFloat32("0." + value) * 1e3;
    };
    parseOffsetToMilliseconds = (value) => {
      const directionStr = value[0];
      let direction = 1;
      if (directionStr == "+") {
        direction = 1;
      } else if (directionStr == "-") {
        direction = -1;
      } else {
        throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`);
      }
      const hour = Number(value.substring(1, 3));
      const minute = Number(value.substring(4, 6));
      return direction * (hour * 60 + minute) * 60 * 1e3;
    };
    stripLeadingZeroes = (value) => {
      let idx = 0;
      while (idx < value.length - 1 && value.charAt(idx) === "0") {
        idx++;
      }
      if (idx === 0) {
        return value;
      }
      return value.slice(idx);
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/lazy-json.js
var LazyJsonString;
var init_lazy_json = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/lazy-json.js"() {
    "use strict";
    LazyJsonString = function LazyJsonString2(val2) {
      const str = Object.assign(new String(val2), {
        deserializeJSON() {
          return JSON.parse(String(val2));
        },
        toString() {
          return String(val2);
        },
        toJSON() {
          return String(val2);
        }
      });
      return str;
    };
    LazyJsonString.from = (object2) => {
      if (object2 && typeof object2 === "object" && (object2 instanceof LazyJsonString || "deserializeJSON" in object2)) {
        return object2;
      } else if (typeof object2 === "string" || Object.getPrototypeOf(object2) === String.prototype) {
        return LazyJsonString(String(object2));
      }
      return LazyJsonString(JSON.stringify(object2));
    };
    LazyJsonString.fromObject = LazyJsonString.from;
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/quote-header.js
var init_quote_header = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/quote-header.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/split-every.js
var init_split_every = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/split-every.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/split-header.js
var init_split_header = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/split-header.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js
var init_NumericValue = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/value/NumericValue.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/index.js
var init_serde2 = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/serde/index.js"() {
    "use strict";
    init_copyDocumentWithTransform();
    init_date_utils();
    init_lazy_json();
    init_parse_utils();
    init_quote_header();
    init_split_every();
    init_split_header();
    init_NumericValue();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js
var init_HttpProtocol = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js"() {
    "use strict";
    init_schema5();
    init_serde2();
    init_dist_es2();
    init_dist_es17();
    init_collect_stream_body();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/HttpBindingProtocol.js
var init_HttpBindingProtocol = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/HttpBindingProtocol.js"() {
    "use strict";
    init_schema5();
    init_dist_es2();
    init_collect_stream_body();
    init_extended_encode_uri_component();
    init_HttpProtocol();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js
var init_RpcProtocol = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js"() {
    "use strict";
    init_schema5();
    init_dist_es2();
    init_collect_stream_body();
    init_HttpProtocol();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/resolve-path.js
var resolvedPath;
var init_resolve_path = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/resolve-path.js"() {
    "use strict";
    init_extended_encode_uri_component();
    resolvedPath = (resolvedPath2, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
      if (input != null && input[memberName] !== void 0) {
        const labelValue = labelValueProvider();
        if (labelValue.length <= 0) {
          throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
        }
        resolvedPath2 = resolvedPath2.replace(uriLabel, isGreedyLabel ? labelValue.split("/").map((segment) => extendedEncodeURIComponent(segment)).join("/") : extendedEncodeURIComponent(labelValue));
      } else {
        throw new Error("No value provided for input HTTP label: " + memberName + ".");
      }
      return resolvedPath2;
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/requestBuilder.js
function requestBuilder(input, context) {
  return new RequestBuilder(input, context);
}
var RequestBuilder;
var init_requestBuilder = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/requestBuilder.js"() {
    "use strict";
    init_dist_es2();
    init_resolve_path();
    RequestBuilder = class {
      constructor(input, context) {
        this.input = input;
        this.context = context;
        this.query = {};
        this.method = "";
        this.headers = {};
        this.path = "";
        this.body = null;
        this.hostname = "";
        this.resolvePathStack = [];
      }
      async build() {
        const { hostname, protocol: protocol2 = "https", port, path: basePath } = await this.context.endpoint();
        this.path = basePath;
        for (const resolvePath of this.resolvePathStack) {
          resolvePath(this.path);
        }
        return new HttpRequest({
          protocol: protocol2,
          hostname: this.hostname || hostname,
          port,
          method: this.method,
          path: this.path,
          query: this.query,
          body: this.body,
          headers: this.headers
        });
      }
      hn(hostname) {
        this.hostname = hostname;
        return this;
      }
      bp(uriLabel) {
        this.resolvePathStack.push((basePath) => {
          this.path = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel;
        });
        return this;
      }
      p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
        this.resolvePathStack.push((path3) => {
          this.path = resolvedPath(path3, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
        });
        return this;
      }
      h(headers) {
        this.headers = headers;
        return this;
      }
      q(query) {
        this.query = query;
        return this;
      }
      b(body2) {
        this.body = body2;
        return this;
      }
      m(method) {
        this.method = method;
        return this;
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/determineTimestampFormat.js
var init_determineTimestampFormat = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/determineTimestampFormat.js"() {
    "use strict";
    init_schema5();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/FromStringShapeDeserializer.js
var init_FromStringShapeDeserializer = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/FromStringShapeDeserializer.js"() {
    "use strict";
    init_schema5();
    init_serde2();
    init_dist_es11();
    init_dist_es10();
    init_determineTimestampFormat();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeDeserializer.js
var init_HttpInterceptingShapeDeserializer = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeDeserializer.js"() {
    "use strict";
    init_schema5();
    init_dist_es10();
    init_FromStringShapeDeserializer();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/ToStringShapeSerializer.js
var init_ToStringShapeSerializer = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/ToStringShapeSerializer.js"() {
    "use strict";
    init_schema5();
    init_serde2();
    init_dist_es11();
    init_determineTimestampFormat();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeSerializer.js
var init_HttpInterceptingShapeSerializer = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/serde/HttpInterceptingShapeSerializer.js"() {
    "use strict";
    init_schema5();
    init_ToStringShapeSerializer();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/index.js
var init_protocols = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/submodules/protocols/index.js"() {
    "use strict";
    init_collect_stream_body();
    init_extended_encode_uri_component();
    init_HttpBindingProtocol();
    init_RpcProtocol();
    init_requestBuilder();
    init_resolve_path();
    init_FromStringShapeDeserializer();
    init_HttpInterceptingShapeDeserializer();
    init_HttpInterceptingShapeSerializer();
    init_ToStringShapeSerializer();
    init_determineTimestampFormat();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/protocols/requestBuilder.js
var init_requestBuilder2 = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/protocols/requestBuilder.js"() {
    "use strict";
    init_protocols();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/setFeature.js
function setFeature(context, feature, value) {
  if (!context.__smithy_context) {
    context.__smithy_context = {
      features: {}
    };
  } else if (!context.__smithy_context.features) {
    context.__smithy_context.features = {};
  }
  context.__smithy_context.features[feature] = value;
}
var init_setFeature = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/setFeature.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/DefaultIdentityProviderConfig.js
var DefaultIdentityProviderConfig;
var init_DefaultIdentityProviderConfig = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/DefaultIdentityProviderConfig.js"() {
    "use strict";
    DefaultIdentityProviderConfig = class {
      constructor(config) {
        this.authSchemes = /* @__PURE__ */ new Map();
        for (const [key, value] of Object.entries(config)) {
          if (value !== void 0) {
            this.authSchemes.set(key, value);
          }
        }
      }
      getIdentityProvider(schemeId) {
        return this.authSchemes.get(schemeId);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpApiKeyAuth.js
var init_httpApiKeyAuth = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpApiKeyAuth.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpBearerAuth.js
var init_httpBearerAuth = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpBearerAuth.js"() {
    "use strict";
    init_dist_es2();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/noAuth.js
var NoAuthSigner;
var init_noAuth = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/noAuth.js"() {
    "use strict";
    NoAuthSigner = class {
      async sign(httpRequest2, identity, signingProperties) {
        return httpRequest2;
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/index.js
var init_httpAuthSchemes = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/index.js"() {
    "use strict";
    init_httpApiKeyAuth();
    init_httpBearerAuth();
    init_noAuth();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js
var createIsIdentityExpiredFunction, EXPIRATION_MS, isIdentityExpired, doesIdentityRequireRefresh, memoizeIdentityProvider;
var init_memoizeIdentityProvider = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js"() {
    "use strict";
    createIsIdentityExpiredFunction = (expirationMs) => (identity) => doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
    EXPIRATION_MS = 3e5;
    isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
    doesIdentityRequireRefresh = (identity) => identity.expiration !== void 0;
    memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
      if (provider === void 0) {
        return void 0;
      }
      const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider;
      let resolved;
      let pending;
      let hasResult;
      let isConstant = false;
      const coalesceProvider = async (options) => {
        if (!pending) {
          pending = normalizedProvider(options);
        }
        try {
          resolved = await pending;
          hasResult = true;
          isConstant = false;
        } finally {
          pending = void 0;
        }
        return resolved;
      };
      if (isExpired === void 0) {
        return async (options) => {
          if (!hasResult || options?.forceRefresh) {
            resolved = await coalesceProvider(options);
          }
          return resolved;
        };
      }
      return async (options) => {
        if (!hasResult || options?.forceRefresh) {
          resolved = await coalesceProvider(options);
        }
        if (isConstant) {
          return resolved;
        }
        if (!requiresRefresh(resolved)) {
          isConstant = true;
          return resolved;
        }
        if (isExpired(resolved)) {
          await coalesceProvider(options);
          return resolved;
        }
        return resolved;
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/index.js
var init_util_identity_and_auth = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/util-identity-and-auth/index.js"() {
    "use strict";
    init_DefaultIdentityProviderConfig();
    init_httpAuthSchemes();
    init_memoizeIdentityProvider();
  }
});

// ../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/index.js
var init_dist_es18 = __esm({
  "../node_modules/.pnpm/@smithy+core@3.5.1/node_modules/@smithy/core/dist-es/index.js"() {
    "use strict";
    init_getSmithyContext();
    init_middleware_http_auth_scheme();
    init_middleware_http_signing();
    init_normalizeProvider2();
    init_createPaginator();
    init_requestBuilder2();
    init_setFeature();
    init_util_identity_and_auth();
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/configurations.js
function isValidUserAgentAppId(appId) {
  if (appId === void 0) {
    return true;
  }
  return typeof appId === "string" && appId.length <= 50;
}
function resolveUserAgentConfig(input) {
  const normalizedAppIdProvider = normalizeProvider2(input.userAgentAppId ?? DEFAULT_UA_APP_ID);
  const { customUserAgent } = input;
  return Object.assign(input, {
    customUserAgent: typeof customUserAgent === "string" ? [[customUserAgent]] : customUserAgent,
    userAgentAppId: async () => {
      const appId = await normalizedAppIdProvider();
      if (!isValidUserAgentAppId(appId)) {
        const logger2 = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
        if (typeof appId !== "string") {
          logger2?.warn("userAgentAppId must be a string or undefined.");
        } else if (appId.length > 50) {
          logger2?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
        }
      }
      return appId;
    }
  });
}
var DEFAULT_UA_APP_ID;
var init_configurations = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/configurations.js"() {
    "use strict";
    init_dist_es18();
    DEFAULT_UA_APP_ID = void 0;
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js
var EndpointCache;
var init_EndpointCache = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/cache/EndpointCache.js"() {
    "use strict";
    EndpointCache = class {
      constructor({ size: size2, params }) {
        this.data = /* @__PURE__ */ new Map();
        this.parameters = [];
        this.capacity = size2 ?? 50;
        if (params) {
          this.parameters = params;
        }
      }
      get(endpointParams, resolver) {
        const key = this.hash(endpointParams);
        if (key === false) {
          return resolver();
        }
        if (!this.data.has(key)) {
          if (this.data.size > this.capacity + 10) {
            const keys = this.data.keys();
            let i8 = 0;
            while (true) {
              const { value, done } = keys.next();
              this.data.delete(value);
              if (done || ++i8 > 10) {
                break;
              }
            }
          }
          this.data.set(key, resolver());
        }
        return this.data.get(key);
      }
      size() {
        return this.data.size;
      }
      hash(endpointParams) {
        let buffer2 = "";
        const { parameters } = this;
        if (parameters.length === 0) {
          return false;
        }
        for (const param2 of parameters) {
          const val2 = String(endpointParams[param2] ?? "");
          if (val2.includes("|;")) {
            return false;
          }
          buffer2 += val2 + "|;";
        }
        return buffer2;
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/isIpAddress.js
var IP_V4_REGEX, isIpAddress;
var init_isIpAddress = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/isIpAddress.js"() {
    "use strict";
    IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`);
    isIpAddress = (value) => IP_V4_REGEX.test(value) || value.startsWith("[") && value.endsWith("]");
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/isValidHostLabel.js
var VALID_HOST_LABEL_REGEX, isValidHostLabel;
var init_isValidHostLabel = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/isValidHostLabel.js"() {
    "use strict";
    VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
    isValidHostLabel = (value, allowSubDomains = false) => {
      if (!allowSubDomains) {
        return VALID_HOST_LABEL_REGEX.test(value);
      }
      const labels = value.split(".");
      for (const label of labels) {
        if (!isValidHostLabel(label)) {
          return false;
        }
      }
      return true;
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/customEndpointFunctions.js
var customEndpointFunctions;
var init_customEndpointFunctions = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/customEndpointFunctions.js"() {
    "use strict";
    customEndpointFunctions = {};
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/debug/debugId.js
var debugId;
var init_debugId = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/debug/debugId.js"() {
    "use strict";
    debugId = "endpoints";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/debug/toDebugString.js
function toDebugString(input) {
  if (typeof input !== "object" || input == null) {
    return input;
  }
  if ("ref" in input) {
    return `$${toDebugString(input.ref)}`;
  }
  if ("fn" in input) {
    return `${input.fn}(${(input.argv || []).map(toDebugString).join(", ")})`;
  }
  return JSON.stringify(input, null, 2);
}
var init_toDebugString = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/debug/toDebugString.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/debug/index.js
var init_debug = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/debug/index.js"() {
    "use strict";
    init_debugId();
    init_toDebugString();
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/EndpointError.js
var EndpointError;
var init_EndpointError = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/EndpointError.js"() {
    "use strict";
    EndpointError = class extends Error {
      constructor(message) {
        super(message);
        this.name = "EndpointError";
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/EndpointFunctions.js
var init_EndpointFunctions = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/EndpointFunctions.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/EndpointRuleObject.js
var init_EndpointRuleObject2 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/EndpointRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/ErrorRuleObject.js
var init_ErrorRuleObject2 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/ErrorRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/RuleSetObject.js
var init_RuleSetObject2 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/RuleSetObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/TreeRuleObject.js
var init_TreeRuleObject2 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/TreeRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/shared.js
var init_shared2 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/shared.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/index.js
var init_types3 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/types/index.js"() {
    "use strict";
    init_EndpointError();
    init_EndpointFunctions();
    init_EndpointRuleObject2();
    init_ErrorRuleObject2();
    init_RuleSetObject2();
    init_TreeRuleObject2();
    init_shared2();
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/booleanEquals.js
var booleanEquals;
var init_booleanEquals = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/booleanEquals.js"() {
    "use strict";
    booleanEquals = (value1, value2) => value1 === value2;
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/getAttrPathList.js
var getAttrPathList;
var init_getAttrPathList = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/getAttrPathList.js"() {
    "use strict";
    init_types3();
    getAttrPathList = (path3) => {
      const parts2 = path3.split(".");
      const pathList = [];
      for (const part of parts2) {
        const squareBracketIndex = part.indexOf("[");
        if (squareBracketIndex !== -1) {
          if (part.indexOf("]") !== part.length - 1) {
            throw new EndpointError(`Path: '${path3}' does not end with ']'`);
          }
          const arrayIndex = part.slice(squareBracketIndex + 1, -1);
          if (Number.isNaN(parseInt(arrayIndex))) {
            throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path3}'`);
          }
          if (squareBracketIndex !== 0) {
            pathList.push(part.slice(0, squareBracketIndex));
          }
          pathList.push(arrayIndex);
        } else {
          pathList.push(part);
        }
      }
      return pathList;
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/getAttr.js
var getAttr;
var init_getAttr = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/getAttr.js"() {
    "use strict";
    init_types3();
    init_getAttrPathList();
    getAttr = (value, path3) => getAttrPathList(path3).reduce((acc, index7) => {
      if (typeof acc !== "object") {
        throw new EndpointError(`Index '${index7}' in '${path3}' not found in '${JSON.stringify(value)}'`);
      } else if (Array.isArray(acc)) {
        return acc[parseInt(index7)];
      }
      return acc[index7];
    }, value);
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/isSet.js
var isSet;
var init_isSet = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/isSet.js"() {
    "use strict";
    isSet = (value) => value != null;
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/not.js
var not2;
var init_not = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/not.js"() {
    "use strict";
    not2 = (value) => !value;
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/parseURL.js
var DEFAULT_PORTS, parseURL;
var init_parseURL = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/parseURL.js"() {
    "use strict";
    init_dist_es();
    init_isIpAddress();
    DEFAULT_PORTS = {
      [EndpointURLScheme.HTTP]: 80,
      [EndpointURLScheme.HTTPS]: 443
    };
    parseURL = (value) => {
      const whatwgURL = (() => {
        try {
          if (value instanceof URL) {
            return value;
          }
          if (typeof value === "object" && "hostname" in value) {
            const { hostname: hostname2, port, protocol: protocol3 = "", path: path3 = "", query = {} } = value;
            const url = new URL(`${protocol3}//${hostname2}${port ? `:${port}` : ""}${path3}`);
            url.search = Object.entries(query).map(([k9, v11]) => `${k9}=${v11}`).join("&");
            return url;
          }
          return new URL(value);
        } catch (error2) {
          return null;
        }
      })();
      if (!whatwgURL) {
        console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`);
        return null;
      }
      const urlString = whatwgURL.href;
      const { host, hostname, pathname, protocol: protocol2, search } = whatwgURL;
      if (search) {
        return null;
      }
      const scheme = protocol2.slice(0, -1);
      if (!Object.values(EndpointURLScheme).includes(scheme)) {
        return null;
      }
      const isIp = isIpAddress(hostname);
      const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) || typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`);
      const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
      return {
        scheme,
        authority,
        path: pathname,
        normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`,
        isIp
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/stringEquals.js
var stringEquals;
var init_stringEquals = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/stringEquals.js"() {
    "use strict";
    stringEquals = (value1, value2) => value1 === value2;
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/substring.js
var substring;
var init_substring = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/substring.js"() {
    "use strict";
    substring = (input, start2, stop2, reverse) => {
      if (start2 >= stop2 || input.length < stop2) {
        return null;
      }
      if (!reverse) {
        return input.substring(start2, stop2);
      }
      return input.substring(input.length - stop2, input.length - start2);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/uriEncode.js
var uriEncode;
var init_uriEncode = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/uriEncode.js"() {
    "use strict";
    uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c6) => `%${c6.charCodeAt(0).toString(16).toUpperCase()}`);
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/index.js
var init_lib = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/lib/index.js"() {
    "use strict";
    init_booleanEquals();
    init_getAttr();
    init_isSet();
    init_isValidHostLabel();
    init_not();
    init_parseURL();
    init_stringEquals();
    init_substring();
    init_uriEncode();
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/endpointFunctions.js
var endpointFunctions;
var init_endpointFunctions = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/endpointFunctions.js"() {
    "use strict";
    init_lib();
    endpointFunctions = {
      booleanEquals,
      getAttr,
      isSet,
      isValidHostLabel,
      not: not2,
      parseURL,
      stringEquals,
      substring,
      uriEncode
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTemplate.js
var evaluateTemplate;
var init_evaluateTemplate = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTemplate.js"() {
    "use strict";
    init_lib();
    evaluateTemplate = (template, options) => {
      const evaluatedTemplateArr = [];
      const templateContext = {
        ...options.endpointParams,
        ...options.referenceRecord
      };
      let currentIndex = 0;
      while (currentIndex < template.length) {
        const openingBraceIndex = template.indexOf("{", currentIndex);
        if (openingBraceIndex === -1) {
          evaluatedTemplateArr.push(template.slice(currentIndex));
          break;
        }
        evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
        const closingBraceIndex = template.indexOf("}", openingBraceIndex);
        if (closingBraceIndex === -1) {
          evaluatedTemplateArr.push(template.slice(openingBraceIndex));
          break;
        }
        if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
          evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
          currentIndex = closingBraceIndex + 2;
        }
        const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
        if (parameterName.includes("#")) {
          const [refName, attrName] = parameterName.split("#");
          evaluatedTemplateArr.push(getAttr(templateContext[refName], attrName));
        } else {
          evaluatedTemplateArr.push(templateContext[parameterName]);
        }
        currentIndex = closingBraceIndex + 1;
      }
      return evaluatedTemplateArr.join("");
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getReferenceValue.js
var getReferenceValue;
var init_getReferenceValue = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getReferenceValue.js"() {
    "use strict";
    getReferenceValue = ({ ref }, options) => {
      const referenceRecord = {
        ...options.endpointParams,
        ...options.referenceRecord
      };
      return referenceRecord[ref];
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js
var evaluateExpression;
var init_evaluateExpression = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js"() {
    "use strict";
    init_types3();
    init_callFunction();
    init_evaluateTemplate();
    init_getReferenceValue();
    evaluateExpression = (obj, keyName, options) => {
      if (typeof obj === "string") {
        return evaluateTemplate(obj, options);
      } else if (obj["fn"]) {
        return callFunction(obj, options);
      } else if (obj["ref"]) {
        return getReferenceValue(obj, options);
      }
      throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/callFunction.js
var callFunction;
var init_callFunction = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/callFunction.js"() {
    "use strict";
    init_customEndpointFunctions();
    init_endpointFunctions();
    init_evaluateExpression();
    callFunction = ({ fn: fn3, argv }, options) => {
      const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options));
      const fnSegments = fn3.split(".");
      if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
        return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
      }
      return endpointFunctions[fn3](...evaluatedArgs);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js
var evaluateCondition;
var init_evaluateCondition = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateCondition.js"() {
    "use strict";
    init_debug();
    init_types3();
    init_callFunction();
    evaluateCondition = ({ assign, ...fnArgs }, options) => {
      if (assign && assign in options.referenceRecord) {
        throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
      }
      const value = callFunction(fnArgs, options);
      options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(fnArgs)} = ${toDebugString(value)}`);
      return {
        result: value === "" ? true : !!value,
        ...assign != null && { toAssign: { name: assign, value } }
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js
var evaluateConditions;
var init_evaluateConditions = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateConditions.js"() {
    "use strict";
    init_debug();
    init_evaluateCondition();
    evaluateConditions = (conditions = [], options) => {
      const conditionsReferenceRecord = {};
      for (const condition of conditions) {
        const { result, toAssign } = evaluateCondition(condition, {
          ...options,
          referenceRecord: {
            ...options.referenceRecord,
            ...conditionsReferenceRecord
          }
        });
        if (!result) {
          return { result };
        }
        if (toAssign) {
          conditionsReferenceRecord[toAssign.name] = toAssign.value;
          options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
        }
      }
      return { result: true, referenceRecord: conditionsReferenceRecord };
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js
var getEndpointHeaders;
var init_getEndpointHeaders = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointHeaders.js"() {
    "use strict";
    init_types3();
    init_evaluateExpression();
    getEndpointHeaders = (headers, options) => Object.entries(headers).reduce((acc, [headerKey, headerVal]) => ({
      ...acc,
      [headerKey]: headerVal.map((headerValEntry) => {
        const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
        if (typeof processedExpr !== "string") {
          throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
        }
        return processedExpr;
      })
    }), {});
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperty.js
var getEndpointProperty;
var init_getEndpointProperty = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperty.js"() {
    "use strict";
    init_types3();
    init_evaluateTemplate();
    init_getEndpointProperties();
    getEndpointProperty = (property, options) => {
      if (Array.isArray(property)) {
        return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
      }
      switch (typeof property) {
        case "string":
          return evaluateTemplate(property, options);
        case "object":
          if (property === null) {
            throw new EndpointError(`Unexpected endpoint property: ${property}`);
          }
          return getEndpointProperties(property, options);
        case "boolean":
          return property;
        default:
          throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js
var getEndpointProperties;
var init_getEndpointProperties = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js"() {
    "use strict";
    init_getEndpointProperty();
    getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
      ...acc,
      [propertyKey]: getEndpointProperty(propertyVal, options)
    }), {});
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js
var getEndpointUrl;
var init_getEndpointUrl = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointUrl.js"() {
    "use strict";
    init_types3();
    init_evaluateExpression();
    getEndpointUrl = (endpointUrl, options) => {
      const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
      if (typeof expression === "string") {
        try {
          return new URL(expression);
        } catch (error2) {
          console.error(`Failed to construct URL with ${expression}`, error2);
          throw error2;
        }
      }
      throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js
var evaluateEndpointRule;
var init_evaluateEndpointRule = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateEndpointRule.js"() {
    "use strict";
    init_debug();
    init_evaluateConditions();
    init_getEndpointHeaders();
    init_getEndpointProperties();
    init_getEndpointUrl();
    evaluateEndpointRule = (endpointRule, options) => {
      const { conditions, endpoint } = endpointRule;
      const { result, referenceRecord } = evaluateConditions(conditions, options);
      if (!result) {
        return;
      }
      const endpointRuleOptions = {
        ...options,
        referenceRecord: { ...options.referenceRecord, ...referenceRecord }
      };
      const { url, properties, headers } = endpoint;
      options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
      return {
        ...headers != void 0 && {
          headers: getEndpointHeaders(headers, endpointRuleOptions)
        },
        ...properties != void 0 && {
          properties: getEndpointProperties(properties, endpointRuleOptions)
        },
        url: getEndpointUrl(url, endpointRuleOptions)
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js
var evaluateErrorRule;
var init_evaluateErrorRule = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateErrorRule.js"() {
    "use strict";
    init_types3();
    init_evaluateConditions();
    init_evaluateExpression();
    evaluateErrorRule = (errorRule, options) => {
      const { conditions, error: error2 } = errorRule;
      const { result, referenceRecord } = evaluateConditions(conditions, options);
      if (!result) {
        return;
      }
      throw new EndpointError(evaluateExpression(error2, "Error", {
        ...options,
        referenceRecord: { ...options.referenceRecord, ...referenceRecord }
      }));
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTreeRule.js
var evaluateTreeRule;
var init_evaluateTreeRule = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTreeRule.js"() {
    "use strict";
    init_evaluateConditions();
    init_evaluateRules();
    evaluateTreeRule = (treeRule, options) => {
      const { conditions, rules } = treeRule;
      const { result, referenceRecord } = evaluateConditions(conditions, options);
      if (!result) {
        return;
      }
      return evaluateRules(rules, {
        ...options,
        referenceRecord: { ...options.referenceRecord, ...referenceRecord }
      });
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js
var evaluateRules;
var init_evaluateRules = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js"() {
    "use strict";
    init_types3();
    init_evaluateEndpointRule();
    init_evaluateErrorRule();
    init_evaluateTreeRule();
    evaluateRules = (rules, options) => {
      for (const rule of rules) {
        if (rule.type === "endpoint") {
          const endpointOrUndefined = evaluateEndpointRule(rule, options);
          if (endpointOrUndefined) {
            return endpointOrUndefined;
          }
        } else if (rule.type === "error") {
          evaluateErrorRule(rule, options);
        } else if (rule.type === "tree") {
          const endpointOrUndefined = evaluateTreeRule(rule, options);
          if (endpointOrUndefined) {
            return endpointOrUndefined;
          }
        } else {
          throw new EndpointError(`Unknown endpoint rule: ${rule}`);
        }
      }
      throw new EndpointError(`Rules evaluation failed`);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/index.js
var init_utils12 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/utils/index.js"() {
    "use strict";
    init_customEndpointFunctions();
    init_evaluateRules();
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js
var resolveEndpoint;
var init_resolveEndpoint = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/resolveEndpoint.js"() {
    "use strict";
    init_debug();
    init_types3();
    init_utils12();
    resolveEndpoint = (ruleSetObject, options) => {
      const { endpointParams, logger: logger2 } = options;
      const { parameters, rules } = ruleSetObject;
      options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);
      const paramsWithDefault = Object.entries(parameters).filter(([, v11]) => v11.default != null).map(([k9, v11]) => [k9, v11.default]);
      if (paramsWithDefault.length > 0) {
        for (const [paramKey, paramDefaultValue] of paramsWithDefault) {
          endpointParams[paramKey] = endpointParams[paramKey] ?? paramDefaultValue;
        }
      }
      const requiredParams = Object.entries(parameters).filter(([, v11]) => v11.required).map(([k9]) => k9);
      for (const requiredParam of requiredParams) {
        if (endpointParams[requiredParam] == null) {
          throw new EndpointError(`Missing required parameter: '${requiredParam}'`);
        }
      }
      const endpoint = evaluateRules(rules, { endpointParams, logger: logger2, referenceRecord: {} });
      options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
      return endpoint;
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/index.js
var init_dist_es19 = __esm({
  "../node_modules/.pnpm/@smithy+util-endpoints@3.0.6/node_modules/@smithy/util-endpoints/dist-es/index.js"() {
    "use strict";
    init_EndpointCache();
    init_isIpAddress();
    init_isValidHostLabel();
    init_customEndpointFunctions();
    init_resolveEndpoint();
    init_types3();
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/isIpAddress.js
var init_isIpAddress2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/isIpAddress.js"() {
    "use strict";
    init_dist_es19();
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/isVirtualHostableS3Bucket.js
var isVirtualHostableS3Bucket;
var init_isVirtualHostableS3Bucket = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/isVirtualHostableS3Bucket.js"() {
    "use strict";
    init_dist_es19();
    init_isIpAddress2();
    isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
      if (allowSubDomains) {
        for (const label of value.split(".")) {
          if (!isVirtualHostableS3Bucket(label)) {
            return false;
          }
        }
        return true;
      }
      if (!isValidHostLabel(value)) {
        return false;
      }
      if (value.length < 3 || value.length > 63) {
        return false;
      }
      if (value !== value.toLowerCase()) {
        return false;
      }
      if (isIpAddress(value)) {
        return false;
      }
      return true;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/parseArn.js
var ARN_DELIMITER, RESOURCE_DELIMITER, parseArn;
var init_parseArn = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/parseArn.js"() {
    "use strict";
    ARN_DELIMITER = ":";
    RESOURCE_DELIMITER = "/";
    parseArn = (value) => {
      const segments = value.split(ARN_DELIMITER);
      if (segments.length < 6)
        return null;
      const [arn, partition2, service, region, accountId, ...resourcePath] = segments;
      if (arn !== "arn" || partition2 === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "")
        return null;
      const resourceId = resourcePath.map((resource) => resource.split(RESOURCE_DELIMITER)).flat();
      return {
        partition: partition2,
        service,
        region,
        accountId,
        resourceId
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partitions.json
var partitions_default;
var init_partitions = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partitions.json"() {
    partitions_default = {
      partitions: [{
        id: "aws",
        outputs: {
          dnsSuffix: "amazonaws.com",
          dualStackDnsSuffix: "api.aws",
          implicitGlobalRegion: "us-east-1",
          name: "aws",
          supportsDualStack: true,
          supportsFIPS: true
        },
        regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$",
        regions: {
          "af-south-1": {
            description: "Africa (Cape Town)"
          },
          "ap-east-1": {
            description: "Asia Pacific (Hong Kong)"
          },
          "ap-northeast-1": {
            description: "Asia Pacific (Tokyo)"
          },
          "ap-northeast-2": {
            description: "Asia Pacific (Seoul)"
          },
          "ap-northeast-3": {
            description: "Asia Pacific (Osaka)"
          },
          "ap-south-1": {
            description: "Asia Pacific (Mumbai)"
          },
          "ap-south-2": {
            description: "Asia Pacific (Hyderabad)"
          },
          "ap-southeast-1": {
            description: "Asia Pacific (Singapore)"
          },
          "ap-southeast-2": {
            description: "Asia Pacific (Sydney)"
          },
          "ap-southeast-3": {
            description: "Asia Pacific (Jakarta)"
          },
          "ap-southeast-4": {
            description: "Asia Pacific (Melbourne)"
          },
          "ap-southeast-5": {
            description: "Asia Pacific (Malaysia)"
          },
          "ap-southeast-7": {
            description: "Asia Pacific (Thailand)"
          },
          "aws-global": {
            description: "AWS Standard global region"
          },
          "ca-central-1": {
            description: "Canada (Central)"
          },
          "ca-west-1": {
            description: "Canada West (Calgary)"
          },
          "eu-central-1": {
            description: "Europe (Frankfurt)"
          },
          "eu-central-2": {
            description: "Europe (Zurich)"
          },
          "eu-north-1": {
            description: "Europe (Stockholm)"
          },
          "eu-south-1": {
            description: "Europe (Milan)"
          },
          "eu-south-2": {
            description: "Europe (Spain)"
          },
          "eu-west-1": {
            description: "Europe (Ireland)"
          },
          "eu-west-2": {
            description: "Europe (London)"
          },
          "eu-west-3": {
            description: "Europe (Paris)"
          },
          "il-central-1": {
            description: "Israel (Tel Aviv)"
          },
          "me-central-1": {
            description: "Middle East (UAE)"
          },
          "me-south-1": {
            description: "Middle East (Bahrain)"
          },
          "mx-central-1": {
            description: "Mexico (Central)"
          },
          "sa-east-1": {
            description: "South America (Sao Paulo)"
          },
          "us-east-1": {
            description: "US East (N. Virginia)"
          },
          "us-east-2": {
            description: "US East (Ohio)"
          },
          "us-west-1": {
            description: "US West (N. California)"
          },
          "us-west-2": {
            description: "US West (Oregon)"
          }
        }
      }, {
        id: "aws-cn",
        outputs: {
          dnsSuffix: "amazonaws.com.cn",
          dualStackDnsSuffix: "api.amazonwebservices.com.cn",
          implicitGlobalRegion: "cn-northwest-1",
          name: "aws-cn",
          supportsDualStack: true,
          supportsFIPS: true
        },
        regionRegex: "^cn\\-\\w+\\-\\d+$",
        regions: {
          "aws-cn-global": {
            description: "AWS China global region"
          },
          "cn-north-1": {
            description: "China (Beijing)"
          },
          "cn-northwest-1": {
            description: "China (Ningxia)"
          }
        }
      }, {
        id: "aws-us-gov",
        outputs: {
          dnsSuffix: "amazonaws.com",
          dualStackDnsSuffix: "api.aws",
          implicitGlobalRegion: "us-gov-west-1",
          name: "aws-us-gov",
          supportsDualStack: true,
          supportsFIPS: true
        },
        regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
        regions: {
          "aws-us-gov-global": {
            description: "AWS GovCloud (US) global region"
          },
          "us-gov-east-1": {
            description: "AWS GovCloud (US-East)"
          },
          "us-gov-west-1": {
            description: "AWS GovCloud (US-West)"
          }
        }
      }, {
        id: "aws-iso",
        outputs: {
          dnsSuffix: "c2s.ic.gov",
          dualStackDnsSuffix: "c2s.ic.gov",
          implicitGlobalRegion: "us-iso-east-1",
          name: "aws-iso",
          supportsDualStack: false,
          supportsFIPS: true
        },
        regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-global": {
            description: "AWS ISO (US) global region"
          },
          "us-iso-east-1": {
            description: "US ISO East"
          },
          "us-iso-west-1": {
            description: "US ISO WEST"
          }
        }
      }, {
        id: "aws-iso-b",
        outputs: {
          dnsSuffix: "sc2s.sgov.gov",
          dualStackDnsSuffix: "sc2s.sgov.gov",
          implicitGlobalRegion: "us-isob-east-1",
          name: "aws-iso-b",
          supportsDualStack: false,
          supportsFIPS: true
        },
        regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-b-global": {
            description: "AWS ISOB (US) global region"
          },
          "us-isob-east-1": {
            description: "US ISOB East (Ohio)"
          }
        }
      }, {
        id: "aws-iso-e",
        outputs: {
          dnsSuffix: "cloud.adc-e.uk",
          dualStackDnsSuffix: "cloud.adc-e.uk",
          implicitGlobalRegion: "eu-isoe-west-1",
          name: "aws-iso-e",
          supportsDualStack: false,
          supportsFIPS: true
        },
        regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-e-global": {
            description: "AWS ISOE (Europe) global region"
          },
          "eu-isoe-west-1": {
            description: "EU ISOE West"
          }
        }
      }, {
        id: "aws-iso-f",
        outputs: {
          dnsSuffix: "csp.hci.ic.gov",
          dualStackDnsSuffix: "csp.hci.ic.gov",
          implicitGlobalRegion: "us-isof-south-1",
          name: "aws-iso-f",
          supportsDualStack: false,
          supportsFIPS: true
        },
        regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
        regions: {
          "aws-iso-f-global": {
            description: "AWS ISOF global region"
          },
          "us-isof-east-1": {
            description: "US ISOF EAST"
          },
          "us-isof-south-1": {
            description: "US ISOF SOUTH"
          }
        }
      }, {
        id: "aws-eusc",
        outputs: {
          dnsSuffix: "amazonaws.eu",
          dualStackDnsSuffix: "amazonaws.eu",
          implicitGlobalRegion: "eusc-de-east-1",
          name: "aws-eusc",
          supportsDualStack: false,
          supportsFIPS: true
        },
        regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
        regions: {
          "eusc-de-east-1": {
            description: "EU (Germany)"
          }
        }
      }],
      version: "1.1"
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partition.js
var selectedPartitionsInfo, selectedUserAgentPrefix, partition, getUserAgentPrefix;
var init_partition = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/lib/aws/partition.js"() {
    "use strict";
    init_partitions();
    selectedPartitionsInfo = partitions_default;
    selectedUserAgentPrefix = "";
    partition = (value) => {
      const { partitions } = selectedPartitionsInfo;
      for (const partition2 of partitions) {
        const { regions, outputs: outputs2 } = partition2;
        for (const [region, regionData] of Object.entries(regions)) {
          if (region === value) {
            return {
              ...outputs2,
              ...regionData
            };
          }
        }
      }
      for (const partition2 of partitions) {
        const { regionRegex, outputs: outputs2 } = partition2;
        if (new RegExp(regionRegex).test(value)) {
          return {
            ...outputs2
          };
        }
      }
      const DEFAULT_PARTITION = partitions.find((partition2) => partition2.id === "aws");
      if (!DEFAULT_PARTITION) {
        throw new Error("Provided region was not found in the partition array or regex, and default partition with id 'aws' doesn't exist.");
      }
      return {
        ...DEFAULT_PARTITION.outputs
      };
    };
    getUserAgentPrefix = () => selectedUserAgentPrefix;
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/aws.js
var awsEndpointFunctions;
var init_aws = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/aws.js"() {
    "use strict";
    init_dist_es19();
    init_isVirtualHostableS3Bucket();
    init_parseArn();
    init_partition();
    awsEndpointFunctions = {
      isVirtualHostableS3Bucket,
      parseArn,
      partition
    };
    customEndpointFunctions.aws = awsEndpointFunctions;
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/resolveEndpoint.js
var init_resolveEndpoint2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/resolveEndpoint.js"() {
    "use strict";
    init_dist_es19();
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/EndpointError.js
var init_EndpointError2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/EndpointError.js"() {
    "use strict";
    init_dist_es19();
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/EndpointRuleObject.js
var init_EndpointRuleObject3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/EndpointRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/ErrorRuleObject.js
var init_ErrorRuleObject3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/ErrorRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/RuleSetObject.js
var init_RuleSetObject3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/RuleSetObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/TreeRuleObject.js
var init_TreeRuleObject3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/TreeRuleObject.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/shared.js
var init_shared3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/shared.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/index.js
var init_types4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/types/index.js"() {
    "use strict";
    init_EndpointError2();
    init_EndpointRuleObject3();
    init_ErrorRuleObject3();
    init_RuleSetObject3();
    init_TreeRuleObject3();
    init_shared3();
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/index.js
var init_dist_es20 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-endpoints@3.808.0/node_modules/@aws-sdk/util-endpoints/dist-es/index.js"() {
    "use strict";
    init_aws();
    init_partition();
    init_isIpAddress2();
    init_resolveEndpoint2();
    init_types4();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/emitWarningIfUnsupportedVersion.js
var state, emitWarningIfUnsupportedVersion;
var init_emitWarningIfUnsupportedVersion = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/emitWarningIfUnsupportedVersion.js"() {
    "use strict";
    state = {
      warningEmitted: false
    };
    emitWarningIfUnsupportedVersion = (version3) => {
      if (version3 && !state.warningEmitted && parseInt(version3.substring(1, version3.indexOf("."))) < 18) {
        state.warningEmitted = true;
        process.emitWarning(`NodeDeprecationWarning: The AWS SDK for JavaScript (v3) will
no longer support Node.js 16.x on January 6, 2025.

To continue receiving updates to AWS services, bug fixes, and security
updates please upgrade to a supported Node.js LTS version.

More information can be found at: https://a.co/74kJMmI`);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/setCredentialFeature.js
function setCredentialFeature(credentials2, feature, value) {
  if (!credentials2.$source) {
    credentials2.$source = {};
  }
  credentials2.$source[feature] = value;
  return credentials2;
}
var init_setCredentialFeature = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/setCredentialFeature.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js
function setFeature2(context, feature, value) {
  if (!context.__aws_sdk_context) {
    context.__aws_sdk_context = {
      features: {}
    };
  } else if (!context.__aws_sdk_context.features) {
    context.__aws_sdk_context.features = {};
  }
  context.__aws_sdk_context.features[feature] = value;
}
var init_setFeature2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/setFeature.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/index.js
var init_client2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/client/index.js"() {
    "use strict";
    init_emitWarningIfUnsupportedVersion();
    init_setCredentialFeature();
    init_setFeature2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getDateHeader.js
var getDateHeader;
var init_getDateHeader = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getDateHeader.js"() {
    "use strict";
    init_dist_es2();
    getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : void 0;
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getSkewCorrectedDate.js
var getSkewCorrectedDate;
var init_getSkewCorrectedDate = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getSkewCorrectedDate.js"() {
    "use strict";
    getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/isClockSkewed.js
var isClockSkewed;
var init_isClockSkewed = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/isClockSkewed.js"() {
    "use strict";
    init_getSkewCorrectedDate();
    isClockSkewed = (clockTime, systemClockOffset) => Math.abs(getSkewCorrectedDate(systemClockOffset).getTime() - clockTime) >= 3e5;
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getUpdatedSystemClockOffset.js
var getUpdatedSystemClockOffset;
var init_getUpdatedSystemClockOffset = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getUpdatedSystemClockOffset.js"() {
    "use strict";
    init_isClockSkewed();
    getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset) => {
      const clockTimeInMs = Date.parse(clockTime);
      if (isClockSkewed(clockTimeInMs, currentSystemClockOffset)) {
        return clockTimeInMs - Date.now();
      }
      return currentSystemClockOffset;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/index.js
var init_utils13 = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/index.js"() {
    "use strict";
    init_getDateHeader();
    init_getSkewCorrectedDate();
    init_getUpdatedSystemClockOffset();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.js
var throwSigningPropertyError, validateSigningProperties, AwsSdkSigV4Signer;
var init_AwsSdkSigV4Signer = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/AwsSdkSigV4Signer.js"() {
    "use strict";
    init_dist_es2();
    init_utils13();
    throwSigningPropertyError = (name3, property) => {
      if (!property) {
        throw new Error(`Property \`${name3}\` is not resolved for AWS SDK SigV4Auth`);
      }
      return property;
    };
    validateSigningProperties = async (signingProperties) => {
      const context = throwSigningPropertyError("context", signingProperties.context);
      const config = throwSigningPropertyError("config", signingProperties.config);
      const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
      const signerFunction = throwSigningPropertyError("signer", config.signer);
      const signer = await signerFunction(authScheme);
      const signingRegion = signingProperties?.signingRegion;
      const signingRegionSet = signingProperties?.signingRegionSet;
      const signingName = signingProperties?.signingName;
      return {
        config,
        signer,
        signingRegion,
        signingRegionSet,
        signingName
      };
    };
    AwsSdkSigV4Signer = class {
      async sign(httpRequest2, identity, signingProperties) {
        if (!HttpRequest.isInstance(httpRequest2)) {
          throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
        }
        const validatedProps = await validateSigningProperties(signingProperties);
        const { config, signer } = validatedProps;
        let { signingRegion, signingName } = validatedProps;
        const handlerExecutionContext = signingProperties.context;
        if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) {
          const [first, second] = handlerExecutionContext.authSchemes;
          if (first?.name === "sigv4a" && second?.name === "sigv4") {
            signingRegion = second?.signingRegion ?? signingRegion;
            signingName = second?.signingName ?? signingName;
          }
        }
        const signedRequest = await signer.sign(httpRequest2, {
          signingDate: getSkewCorrectedDate(config.systemClockOffset),
          signingRegion,
          signingService: signingName
        });
        return signedRequest;
      }
      errorHandler(signingProperties) {
        return (error2) => {
          const serverTime = error2.ServerTime ?? getDateHeader(error2.$response);
          if (serverTime) {
            const config = throwSigningPropertyError("config", signingProperties.config);
            const initialSystemClockOffset = config.systemClockOffset;
            config.systemClockOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset);
            const clockSkewCorrected = config.systemClockOffset !== initialSystemClockOffset;
            if (clockSkewCorrected && error2.$metadata) {
              error2.$metadata.clockSkewCorrected = true;
            }
          }
          throw error2;
        };
      }
      successHandler(httpResponse, signingProperties) {
        const dateHeader = getDateHeader(httpResponse);
        if (dateHeader) {
          const config = throwSigningPropertyError("config", signingProperties.config);
          config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset);
        }
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getArrayForCommaSeparatedString.js
var getArrayForCommaSeparatedString;
var init_getArrayForCommaSeparatedString = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getArrayForCommaSeparatedString.js"() {
    "use strict";
    getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getBearerTokenEnvKey.js
var getBearerTokenEnvKey;
var init_getBearerTokenEnvKey = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/utils/getBearerTokenEnvKey.js"() {
    "use strict";
    getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/NODE_AUTH_SCHEME_PREFERENCE_OPTIONS.js
var NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY, NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS;
var init_NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/NODE_AUTH_SCHEME_PREFERENCE_OPTIONS.js"() {
    "use strict";
    init_getArrayForCommaSeparatedString();
    init_getBearerTokenEnvKey();
    NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
    NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
    NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
      environmentVariableSelector: (env4, options) => {
        if (options?.signingName) {
          const bearerTokenKey = getBearerTokenEnvKey(options.signingName);
          if (bearerTokenKey in env4)
            return ["httpBearerAuth"];
        }
        if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env4))
          return void 0;
        return getArrayForCommaSeparatedString(env4[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]);
      },
      configFileSelector: (profile) => {
        if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile))
          return void 0;
        return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]);
      },
      default: []
    };
  }
});

// ../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/ProviderError.js
var ProviderError;
var init_ProviderError = __esm({
  "../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/ProviderError.js"() {
    "use strict";
    ProviderError = class _ProviderError extends Error {
      constructor(message, options = true) {
        let logger2;
        let tryNextLink = true;
        if (typeof options === "boolean") {
          logger2 = void 0;
          tryNextLink = options;
        } else if (options != null && typeof options === "object") {
          logger2 = options.logger;
          tryNextLink = options.tryNextLink ?? true;
        }
        super(message);
        this.name = "ProviderError";
        this.tryNextLink = tryNextLink;
        Object.setPrototypeOf(this, _ProviderError.prototype);
        logger2?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
      }
      static from(error2, options = true) {
        return Object.assign(new this(error2.message, options), error2);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/CredentialsProviderError.js
var CredentialsProviderError;
var init_CredentialsProviderError = __esm({
  "../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/CredentialsProviderError.js"() {
    "use strict";
    init_ProviderError();
    CredentialsProviderError = class _CredentialsProviderError extends ProviderError {
      constructor(message, options = true) {
        super(message, options);
        this.name = "CredentialsProviderError";
        Object.setPrototypeOf(this, _CredentialsProviderError.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/TokenProviderError.js
var TokenProviderError;
var init_TokenProviderError = __esm({
  "../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/TokenProviderError.js"() {
    "use strict";
    init_ProviderError();
    TokenProviderError = class _TokenProviderError extends ProviderError {
      constructor(message, options = true) {
        super(message, options);
        this.name = "TokenProviderError";
        Object.setPrototypeOf(this, _TokenProviderError.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/chain.js
var chain;
var init_chain = __esm({
  "../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/chain.js"() {
    "use strict";
    init_ProviderError();
    chain = (...providers) => async () => {
      if (providers.length === 0) {
        throw new ProviderError("No providers in chain");
      }
      let lastProviderError;
      for (const provider of providers) {
        try {
          const credentials2 = await provider();
          return credentials2;
        } catch (err3) {
          lastProviderError = err3;
          if (err3?.tryNextLink) {
            continue;
          }
          throw err3;
        }
      }
      throw lastProviderError;
    };
  }
});

// ../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/fromStatic.js
var fromStatic;
var init_fromStatic = __esm({
  "../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/fromStatic.js"() {
    "use strict";
    fromStatic = (staticValue) => () => Promise.resolve(staticValue);
  }
});

// ../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/memoize.js
var memoize;
var init_memoize = __esm({
  "../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/memoize.js"() {
    "use strict";
    memoize = (provider, isExpired, requiresRefresh) => {
      let resolved;
      let pending;
      let hasResult;
      let isConstant = false;
      const coalesceProvider = async () => {
        if (!pending) {
          pending = provider();
        }
        try {
          resolved = await pending;
          hasResult = true;
          isConstant = false;
        } finally {
          pending = void 0;
        }
        return resolved;
      };
      if (isExpired === void 0) {
        return async (options) => {
          if (!hasResult || options?.forceRefresh) {
            resolved = await coalesceProvider();
          }
          return resolved;
        };
      }
      return async (options) => {
        if (!hasResult || options?.forceRefresh) {
          resolved = await coalesceProvider();
        }
        if (isConstant) {
          return resolved;
        }
        if (requiresRefresh && !requiresRefresh(resolved)) {
          isConstant = true;
          return resolved;
        }
        if (isExpired(resolved)) {
          await coalesceProvider();
          return resolved;
        }
        return resolved;
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/index.js
var init_dist_es21 = __esm({
  "../node_modules/.pnpm/@smithy+property-provider@4.0.4/node_modules/@smithy/property-provider/dist-es/index.js"() {
    "use strict";
    init_CredentialsProviderError();
    init_ProviderError();
    init_TokenProviderError();
    init_chain();
    init_fromStatic();
    init_memoize();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4AConfig.js
var init_resolveAwsSdkSigV4AConfig = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4AConfig.js"() {
    "use strict";
    init_dist_es18();
    init_dist_es21();
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/constants.js
var ALGORITHM_QUERY_PARAM, CREDENTIAL_QUERY_PARAM, AMZ_DATE_QUERY_PARAM, SIGNED_HEADERS_QUERY_PARAM, EXPIRES_QUERY_PARAM, SIGNATURE_QUERY_PARAM, TOKEN_QUERY_PARAM, AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER, GENERATED_HEADERS, SIGNATURE_HEADER, SHA256_HEADER, TOKEN_HEADER, ALWAYS_UNSIGNABLE_HEADERS, PROXY_HEADER_PATTERN, SEC_HEADER_PATTERN, ALGORITHM_IDENTIFIER, EVENT_ALGORITHM_IDENTIFIER, UNSIGNED_PAYLOAD, MAX_CACHE_SIZE, KEY_TYPE_IDENTIFIER, MAX_PRESIGNED_TTL;
var init_constants3 = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/constants.js"() {
    "use strict";
    ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
    CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
    AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
    SIGNED_HEADERS_QUERY_PARAM = "X-Amz-SignedHeaders";
    EXPIRES_QUERY_PARAM = "X-Amz-Expires";
    SIGNATURE_QUERY_PARAM = "X-Amz-Signature";
    TOKEN_QUERY_PARAM = "X-Amz-Security-Token";
    AUTH_HEADER = "authorization";
    AMZ_DATE_HEADER = AMZ_DATE_QUERY_PARAM.toLowerCase();
    DATE_HEADER = "date";
    GENERATED_HEADERS = [AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER];
    SIGNATURE_HEADER = SIGNATURE_QUERY_PARAM.toLowerCase();
    SHA256_HEADER = "x-amz-content-sha256";
    TOKEN_HEADER = TOKEN_QUERY_PARAM.toLowerCase();
    ALWAYS_UNSIGNABLE_HEADERS = {
      authorization: true,
      "cache-control": true,
      connection: true,
      expect: true,
      from: true,
      "keep-alive": true,
      "max-forwards": true,
      pragma: true,
      referer: true,
      te: true,
      trailer: true,
      "transfer-encoding": true,
      upgrade: true,
      "user-agent": true,
      "x-amzn-trace-id": true
    };
    PROXY_HEADER_PATTERN = /^proxy-/;
    SEC_HEADER_PATTERN = /^sec-/;
    ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256";
    EVENT_ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256-PAYLOAD";
    UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
    MAX_CACHE_SIZE = 50;
    KEY_TYPE_IDENTIFIER = "aws4_request";
    MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/credentialDerivation.js
var signingKeyCache, cacheQueue, createScope, getSigningKey, hmac;
var init_credentialDerivation = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/credentialDerivation.js"() {
    "use strict";
    init_dist_es16();
    init_dist_es10();
    init_constants3();
    signingKeyCache = {};
    cacheQueue = [];
    createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
    getSigningKey = async (sha256Constructor, credentials2, shortDate, region, service) => {
      const credsHash = await hmac(sha256Constructor, credentials2.secretAccessKey, credentials2.accessKeyId);
      const cacheKey2 = `${shortDate}:${region}:${service}:${toHex(credsHash)}:${credentials2.sessionToken}`;
      if (cacheKey2 in signingKeyCache) {
        return signingKeyCache[cacheKey2];
      }
      cacheQueue.push(cacheKey2);
      while (cacheQueue.length > MAX_CACHE_SIZE) {
        delete signingKeyCache[cacheQueue.shift()];
      }
      let key = `AWS4${credentials2.secretAccessKey}`;
      for (const signable of [shortDate, region, service, KEY_TYPE_IDENTIFIER]) {
        key = await hmac(sha256Constructor, key, signable);
      }
      return signingKeyCache[cacheKey2] = key;
    };
    hmac = (ctor, secret, data) => {
      const hash = new ctor(secret);
      hash.update(toUint8Array(data));
      return hash.digest();
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/getCanonicalHeaders.js
var getCanonicalHeaders;
var init_getCanonicalHeaders = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/getCanonicalHeaders.js"() {
    "use strict";
    init_constants3();
    getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
      const canonical = {};
      for (const headerName of Object.keys(headers).sort()) {
        if (headers[headerName] == void 0) {
          continue;
        }
        const canonicalHeaderName = headerName.toLowerCase();
        if (canonicalHeaderName in ALWAYS_UNSIGNABLE_HEADERS || unsignableHeaders?.has(canonicalHeaderName) || PROXY_HEADER_PATTERN.test(canonicalHeaderName) || SEC_HEADER_PATTERN.test(canonicalHeaderName)) {
          if (!signableHeaders || signableHeaders && !signableHeaders.has(canonicalHeaderName)) {
            continue;
          }
        }
        canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
      }
      return canonical;
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/getPayloadHash.js
var getPayloadHash;
var init_getPayloadHash = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/getPayloadHash.js"() {
    "use strict";
    init_dist_es8();
    init_dist_es16();
    init_dist_es10();
    init_constants3();
    getPayloadHash = async ({ headers, body: body2 }, hashConstructor) => {
      for (const headerName of Object.keys(headers)) {
        if (headerName.toLowerCase() === SHA256_HEADER) {
          return headers[headerName];
        }
      }
      if (body2 == void 0) {
        return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
      } else if (typeof body2 === "string" || ArrayBuffer.isView(body2) || isArrayBuffer(body2)) {
        const hashCtor = new hashConstructor();
        hashCtor.update(toUint8Array(body2));
        return toHex(await hashCtor.digest());
      }
      return UNSIGNED_PAYLOAD;
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/HeaderFormatter.js
function negate(bytes2) {
  for (let i8 = 0; i8 < 8; i8++) {
    bytes2[i8] ^= 255;
  }
  for (let i8 = 7; i8 > -1; i8--) {
    bytes2[i8]++;
    if (bytes2[i8] !== 0)
      break;
  }
}
var HeaderFormatter, HEADER_VALUE_TYPE, UUID_PATTERN, Int64;
var init_HeaderFormatter = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/HeaderFormatter.js"() {
    "use strict";
    init_dist_es16();
    init_dist_es10();
    HeaderFormatter = class {
      format(headers) {
        const chunks = [];
        for (const headerName of Object.keys(headers)) {
          const bytes2 = fromUtf8(headerName);
          chunks.push(Uint8Array.from([bytes2.byteLength]), bytes2, this.formatHeaderValue(headers[headerName]));
        }
        const out2 = new Uint8Array(chunks.reduce((carry, bytes2) => carry + bytes2.byteLength, 0));
        let position = 0;
        for (const chunk of chunks) {
          out2.set(chunk, position);
          position += chunk.byteLength;
        }
        return out2;
      }
      formatHeaderValue(header) {
        switch (header.type) {
          case "boolean":
            return Uint8Array.from([header.value ? 0 : 1]);
          case "byte":
            return Uint8Array.from([2, header.value]);
          case "short":
            const shortView = new DataView(new ArrayBuffer(3));
            shortView.setUint8(0, 3);
            shortView.setInt16(1, header.value, false);
            return new Uint8Array(shortView.buffer);
          case "integer":
            const intView = new DataView(new ArrayBuffer(5));
            intView.setUint8(0, 4);
            intView.setInt32(1, header.value, false);
            return new Uint8Array(intView.buffer);
          case "long":
            const longBytes = new Uint8Array(9);
            longBytes[0] = 5;
            longBytes.set(header.value.bytes, 1);
            return longBytes;
          case "binary":
            const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
            binView.setUint8(0, 6);
            binView.setUint16(1, header.value.byteLength, false);
            const binBytes = new Uint8Array(binView.buffer);
            binBytes.set(header.value, 3);
            return binBytes;
          case "string":
            const utf8Bytes = fromUtf8(header.value);
            const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
            strView.setUint8(0, 7);
            strView.setUint16(1, utf8Bytes.byteLength, false);
            const strBytes = new Uint8Array(strView.buffer);
            strBytes.set(utf8Bytes, 3);
            return strBytes;
          case "timestamp":
            const tsBytes = new Uint8Array(9);
            tsBytes[0] = 8;
            tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
            return tsBytes;
          case "uuid":
            if (!UUID_PATTERN.test(header.value)) {
              throw new Error(`Invalid UUID received: ${header.value}`);
            }
            const uuidBytes = new Uint8Array(17);
            uuidBytes[0] = 9;
            uuidBytes.set(fromHex(header.value.replace(/\-/g, "")), 1);
            return uuidBytes;
        }
      }
    };
    (function(HEADER_VALUE_TYPE2) {
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolTrue"] = 0] = "boolTrue";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["boolFalse"] = 1] = "boolFalse";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byte"] = 2] = "byte";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["short"] = 3] = "short";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["integer"] = 4] = "integer";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["long"] = 5] = "long";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["byteArray"] = 6] = "byteArray";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["string"] = 7] = "string";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["timestamp"] = 8] = "timestamp";
      HEADER_VALUE_TYPE2[HEADER_VALUE_TYPE2["uuid"] = 9] = "uuid";
    })(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
    UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
    Int64 = class _Int64 {
      constructor(bytes2) {
        this.bytes = bytes2;
        if (bytes2.byteLength !== 8) {
          throw new Error("Int64 buffers must be exactly 8 bytes");
        }
      }
      static fromNumber(number2) {
        if (number2 > 9223372036854776e3 || number2 < -9223372036854776e3) {
          throw new Error(`${number2} is too large (or, if negative, too small) to represent as an Int64`);
        }
        const bytes2 = new Uint8Array(8);
        for (let i8 = 7, remaining = Math.abs(Math.round(number2)); i8 > -1 && remaining > 0; i8--, remaining /= 256) {
          bytes2[i8] = remaining;
        }
        if (number2 < 0) {
          negate(bytes2);
        }
        return new _Int64(bytes2);
      }
      valueOf() {
        const bytes2 = this.bytes.slice(0);
        const negative = bytes2[0] & 128;
        if (negative) {
          negate(bytes2);
        }
        return parseInt(toHex(bytes2), 16) * (negative ? -1 : 1);
      }
      toString() {
        return String(this.valueOf());
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/headerUtil.js
var hasHeader;
var init_headerUtil = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/headerUtil.js"() {
    "use strict";
    hasHeader = (soughtHeader, headers) => {
      soughtHeader = soughtHeader.toLowerCase();
      for (const headerName of Object.keys(headers)) {
        if (soughtHeader === headerName.toLowerCase()) {
          return true;
        }
      }
      return false;
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/moveHeadersToQuery.js
var moveHeadersToQuery;
var init_moveHeadersToQuery = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/moveHeadersToQuery.js"() {
    "use strict";
    init_dist_es2();
    moveHeadersToQuery = (request2, options = {}) => {
      const { headers, query = {} } = HttpRequest.clone(request2);
      for (const name3 of Object.keys(headers)) {
        const lname = name3.toLowerCase();
        if (lname.slice(0, 6) === "x-amz-" && !options.unhoistableHeaders?.has(lname) || options.hoistableHeaders?.has(lname)) {
          query[name3] = headers[name3];
          delete headers[name3];
        }
      }
      return {
        ...request2,
        headers,
        query
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/prepareRequest.js
var prepareRequest;
var init_prepareRequest = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/prepareRequest.js"() {
    "use strict";
    init_dist_es2();
    init_constants3();
    prepareRequest = (request2) => {
      request2 = HttpRequest.clone(request2);
      for (const headerName of Object.keys(request2.headers)) {
        if (GENERATED_HEADERS.indexOf(headerName.toLowerCase()) > -1) {
          delete request2.headers[headerName];
        }
      }
      return request2;
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/getCanonicalQuery.js
var getCanonicalQuery;
var init_getCanonicalQuery = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/getCanonicalQuery.js"() {
    "use strict";
    init_dist_es12();
    init_constants3();
    getCanonicalQuery = ({ query = {} }) => {
      const keys = [];
      const serialized = {};
      for (const key of Object.keys(query)) {
        if (key.toLowerCase() === SIGNATURE_HEADER) {
          continue;
        }
        const encodedKey = escapeUri(key);
        keys.push(encodedKey);
        const value = query[key];
        if (typeof value === "string") {
          serialized[encodedKey] = `${encodedKey}=${escapeUri(value)}`;
        } else if (Array.isArray(value)) {
          serialized[encodedKey] = value.slice(0).reduce((encoded, value2) => encoded.concat([`${encodedKey}=${escapeUri(value2)}`]), []).sort().join("&");
        }
      }
      return keys.sort().map((key) => serialized[key]).filter((serialized2) => serialized2).join("&");
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/utilDate.js
var iso8601, toDate;
var init_utilDate = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/utilDate.js"() {
    "use strict";
    iso8601 = (time4) => toDate(time4).toISOString().replace(/\.\d{3}Z$/, "Z");
    toDate = (time4) => {
      if (typeof time4 === "number") {
        return new Date(time4 * 1e3);
      }
      if (typeof time4 === "string") {
        if (Number(time4)) {
          return new Date(Number(time4) * 1e3);
        }
        return new Date(time4);
      }
      return time4;
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/SignatureV4Base.js
var SignatureV4Base;
var init_SignatureV4Base = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/SignatureV4Base.js"() {
    "use strict";
    init_dist_es16();
    init_dist_es6();
    init_dist_es12();
    init_dist_es10();
    init_getCanonicalQuery();
    init_utilDate();
    SignatureV4Base = class {
      constructor({ applyChecksum, credentials: credentials2, region, service, sha256: sha2563, uriEscapePath = true }) {
        this.service = service;
        this.sha256 = sha2563;
        this.uriEscapePath = uriEscapePath;
        this.applyChecksum = typeof applyChecksum === "boolean" ? applyChecksum : true;
        this.regionProvider = normalizeProvider(region);
        this.credentialProvider = normalizeProvider(credentials2);
      }
      createCanonicalRequest(request2, canonicalHeaders, payloadHash) {
        const sortedHeaders = Object.keys(canonicalHeaders).sort();
        return `${request2.method}
${this.getCanonicalPath(request2)}
${getCanonicalQuery(request2)}
${sortedHeaders.map((name3) => `${name3}:${canonicalHeaders[name3]}`).join("\n")}

${sortedHeaders.join(";")}
${payloadHash}`;
      }
      async createStringToSign(longDate, credentialScope, canonicalRequest, algorithmIdentifier) {
        const hash = new this.sha256();
        hash.update(toUint8Array(canonicalRequest));
        const hashedRequest = await hash.digest();
        return `${algorithmIdentifier}
${longDate}
${credentialScope}
${toHex(hashedRequest)}`;
      }
      getCanonicalPath({ path: path3 }) {
        if (this.uriEscapePath) {
          const normalizedPathSegments = [];
          for (const pathSegment of path3.split("/")) {
            if (pathSegment?.length === 0)
              continue;
            if (pathSegment === ".")
              continue;
            if (pathSegment === "..") {
              normalizedPathSegments.pop();
            } else {
              normalizedPathSegments.push(pathSegment);
            }
          }
          const normalizedPath = `${path3?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path3?.endsWith("/") ? "/" : ""}`;
          const doubleEncoded = escapeUri(normalizedPath);
          return doubleEncoded.replace(/%2F/g, "/");
        }
        return path3;
      }
      validateResolvedCredentials(credentials2) {
        if (typeof credentials2 !== "object" || typeof credentials2.accessKeyId !== "string" || typeof credentials2.secretAccessKey !== "string") {
          throw new Error("Resolved credential object is not valid");
        }
      }
      formatDate(now) {
        const longDate = iso8601(now).replace(/[\-:]/g, "");
        return {
          longDate,
          shortDate: longDate.slice(0, 8)
        };
      }
      getCanonicalHeaderList(headers) {
        return Object.keys(headers).sort().join(";");
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/SignatureV4.js
var SignatureV4;
var init_SignatureV4 = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/SignatureV4.js"() {
    "use strict";
    init_dist_es16();
    init_dist_es10();
    init_constants3();
    init_credentialDerivation();
    init_getCanonicalHeaders();
    init_getPayloadHash();
    init_HeaderFormatter();
    init_headerUtil();
    init_moveHeadersToQuery();
    init_prepareRequest();
    init_SignatureV4Base();
    SignatureV4 = class extends SignatureV4Base {
      constructor({ applyChecksum, credentials: credentials2, region, service, sha256: sha2563, uriEscapePath = true }) {
        super({
          applyChecksum,
          credentials: credentials2,
          region,
          service,
          sha256: sha2563,
          uriEscapePath
        });
        this.headerFormatter = new HeaderFormatter();
      }
      async presign(originalRequest, options = {}) {
        const { signingDate = /* @__PURE__ */ new Date(), expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService } = options;
        const credentials2 = await this.credentialProvider();
        this.validateResolvedCredentials(credentials2);
        const region = signingRegion ?? await this.regionProvider();
        const { longDate, shortDate } = this.formatDate(signingDate);
        if (expiresIn > MAX_PRESIGNED_TTL) {
          return Promise.reject("Signature version 4 presigned URLs must have an expiration date less than one week in the future");
        }
        const scope = createScope(shortDate, region, signingService ?? this.service);
        const request2 = moveHeadersToQuery(prepareRequest(originalRequest), { unhoistableHeaders, hoistableHeaders });
        if (credentials2.sessionToken) {
          request2.query[TOKEN_QUERY_PARAM] = credentials2.sessionToken;
        }
        request2.query[ALGORITHM_QUERY_PARAM] = ALGORITHM_IDENTIFIER;
        request2.query[CREDENTIAL_QUERY_PARAM] = `${credentials2.accessKeyId}/${scope}`;
        request2.query[AMZ_DATE_QUERY_PARAM] = longDate;
        request2.query[EXPIRES_QUERY_PARAM] = expiresIn.toString(10);
        const canonicalHeaders = getCanonicalHeaders(request2, unsignableHeaders, signableHeaders);
        request2.query[SIGNED_HEADERS_QUERY_PARAM] = this.getCanonicalHeaderList(canonicalHeaders);
        request2.query[SIGNATURE_QUERY_PARAM] = await this.getSignature(longDate, scope, this.getSigningKey(credentials2, region, shortDate, signingService), this.createCanonicalRequest(request2, canonicalHeaders, await getPayloadHash(originalRequest, this.sha256)));
        return request2;
      }
      async sign(toSign, options) {
        if (typeof toSign === "string") {
          return this.signString(toSign, options);
        } else if (toSign.headers && toSign.payload) {
          return this.signEvent(toSign, options);
        } else if (toSign.message) {
          return this.signMessage(toSign, options);
        } else {
          return this.signRequest(toSign, options);
        }
      }
      async signEvent({ headers, payload }, { signingDate = /* @__PURE__ */ new Date(), priorSignature, signingRegion, signingService }) {
        const region = signingRegion ?? await this.regionProvider();
        const { shortDate, longDate } = this.formatDate(signingDate);
        const scope = createScope(shortDate, region, signingService ?? this.service);
        const hashedPayload = await getPayloadHash({ headers: {}, body: payload }, this.sha256);
        const hash = new this.sha256();
        hash.update(headers);
        const hashedHeaders = toHex(await hash.digest());
        const stringToSign = [
          EVENT_ALGORITHM_IDENTIFIER,
          longDate,
          scope,
          priorSignature,
          hashedHeaders,
          hashedPayload
        ].join("\n");
        return this.signString(stringToSign, { signingDate, signingRegion: region, signingService });
      }
      async signMessage(signableMessage, { signingDate = /* @__PURE__ */ new Date(), signingRegion, signingService }) {
        const promise = this.signEvent({
          headers: this.headerFormatter.format(signableMessage.message.headers),
          payload: signableMessage.message.body
        }, {
          signingDate,
          signingRegion,
          signingService,
          priorSignature: signableMessage.priorSignature
        });
        return promise.then((signature) => {
          return { message: signableMessage.message, signature };
        });
      }
      async signString(stringToSign, { signingDate = /* @__PURE__ */ new Date(), signingRegion, signingService } = {}) {
        const credentials2 = await this.credentialProvider();
        this.validateResolvedCredentials(credentials2);
        const region = signingRegion ?? await this.regionProvider();
        const { shortDate } = this.formatDate(signingDate);
        const hash = new this.sha256(await this.getSigningKey(credentials2, region, shortDate, signingService));
        hash.update(toUint8Array(stringToSign));
        return toHex(await hash.digest());
      }
      async signRequest(requestToSign, { signingDate = /* @__PURE__ */ new Date(), signableHeaders, unsignableHeaders, signingRegion, signingService } = {}) {
        const credentials2 = await this.credentialProvider();
        this.validateResolvedCredentials(credentials2);
        const region = signingRegion ?? await this.regionProvider();
        const request2 = prepareRequest(requestToSign);
        const { longDate, shortDate } = this.formatDate(signingDate);
        const scope = createScope(shortDate, region, signingService ?? this.service);
        request2.headers[AMZ_DATE_HEADER] = longDate;
        if (credentials2.sessionToken) {
          request2.headers[TOKEN_HEADER] = credentials2.sessionToken;
        }
        const payloadHash = await getPayloadHash(request2, this.sha256);
        if (!hasHeader(SHA256_HEADER, request2.headers) && this.applyChecksum) {
          request2.headers[SHA256_HEADER] = payloadHash;
        }
        const canonicalHeaders = getCanonicalHeaders(request2, unsignableHeaders, signableHeaders);
        const signature = await this.getSignature(longDate, scope, this.getSigningKey(credentials2, region, shortDate, signingService), this.createCanonicalRequest(request2, canonicalHeaders, payloadHash));
        request2.headers[AUTH_HEADER] = `${ALGORITHM_IDENTIFIER} Credential=${credentials2.accessKeyId}/${scope}, SignedHeaders=${this.getCanonicalHeaderList(canonicalHeaders)}, Signature=${signature}`;
        return request2;
      }
      async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) {
        const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest, ALGORITHM_IDENTIFIER);
        const hash = new this.sha256(await keyPromise);
        hash.update(toUint8Array(stringToSign));
        return toHex(await hash.digest());
      }
      getSigningKey(credentials2, region, shortDate, service) {
        return getSigningKey(this.sha256, credentials2, shortDate, region, service || this.service);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/signature-v4a-container.js
var init_signature_v4a_container = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/signature-v4a-container.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/index.js
var init_dist_es22 = __esm({
  "../node_modules/.pnpm/@smithy+signature-v4@5.1.2/node_modules/@smithy/signature-v4/dist-es/index.js"() {
    "use strict";
    init_SignatureV4();
    init_constants3();
    init_getCanonicalHeaders();
    init_getCanonicalQuery();
    init_getPayloadHash();
    init_moveHeadersToQuery();
    init_prepareRequest();
    init_credentialDerivation();
    init_SignatureV4Base();
    init_headerUtil();
    init_signature_v4a_container();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.js
function normalizeCredentialProvider(config, { credentials: credentials2, credentialDefaultProvider }) {
  let credentialsProvider;
  if (credentials2) {
    if (!credentials2?.memoized) {
      credentialsProvider = memoizeIdentityProvider(credentials2, isIdentityExpired, doesIdentityRequireRefresh);
    } else {
      credentialsProvider = credentials2;
    }
  } else {
    if (credentialDefaultProvider) {
      credentialsProvider = normalizeProvider2(credentialDefaultProvider(Object.assign({}, config, {
        parentClientConfig: config
      })));
    } else {
      credentialsProvider = async () => {
        throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured.");
      };
    }
  }
  credentialsProvider.memoized = true;
  return credentialsProvider;
}
function bindCallerConfig(config, credentialsProvider) {
  if (credentialsProvider.configBound) {
    return credentialsProvider;
  }
  const fn3 = async (options) => credentialsProvider({ ...options, callerClientConfig: config });
  fn3.memoized = credentialsProvider.memoized;
  fn3.configBound = true;
  return fn3;
}
var resolveAwsSdkSigV4Config;
var init_resolveAwsSdkSigV4Config = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/resolveAwsSdkSigV4Config.js"() {
    "use strict";
    init_client2();
    init_dist_es18();
    init_dist_es22();
    resolveAwsSdkSigV4Config = (config) => {
      let inputCredentials = config.credentials;
      let isUserSupplied = !!config.credentials;
      let resolvedCredentials = void 0;
      Object.defineProperty(config, "credentials", {
        set(credentials2) {
          if (credentials2 && credentials2 !== inputCredentials && credentials2 !== resolvedCredentials) {
            isUserSupplied = true;
          }
          inputCredentials = credentials2;
          const memoizedProvider = normalizeCredentialProvider(config, {
            credentials: inputCredentials,
            credentialDefaultProvider: config.credentialDefaultProvider
          });
          const boundProvider = bindCallerConfig(config, memoizedProvider);
          if (isUserSupplied && !boundProvider.attributed) {
            resolvedCredentials = async (options) => boundProvider(options).then((creds) => setCredentialFeature(creds, "CREDENTIALS_CODE", "e"));
            resolvedCredentials.memoized = boundProvider.memoized;
            resolvedCredentials.configBound = boundProvider.configBound;
            resolvedCredentials.attributed = true;
          } else {
            resolvedCredentials = boundProvider;
          }
        },
        get() {
          return resolvedCredentials;
        },
        enumerable: true,
        configurable: true
      });
      config.credentials = inputCredentials;
      const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256: sha2563 } = config;
      let signer;
      if (config.signer) {
        signer = normalizeProvider2(config.signer);
      } else if (config.regionInfoProvider) {
        signer = () => normalizeProvider2(config.region)().then(async (region) => [
          await config.regionInfoProvider(region, {
            useFipsEndpoint: await config.useFipsEndpoint(),
            useDualstackEndpoint: await config.useDualstackEndpoint()
          }) || {},
          region
        ]).then(([regionInfo, region]) => {
          const { signingRegion, signingService } = regionInfo;
          config.signingRegion = config.signingRegion || signingRegion || region;
          config.signingName = config.signingName || signingService || config.serviceId;
          const params = {
            ...config,
            credentials: config.credentials,
            region: config.signingRegion,
            service: config.signingName,
            sha256: sha2563,
            uriEscapePath: signingEscapePath
          };
          const SignerCtor = config.signerConstructor || SignatureV4;
          return new SignerCtor(params);
        });
      } else {
        signer = async (authScheme) => {
          authScheme = Object.assign({}, {
            name: "sigv4",
            signingName: config.signingName || config.defaultSigningName,
            signingRegion: await normalizeProvider2(config.region)(),
            properties: {}
          }, authScheme);
          const signingRegion = authScheme.signingRegion;
          const signingService = authScheme.signingName;
          config.signingRegion = config.signingRegion || signingRegion;
          config.signingName = config.signingName || signingService || config.serviceId;
          const params = {
            ...config,
            credentials: config.credentials,
            region: config.signingRegion,
            service: config.signingName,
            sha256: sha2563,
            uriEscapePath: signingEscapePath
          };
          const SignerCtor = config.signerConstructor || SignatureV4;
          return new SignerCtor(params);
        };
      }
      const resolvedConfig = Object.assign(config, {
        systemClockOffset,
        signingEscapePath,
        signer
      });
      return resolvedConfig;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/index.js
var init_aws_sdk = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/aws_sdk/index.js"() {
    "use strict";
    init_AwsSdkSigV4Signer();
    init_NODE_AUTH_SCHEME_PREFERENCE_OPTIONS();
    init_resolveAwsSdkSigV4AConfig();
    init_resolveAwsSdkSigV4Config();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/index.js
var init_httpAuthSchemes2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/httpAuthSchemes/index.js"() {
    "use strict";
    init_aws_sdk();
    init_getBearerTokenEnvKey();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/coercing-serializers.js
var init_coercing_serializers = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/coercing-serializers.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+middleware-stack@4.0.4/node_modules/@smithy/middleware-stack/dist-es/MiddlewareStack.js
var getAllAliases, getMiddlewareNameWithAliases, constructStack, stepWeights, priorityWeights;
var init_MiddlewareStack = __esm({
  "../node_modules/.pnpm/@smithy+middleware-stack@4.0.4/node_modules/@smithy/middleware-stack/dist-es/MiddlewareStack.js"() {
    "use strict";
    getAllAliases = (name3, aliases) => {
      const _aliases = [];
      if (name3) {
        _aliases.push(name3);
      }
      if (aliases) {
        for (const alias2 of aliases) {
          _aliases.push(alias2);
        }
      }
      return _aliases;
    };
    getMiddlewareNameWithAliases = (name3, aliases) => {
      return `${name3 || "anonymous"}${aliases && aliases.length > 0 ? ` (a.k.a. ${aliases.join(",")})` : ""}`;
    };
    constructStack = () => {
      let absoluteEntries = [];
      let relativeEntries = [];
      let identifyOnResolve = false;
      const entriesNameSet = /* @__PURE__ */ new Set();
      const sort = (entries) => entries.sort((a9, b9) => stepWeights[b9.step] - stepWeights[a9.step] || priorityWeights[b9.priority || "normal"] - priorityWeights[a9.priority || "normal"]);
      const removeByName = (toRemove) => {
        let isRemoved = false;
        const filterCb = (entry) => {
          const aliases = getAllAliases(entry.name, entry.aliases);
          if (aliases.includes(toRemove)) {
            isRemoved = true;
            for (const alias2 of aliases) {
              entriesNameSet.delete(alias2);
            }
            return false;
          }
          return true;
        };
        absoluteEntries = absoluteEntries.filter(filterCb);
        relativeEntries = relativeEntries.filter(filterCb);
        return isRemoved;
      };
      const removeByReference = (toRemove) => {
        let isRemoved = false;
        const filterCb = (entry) => {
          if (entry.middleware === toRemove) {
            isRemoved = true;
            for (const alias2 of getAllAliases(entry.name, entry.aliases)) {
              entriesNameSet.delete(alias2);
            }
            return false;
          }
          return true;
        };
        absoluteEntries = absoluteEntries.filter(filterCb);
        relativeEntries = relativeEntries.filter(filterCb);
        return isRemoved;
      };
      const cloneTo = (toStack) => {
        absoluteEntries.forEach((entry) => {
          toStack.add(entry.middleware, { ...entry });
        });
        relativeEntries.forEach((entry) => {
          toStack.addRelativeTo(entry.middleware, { ...entry });
        });
        toStack.identifyOnResolve?.(stack.identifyOnResolve());
        return toStack;
      };
      const expandRelativeMiddlewareList = (from) => {
        const expandedMiddlewareList = [];
        from.before.forEach((entry) => {
          if (entry.before.length === 0 && entry.after.length === 0) {
            expandedMiddlewareList.push(entry);
          } else {
            expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
          }
        });
        expandedMiddlewareList.push(from);
        from.after.reverse().forEach((entry) => {
          if (entry.before.length === 0 && entry.after.length === 0) {
            expandedMiddlewareList.push(entry);
          } else {
            expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
          }
        });
        return expandedMiddlewareList;
      };
      const getMiddlewareList = (debug = false) => {
        const normalizedAbsoluteEntries = [];
        const normalizedRelativeEntries = [];
        const normalizedEntriesNameMap = {};
        absoluteEntries.forEach((entry) => {
          const normalizedEntry = {
            ...entry,
            before: [],
            after: []
          };
          for (const alias2 of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
            normalizedEntriesNameMap[alias2] = normalizedEntry;
          }
          normalizedAbsoluteEntries.push(normalizedEntry);
        });
        relativeEntries.forEach((entry) => {
          const normalizedEntry = {
            ...entry,
            before: [],
            after: []
          };
          for (const alias2 of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
            normalizedEntriesNameMap[alias2] = normalizedEntry;
          }
          normalizedRelativeEntries.push(normalizedEntry);
        });
        normalizedRelativeEntries.forEach((entry) => {
          if (entry.toMiddleware) {
            const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware];
            if (toMiddleware === void 0) {
              if (debug) {
                return;
              }
              throw new Error(`${entry.toMiddleware} is not found when adding ${getMiddlewareNameWithAliases(entry.name, entry.aliases)} middleware ${entry.relation} ${entry.toMiddleware}`);
            }
            if (entry.relation === "after") {
              toMiddleware.after.push(entry);
            }
            if (entry.relation === "before") {
              toMiddleware.before.push(entry);
            }
          }
        });
        const mainChain = sort(normalizedAbsoluteEntries).map(expandRelativeMiddlewareList).reduce((wholeList, expandedMiddlewareList) => {
          wholeList.push(...expandedMiddlewareList);
          return wholeList;
        }, []);
        return mainChain;
      };
      const stack = {
        add: (middleware, options = {}) => {
          const { name: name3, override, aliases: _aliases } = options;
          const entry = {
            step: "initialize",
            priority: "normal",
            middleware,
            ...options
          };
          const aliases = getAllAliases(name3, _aliases);
          if (aliases.length > 0) {
            if (aliases.some((alias2) => entriesNameSet.has(alias2))) {
              if (!override)
                throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name3, _aliases)}'`);
              for (const alias2 of aliases) {
                const toOverrideIndex = absoluteEntries.findIndex((entry2) => entry2.name === alias2 || entry2.aliases?.some((a9) => a9 === alias2));
                if (toOverrideIndex === -1) {
                  continue;
                }
                const toOverride = absoluteEntries[toOverrideIndex];
                if (toOverride.step !== entry.step || entry.priority !== toOverride.priority) {
                  throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware with ${toOverride.priority} priority in ${toOverride.step} step cannot be overridden by "${getMiddlewareNameWithAliases(name3, _aliases)}" middleware with ${entry.priority} priority in ${entry.step} step.`);
                }
                absoluteEntries.splice(toOverrideIndex, 1);
              }
            }
            for (const alias2 of aliases) {
              entriesNameSet.add(alias2);
            }
          }
          absoluteEntries.push(entry);
        },
        addRelativeTo: (middleware, options) => {
          const { name: name3, override, aliases: _aliases } = options;
          const entry = {
            middleware,
            ...options
          };
          const aliases = getAllAliases(name3, _aliases);
          if (aliases.length > 0) {
            if (aliases.some((alias2) => entriesNameSet.has(alias2))) {
              if (!override)
                throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name3, _aliases)}'`);
              for (const alias2 of aliases) {
                const toOverrideIndex = relativeEntries.findIndex((entry2) => entry2.name === alias2 || entry2.aliases?.some((a9) => a9 === alias2));
                if (toOverrideIndex === -1) {
                  continue;
                }
                const toOverride = relativeEntries[toOverrideIndex];
                if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) {
                  throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware ${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden by "${getMiddlewareNameWithAliases(name3, _aliases)}" middleware ${entry.relation} "${entry.toMiddleware}" middleware.`);
                }
                relativeEntries.splice(toOverrideIndex, 1);
              }
            }
            for (const alias2 of aliases) {
              entriesNameSet.add(alias2);
            }
          }
          relativeEntries.push(entry);
        },
        clone: () => cloneTo(constructStack()),
        use: (plugin) => {
          plugin.applyToStack(stack);
        },
        remove: (toRemove) => {
          if (typeof toRemove === "string")
            return removeByName(toRemove);
          else
            return removeByReference(toRemove);
        },
        removeByTag: (toRemove) => {
          let isRemoved = false;
          const filterCb = (entry) => {
            const { tags, name: name3, aliases: _aliases } = entry;
            if (tags && tags.includes(toRemove)) {
              const aliases = getAllAliases(name3, _aliases);
              for (const alias2 of aliases) {
                entriesNameSet.delete(alias2);
              }
              isRemoved = true;
              return false;
            }
            return true;
          };
          absoluteEntries = absoluteEntries.filter(filterCb);
          relativeEntries = relativeEntries.filter(filterCb);
          return isRemoved;
        },
        concat: (from) => {
          const cloned = cloneTo(constructStack());
          cloned.use(from);
          cloned.identifyOnResolve(identifyOnResolve || cloned.identifyOnResolve() || (from.identifyOnResolve?.() ?? false));
          return cloned;
        },
        applyToStack: cloneTo,
        identify: () => {
          return getMiddlewareList(true).map((mw) => {
            const step = mw.step ?? mw.relation + " " + mw.toMiddleware;
            return getMiddlewareNameWithAliases(mw.name, mw.aliases) + " - " + step;
          });
        },
        identifyOnResolve(toggle) {
          if (typeof toggle === "boolean")
            identifyOnResolve = toggle;
          return identifyOnResolve;
        },
        resolve: (handler, context) => {
          for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
            handler = middleware(handler, context);
          }
          if (identifyOnResolve) {
            console.log(stack.identify());
          }
          return handler;
        }
      };
      return stack;
    };
    stepWeights = {
      initialize: 5,
      serialize: 4,
      build: 3,
      finalizeRequest: 2,
      deserialize: 1
    };
    priorityWeights = {
      high: 3,
      normal: 2,
      low: 1
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-stack@4.0.4/node_modules/@smithy/middleware-stack/dist-es/index.js
var init_dist_es23 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-stack@4.0.4/node_modules/@smithy/middleware-stack/dist-es/index.js"() {
    "use strict";
    init_MiddlewareStack();
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/client.js
var Client;
var init_client3 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/client.js"() {
    "use strict";
    init_dist_es23();
    Client = class {
      constructor(config) {
        this.config = config;
        this.middlewareStack = constructStack();
      }
      send(command, optionsOrCb, cb) {
        const options = typeof optionsOrCb !== "function" ? optionsOrCb : void 0;
        const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
        const useHandlerCache = options === void 0 && this.config.cacheMiddleware === true;
        let handler;
        if (useHandlerCache) {
          if (!this.handlers) {
            this.handlers = /* @__PURE__ */ new WeakMap();
          }
          const handlers = this.handlers;
          if (handlers.has(command.constructor)) {
            handler = handlers.get(command.constructor);
          } else {
            handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
            handlers.set(command.constructor, handler);
          }
        } else {
          delete this.handlers;
          handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
        }
        if (callback) {
          handler(command).then((result) => callback(null, result.output), (err3) => callback(err3)).catch(() => {
          });
        } else {
          return handler(command).then((result) => result.output);
        }
      }
      destroy() {
        this.config?.requestHandler?.destroy?.();
        delete this.handlers;
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/collect-stream-body.js
var init_collect_stream_body2 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/collect-stream-body.js"() {
    "use strict";
    init_protocols();
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/command.js
var Command, ClassBuilder;
var init_command2 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/command.js"() {
    "use strict";
    init_dist_es23();
    init_dist_es();
    Command = class {
      constructor() {
        this.middlewareStack = constructStack();
      }
      static classBuilder() {
        return new ClassBuilder();
      }
      resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor }) {
        for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
          this.middlewareStack.use(mw);
        }
        const stack = clientStack.concat(this.middlewareStack);
        const { logger: logger2 } = configuration;
        const handlerExecutionContext = {
          logger: logger2,
          clientName,
          commandName,
          inputFilterSensitiveLog,
          outputFilterSensitiveLog,
          [SMITHY_CONTEXT_KEY]: {
            commandInstance: this,
            ...smithyContext
          },
          ...additionalContext
        };
        const { requestHandler } = configuration;
        return stack.resolve((request2) => requestHandler.handle(request2.request, options || {}), handlerExecutionContext);
      }
    };
    ClassBuilder = class {
      constructor() {
        this._init = () => {
        };
        this._ep = {};
        this._middlewareFn = () => [];
        this._commandName = "";
        this._clientName = "";
        this._additionalContext = {};
        this._smithyContext = {};
        this._inputFilterSensitiveLog = (_7) => _7;
        this._outputFilterSensitiveLog = (_7) => _7;
        this._serializer = null;
        this._deserializer = null;
      }
      init(cb) {
        this._init = cb;
      }
      ep(endpointParameterInstructions) {
        this._ep = endpointParameterInstructions;
        return this;
      }
      m(middlewareSupplier) {
        this._middlewareFn = middlewareSupplier;
        return this;
      }
      s(service, operation, smithyContext = {}) {
        this._smithyContext = {
          service,
          operation,
          ...smithyContext
        };
        return this;
      }
      c(additionalContext = {}) {
        this._additionalContext = additionalContext;
        return this;
      }
      n(clientName, commandName) {
        this._clientName = clientName;
        this._commandName = commandName;
        return this;
      }
      f(inputFilter = (_7) => _7, outputFilter = (_7) => _7) {
        this._inputFilterSensitiveLog = inputFilter;
        this._outputFilterSensitiveLog = outputFilter;
        return this;
      }
      ser(serializer) {
        this._serializer = serializer;
        return this;
      }
      de(deserializer) {
        this._deserializer = deserializer;
        return this;
      }
      sc(operation) {
        this._operationSchema = operation;
        this._smithyContext.operationSchema = operation;
        return this;
      }
      build() {
        const closure = this;
        let CommandRef;
        return CommandRef = class extends Command {
          static getEndpointParameterInstructions() {
            return closure._ep;
          }
          constructor(...[input]) {
            super();
            this.serialize = closure._serializer;
            this.deserialize = closure._deserializer;
            this.input = input ?? {};
            closure._init(this);
            this.schema = closure._operationSchema;
          }
          resolveMiddleware(stack, configuration, options) {
            return this.resolveMiddlewareWithContext(stack, configuration, options, {
              CommandCtor: CommandRef,
              middlewareFn: closure._middlewareFn,
              clientName: closure._clientName,
              commandName: closure._commandName,
              inputFilterSensitiveLog: closure._inputFilterSensitiveLog,
              outputFilterSensitiveLog: closure._outputFilterSensitiveLog,
              smithyContext: closure._smithyContext,
              additionalContext: closure._additionalContext
            });
          }
        };
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/constants.js
var SENSITIVE_STRING;
var init_constants4 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/constants.js"() {
    "use strict";
    SENSITIVE_STRING = "***SensitiveInformation***";
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/create-aggregated-client.js
var createAggregatedClient;
var init_create_aggregated_client = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/create-aggregated-client.js"() {
    "use strict";
    createAggregatedClient = (commands5, Client6) => {
      for (const command of Object.keys(commands5)) {
        const CommandCtor = commands5[command];
        const methodImpl = async function(args2, optionsOrCb, cb) {
          const command2 = new CommandCtor(args2);
          if (typeof optionsOrCb === "function") {
            this.send(command2, optionsOrCb);
          } else if (typeof cb === "function") {
            if (typeof optionsOrCb !== "object")
              throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
            this.send(command2, optionsOrCb || {}, cb);
          } else {
            return this.send(command2, optionsOrCb);
          }
        };
        const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
        Client6.prototype[methodName] = methodImpl;
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/exceptions.js
var ServiceException, decorateServiceException;
var init_exceptions = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/exceptions.js"() {
    "use strict";
    ServiceException = class _ServiceException extends Error {
      constructor(options) {
        super(options.message);
        Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
        this.name = options.name;
        this.$fault = options.$fault;
        this.$metadata = options.$metadata;
      }
      static isInstance(value) {
        if (!value)
          return false;
        const candidate = value;
        return _ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
      }
      static [Symbol.hasInstance](instance2) {
        if (!instance2)
          return false;
        const candidate = instance2;
        if (this === _ServiceException) {
          return _ServiceException.isInstance(instance2);
        }
        if (_ServiceException.isInstance(instance2)) {
          if (candidate.name && this.name) {
            return this.prototype.isPrototypeOf(instance2) || candidate.name === this.name;
          }
          return this.prototype.isPrototypeOf(instance2);
        }
        return false;
      }
    };
    decorateServiceException = (exception, additions = {}) => {
      Object.entries(additions).filter(([, v11]) => v11 !== void 0).forEach(([k9, v11]) => {
        if (exception[k9] == void 0 || exception[k9] === "") {
          exception[k9] = v11;
        }
      });
      const message = exception.message || exception.Message || "UnknownError";
      exception.message = message;
      delete exception.Message;
      return exception;
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/default-error-handler.js
var throwDefaultError, withBaseException, deserializeMetadata;
var init_default_error_handler = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/default-error-handler.js"() {
    "use strict";
    init_exceptions();
    throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => {
      const $metadata = deserializeMetadata(output);
      const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : void 0;
      const response = new exceptionCtor({
        name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError",
        $fault: "client",
        $metadata
      });
      throw decorateServiceException(response, parsedBody);
    };
    withBaseException = (ExceptionCtor) => {
      return ({ output, parsedBody, errorCode }) => {
        throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode });
      };
    };
    deserializeMetadata = (output) => ({
      httpStatusCode: output.statusCode,
      requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
      extendedRequestId: output.headers["x-amz-id-2"],
      cfId: output.headers["x-amz-cf-id"]
    });
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/defaults-mode.js
var loadConfigsForDefaultMode;
var init_defaults_mode = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/defaults-mode.js"() {
    "use strict";
    loadConfigsForDefaultMode = (mode) => {
      switch (mode) {
        case "standard":
          return {
            retryMode: "standard",
            connectionTimeout: 3100
          };
        case "in-region":
          return {
            retryMode: "standard",
            connectionTimeout: 1100
          };
        case "cross-region":
          return {
            retryMode: "standard",
            connectionTimeout: 3100
          };
        case "mobile":
          return {
            retryMode: "standard",
            connectionTimeout: 3e4
          };
        default:
          return {};
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/emitWarningIfUnsupportedVersion.js
var warningEmitted, emitWarningIfUnsupportedVersion2;
var init_emitWarningIfUnsupportedVersion2 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/emitWarningIfUnsupportedVersion.js"() {
    "use strict";
    warningEmitted = false;
    emitWarningIfUnsupportedVersion2 = (version3) => {
      if (version3 && !warningEmitted && parseInt(version3.substring(1, version3.indexOf("."))) < 16) {
        warningEmitted = true;
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extended-encode-uri-component.js
var init_extended_encode_uri_component2 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extended-encode-uri-component.js"() {
    "use strict";
    init_protocols();
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/checksum.js
var getChecksumConfiguration2, resolveChecksumRuntimeConfig2;
var init_checksum3 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/checksum.js"() {
    "use strict";
    init_dist_es();
    getChecksumConfiguration2 = (runtimeConfig) => {
      const checksumAlgorithms = [];
      for (const id in AlgorithmId) {
        const algorithmId = AlgorithmId[id];
        if (runtimeConfig[algorithmId] === void 0) {
          continue;
        }
        checksumAlgorithms.push({
          algorithmId: () => algorithmId,
          checksumConstructor: () => runtimeConfig[algorithmId]
        });
      }
      return {
        addChecksumAlgorithm(algo) {
          checksumAlgorithms.push(algo);
        },
        checksumAlgorithms() {
          return checksumAlgorithms;
        }
      };
    };
    resolveChecksumRuntimeConfig2 = (clientConfig) => {
      const runtimeConfig = {};
      clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
        runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
      });
      return runtimeConfig;
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/retry.js
var getRetryConfiguration, resolveRetryRuntimeConfig;
var init_retry2 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/retry.js"() {
    "use strict";
    getRetryConfiguration = (runtimeConfig) => {
      return {
        setRetryStrategy(retryStrategy) {
          runtimeConfig.retryStrategy = retryStrategy;
        },
        retryStrategy() {
          return runtimeConfig.retryStrategy;
        }
      };
    };
    resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
      const runtimeConfig = {};
      runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
      return runtimeConfig;
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/defaultExtensionConfiguration.js
var getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig;
var init_defaultExtensionConfiguration2 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/defaultExtensionConfiguration.js"() {
    "use strict";
    init_checksum3();
    init_retry2();
    getDefaultExtensionConfiguration = (runtimeConfig) => {
      return Object.assign(getChecksumConfiguration2(runtimeConfig), getRetryConfiguration(runtimeConfig));
    };
    resolveDefaultRuntimeConfig = (config) => {
      return Object.assign(resolveChecksumRuntimeConfig2(config), resolveRetryRuntimeConfig(config));
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/index.js
var init_extensions3 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/extensions/index.js"() {
    "use strict";
    init_defaultExtensionConfiguration2();
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/get-array-if-single-item.js
var init_get_array_if_single_item = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/get-array-if-single-item.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/get-value-from-text-node.js
var getValueFromTextNode;
var init_get_value_from_text_node = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/get-value-from-text-node.js"() {
    "use strict";
    getValueFromTextNode = (obj) => {
      const textNodeName = "#text";
      for (const key in obj) {
        if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== void 0) {
          obj[key] = obj[key][textNodeName];
        } else if (typeof obj[key] === "object" && obj[key] !== null) {
          obj[key] = getValueFromTextNode(obj[key]);
        }
      }
      return obj;
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/is-serializable-header-value.js
var isSerializableHeaderValue;
var init_is_serializable_header_value = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/is-serializable-header-value.js"() {
    "use strict";
    isSerializableHeaderValue = (value) => {
      return value != null;
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/NoOpLogger.js
var NoOpLogger;
var init_NoOpLogger = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/NoOpLogger.js"() {
    "use strict";
    NoOpLogger = class {
      trace() {
      }
      debug() {
      }
      info() {
      }
      warn() {
      }
      error() {
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/object-mapping.js
function map(arg0, arg1, arg2) {
  let target;
  let filter2;
  let instructions;
  if (typeof arg1 === "undefined" && typeof arg2 === "undefined") {
    target = {};
    instructions = arg0;
  } else {
    target = arg0;
    if (typeof arg1 === "function") {
      filter2 = arg1;
      instructions = arg2;
      return mapWithFilter(target, filter2, instructions);
    } else {
      instructions = arg1;
    }
  }
  for (const key of Object.keys(instructions)) {
    if (!Array.isArray(instructions[key])) {
      target[key] = instructions[key];
      continue;
    }
    applyInstruction(target, null, instructions, key);
  }
  return target;
}
var take, mapWithFilter, applyInstruction, nonNullish, pass;
var init_object_mapping = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/object-mapping.js"() {
    "use strict";
    take = (source, instructions) => {
      const out2 = {};
      for (const key in instructions) {
        applyInstruction(out2, source, instructions, key);
      }
      return out2;
    };
    mapWithFilter = (target, filter2, instructions) => {
      return map(target, Object.entries(instructions).reduce((_instructions, [key, value]) => {
        if (Array.isArray(value)) {
          _instructions[key] = value;
        } else {
          if (typeof value === "function") {
            _instructions[key] = [filter2, value()];
          } else {
            _instructions[key] = [filter2, value];
          }
        }
        return _instructions;
      }, {}));
    };
    applyInstruction = (target, source, instructions, targetKey) => {
      if (source !== null) {
        let instruction = instructions[targetKey];
        if (typeof instruction === "function") {
          instruction = [, instruction];
        }
        const [filter3 = nonNullish, valueFn = pass, sourceKey = targetKey] = instruction;
        if (typeof filter3 === "function" && filter3(source[sourceKey]) || typeof filter3 !== "function" && !!filter3) {
          target[targetKey] = valueFn(source[sourceKey]);
        }
        return;
      }
      let [filter2, value] = instructions[targetKey];
      if (typeof value === "function") {
        let _value;
        const defaultFilterPassed = filter2 === void 0 && (_value = value()) != null;
        const customFilterPassed = typeof filter2 === "function" && !!filter2(void 0) || typeof filter2 !== "function" && !!filter2;
        if (defaultFilterPassed) {
          target[targetKey] = _value;
        } else if (customFilterPassed) {
          target[targetKey] = value();
        }
      } else {
        const defaultFilterPassed = filter2 === void 0 && value != null;
        const customFilterPassed = typeof filter2 === "function" && !!filter2(value) || typeof filter2 !== "function" && !!filter2;
        if (defaultFilterPassed || customFilterPassed) {
          target[targetKey] = value;
        }
      }
    };
    nonNullish = (_7) => _7 != null;
    pass = (_7) => _7;
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/resolve-path.js
var init_resolve_path2 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/resolve-path.js"() {
    "use strict";
    init_protocols();
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/ser-utils.js
var serializeFloat;
var init_ser_utils = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/ser-utils.js"() {
    "use strict";
    serializeFloat = (value) => {
      if (value !== value) {
        return "NaN";
      }
      switch (value) {
        case Infinity:
          return "Infinity";
        case -Infinity:
          return "-Infinity";
        default:
          return value;
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/serde-json.js
var _json;
var init_serde_json = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/serde-json.js"() {
    "use strict";
    _json = (obj) => {
      if (obj == null) {
        return {};
      }
      if (Array.isArray(obj)) {
        return obj.filter((_7) => _7 != null).map(_json);
      }
      if (typeof obj === "object") {
        const target = {};
        for (const key of Object.keys(obj)) {
          if (obj[key] == null) {
            continue;
          }
          target[key] = _json(obj[key]);
        }
        return target;
      }
      return obj;
    };
  }
});

// ../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/index.js
var init_dist_es24 = __esm({
  "../node_modules/.pnpm/@smithy+smithy-client@4.4.1/node_modules/@smithy/smithy-client/dist-es/index.js"() {
    "use strict";
    init_client3();
    init_collect_stream_body2();
    init_command2();
    init_constants4();
    init_create_aggregated_client();
    init_default_error_handler();
    init_defaults_mode();
    init_emitWarningIfUnsupportedVersion2();
    init_exceptions();
    init_extended_encode_uri_component2();
    init_extensions3();
    init_get_array_if_single_item();
    init_get_value_from_text_node();
    init_is_serializable_header_value();
    init_NoOpLogger();
    init_object_mapping();
    init_resolve_path2();
    init_ser_utils();
    init_serde_json();
    init_serde2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/awsExpectUnion.js
var awsExpectUnion;
var init_awsExpectUnion = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/awsExpectUnion.js"() {
    "use strict";
    init_dist_es24();
    awsExpectUnion = (value) => {
      if (value == null) {
        return void 0;
      }
      if (typeof value === "object" && "__type" in value) {
        delete value.__type;
      }
      return expectUnion(value);
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js
var collectBodyString;
var init_common6 = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/common.js"() {
    "use strict";
    init_dist_es24();
    collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body2) => context.utf8Encoder(body2));
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/parseJsonBody.js
var parseJsonBody, parseJsonErrorBody, loadRestJsonErrorCode;
var init_parseJsonBody = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/json/parseJsonBody.js"() {
    "use strict";
    init_common6();
    parseJsonBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
      if (encoded.length) {
        try {
          return JSON.parse(encoded);
        } catch (e6) {
          if (e6?.name === "SyntaxError") {
            Object.defineProperty(e6, "$responseBodyText", {
              value: encoded
            });
          }
          throw e6;
        }
      }
      return {};
    });
    parseJsonErrorBody = async (errorBody, context) => {
      const value = await parseJsonBody(errorBody, context);
      value.message = value.message ?? value.Message;
      return value;
    };
    loadRestJsonErrorCode = (output, data) => {
      const findKey = (object2, key) => Object.keys(object2).find((k9) => k9.toLowerCase() === key.toLowerCase());
      const sanitizeErrorCode = (rawValue) => {
        let cleanValue = rawValue;
        if (typeof cleanValue === "number") {
          cleanValue = cleanValue.toString();
        }
        if (cleanValue.indexOf(",") >= 0) {
          cleanValue = cleanValue.split(",")[0];
        }
        if (cleanValue.indexOf(":") >= 0) {
          cleanValue = cleanValue.split(":")[0];
        }
        if (cleanValue.indexOf("#") >= 0) {
          cleanValue = cleanValue.split("#")[1];
        }
        return cleanValue;
      };
      const headerKey = findKey(output.headers, "x-amzn-errortype");
      if (headerKey !== void 0) {
        return sanitizeErrorCode(output.headers[headerKey]);
      }
      if (data && typeof data === "object") {
        const codeKey = findKey(data, "code");
        if (codeKey && data[codeKey] !== void 0) {
          return sanitizeErrorCode(data[codeKey]);
        }
        if (data["__type"] !== void 0) {
          return sanitizeErrorCode(data["__type"]);
        }
      }
    };
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/util.js
var require_util2 = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/util.js"(exports2) {
    "use strict";
    var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD";
    var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040";
    var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*";
    var regexName = new RegExp("^" + nameRegexp + "$");
    var getAllMatches = function(string2, regex) {
      const matches = [];
      let match2 = regex.exec(string2);
      while (match2) {
        const allmatches = [];
        allmatches.startIndex = regex.lastIndex - match2[0].length;
        const len = match2.length;
        for (let index7 = 0; index7 < len; index7++) {
          allmatches.push(match2[index7]);
        }
        matches.push(allmatches);
        match2 = regex.exec(string2);
      }
      return matches;
    };
    var isName = function(string2) {
      const match2 = regexName.exec(string2);
      return !(match2 === null || typeof match2 === "undefined");
    };
    exports2.isExist = function(v11) {
      return typeof v11 !== "undefined";
    };
    exports2.isEmptyObject = function(obj) {
      return Object.keys(obj).length === 0;
    };
    exports2.merge = function(target, a9, arrayMode) {
      if (a9) {
        const keys = Object.keys(a9);
        const len = keys.length;
        for (let i8 = 0; i8 < len; i8++) {
          if (arrayMode === "strict") {
            target[keys[i8]] = [a9[keys[i8]]];
          } else {
            target[keys[i8]] = a9[keys[i8]];
          }
        }
      }
    };
    exports2.getValue = function(v11) {
      if (exports2.isExist(v11)) {
        return v11;
      } else {
        return "";
      }
    };
    exports2.isName = isName;
    exports2.getAllMatches = getAllMatches;
    exports2.nameRegexp = nameRegexp;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/validator.js
var require_validator = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/validator.js"(exports2) {
    "use strict";
    var util2 = require_util2();
    var defaultOptions = {
      allowBooleanAttributes: false,
      //A tag can have attributes without any value
      unpairedTags: []
    };
    exports2.validate = function(xmlData, options) {
      options = Object.assign({}, defaultOptions, options);
      const tags = [];
      let tagFound = false;
      let reachedRoot = false;
      if (xmlData[0] === "\uFEFF") {
        xmlData = xmlData.substr(1);
      }
      for (let i8 = 0; i8 < xmlData.length; i8++) {
        if (xmlData[i8] === "<" && xmlData[i8 + 1] === "?") {
          i8 += 2;
          i8 = readPI(xmlData, i8);
          if (i8.err) return i8;
        } else if (xmlData[i8] === "<") {
          let tagStartPos = i8;
          i8++;
          if (xmlData[i8] === "!") {
            i8 = readCommentAndCDATA(xmlData, i8);
            continue;
          } else {
            let closingTag = false;
            if (xmlData[i8] === "/") {
              closingTag = true;
              i8++;
            }
            let tagName = "";
            for (; i8 < xmlData.length && xmlData[i8] !== ">" && xmlData[i8] !== " " && xmlData[i8] !== "	" && xmlData[i8] !== "\n" && xmlData[i8] !== "\r"; i8++) {
              tagName += xmlData[i8];
            }
            tagName = tagName.trim();
            if (tagName[tagName.length - 1] === "/") {
              tagName = tagName.substring(0, tagName.length - 1);
              i8--;
            }
            if (!validateTagName(tagName)) {
              let msg;
              if (tagName.trim().length === 0) {
                msg = "Invalid space after '<'.";
              } else {
                msg = "Tag '" + tagName + "' is an invalid name.";
              }
              return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i8));
            }
            const result = readAttributeStr(xmlData, i8);
            if (result === false) {
              return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i8));
            }
            let attrStr = result.value;
            i8 = result.index;
            if (attrStr[attrStr.length - 1] === "/") {
              const attrStrStart = i8 - attrStr.length;
              attrStr = attrStr.substring(0, attrStr.length - 1);
              const isValid3 = validateAttributeString(attrStr, options);
              if (isValid3 === true) {
                tagFound = true;
              } else {
                return getErrorObject(isValid3.err.code, isValid3.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid3.err.line));
              }
            } else if (closingTag) {
              if (!result.tagClosed) {
                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i8));
              } else if (attrStr.trim().length > 0) {
                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos));
              } else if (tags.length === 0) {
                return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' has not been opened.", getLineNumberForPosition(xmlData, tagStartPos));
              } else {
                const otg = tags.pop();
                if (tagName !== otg.tagName) {
                  let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos);
                  return getErrorObject(
                    "InvalidTag",
                    "Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.",
                    getLineNumberForPosition(xmlData, tagStartPos)
                  );
                }
                if (tags.length == 0) {
                  reachedRoot = true;
                }
              }
            } else {
              const isValid3 = validateAttributeString(attrStr, options);
              if (isValid3 !== true) {
                return getErrorObject(isValid3.err.code, isValid3.err.msg, getLineNumberForPosition(xmlData, i8 - attrStr.length + isValid3.err.line));
              }
              if (reachedRoot === true) {
                return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i8));
              } else if (options.unpairedTags.indexOf(tagName) !== -1) {
              } else {
                tags.push({ tagName, tagStartPos });
              }
              tagFound = true;
            }
            for (i8++; i8 < xmlData.length; i8++) {
              if (xmlData[i8] === "<") {
                if (xmlData[i8 + 1] === "!") {
                  i8++;
                  i8 = readCommentAndCDATA(xmlData, i8);
                  continue;
                } else if (xmlData[i8 + 1] === "?") {
                  i8 = readPI(xmlData, ++i8);
                  if (i8.err) return i8;
                } else {
                  break;
                }
              } else if (xmlData[i8] === "&") {
                const afterAmp = validateAmpersand(xmlData, i8);
                if (afterAmp == -1)
                  return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i8));
                i8 = afterAmp;
              } else {
                if (reachedRoot === true && !isWhiteSpace(xmlData[i8])) {
                  return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i8));
                }
              }
            }
            if (xmlData[i8] === "<") {
              i8--;
            }
          }
        } else {
          if (isWhiteSpace(xmlData[i8])) {
            continue;
          }
          return getErrorObject("InvalidChar", "char '" + xmlData[i8] + "' is not expected.", getLineNumberForPosition(xmlData, i8));
        }
      }
      if (!tagFound) {
        return getErrorObject("InvalidXml", "Start tag expected.", 1);
      } else if (tags.length == 1) {
        return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos));
      } else if (tags.length > 0) {
        return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t6) => t6.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 });
      }
      return true;
    };
    function isWhiteSpace(char4) {
      return char4 === " " || char4 === "	" || char4 === "\n" || char4 === "\r";
    }
    function readPI(xmlData, i8) {
      const start2 = i8;
      for (; i8 < xmlData.length; i8++) {
        if (xmlData[i8] == "?" || xmlData[i8] == " ") {
          const tagname = xmlData.substr(start2, i8 - start2);
          if (i8 > 5 && tagname === "xml") {
            return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i8));
          } else if (xmlData[i8] == "?" && xmlData[i8 + 1] == ">") {
            i8++;
            break;
          } else {
            continue;
          }
        }
      }
      return i8;
    }
    function readCommentAndCDATA(xmlData, i8) {
      if (xmlData.length > i8 + 5 && xmlData[i8 + 1] === "-" && xmlData[i8 + 2] === "-") {
        for (i8 += 3; i8 < xmlData.length; i8++) {
          if (xmlData[i8] === "-" && xmlData[i8 + 1] === "-" && xmlData[i8 + 2] === ">") {
            i8 += 2;
            break;
          }
        }
      } else if (xmlData.length > i8 + 8 && xmlData[i8 + 1] === "D" && xmlData[i8 + 2] === "O" && xmlData[i8 + 3] === "C" && xmlData[i8 + 4] === "T" && xmlData[i8 + 5] === "Y" && xmlData[i8 + 6] === "P" && xmlData[i8 + 7] === "E") {
        let angleBracketsCount = 1;
        for (i8 += 8; i8 < xmlData.length; i8++) {
          if (xmlData[i8] === "<") {
            angleBracketsCount++;
          } else if (xmlData[i8] === ">") {
            angleBracketsCount--;
            if (angleBracketsCount === 0) {
              break;
            }
          }
        }
      } else if (xmlData.length > i8 + 9 && xmlData[i8 + 1] === "[" && xmlData[i8 + 2] === "C" && xmlData[i8 + 3] === "D" && xmlData[i8 + 4] === "A" && xmlData[i8 + 5] === "T" && xmlData[i8 + 6] === "A" && xmlData[i8 + 7] === "[") {
        for (i8 += 8; i8 < xmlData.length; i8++) {
          if (xmlData[i8] === "]" && xmlData[i8 + 1] === "]" && xmlData[i8 + 2] === ">") {
            i8 += 2;
            break;
          }
        }
      }
      return i8;
    }
    var doubleQuote = '"';
    var singleQuote = "'";
    function readAttributeStr(xmlData, i8) {
      let attrStr = "";
      let startChar = "";
      let tagClosed = false;
      for (; i8 < xmlData.length; i8++) {
        if (xmlData[i8] === doubleQuote || xmlData[i8] === singleQuote) {
          if (startChar === "") {
            startChar = xmlData[i8];
          } else if (startChar !== xmlData[i8]) {
          } else {
            startChar = "";
          }
        } else if (xmlData[i8] === ">") {
          if (startChar === "") {
            tagClosed = true;
            break;
          }
        }
        attrStr += xmlData[i8];
      }
      if (startChar !== "") {
        return false;
      }
      return {
        value: attrStr,
        index: i8,
        tagClosed
      };
    }
    var validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g");
    function validateAttributeString(attrStr, options) {
      const matches = util2.getAllMatches(attrStr, validAttrStrRegxp);
      const attrNames = {};
      for (let i8 = 0; i8 < matches.length; i8++) {
        if (matches[i8][1].length === 0) {
          return getErrorObject("InvalidAttr", "Attribute '" + matches[i8][2] + "' has no space in starting.", getPositionFromMatch(matches[i8]));
        } else if (matches[i8][3] !== void 0 && matches[i8][4] === void 0) {
          return getErrorObject("InvalidAttr", "Attribute '" + matches[i8][2] + "' is without value.", getPositionFromMatch(matches[i8]));
        } else if (matches[i8][3] === void 0 && !options.allowBooleanAttributes) {
          return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i8][2] + "' is not allowed.", getPositionFromMatch(matches[i8]));
        }
        const attrName = matches[i8][2];
        if (!validateAttrName(attrName)) {
          return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i8]));
        }
        if (!attrNames.hasOwnProperty(attrName)) {
          attrNames[attrName] = 1;
        } else {
          return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i8]));
        }
      }
      return true;
    }
    function validateNumberAmpersand(xmlData, i8) {
      let re3 = /\d/;
      if (xmlData[i8] === "x") {
        i8++;
        re3 = /[\da-fA-F]/;
      }
      for (; i8 < xmlData.length; i8++) {
        if (xmlData[i8] === ";")
          return i8;
        if (!xmlData[i8].match(re3))
          break;
      }
      return -1;
    }
    function validateAmpersand(xmlData, i8) {
      i8++;
      if (xmlData[i8] === ";")
        return -1;
      if (xmlData[i8] === "#") {
        i8++;
        return validateNumberAmpersand(xmlData, i8);
      }
      let count2 = 0;
      for (; i8 < xmlData.length; i8++, count2++) {
        if (xmlData[i8].match(/\w/) && count2 < 20)
          continue;
        if (xmlData[i8] === ";")
          break;
        return -1;
      }
      return i8;
    }
    function getErrorObject(code, message, lineNumber) {
      return {
        err: {
          code,
          msg: message,
          line: lineNumber.line || lineNumber,
          col: lineNumber.col
        }
      };
    }
    function validateAttrName(attrName) {
      return util2.isName(attrName);
    }
    function validateTagName(tagname) {
      return util2.isName(tagname);
    }
    function getLineNumberForPosition(xmlData, index7) {
      const lines = xmlData.substring(0, index7).split(/\r?\n/);
      return {
        line: lines.length,
        // column number is last line's length + 1, because column numbering starts at 1:
        col: lines[lines.length - 1].length + 1
      };
    }
    function getPositionFromMatch(match2) {
      return match2.startIndex + match2[1].length;
    }
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js
var require_OptionsBuilder = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"(exports2) {
    "use strict";
    var defaultOptions = {
      preserveOrder: false,
      attributeNamePrefix: "@_",
      attributesGroupName: false,
      textNodeName: "#text",
      ignoreAttributes: true,
      removeNSPrefix: false,
      // remove NS from tag name or attribute name if true
      allowBooleanAttributes: false,
      //a tag can have attributes without any value
      //ignoreRootElement : false,
      parseTagValue: true,
      parseAttributeValue: false,
      trimValues: true,
      //Trim string values of tag and attributes
      cdataPropName: false,
      numberParseOptions: {
        hex: true,
        leadingZeros: true,
        eNotation: true
      },
      tagValueProcessor: function(tagName, val2) {
        return val2;
      },
      attributeValueProcessor: function(attrName, val2) {
        return val2;
      },
      stopNodes: [],
      //nested tags will not be parsed even for errors
      alwaysCreateTextNode: false,
      isArray: () => false,
      commentPropName: false,
      unpairedTags: [],
      processEntities: true,
      htmlEntities: false,
      ignoreDeclaration: false,
      ignorePiTags: false,
      transformTagName: false,
      transformAttributeName: false,
      updateTag: function(tagName, jPath, attrs) {
        return tagName;
      }
      // skipEmptyListItem: false
    };
    var buildOptions = function(options) {
      return Object.assign({}, defaultOptions, options);
    };
    exports2.buildOptions = buildOptions;
    exports2.defaultOptions = defaultOptions;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js
var require_xmlNode = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"(exports2, module2) {
    "use strict";
    var XmlNode = class {
      constructor(tagname) {
        this.tagname = tagname;
        this.child = [];
        this[":@"] = {};
      }
      add(key, val2) {
        if (key === "__proto__") key = "#__proto__";
        this.child.push({ [key]: val2 });
      }
      addChild(node) {
        if (node.tagname === "__proto__") node.tagname = "#__proto__";
        if (node[":@"] && Object.keys(node[":@"]).length > 0) {
          this.child.push({ [node.tagname]: node.child, [":@"]: node[":@"] });
        } else {
          this.child.push({ [node.tagname]: node.child });
        }
      }
    };
    module2.exports = XmlNode;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js
var require_DocTypeReader = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"(exports2, module2) {
    "use strict";
    var util2 = require_util2();
    function readDocType(xmlData, i8) {
      const entities = {};
      if (xmlData[i8 + 3] === "O" && xmlData[i8 + 4] === "C" && xmlData[i8 + 5] === "T" && xmlData[i8 + 6] === "Y" && xmlData[i8 + 7] === "P" && xmlData[i8 + 8] === "E") {
        i8 = i8 + 9;
        let angleBracketsCount = 1;
        let hasBody = false, comment = false;
        let exp = "";
        for (; i8 < xmlData.length; i8++) {
          if (xmlData[i8] === "<" && !comment) {
            if (hasBody && isEntity(xmlData, i8)) {
              i8 += 7;
              [entityName, val, i8] = readEntityExp(xmlData, i8 + 1);
              if (val.indexOf("&") === -1)
                entities[validateEntityName(entityName)] = {
                  regx: RegExp(`&${entityName};`, "g"),
                  val
                };
            } else if (hasBody && isElement(xmlData, i8)) i8 += 8;
            else if (hasBody && isAttlist(xmlData, i8)) i8 += 8;
            else if (hasBody && isNotation(xmlData, i8)) i8 += 9;
            else if (isComment) comment = true;
            else throw new Error("Invalid DOCTYPE");
            angleBracketsCount++;
            exp = "";
          } else if (xmlData[i8] === ">") {
            if (comment) {
              if (xmlData[i8 - 1] === "-" && xmlData[i8 - 2] === "-") {
                comment = false;
                angleBracketsCount--;
              }
            } else {
              angleBracketsCount--;
            }
            if (angleBracketsCount === 0) {
              break;
            }
          } else if (xmlData[i8] === "[") {
            hasBody = true;
          } else {
            exp += xmlData[i8];
          }
        }
        if (angleBracketsCount !== 0) {
          throw new Error(`Unclosed DOCTYPE`);
        }
      } else {
        throw new Error(`Invalid Tag instead of DOCTYPE`);
      }
      return { entities, i: i8 };
    }
    function readEntityExp(xmlData, i8) {
      let entityName2 = "";
      for (; i8 < xmlData.length && (xmlData[i8] !== "'" && xmlData[i8] !== '"'); i8++) {
        entityName2 += xmlData[i8];
      }
      entityName2 = entityName2.trim();
      if (entityName2.indexOf(" ") !== -1) throw new Error("External entites are not supported");
      const startChar = xmlData[i8++];
      let val2 = "";
      for (; i8 < xmlData.length && xmlData[i8] !== startChar; i8++) {
        val2 += xmlData[i8];
      }
      return [entityName2, val2, i8];
    }
    function isComment(xmlData, i8) {
      if (xmlData[i8 + 1] === "!" && xmlData[i8 + 2] === "-" && xmlData[i8 + 3] === "-") return true;
      return false;
    }
    function isEntity(xmlData, i8) {
      if (xmlData[i8 + 1] === "!" && xmlData[i8 + 2] === "E" && xmlData[i8 + 3] === "N" && xmlData[i8 + 4] === "T" && xmlData[i8 + 5] === "I" && xmlData[i8 + 6] === "T" && xmlData[i8 + 7] === "Y") return true;
      return false;
    }
    function isElement(xmlData, i8) {
      if (xmlData[i8 + 1] === "!" && xmlData[i8 + 2] === "E" && xmlData[i8 + 3] === "L" && xmlData[i8 + 4] === "E" && xmlData[i8 + 5] === "M" && xmlData[i8 + 6] === "E" && xmlData[i8 + 7] === "N" && xmlData[i8 + 8] === "T") return true;
      return false;
    }
    function isAttlist(xmlData, i8) {
      if (xmlData[i8 + 1] === "!" && xmlData[i8 + 2] === "A" && xmlData[i8 + 3] === "T" && xmlData[i8 + 4] === "T" && xmlData[i8 + 5] === "L" && xmlData[i8 + 6] === "I" && xmlData[i8 + 7] === "S" && xmlData[i8 + 8] === "T") return true;
      return false;
    }
    function isNotation(xmlData, i8) {
      if (xmlData[i8 + 1] === "!" && xmlData[i8 + 2] === "N" && xmlData[i8 + 3] === "O" && xmlData[i8 + 4] === "T" && xmlData[i8 + 5] === "A" && xmlData[i8 + 6] === "T" && xmlData[i8 + 7] === "I" && xmlData[i8 + 8] === "O" && xmlData[i8 + 9] === "N") return true;
      return false;
    }
    function validateEntityName(name3) {
      if (util2.isName(name3))
        return name3;
      else
        throw new Error(`Invalid entity name ${name3}`);
    }
    module2.exports = readDocType;
  }
});

// ../node_modules/.pnpm/strnum@1.1.2/node_modules/strnum/strnum.js
var require_strnum = __commonJS({
  "../node_modules/.pnpm/strnum@1.1.2/node_modules/strnum/strnum.js"(exports2, module2) {
    "use strict";
    var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/;
    var numRegex = /^([\-\+])?(0*)([0-9]*(\.[0-9]*)?)$/;
    var consider = {
      hex: true,
      // oct: false,
      leadingZeros: true,
      decimalPoint: ".",
      eNotation: true
      //skipLike: /regex/
    };
    function toNumber(str, options = {}) {
      options = Object.assign({}, consider, options);
      if (!str || typeof str !== "string") return str;
      let trimmedStr = str.trim();
      if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr)) return str;
      else if (str === "0") return 0;
      else if (options.hex && hexRegex.test(trimmedStr)) {
        return parse_int(trimmedStr, 16);
      } else if (trimmedStr.search(/[eE]/) !== -1) {
        const notation = trimmedStr.match(/^([-\+])?(0*)([0-9]*(\.[0-9]*)?[eE][-\+]?[0-9]+)$/);
        if (notation) {
          if (options.leadingZeros) {
            trimmedStr = (notation[1] || "") + notation[3];
          } else {
            if (notation[2] === "0" && notation[3][0] === ".") {
            } else {
              return str;
            }
          }
          return options.eNotation ? Number(trimmedStr) : str;
        } else {
          return str;
        }
      } else {
        const match2 = numRegex.exec(trimmedStr);
        if (match2) {
          const sign = match2[1];
          const leadingZeros = match2[2];
          let numTrimmedByZeros = trimZeros(match2[3]);
          if (!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") return str;
          else if (!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") return str;
          else if (options.leadingZeros && leadingZeros === str) return 0;
          else {
            const num = Number(trimmedStr);
            const numStr = "" + num;
            if (numStr.search(/[eE]/) !== -1) {
              if (options.eNotation) return num;
              else return str;
            } else if (trimmedStr.indexOf(".") !== -1) {
              if (numStr === "0" && numTrimmedByZeros === "") return num;
              else if (numStr === numTrimmedByZeros) return num;
              else if (sign && numStr === "-" + numTrimmedByZeros) return num;
              else return str;
            }
            if (leadingZeros) {
              return numTrimmedByZeros === numStr || sign + numTrimmedByZeros === numStr ? num : str;
            } else {
              return trimmedStr === numStr || trimmedStr === sign + numStr ? num : str;
            }
          }
        } else {
          return str;
        }
      }
    }
    function trimZeros(numStr) {
      if (numStr && numStr.indexOf(".") !== -1) {
        numStr = numStr.replace(/0+$/, "");
        if (numStr === ".") numStr = "0";
        else if (numStr[0] === ".") numStr = "0" + numStr;
        else if (numStr[numStr.length - 1] === ".") numStr = numStr.substr(0, numStr.length - 1);
        return numStr;
      }
      return numStr;
    }
    function parse_int(numStr, base) {
      if (parseInt) return parseInt(numStr, base);
      else if (Number.parseInt) return Number.parseInt(numStr, base);
      else if (window && window.parseInt) return window.parseInt(numStr, base);
      else throw new Error("parseInt, Number.parseInt, window.parseInt are not supported");
    }
    module2.exports = toNumber;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js
var require_OrderedObjParser = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js"(exports2, module2) {
    "use strict";
    var util2 = require_util2();
    var xmlNode = require_xmlNode();
    var readDocType = require_DocTypeReader();
    var toNumber = require_strnum();
    var OrderedObjParser = class {
      constructor(options) {
        this.options = options;
        this.currentNode = null;
        this.tagsNodeStack = [];
        this.docTypeEntities = {};
        this.lastEntities = {
          "apos": { regex: /&(apos|#39|#x27);/g, val: "'" },
          "gt": { regex: /&(gt|#62|#x3E);/g, val: ">" },
          "lt": { regex: /&(lt|#60|#x3C);/g, val: "<" },
          "quot": { regex: /&(quot|#34|#x22);/g, val: '"' }
        };
        this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" };
        this.htmlEntities = {
          "space": { regex: /&(nbsp|#160);/g, val: " " },
          // "lt" : { regex: /&(lt|#60);/g, val: "<" },
          // "gt" : { regex: /&(gt|#62);/g, val: ">" },
          // "amp" : { regex: /&(amp|#38);/g, val: "&" },
          // "quot" : { regex: /&(quot|#34);/g, val: "\"" },
          // "apos" : { regex: /&(apos|#39);/g, val: "'" },
          "cent": { regex: /&(cent|#162);/g, val: "\xA2" },
          "pound": { regex: /&(pound|#163);/g, val: "\xA3" },
          "yen": { regex: /&(yen|#165);/g, val: "\xA5" },
          "euro": { regex: /&(euro|#8364);/g, val: "\u20AC" },
          "copyright": { regex: /&(copy|#169);/g, val: "\xA9" },
          "reg": { regex: /&(reg|#174);/g, val: "\xAE" },
          "inr": { regex: /&(inr|#8377);/g, val: "\u20B9" },
          "num_dec": { regex: /&#([0-9]{1,7});/g, val: (_7, str) => String.fromCharCode(Number.parseInt(str, 10)) },
          "num_hex": { regex: /&#x([0-9a-fA-F]{1,6});/g, val: (_7, str) => String.fromCharCode(Number.parseInt(str, 16)) }
        };
        this.addExternalEntities = addExternalEntities;
        this.parseXml = parseXml;
        this.parseTextData = parseTextData;
        this.resolveNameSpace = resolveNameSpace;
        this.buildAttributesMap = buildAttributesMap;
        this.isItStopNode = isItStopNode;
        this.replaceEntitiesValue = replaceEntitiesValue;
        this.readStopNodeData = readStopNodeData;
        this.saveTextToParentTag = saveTextToParentTag;
        this.addChild = addChild;
      }
    };
    function addExternalEntities(externalEntities) {
      const entKeys = Object.keys(externalEntities);
      for (let i8 = 0; i8 < entKeys.length; i8++) {
        const ent = entKeys[i8];
        this.lastEntities[ent] = {
          regex: new RegExp("&" + ent + ";", "g"),
          val: externalEntities[ent]
        };
      }
    }
    function parseTextData(val2, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) {
      if (val2 !== void 0) {
        if (this.options.trimValues && !dontTrim) {
          val2 = val2.trim();
        }
        if (val2.length > 0) {
          if (!escapeEntities) val2 = this.replaceEntitiesValue(val2);
          const newval = this.options.tagValueProcessor(tagName, val2, jPath, hasAttributes, isLeafNode);
          if (newval === null || newval === void 0) {
            return val2;
          } else if (typeof newval !== typeof val2 || newval !== val2) {
            return newval;
          } else if (this.options.trimValues) {
            return parseValue(val2, this.options.parseTagValue, this.options.numberParseOptions);
          } else {
            const trimmedVal = val2.trim();
            if (trimmedVal === val2) {
              return parseValue(val2, this.options.parseTagValue, this.options.numberParseOptions);
            } else {
              return val2;
            }
          }
        }
      }
    }
    function resolveNameSpace(tagname) {
      if (this.options.removeNSPrefix) {
        const tags = tagname.split(":");
        const prefix2 = tagname.charAt(0) === "/" ? "/" : "";
        if (tags[0] === "xmlns") {
          return "";
        }
        if (tags.length === 2) {
          tagname = prefix2 + tags[1];
        }
      }
      return tagname;
    }
    var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm");
    function buildAttributesMap(attrStr, jPath, tagName) {
      if (!this.options.ignoreAttributes && typeof attrStr === "string") {
        const matches = util2.getAllMatches(attrStr, attrsRegx);
        const len = matches.length;
        const attrs = {};
        for (let i8 = 0; i8 < len; i8++) {
          const attrName = this.resolveNameSpace(matches[i8][1]);
          let oldVal = matches[i8][4];
          let aName = this.options.attributeNamePrefix + attrName;
          if (attrName.length) {
            if (this.options.transformAttributeName) {
              aName = this.options.transformAttributeName(aName);
            }
            if (aName === "__proto__") aName = "#__proto__";
            if (oldVal !== void 0) {
              if (this.options.trimValues) {
                oldVal = oldVal.trim();
              }
              oldVal = this.replaceEntitiesValue(oldVal);
              const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath);
              if (newVal === null || newVal === void 0) {
                attrs[aName] = oldVal;
              } else if (typeof newVal !== typeof oldVal || newVal !== oldVal) {
                attrs[aName] = newVal;
              } else {
                attrs[aName] = parseValue(
                  oldVal,
                  this.options.parseAttributeValue,
                  this.options.numberParseOptions
                );
              }
            } else if (this.options.allowBooleanAttributes) {
              attrs[aName] = true;
            }
          }
        }
        if (!Object.keys(attrs).length) {
          return;
        }
        if (this.options.attributesGroupName) {
          const attrCollection = {};
          attrCollection[this.options.attributesGroupName] = attrs;
          return attrCollection;
        }
        return attrs;
      }
    }
    var parseXml = function(xmlData) {
      xmlData = xmlData.replace(/\r\n?/g, "\n");
      const xmlObj = new xmlNode("!xml");
      let currentNode = xmlObj;
      let textData = "";
      let jPath = "";
      for (let i8 = 0; i8 < xmlData.length; i8++) {
        const ch = xmlData[i8];
        if (ch === "<") {
          if (xmlData[i8 + 1] === "/") {
            const closeIndex = findClosingIndex(xmlData, ">", i8, "Closing Tag is not closed.");
            let tagName = xmlData.substring(i8 + 2, closeIndex).trim();
            if (this.options.removeNSPrefix) {
              const colonIndex = tagName.indexOf(":");
              if (colonIndex !== -1) {
                tagName = tagName.substr(colonIndex + 1);
              }
            }
            if (this.options.transformTagName) {
              tagName = this.options.transformTagName(tagName);
            }
            if (currentNode) {
              textData = this.saveTextToParentTag(textData, currentNode, jPath);
            }
            const lastTagName = jPath.substring(jPath.lastIndexOf(".") + 1);
            if (tagName && this.options.unpairedTags.indexOf(tagName) !== -1) {
              throw new Error(`Unpaired tag can not be used as closing tag: </${tagName}>`);
            }
            let propIndex = 0;
            if (lastTagName && this.options.unpairedTags.indexOf(lastTagName) !== -1) {
              propIndex = jPath.lastIndexOf(".", jPath.lastIndexOf(".") - 1);
              this.tagsNodeStack.pop();
            } else {
              propIndex = jPath.lastIndexOf(".");
            }
            jPath = jPath.substring(0, propIndex);
            currentNode = this.tagsNodeStack.pop();
            textData = "";
            i8 = closeIndex;
          } else if (xmlData[i8 + 1] === "?") {
            let tagData = readTagExp(xmlData, i8, false, "?>");
            if (!tagData) throw new Error("Pi Tag is not closed.");
            textData = this.saveTextToParentTag(textData, currentNode, jPath);
            if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) {
            } else {
              const childNode = new xmlNode(tagData.tagName);
              childNode.add(this.options.textNodeName, "");
              if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) {
                childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath, tagData.tagName);
              }
              this.addChild(currentNode, childNode, jPath);
            }
            i8 = tagData.closeIndex + 1;
          } else if (xmlData.substr(i8 + 1, 3) === "!--") {
            const endIndex = findClosingIndex(xmlData, "-->", i8 + 4, "Comment is not closed.");
            if (this.options.commentPropName) {
              const comment = xmlData.substring(i8 + 4, endIndex - 2);
              textData = this.saveTextToParentTag(textData, currentNode, jPath);
              currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]);
            }
            i8 = endIndex;
          } else if (xmlData.substr(i8 + 1, 2) === "!D") {
            const result = readDocType(xmlData, i8);
            this.docTypeEntities = result.entities;
            i8 = result.i;
          } else if (xmlData.substr(i8 + 1, 2) === "![") {
            const closeIndex = findClosingIndex(xmlData, "]]>", i8, "CDATA is not closed.") - 2;
            const tagExp = xmlData.substring(i8 + 9, closeIndex);
            textData = this.saveTextToParentTag(textData, currentNode, jPath);
            let val2 = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true, true);
            if (val2 == void 0) val2 = "";
            if (this.options.cdataPropName) {
              currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]);
            } else {
              currentNode.add(this.options.textNodeName, val2);
            }
            i8 = closeIndex + 2;
          } else {
            let result = readTagExp(xmlData, i8, this.options.removeNSPrefix);
            let tagName = result.tagName;
            const rawTagName = result.rawTagName;
            let tagExp = result.tagExp;
            let attrExpPresent = result.attrExpPresent;
            let closeIndex = result.closeIndex;
            if (this.options.transformTagName) {
              tagName = this.options.transformTagName(tagName);
            }
            if (currentNode && textData) {
              if (currentNode.tagname !== "!xml") {
                textData = this.saveTextToParentTag(textData, currentNode, jPath, false);
              }
            }
            const lastTag = currentNode;
            if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) {
              currentNode = this.tagsNodeStack.pop();
              jPath = jPath.substring(0, jPath.lastIndexOf("."));
            }
            if (tagName !== xmlObj.tagname) {
              jPath += jPath ? "." + tagName : tagName;
            }
            if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) {
              let tagContent = "";
              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
                if (tagName[tagName.length - 1] === "/") {
                  tagName = tagName.substr(0, tagName.length - 1);
                  jPath = jPath.substr(0, jPath.length - 1);
                  tagExp = tagName;
                } else {
                  tagExp = tagExp.substr(0, tagExp.length - 1);
                }
                i8 = result.closeIndex;
              } else if (this.options.unpairedTags.indexOf(tagName) !== -1) {
                i8 = result.closeIndex;
              } else {
                const result2 = this.readStopNodeData(xmlData, rawTagName, closeIndex + 1);
                if (!result2) throw new Error(`Unexpected end of ${rawTagName}`);
                i8 = result2.i;
                tagContent = result2.tagContent;
              }
              const childNode = new xmlNode(tagName);
              if (tagName !== tagExp && attrExpPresent) {
                childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
              }
              if (tagContent) {
                tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true);
              }
              jPath = jPath.substr(0, jPath.lastIndexOf("."));
              childNode.add(this.options.textNodeName, tagContent);
              this.addChild(currentNode, childNode, jPath);
            } else {
              if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) {
                if (tagName[tagName.length - 1] === "/") {
                  tagName = tagName.substr(0, tagName.length - 1);
                  jPath = jPath.substr(0, jPath.length - 1);
                  tagExp = tagName;
                } else {
                  tagExp = tagExp.substr(0, tagExp.length - 1);
                }
                if (this.options.transformTagName) {
                  tagName = this.options.transformTagName(tagName);
                }
                const childNode = new xmlNode(tagName);
                if (tagName !== tagExp && attrExpPresent) {
                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                }
                this.addChild(currentNode, childNode, jPath);
                jPath = jPath.substr(0, jPath.lastIndexOf("."));
              } else {
                const childNode = new xmlNode(tagName);
                this.tagsNodeStack.push(currentNode);
                if (tagName !== tagExp && attrExpPresent) {
                  childNode[":@"] = this.buildAttributesMap(tagExp, jPath, tagName);
                }
                this.addChild(currentNode, childNode, jPath);
                currentNode = childNode;
              }
              textData = "";
              i8 = closeIndex;
            }
          }
        } else {
          textData += xmlData[i8];
        }
      }
      return xmlObj.child;
    };
    function addChild(currentNode, childNode, jPath) {
      const result = this.options.updateTag(childNode.tagname, jPath, childNode[":@"]);
      if (result === false) {
      } else if (typeof result === "string") {
        childNode.tagname = result;
        currentNode.addChild(childNode);
      } else {
        currentNode.addChild(childNode);
      }
    }
    var replaceEntitiesValue = function(val2) {
      if (this.options.processEntities) {
        for (let entityName2 in this.docTypeEntities) {
          const entity = this.docTypeEntities[entityName2];
          val2 = val2.replace(entity.regx, entity.val);
        }
        for (let entityName2 in this.lastEntities) {
          const entity = this.lastEntities[entityName2];
          val2 = val2.replace(entity.regex, entity.val);
        }
        if (this.options.htmlEntities) {
          for (let entityName2 in this.htmlEntities) {
            const entity = this.htmlEntities[entityName2];
            val2 = val2.replace(entity.regex, entity.val);
          }
        }
        val2 = val2.replace(this.ampEntity.regex, this.ampEntity.val);
      }
      return val2;
    };
    function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) {
      if (textData) {
        if (isLeafNode === void 0) isLeafNode = Object.keys(currentNode.child).length === 0;
        textData = this.parseTextData(
          textData,
          currentNode.tagname,
          jPath,
          false,
          currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false,
          isLeafNode
        );
        if (textData !== void 0 && textData !== "")
          currentNode.add(this.options.textNodeName, textData);
        textData = "";
      }
      return textData;
    }
    function isItStopNode(stopNodes, jPath, currentTagName) {
      const allNodesExp = "*." + currentTagName;
      for (const stopNodePath in stopNodes) {
        const stopNodeExp = stopNodes[stopNodePath];
        if (allNodesExp === stopNodeExp || jPath === stopNodeExp) return true;
      }
      return false;
    }
    function tagExpWithClosingIndex(xmlData, i8, closingChar = ">") {
      let attrBoundary;
      let tagExp = "";
      for (let index7 = i8; index7 < xmlData.length; index7++) {
        let ch = xmlData[index7];
        if (attrBoundary) {
          if (ch === attrBoundary) attrBoundary = "";
        } else if (ch === '"' || ch === "'") {
          attrBoundary = ch;
        } else if (ch === closingChar[0]) {
          if (closingChar[1]) {
            if (xmlData[index7 + 1] === closingChar[1]) {
              return {
                data: tagExp,
                index: index7
              };
            }
          } else {
            return {
              data: tagExp,
              index: index7
            };
          }
        } else if (ch === "	") {
          ch = " ";
        }
        tagExp += ch;
      }
    }
    function findClosingIndex(xmlData, str, i8, errMsg) {
      const closingIndex = xmlData.indexOf(str, i8);
      if (closingIndex === -1) {
        throw new Error(errMsg);
      } else {
        return closingIndex + str.length - 1;
      }
    }
    function readTagExp(xmlData, i8, removeNSPrefix, closingChar = ">") {
      const result = tagExpWithClosingIndex(xmlData, i8 + 1, closingChar);
      if (!result) return;
      let tagExp = result.data;
      const closeIndex = result.index;
      const separatorIndex = tagExp.search(/\s/);
      let tagName = tagExp;
      let attrExpPresent = true;
      if (separatorIndex !== -1) {
        tagName = tagExp.substring(0, separatorIndex);
        tagExp = tagExp.substring(separatorIndex + 1).trimStart();
      }
      const rawTagName = tagName;
      if (removeNSPrefix) {
        const colonIndex = tagName.indexOf(":");
        if (colonIndex !== -1) {
          tagName = tagName.substr(colonIndex + 1);
          attrExpPresent = tagName !== result.data.substr(colonIndex + 1);
        }
      }
      return {
        tagName,
        tagExp,
        closeIndex,
        attrExpPresent,
        rawTagName
      };
    }
    function readStopNodeData(xmlData, tagName, i8) {
      const startIndex = i8;
      let openTagCount = 1;
      for (; i8 < xmlData.length; i8++) {
        if (xmlData[i8] === "<") {
          if (xmlData[i8 + 1] === "/") {
            const closeIndex = findClosingIndex(xmlData, ">", i8, `${tagName} is not closed`);
            let closeTagName = xmlData.substring(i8 + 2, closeIndex).trim();
            if (closeTagName === tagName) {
              openTagCount--;
              if (openTagCount === 0) {
                return {
                  tagContent: xmlData.substring(startIndex, i8),
                  i: closeIndex
                };
              }
            }
            i8 = closeIndex;
          } else if (xmlData[i8 + 1] === "?") {
            const closeIndex = findClosingIndex(xmlData, "?>", i8 + 1, "StopNode is not closed.");
            i8 = closeIndex;
          } else if (xmlData.substr(i8 + 1, 3) === "!--") {
            const closeIndex = findClosingIndex(xmlData, "-->", i8 + 3, "StopNode is not closed.");
            i8 = closeIndex;
          } else if (xmlData.substr(i8 + 1, 2) === "![") {
            const closeIndex = findClosingIndex(xmlData, "]]>", i8, "StopNode is not closed.") - 2;
            i8 = closeIndex;
          } else {
            const tagData = readTagExp(xmlData, i8, ">");
            if (tagData) {
              const openTagName = tagData && tagData.tagName;
              if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") {
                openTagCount++;
              }
              i8 = tagData.closeIndex;
            }
          }
        }
      }
    }
    function parseValue(val2, shouldParse, options) {
      if (shouldParse && typeof val2 === "string") {
        const newval = val2.trim();
        if (newval === "true") return true;
        else if (newval === "false") return false;
        else return toNumber(val2, options);
      } else {
        if (util2.isExist(val2)) {
          return val2;
        } else {
          return "";
        }
      }
    }
    module2.exports = OrderedObjParser;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/node2json.js
var require_node2json = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/node2json.js"(exports2) {
    "use strict";
    function prettify(node, options) {
      return compress2(node, options);
    }
    function compress2(arr, options, jPath) {
      let text5;
      const compressedObj = {};
      for (let i8 = 0; i8 < arr.length; i8++) {
        const tagObj = arr[i8];
        const property = propName(tagObj);
        let newJpath = "";
        if (jPath === void 0) newJpath = property;
        else newJpath = jPath + "." + property;
        if (property === options.textNodeName) {
          if (text5 === void 0) text5 = tagObj[property];
          else text5 += "" + tagObj[property];
        } else if (property === void 0) {
          continue;
        } else if (tagObj[property]) {
          let val2 = compress2(tagObj[property], options, newJpath);
          const isLeaf = isLeafTag(val2, options);
          if (tagObj[":@"]) {
            assignAttributes(val2, tagObj[":@"], newJpath, options);
          } else if (Object.keys(val2).length === 1 && val2[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) {
            val2 = val2[options.textNodeName];
          } else if (Object.keys(val2).length === 0) {
            if (options.alwaysCreateTextNode) val2[options.textNodeName] = "";
            else val2 = "";
          }
          if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) {
            if (!Array.isArray(compressedObj[property])) {
              compressedObj[property] = [compressedObj[property]];
            }
            compressedObj[property].push(val2);
          } else {
            if (options.isArray(property, newJpath, isLeaf)) {
              compressedObj[property] = [val2];
            } else {
              compressedObj[property] = val2;
            }
          }
        }
      }
      if (typeof text5 === "string") {
        if (text5.length > 0) compressedObj[options.textNodeName] = text5;
      } else if (text5 !== void 0) compressedObj[options.textNodeName] = text5;
      return compressedObj;
    }
    function propName(obj) {
      const keys = Object.keys(obj);
      for (let i8 = 0; i8 < keys.length; i8++) {
        const key = keys[i8];
        if (key !== ":@") return key;
      }
    }
    function assignAttributes(obj, attrMap, jpath, options) {
      if (attrMap) {
        const keys = Object.keys(attrMap);
        const len = keys.length;
        for (let i8 = 0; i8 < len; i8++) {
          const atrrName = keys[i8];
          if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) {
            obj[atrrName] = [attrMap[atrrName]];
          } else {
            obj[atrrName] = attrMap[atrrName];
          }
        }
      }
    }
    function isLeafTag(obj, options) {
      const { textNodeName } = options;
      const propCount = Object.keys(obj).length;
      if (propCount === 0) {
        return true;
      }
      if (propCount === 1 && (obj[textNodeName] || typeof obj[textNodeName] === "boolean" || obj[textNodeName] === 0)) {
        return true;
      }
      return false;
    }
    exports2.prettify = prettify;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js
var require_XMLParser = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js"(exports2, module2) {
    "use strict";
    var { buildOptions } = require_OptionsBuilder();
    var OrderedObjParser = require_OrderedObjParser();
    var { prettify } = require_node2json();
    var validator2 = require_validator();
    var XMLParser2 = class {
      constructor(options) {
        this.externalEntities = {};
        this.options = buildOptions(options);
      }
      /**
       * Parse XML dats to JS object 
       * @param {string|Buffer} xmlData 
       * @param {boolean|Object} validationOption 
       */
      parse(xmlData, validationOption) {
        if (typeof xmlData === "string") {
        } else if (xmlData.toString) {
          xmlData = xmlData.toString();
        } else {
          throw new Error("XML data is accepted in String or Bytes[] form.");
        }
        if (validationOption) {
          if (validationOption === true) validationOption = {};
          const result = validator2.validate(xmlData, validationOption);
          if (result !== true) {
            throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`);
          }
        }
        const orderedObjParser = new OrderedObjParser(this.options);
        orderedObjParser.addExternalEntities(this.externalEntities);
        const orderedResult = orderedObjParser.parseXml(xmlData);
        if (this.options.preserveOrder || orderedResult === void 0) return orderedResult;
        else return prettify(orderedResult, this.options);
      }
      /**
       * Add Entity which is not by default supported by this library
       * @param {string} key 
       * @param {string} value 
       */
      addEntity(key, value) {
        if (value.indexOf("&") !== -1) {
          throw new Error("Entity value can't have '&'");
        } else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) {
          throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '&#xD;'");
        } else if (value === "&") {
          throw new Error("An entity with value '&' is not permitted");
        } else {
          this.externalEntities[key] = value;
        }
      }
    };
    module2.exports = XMLParser2;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js
var require_orderedJs2Xml = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js"(exports2, module2) {
    "use strict";
    var EOL = "\n";
    function toXml(jArray, options) {
      let indentation = "";
      if (options.format && options.indentBy.length > 0) {
        indentation = EOL;
      }
      return arrToStr(jArray, options, "", indentation);
    }
    function arrToStr(arr, options, jPath, indentation) {
      let xmlStr = "";
      let isPreviousElementTag = false;
      for (let i8 = 0; i8 < arr.length; i8++) {
        const tagObj = arr[i8];
        const tagName = propName(tagObj);
        if (tagName === void 0) continue;
        let newJPath = "";
        if (jPath.length === 0) newJPath = tagName;
        else newJPath = `${jPath}.${tagName}`;
        if (tagName === options.textNodeName) {
          let tagText = tagObj[tagName];
          if (!isStopNode(newJPath, options)) {
            tagText = options.tagValueProcessor(tagName, tagText);
            tagText = replaceEntitiesValue(tagText, options);
          }
          if (isPreviousElementTag) {
            xmlStr += indentation;
          }
          xmlStr += tagText;
          isPreviousElementTag = false;
          continue;
        } else if (tagName === options.cdataPropName) {
          if (isPreviousElementTag) {
            xmlStr += indentation;
          }
          xmlStr += `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`;
          isPreviousElementTag = false;
          continue;
        } else if (tagName === options.commentPropName) {
          xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`;
          isPreviousElementTag = true;
          continue;
        } else if (tagName[0] === "?") {
          const attStr2 = attr_to_str(tagObj[":@"], options);
          const tempInd = tagName === "?xml" ? "" : indentation;
          let piTextNodeName = tagObj[tagName][0][options.textNodeName];
          piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : "";
          xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr2}?>`;
          isPreviousElementTag = true;
          continue;
        }
        let newIdentation = indentation;
        if (newIdentation !== "") {
          newIdentation += options.indentBy;
        }
        const attStr = attr_to_str(tagObj[":@"], options);
        const tagStart = indentation + `<${tagName}${attStr}`;
        const tagValue = arrToStr(tagObj[tagName], options, newJPath, newIdentation);
        if (options.unpairedTags.indexOf(tagName) !== -1) {
          if (options.suppressUnpairedNode) xmlStr += tagStart + ">";
          else xmlStr += tagStart + "/>";
        } else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) {
          xmlStr += tagStart + "/>";
        } else if (tagValue && tagValue.endsWith(">")) {
          xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`;
        } else {
          xmlStr += tagStart + ">";
          if (tagValue && indentation !== "" && (tagValue.includes("/>") || tagValue.includes("</"))) {
            xmlStr += indentation + options.indentBy + tagValue + indentation;
          } else {
            xmlStr += tagValue;
          }
          xmlStr += `</${tagName}>`;
        }
        isPreviousElementTag = true;
      }
      return xmlStr;
    }
    function propName(obj) {
      const keys = Object.keys(obj);
      for (let i8 = 0; i8 < keys.length; i8++) {
        const key = keys[i8];
        if (!obj.hasOwnProperty(key)) continue;
        if (key !== ":@") return key;
      }
    }
    function attr_to_str(attrMap, options) {
      let attrStr = "";
      if (attrMap && !options.ignoreAttributes) {
        for (let attr in attrMap) {
          if (!attrMap.hasOwnProperty(attr)) continue;
          let attrVal = options.attributeValueProcessor(attr, attrMap[attr]);
          attrVal = replaceEntitiesValue(attrVal, options);
          if (attrVal === true && options.suppressBooleanAttributes) {
            attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`;
          } else {
            attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`;
          }
        }
      }
      return attrStr;
    }
    function isStopNode(jPath, options) {
      jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1);
      let tagName = jPath.substr(jPath.lastIndexOf(".") + 1);
      for (let index7 in options.stopNodes) {
        if (options.stopNodes[index7] === jPath || options.stopNodes[index7] === "*." + tagName) return true;
      }
      return false;
    }
    function replaceEntitiesValue(textValue, options) {
      if (textValue && textValue.length > 0 && options.processEntities) {
        for (let i8 = 0; i8 < options.entities.length; i8++) {
          const entity = options.entities[i8];
          textValue = textValue.replace(entity.regex, entity.val);
        }
      }
      return textValue;
    }
    module2.exports = toXml;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js
var require_json2xml = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js"(exports2, module2) {
    "use strict";
    var buildFromOrderedJs = require_orderedJs2Xml();
    var defaultOptions = {
      attributeNamePrefix: "@_",
      attributesGroupName: false,
      textNodeName: "#text",
      ignoreAttributes: true,
      cdataPropName: false,
      format: false,
      indentBy: "  ",
      suppressEmptyNode: false,
      suppressUnpairedNode: true,
      suppressBooleanAttributes: true,
      tagValueProcessor: function(key, a9) {
        return a9;
      },
      attributeValueProcessor: function(attrName, a9) {
        return a9;
      },
      preserveOrder: false,
      commentPropName: false,
      unpairedTags: [],
      entities: [
        { regex: new RegExp("&", "g"), val: "&amp;" },
        //it must be on top
        { regex: new RegExp(">", "g"), val: "&gt;" },
        { regex: new RegExp("<", "g"), val: "&lt;" },
        { regex: new RegExp("'", "g"), val: "&apos;" },
        { regex: new RegExp('"', "g"), val: "&quot;" }
      ],
      processEntities: true,
      stopNodes: [],
      // transformTagName: false,
      // transformAttributeName: false,
      oneListGroup: false
    };
    function Builder2(options) {
      this.options = Object.assign({}, defaultOptions, options);
      if (this.options.ignoreAttributes || this.options.attributesGroupName) {
        this.isAttribute = function() {
          return false;
        };
      } else {
        this.attrPrefixLen = this.options.attributeNamePrefix.length;
        this.isAttribute = isAttribute;
      }
      this.processTextOrObjNode = processTextOrObjNode;
      if (this.options.format) {
        this.indentate = indentate;
        this.tagEndChar = ">\n";
        this.newLine = "\n";
      } else {
        this.indentate = function() {
          return "";
        };
        this.tagEndChar = ">";
        this.newLine = "";
      }
    }
    Builder2.prototype.build = function(jObj) {
      if (this.options.preserveOrder) {
        return buildFromOrderedJs(jObj, this.options);
      } else {
        if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) {
          jObj = {
            [this.options.arrayNodeName]: jObj
          };
        }
        return this.j2x(jObj, 0).val;
      }
    };
    Builder2.prototype.j2x = function(jObj, level) {
      let attrStr = "";
      let val2 = "";
      for (let key in jObj) {
        if (!Object.prototype.hasOwnProperty.call(jObj, key)) continue;
        if (typeof jObj[key] === "undefined") {
          if (this.isAttribute(key)) {
            val2 += "";
          }
        } else if (jObj[key] === null) {
          if (this.isAttribute(key)) {
            val2 += "";
          } else if (key[0] === "?") {
            val2 += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
          } else {
            val2 += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
          }
        } else if (jObj[key] instanceof Date) {
          val2 += this.buildTextValNode(jObj[key], key, "", level);
        } else if (typeof jObj[key] !== "object") {
          const attr = this.isAttribute(key);
          if (attr) {
            attrStr += this.buildAttrPairStr(attr, "" + jObj[key]);
          } else {
            if (key === this.options.textNodeName) {
              let newval = this.options.tagValueProcessor(key, "" + jObj[key]);
              val2 += this.replaceEntitiesValue(newval);
            } else {
              val2 += this.buildTextValNode(jObj[key], key, "", level);
            }
          }
        } else if (Array.isArray(jObj[key])) {
          const arrLen = jObj[key].length;
          let listTagVal = "";
          let listTagAttr = "";
          for (let j7 = 0; j7 < arrLen; j7++) {
            const item = jObj[key][j7];
            if (typeof item === "undefined") {
            } else if (item === null) {
              if (key[0] === "?") val2 += this.indentate(level) + "<" + key + "?" + this.tagEndChar;
              else val2 += this.indentate(level) + "<" + key + "/" + this.tagEndChar;
            } else if (typeof item === "object") {
              if (this.options.oneListGroup) {
                const result = this.j2x(item, level + 1);
                listTagVal += result.val;
                if (this.options.attributesGroupName && item.hasOwnProperty(this.options.attributesGroupName)) {
                  listTagAttr += result.attrStr;
                }
              } else {
                listTagVal += this.processTextOrObjNode(item, key, level);
              }
            } else {
              if (this.options.oneListGroup) {
                let textValue = this.options.tagValueProcessor(key, item);
                textValue = this.replaceEntitiesValue(textValue);
                listTagVal += textValue;
              } else {
                listTagVal += this.buildTextValNode(item, key, "", level);
              }
            }
          }
          if (this.options.oneListGroup) {
            listTagVal = this.buildObjectNode(listTagVal, key, listTagAttr, level);
          }
          val2 += listTagVal;
        } else {
          if (this.options.attributesGroupName && key === this.options.attributesGroupName) {
            const Ks4 = Object.keys(jObj[key]);
            const L6 = Ks4.length;
            for (let j7 = 0; j7 < L6; j7++) {
              attrStr += this.buildAttrPairStr(Ks4[j7], "" + jObj[key][Ks4[j7]]);
            }
          } else {
            val2 += this.processTextOrObjNode(jObj[key], key, level);
          }
        }
      }
      return { attrStr, val: val2 };
    };
    Builder2.prototype.buildAttrPairStr = function(attrName, val2) {
      val2 = this.options.attributeValueProcessor(attrName, "" + val2);
      val2 = this.replaceEntitiesValue(val2);
      if (this.options.suppressBooleanAttributes && val2 === "true") {
        return " " + attrName;
      } else return " " + attrName + '="' + val2 + '"';
    };
    function processTextOrObjNode(object2, key, level) {
      const result = this.j2x(object2, level + 1);
      if (object2[this.options.textNodeName] !== void 0 && Object.keys(object2).length === 1) {
        return this.buildTextValNode(object2[this.options.textNodeName], key, result.attrStr, level);
      } else {
        return this.buildObjectNode(result.val, key, result.attrStr, level);
      }
    }
    Builder2.prototype.buildObjectNode = function(val2, key, attrStr, level) {
      if (val2 === "") {
        if (key[0] === "?") return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
        else {
          return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
        }
      } else {
        let tagEndExp = "</" + key + this.tagEndChar;
        let piClosingChar = "";
        if (key[0] === "?") {
          piClosingChar = "?";
          tagEndExp = "";
        }
        if ((attrStr || attrStr === "") && val2.indexOf("<") === -1) {
          return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val2 + tagEndExp;
        } else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) {
          return this.indentate(level) + `<!--${val2}-->` + this.newLine;
        } else {
          return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val2 + this.indentate(level) + tagEndExp;
        }
      }
    };
    Builder2.prototype.closeTag = function(key) {
      let closeTag = "";
      if (this.options.unpairedTags.indexOf(key) !== -1) {
        if (!this.options.suppressUnpairedNode) closeTag = "/";
      } else if (this.options.suppressEmptyNode) {
        closeTag = "/";
      } else {
        closeTag = `></${key}`;
      }
      return closeTag;
    };
    Builder2.prototype.buildTextValNode = function(val2, key, attrStr, level) {
      if (this.options.cdataPropName !== false && key === this.options.cdataPropName) {
        return this.indentate(level) + `<![CDATA[${val2}]]>` + this.newLine;
      } else if (this.options.commentPropName !== false && key === this.options.commentPropName) {
        return this.indentate(level) + `<!--${val2}-->` + this.newLine;
      } else if (key[0] === "?") {
        return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar;
      } else {
        let textValue = this.options.tagValueProcessor(key, val2);
        textValue = this.replaceEntitiesValue(textValue);
        if (textValue === "") {
          return this.indentate(level) + "<" + key + attrStr + this.closeTag(key) + this.tagEndChar;
        } else {
          return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar;
        }
      }
    };
    Builder2.prototype.replaceEntitiesValue = function(textValue) {
      if (textValue && textValue.length > 0 && this.options.processEntities) {
        for (let i8 = 0; i8 < this.options.entities.length; i8++) {
          const entity = this.options.entities[i8];
          textValue = textValue.replace(entity.regex, entity.val);
        }
      }
      return textValue;
    };
    function indentate(level) {
      return this.options.indentBy.repeat(level);
    }
    function isAttribute(name3) {
      if (name3.startsWith(this.options.attributeNamePrefix) && name3 !== this.options.textNodeName) {
        return name3.substr(this.attrPrefixLen);
      } else {
        return false;
      }
    }
    module2.exports = Builder2;
  }
});

// ../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/fxp.js
var require_fxp = __commonJS({
  "../node_modules/.pnpm/fast-xml-parser@4.4.1/node_modules/fast-xml-parser/src/fxp.js"(exports2, module2) {
    "use strict";
    var validator2 = require_validator();
    var XMLParser2 = require_XMLParser();
    var XMLBuilder = require_json2xml();
    module2.exports = {
      XMLParser: XMLParser2,
      XMLValidator: validator2,
      XMLBuilder
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/parseXmlBody.js
var import_fast_xml_parser, parseXmlBody, parseXmlErrorBody;
var init_parseXmlBody = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/xml/parseXmlBody.js"() {
    "use strict";
    init_dist_es24();
    import_fast_xml_parser = __toESM(require_fxp());
    init_common6();
    parseXmlBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
      if (encoded.length) {
        const parser = new import_fast_xml_parser.XMLParser({
          attributeNamePrefix: "",
          htmlEntities: true,
          ignoreAttributes: false,
          ignoreDeclaration: true,
          parseTagValue: false,
          trimValues: false,
          tagValueProcessor: (_7, val2) => val2.trim() === "" && val2.includes("\n") ? "" : void 0
        });
        parser.addEntity("#xD", "\r");
        parser.addEntity("#10", "\n");
        let parsedObj;
        try {
          parsedObj = parser.parse(encoded, true);
        } catch (e6) {
          if (e6 && typeof e6 === "object") {
            Object.defineProperty(e6, "$responseBodyText", {
              value: encoded
            });
          }
          throw e6;
        }
        const textNodeName = "#text";
        const key = Object.keys(parsedObj)[0];
        const parsedObjToReturn = parsedObj[key];
        if (parsedObjToReturn[textNodeName]) {
          parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
          delete parsedObjToReturn[textNodeName];
        }
        return getValueFromTextNode(parsedObjToReturn);
      }
      return {};
    });
    parseXmlErrorBody = async (errorBody, context) => {
      const value = await parseXmlBody(errorBody, context);
      if (value.Error) {
        value.Error.message = value.Error.message ?? value.Error.Message;
      }
      return value;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/index.js
var init_protocols2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/submodules/protocols/index.js"() {
    "use strict";
    init_coercing_serializers();
    init_awsExpectUnion();
    init_parseJsonBody();
    init_parseXmlBody();
  }
});

// ../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/index.js
var init_dist_es25 = __esm({
  "../node_modules/.pnpm/@aws-sdk+core@3.816.0/node_modules/@aws-sdk/core/dist-es/index.js"() {
    "use strict";
    init_client2();
    init_httpAuthSchemes2();
    init_protocols2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/check-features.js
async function checkFeatures(context, config, args2) {
  const request2 = args2.request;
  if (request2?.headers?.["smithy-protocol"] === "rpc-v2-cbor") {
    setFeature2(context, "PROTOCOL_RPC_V2_CBOR", "M");
  }
  if (typeof config.retryStrategy === "function") {
    const retryStrategy = await config.retryStrategy();
    if (typeof retryStrategy.acquireInitialRetryToken === "function") {
      if (retryStrategy.constructor?.name?.includes("Adaptive")) {
        setFeature2(context, "RETRY_MODE_ADAPTIVE", "F");
      } else {
        setFeature2(context, "RETRY_MODE_STANDARD", "E");
      }
    } else {
      setFeature2(context, "RETRY_MODE_LEGACY", "D");
    }
  }
  if (typeof config.accountIdEndpointMode === "function") {
    const endpointV2 = context.endpointV2;
    if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
      setFeature2(context, "ACCOUNT_ID_ENDPOINT", "O");
    }
    switch (await config.accountIdEndpointMode?.()) {
      case "disabled":
        setFeature2(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
        break;
      case "preferred":
        setFeature2(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
        break;
      case "required":
        setFeature2(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
        break;
    }
  }
  const identity = context.__smithy_context?.selectedHttpAuthScheme?.identity;
  if (identity?.$source) {
    const credentials2 = identity;
    if (credentials2.accountId) {
      setFeature2(context, "RESOLVED_ACCOUNT_ID", "T");
    }
    for (const [key, value] of Object.entries(credentials2.$source ?? {})) {
      setFeature2(context, key, value);
    }
  }
}
var ACCOUNT_ID_ENDPOINT_REGEX;
var init_check_features = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/check-features.js"() {
    "use strict";
    init_dist_es25();
    ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/constants.js
var USER_AGENT, X_AMZ_USER_AGENT, SPACE2, UA_NAME_SEPARATOR, UA_NAME_ESCAPE_REGEX, UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR;
var init_constants5 = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/constants.js"() {
    "use strict";
    USER_AGENT = "user-agent";
    X_AMZ_USER_AGENT = "x-amz-user-agent";
    SPACE2 = " ";
    UA_NAME_SEPARATOR = "/";
    UA_NAME_ESCAPE_REGEX = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w]/g;
    UA_VALUE_ESCAPE_REGEX = /[^\!\$\%\&\'\*\+\-\.\^\_\`\|\~\d\w\#]/g;
    UA_ESCAPE_CHAR = "-";
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/encode-features.js
function encodeFeatures(features) {
  let buffer2 = "";
  for (const key in features) {
    const val2 = features[key];
    if (buffer2.length + val2.length + 1 <= BYTE_LIMIT) {
      if (buffer2.length) {
        buffer2 += "," + val2;
      } else {
        buffer2 += val2;
      }
      continue;
    }
    break;
  }
  return buffer2;
}
var BYTE_LIMIT;
var init_encode_features = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/encode-features.js"() {
    "use strict";
    BYTE_LIMIT = 1024;
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/user-agent-middleware.js
var userAgentMiddleware, escapeUserAgent, getUserAgentMiddlewareOptions, getUserAgentPlugin;
var init_user_agent_middleware = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/user-agent-middleware.js"() {
    "use strict";
    init_dist_es20();
    init_dist_es2();
    init_check_features();
    init_constants5();
    init_encode_features();
    userAgentMiddleware = (options) => (next, context) => async (args2) => {
      const { request: request2 } = args2;
      if (!HttpRequest.isInstance(request2)) {
        return next(args2);
      }
      const { headers } = request2;
      const userAgent = context?.userAgent?.map(escapeUserAgent) || [];
      const defaultUserAgent = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
      await checkFeatures(context, options, args2);
      const awsContext = context;
      defaultUserAgent.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
      const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
      const appId = await options.userAgentAppId();
      if (appId) {
        defaultUserAgent.push(escapeUserAgent([`app/${appId}`]));
      }
      const prefix2 = getUserAgentPrefix();
      const sdkUserAgentValue = (prefix2 ? [prefix2] : []).concat([...defaultUserAgent, ...userAgent, ...customUserAgent]).join(SPACE2);
      const normalUAValue = [
        ...defaultUserAgent.filter((section) => section.startsWith("aws-sdk-")),
        ...customUserAgent
      ].join(SPACE2);
      if (options.runtime !== "browser") {
        if (normalUAValue) {
          headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] ? `${headers[USER_AGENT]} ${normalUAValue}` : normalUAValue;
        }
        headers[USER_AGENT] = sdkUserAgentValue;
      } else {
        headers[X_AMZ_USER_AGENT] = sdkUserAgentValue;
      }
      return next({
        ...args2,
        request: request2
      });
    };
    escapeUserAgent = (userAgentPair) => {
      const name3 = userAgentPair[0].split(UA_NAME_SEPARATOR).map((part) => part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR)).join(UA_NAME_SEPARATOR);
      const version3 = userAgentPair[1]?.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR);
      const prefixSeparatorIndex = name3.indexOf(UA_NAME_SEPARATOR);
      const prefix2 = name3.substring(0, prefixSeparatorIndex);
      let uaName = name3.substring(prefixSeparatorIndex + 1);
      if (prefix2 === "api") {
        uaName = uaName.toLowerCase();
      }
      return [prefix2, uaName, version3].filter((item) => item && item.length > 0).reduce((acc, item, index7) => {
        switch (index7) {
          case 0:
            return item;
          case 1:
            return `${acc}/${item}`;
          default:
            return `${acc}#${item}`;
        }
      }, "");
    };
    getUserAgentMiddlewareOptions = {
      name: "getUserAgentMiddleware",
      step: "build",
      priority: "low",
      tags: ["SET_USER_AGENT", "USER_AGENT"],
      override: true
    };
    getUserAgentPlugin = (config) => ({
      applyToStack: (clientStack) => {
        clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/index.js
var init_dist_es26 = __esm({
  "../node_modules/.pnpm/@aws-sdk+middleware-user-agent@3.816.0/node_modules/@aws-sdk/middleware-user-agent/dist-es/index.js"() {
    "use strict";
    init_configurations();
    init_user_agent_middleware();
  }
});

// ../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/booleanSelector.js
var booleanSelector;
var init_booleanSelector = __esm({
  "../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/booleanSelector.js"() {
    "use strict";
    booleanSelector = (obj, key, type) => {
      if (!(key in obj))
        return void 0;
      if (obj[key] === "true")
        return true;
      if (obj[key] === "false")
        return false;
      throw new Error(`Cannot load ${type} "${key}". Expected "true" or "false", got ${obj[key]}.`);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/numberSelector.js
var init_numberSelector = __esm({
  "../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/numberSelector.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/types.js
var SelectorType;
var init_types5 = __esm({
  "../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/types.js"() {
    "use strict";
    (function(SelectorType2) {
      SelectorType2["ENV"] = "env";
      SelectorType2["CONFIG"] = "shared config entry";
    })(SelectorType || (SelectorType = {}));
  }
});

// ../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/index.js
var init_dist_es27 = __esm({
  "../node_modules/.pnpm/@smithy+util-config-provider@4.0.0/node_modules/@smithy/util-config-provider/dist-es/index.js"() {
    "use strict";
    init_booleanSelector();
    init_numberSelector();
    init_types5();
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js
var ENV_USE_DUALSTACK_ENDPOINT, CONFIG_USE_DUALSTACK_ENDPOINT, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS;
var init_NodeUseDualstackEndpointConfigOptions = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseDualstackEndpointConfigOptions.js"() {
    "use strict";
    init_dist_es27();
    ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
    CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
    NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => booleanSelector(env4, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
      configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
      default: false
    };
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseFipsEndpointConfigOptions.js
var ENV_USE_FIPS_ENDPOINT, CONFIG_USE_FIPS_ENDPOINT, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS;
var init_NodeUseFipsEndpointConfigOptions = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/NodeUseFipsEndpointConfigOptions.js"() {
    "use strict";
    init_dist_es27();
    ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
    CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
    NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => booleanSelector(env4, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
      configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
      default: false
    };
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/resolveCustomEndpointsConfig.js
var init_resolveCustomEndpointsConfig = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/resolveCustomEndpointsConfig.js"() {
    "use strict";
    init_dist_es6();
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/utils/getEndpointFromRegion.js
var init_getEndpointFromRegion = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/utils/getEndpointFromRegion.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/resolveEndpointsConfig.js
var init_resolveEndpointsConfig = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/resolveEndpointsConfig.js"() {
    "use strict";
    init_dist_es6();
    init_getEndpointFromRegion();
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/index.js
var init_endpointsConfig = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/endpointsConfig/index.js"() {
    "use strict";
    init_NodeUseDualstackEndpointConfigOptions();
    init_NodeUseFipsEndpointConfigOptions();
    init_resolveCustomEndpointsConfig();
    init_resolveEndpointsConfig();
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/config.js
var REGION_ENV_NAME, REGION_INI_NAME, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS;
var init_config2 = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/config.js"() {
    "use strict";
    REGION_ENV_NAME = "AWS_REGION";
    REGION_INI_NAME = "region";
    NODE_REGION_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => env4[REGION_ENV_NAME],
      configFileSelector: (profile) => profile[REGION_INI_NAME],
      default: () => {
        throw new Error("Region is missing");
      }
    };
    NODE_REGION_CONFIG_FILE_OPTIONS = {
      preferredFile: "credentials"
    };
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/isFipsRegion.js
var isFipsRegion;
var init_isFipsRegion = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/isFipsRegion.js"() {
    "use strict";
    isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/getRealRegion.js
var getRealRegion;
var init_getRealRegion = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/getRealRegion.js"() {
    "use strict";
    init_isFipsRegion();
    getRealRegion = (region) => isFipsRegion(region) ? ["fips-aws-global", "aws-fips"].includes(region) ? "us-east-1" : region.replace(/fips-(dkr-|prod-)?|-fips/, "") : region;
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/resolveRegionConfig.js
var resolveRegionConfig;
var init_resolveRegionConfig = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/resolveRegionConfig.js"() {
    "use strict";
    init_getRealRegion();
    init_isFipsRegion();
    resolveRegionConfig = (input) => {
      const { region, useFipsEndpoint } = input;
      if (!region) {
        throw new Error("Region is missing");
      }
      return Object.assign(input, {
        region: async () => {
          if (typeof region === "string") {
            return getRealRegion(region);
          }
          const providedRegion = await region();
          return getRealRegion(providedRegion);
        },
        useFipsEndpoint: async () => {
          const providedRegion = typeof region === "string" ? region : await region();
          if (isFipsRegion(providedRegion)) {
            return true;
          }
          return typeof useFipsEndpoint !== "function" ? Promise.resolve(!!useFipsEndpoint) : useFipsEndpoint();
        }
      });
    };
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/index.js
var init_regionConfig = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionConfig/index.js"() {
    "use strict";
    init_config2();
    init_resolveRegionConfig();
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/PartitionHash.js
var init_PartitionHash = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/PartitionHash.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/RegionHash.js
var init_RegionHash = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/RegionHash.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getHostnameFromVariants.js
var init_getHostnameFromVariants = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getHostnameFromVariants.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getResolvedHostname.js
var init_getResolvedHostname = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getResolvedHostname.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getResolvedPartition.js
var init_getResolvedPartition = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getResolvedPartition.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getResolvedSigningRegion.js
var init_getResolvedSigningRegion = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getResolvedSigningRegion.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getRegionInfo.js
var init_getRegionInfo = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/getRegionInfo.js"() {
    "use strict";
    init_getHostnameFromVariants();
    init_getResolvedHostname();
    init_getResolvedPartition();
    init_getResolvedSigningRegion();
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/index.js
var init_regionInfo = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/regionInfo/index.js"() {
    "use strict";
    init_PartitionHash();
    init_RegionHash();
    init_getRegionInfo();
  }
});

// ../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/index.js
var init_dist_es28 = __esm({
  "../node_modules/.pnpm/@smithy+config-resolver@4.1.4/node_modules/@smithy/config-resolver/dist-es/index.js"() {
    "use strict";
    init_endpointsConfig();
    init_regionConfig();
    init_regionInfo();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-content-length@4.0.4/node_modules/@smithy/middleware-content-length/dist-es/index.js
function contentLengthMiddleware(bodyLengthChecker) {
  return (next) => async (args2) => {
    const request2 = args2.request;
    if (HttpRequest.isInstance(request2)) {
      const { body: body2, headers } = request2;
      if (body2 && Object.keys(headers).map((str) => str.toLowerCase()).indexOf(CONTENT_LENGTH_HEADER) === -1) {
        try {
          const length = bodyLengthChecker(body2);
          request2.headers = {
            ...request2.headers,
            [CONTENT_LENGTH_HEADER]: String(length)
          };
        } catch (error2) {
        }
      }
    }
    return next({
      ...args2,
      request: request2
    });
  };
}
var CONTENT_LENGTH_HEADER, contentLengthMiddlewareOptions, getContentLengthPlugin;
var init_dist_es29 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-content-length@4.0.4/node_modules/@smithy/middleware-content-length/dist-es/index.js"() {
    "use strict";
    init_dist_es2();
    CONTENT_LENGTH_HEADER = "content-length";
    contentLengthMiddlewareOptions = {
      step: "build",
      tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"],
      name: "contentLengthMiddleware",
      override: true
    };
    getContentLengthPlugin = (options) => ({
      applyToStack: (clientStack) => {
        clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/s3.js
var resolveParamsForS3, DOMAIN_PATTERN, IP_ADDRESS_PATTERN, DOTS_PATTERN, isDnsCompatibleBucketName, isArnBucketName;
var init_s3 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/s3.js"() {
    "use strict";
    resolveParamsForS3 = async (endpointParams) => {
      const bucket = endpointParams?.Bucket || "";
      if (typeof endpointParams.Bucket === "string") {
        endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
      }
      if (isArnBucketName(bucket)) {
        if (endpointParams.ForcePathStyle === true) {
          throw new Error("Path-style addressing cannot be used with ARN buckets");
        }
      } else if (!isDnsCompatibleBucketName(bucket) || bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:") || bucket.toLowerCase() !== bucket || bucket.length < 3) {
        endpointParams.ForcePathStyle = true;
      }
      if (endpointParams.DisableMultiRegionAccessPoints) {
        endpointParams.disableMultiRegionAccessPoints = true;
        endpointParams.DisableMRAP = true;
      }
      return endpointParams;
    };
    DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/;
    IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
    DOTS_PATTERN = /\.\./;
    isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
    isArnBucketName = (bucketName) => {
      const [arn, partition2, service, , , bucket] = bucketName.split(":");
      const isArn = arn === "arn" && bucketName.split(":").length >= 6;
      const isValidArn = Boolean(isArn && partition2 && service && bucket);
      if (isArn && !isValidArn) {
        throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
      }
      return isValidArn;
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/index.js
var init_service_customizations = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/service-customizations/index.js"() {
    "use strict";
    init_s3();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/createConfigValueProvider.js
var createConfigValueProvider;
var init_createConfigValueProvider = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/createConfigValueProvider.js"() {
    "use strict";
    createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => {
      const configProvider = async () => {
        const configValue = config[configKey] ?? config[canonicalEndpointParamKey];
        if (typeof configValue === "function") {
          return configValue();
        }
        return configValue;
      };
      if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
        return async () => {
          const credentials2 = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
          const configValue = credentials2?.credentialScope ?? credentials2?.CredentialScope;
          return configValue;
        };
      }
      if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
        return async () => {
          const credentials2 = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
          const configValue = credentials2?.accountId ?? credentials2?.AccountId;
          return configValue;
        };
      }
      if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
        return async () => {
          const endpoint = await configProvider();
          if (endpoint && typeof endpoint === "object") {
            if ("url" in endpoint) {
              return endpoint.url.href;
            }
            if ("hostname" in endpoint) {
              const { protocol: protocol2, hostname, port, path: path3 } = endpoint;
              return `${protocol2}//${hostname}${port ? ":" + port : ""}${path3}`;
            }
          }
          return endpoint;
        };
      }
      return configProvider;
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/getSelectorName.js
function getSelectorName(functionString) {
  try {
    const constants = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
    constants.delete("CONFIG");
    constants.delete("CONFIG_PREFIX_SEPARATOR");
    constants.delete("ENV");
    return [...constants].join(", ");
  } catch (e6) {
    return functionString;
  }
}
var init_getSelectorName = __esm({
  "../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/getSelectorName.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/fromEnv.js
var fromEnv;
var init_fromEnv = __esm({
  "../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/fromEnv.js"() {
    "use strict";
    init_dist_es21();
    init_getSelectorName();
    fromEnv = (envVarSelector, options) => async () => {
      try {
        const config = envVarSelector(process.env, options);
        if (config === void 0) {
          throw new Error();
        }
        return config;
      } catch (e6) {
        throw new CredentialsProviderError(e6.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger: options?.logger });
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getHomeDir.js
var import_os, import_path3, homeDirCache, getHomeDirCacheKey, getHomeDir;
var init_getHomeDir = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getHomeDir.js"() {
    "use strict";
    import_os = require("os");
    import_path3 = require("path");
    homeDirCache = {};
    getHomeDirCacheKey = () => {
      if (process && process.geteuid) {
        return `${process.geteuid()}`;
      }
      return "DEFAULT";
    };
    getHomeDir = () => {
      const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${import_path3.sep}` } = process.env;
      if (HOME)
        return HOME;
      if (USERPROFILE)
        return USERPROFILE;
      if (HOMEPATH)
        return `${HOMEDRIVE}${HOMEPATH}`;
      const homeDirCacheKey = getHomeDirCacheKey();
      if (!homeDirCache[homeDirCacheKey])
        homeDirCache[homeDirCacheKey] = (0, import_os.homedir)();
      return homeDirCache[homeDirCacheKey];
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getProfileName.js
var ENV_PROFILE, DEFAULT_PROFILE, getProfileName;
var init_getProfileName = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getProfileName.js"() {
    "use strict";
    ENV_PROFILE = "AWS_PROFILE";
    DEFAULT_PROFILE = "default";
    getProfileName = (init3) => init3.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getSSOTokenFilepath.js
var import_crypto3, import_path4, getSSOTokenFilepath;
var init_getSSOTokenFilepath = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getSSOTokenFilepath.js"() {
    "use strict";
    import_crypto3 = require("crypto");
    import_path4 = require("path");
    init_getHomeDir();
    getSSOTokenFilepath = (id) => {
      const hasher = (0, import_crypto3.createHash)("sha1");
      const cacheName = hasher.update(id).digest("hex");
      return (0, import_path4.join)(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getSSOTokenFromFile.js
var import_fs3, readFile2, getSSOTokenFromFile;
var init_getSSOTokenFromFile = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getSSOTokenFromFile.js"() {
    "use strict";
    import_fs3 = require("fs");
    init_getSSOTokenFilepath();
    ({ readFile: readFile2 } = import_fs3.promises);
    getSSOTokenFromFile = async (id) => {
      const ssoTokenFilepath = getSSOTokenFilepath(id);
      const ssoTokenText = await readFile2(ssoTokenFilepath, "utf8");
      return JSON.parse(ssoTokenText);
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getConfigData.js
var getConfigData;
var init_getConfigData = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getConfigData.js"() {
    "use strict";
    init_dist_es();
    init_loadSharedConfigFiles();
    getConfigData = (data) => Object.entries(data).filter(([key]) => {
      const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
      if (indexOfSeparator === -1) {
        return false;
      }
      return Object.values(IniSectionType).includes(key.substring(0, indexOfSeparator));
    }).reduce((acc, [key, value]) => {
      const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
      const updatedKey = key.substring(0, indexOfSeparator) === IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
      acc[updatedKey] = value;
      return acc;
    }, {
      ...data.default && { default: data.default }
    });
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getConfigFilepath.js
var import_path5, ENV_CONFIG_PATH, getConfigFilepath;
var init_getConfigFilepath = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getConfigFilepath.js"() {
    "use strict";
    import_path5 = require("path");
    init_getHomeDir();
    ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
    getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || (0, import_path5.join)(getHomeDir(), ".aws", "config");
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getCredentialsFilepath.js
var import_path6, ENV_CREDENTIALS_PATH, getCredentialsFilepath;
var init_getCredentialsFilepath = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getCredentialsFilepath.js"() {
    "use strict";
    import_path6 = require("path");
    init_getHomeDir();
    ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
    getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || (0, import_path6.join)(getHomeDir(), ".aws", "credentials");
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/parseIni.js
var prefixKeyRegex, profileNameBlockList, parseIni;
var init_parseIni = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/parseIni.js"() {
    "use strict";
    init_dist_es();
    init_loadSharedConfigFiles();
    prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@\+\.%:/]+)\2$/;
    profileNameBlockList = ["__proto__", "profile __proto__"];
    parseIni = (iniData) => {
      const map2 = {};
      let currentSection;
      let currentSubSection;
      for (const iniLine of iniData.split(/\r?\n/)) {
        const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim();
        const isSection = trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
        if (isSection) {
          currentSection = void 0;
          currentSubSection = void 0;
          const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
          const matches = prefixKeyRegex.exec(sectionName);
          if (matches) {
            const [, prefix2, , name3] = matches;
            if (Object.values(IniSectionType).includes(prefix2)) {
              currentSection = [prefix2, name3].join(CONFIG_PREFIX_SEPARATOR);
            }
          } else {
            currentSection = sectionName;
          }
          if (profileNameBlockList.includes(sectionName)) {
            throw new Error(`Found invalid profile name "${sectionName}"`);
          }
        } else if (currentSection) {
          const indexOfEqualsSign = trimmedLine.indexOf("=");
          if (![0, -1].includes(indexOfEqualsSign)) {
            const [name3, value] = [
              trimmedLine.substring(0, indexOfEqualsSign).trim(),
              trimmedLine.substring(indexOfEqualsSign + 1).trim()
            ];
            if (value === "") {
              currentSubSection = name3;
            } else {
              if (currentSubSection && iniLine.trimStart() === iniLine) {
                currentSubSection = void 0;
              }
              map2[currentSection] = map2[currentSection] || {};
              const key = currentSubSection ? [currentSubSection, name3].join(CONFIG_PREFIX_SEPARATOR) : name3;
              map2[currentSection][key] = value;
            }
          }
        }
      }
      return map2;
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/slurpFile.js
var import_fs4, readFile3, filePromisesHash, slurpFile;
var init_slurpFile = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/slurpFile.js"() {
    "use strict";
    import_fs4 = require("fs");
    ({ readFile: readFile3 } = import_fs4.promises);
    filePromisesHash = {};
    slurpFile = (path3, options) => {
      if (!filePromisesHash[path3] || options?.ignoreCache) {
        filePromisesHash[path3] = readFile3(path3, "utf8");
      }
      return filePromisesHash[path3];
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/loadSharedConfigFiles.js
var import_path7, swallowError, CONFIG_PREFIX_SEPARATOR, loadSharedConfigFiles;
var init_loadSharedConfigFiles = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/loadSharedConfigFiles.js"() {
    "use strict";
    import_path7 = require("path");
    init_getConfigData();
    init_getConfigFilepath();
    init_getCredentialsFilepath();
    init_getHomeDir();
    init_parseIni();
    init_slurpFile();
    swallowError = () => ({});
    CONFIG_PREFIX_SEPARATOR = ".";
    loadSharedConfigFiles = async (init3 = {}) => {
      const { filepath = getCredentialsFilepath(), configFilepath = getConfigFilepath() } = init3;
      const homeDir = getHomeDir();
      const relativeHomeDirPrefix = "~/";
      let resolvedFilepath = filepath;
      if (filepath.startsWith(relativeHomeDirPrefix)) {
        resolvedFilepath = (0, import_path7.join)(homeDir, filepath.slice(2));
      }
      let resolvedConfigFilepath = configFilepath;
      if (configFilepath.startsWith(relativeHomeDirPrefix)) {
        resolvedConfigFilepath = (0, import_path7.join)(homeDir, configFilepath.slice(2));
      }
      const parsedFiles = await Promise.all([
        slurpFile(resolvedConfigFilepath, {
          ignoreCache: init3.ignoreCache
        }).then(parseIni).then(getConfigData).catch(swallowError),
        slurpFile(resolvedFilepath, {
          ignoreCache: init3.ignoreCache
        }).then(parseIni).catch(swallowError)
      ]);
      return {
        configFile: parsedFiles[0],
        credentialsFile: parsedFiles[1]
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getSsoSessionData.js
var getSsoSessionData;
var init_getSsoSessionData = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/getSsoSessionData.js"() {
    "use strict";
    init_dist_es();
    init_loadSharedConfigFiles();
    getSsoSessionData = (data) => Object.entries(data).filter(([key]) => key.startsWith(IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/loadSsoSessionData.js
var swallowError2, loadSsoSessionData;
var init_loadSsoSessionData = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/loadSsoSessionData.js"() {
    "use strict";
    init_getConfigFilepath();
    init_getSsoSessionData();
    init_parseIni();
    init_slurpFile();
    swallowError2 = () => ({});
    loadSsoSessionData = async (init3 = {}) => slurpFile(init3.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError2);
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/mergeConfigFiles.js
var mergeConfigFiles;
var init_mergeConfigFiles = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/mergeConfigFiles.js"() {
    "use strict";
    mergeConfigFiles = (...files) => {
      const merged = {};
      for (const file of files) {
        for (const [key, values2] of Object.entries(file)) {
          if (merged[key] !== void 0) {
            Object.assign(merged[key], values2);
          } else {
            merged[key] = values2;
          }
        }
      }
      return merged;
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/parseKnownFiles.js
var parseKnownFiles;
var init_parseKnownFiles = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/parseKnownFiles.js"() {
    "use strict";
    init_loadSharedConfigFiles();
    init_mergeConfigFiles();
    parseKnownFiles = async (init3) => {
      const parsedFiles = await loadSharedConfigFiles(init3);
      return mergeConfigFiles(parsedFiles.configFile, parsedFiles.credentialsFile);
    };
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/types.js
var init_types6 = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/index.js
var init_dist_es30 = __esm({
  "../node_modules/.pnpm/@smithy+shared-ini-file-loader@4.0.4/node_modules/@smithy/shared-ini-file-loader/dist-es/index.js"() {
    "use strict";
    init_getHomeDir();
    init_getProfileName();
    init_getSSOTokenFilepath();
    init_getSSOTokenFromFile();
    init_loadSharedConfigFiles();
    init_loadSsoSessionData();
    init_parseKnownFiles();
    init_types6();
  }
});

// ../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/fromSharedConfigFiles.js
var fromSharedConfigFiles;
var init_fromSharedConfigFiles = __esm({
  "../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/fromSharedConfigFiles.js"() {
    "use strict";
    init_dist_es21();
    init_dist_es30();
    init_getSelectorName();
    fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init3 } = {}) => async () => {
      const profile = getProfileName(init3);
      const { configFile, credentialsFile } = await loadSharedConfigFiles(init3);
      const profileFromCredentials = credentialsFile[profile] || {};
      const profileFromConfig = configFile[profile] || {};
      const mergedProfile = preferredFile === "config" ? { ...profileFromCredentials, ...profileFromConfig } : { ...profileFromConfig, ...profileFromCredentials };
      try {
        const cfgFile = preferredFile === "config" ? configFile : credentialsFile;
        const configValue = configSelector(mergedProfile, cfgFile);
        if (configValue === void 0) {
          throw new Error();
        }
        return configValue;
      } catch (e6) {
        throw new CredentialsProviderError(e6.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init3.logger });
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/fromStatic.js
var isFunction, fromStatic2;
var init_fromStatic2 = __esm({
  "../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/fromStatic.js"() {
    "use strict";
    init_dist_es21();
    isFunction = (func2) => typeof func2 === "function";
    fromStatic2 = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : fromStatic(defaultValue);
  }
});

// ../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/configLoader.js
var loadConfig;
var init_configLoader = __esm({
  "../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/configLoader.js"() {
    "use strict";
    init_dist_es21();
    init_fromEnv();
    init_fromSharedConfigFiles();
    init_fromStatic2();
    loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
      const { signingName, logger: logger2 } = configuration;
      const envOptions = { signingName, logger: logger2 };
      return memoize(chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic2(defaultValue)));
    };
  }
});

// ../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/index.js
var init_dist_es31 = __esm({
  "../node_modules/.pnpm/@smithy+node-config-provider@4.1.3/node_modules/@smithy/node-config-provider/dist-es/index.js"() {
    "use strict";
    init_configLoader();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointUrlConfig.js
var ENV_ENDPOINT_URL, CONFIG_ENDPOINT_URL, getEndpointUrlConfig;
var init_getEndpointUrlConfig = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointUrlConfig.js"() {
    "use strict";
    init_dist_es30();
    ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
    CONFIG_ENDPOINT_URL = "endpoint_url";
    getEndpointUrlConfig = (serviceId) => ({
      environmentVariableSelector: (env4) => {
        const serviceSuffixParts = serviceId.split(" ").map((w10) => w10.toUpperCase());
        const serviceEndpointUrl = env4[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")];
        if (serviceEndpointUrl)
          return serviceEndpointUrl;
        const endpointUrl = env4[ENV_ENDPOINT_URL];
        if (endpointUrl)
          return endpointUrl;
        return void 0;
      },
      configFileSelector: (profile, config) => {
        if (config && profile.services) {
          const servicesSection = config[["services", profile.services].join(CONFIG_PREFIX_SEPARATOR)];
          if (servicesSection) {
            const servicePrefixParts = serviceId.split(" ").map((w10) => w10.toLowerCase());
            const endpointUrl2 = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(CONFIG_PREFIX_SEPARATOR)];
            if (endpointUrl2)
              return endpointUrl2;
          }
        }
        const endpointUrl = profile[CONFIG_ENDPOINT_URL];
        if (endpointUrl)
          return endpointUrl;
        return void 0;
      },
      default: void 0
    });
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.js
var getEndpointFromConfig;
var init_getEndpointFromConfig = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromConfig.js"() {
    "use strict";
    init_dist_es31();
    init_getEndpointUrlConfig();
    getEndpointFromConfig = async (serviceId) => loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
  }
});

// ../node_modules/.pnpm/@smithy+querystring-parser@4.0.4/node_modules/@smithy/querystring-parser/dist-es/index.js
function parseQueryString(querystring) {
  const query = {};
  querystring = querystring.replace(/^\?/, "");
  if (querystring) {
    for (const pair of querystring.split("&")) {
      let [key, value = null] = pair.split("=");
      key = decodeURIComponent(key);
      if (value) {
        value = decodeURIComponent(value);
      }
      if (!(key in query)) {
        query[key] = value;
      } else if (Array.isArray(query[key])) {
        query[key].push(value);
      } else {
        query[key] = [query[key], value];
      }
    }
  }
  return query;
}
var init_dist_es32 = __esm({
  "../node_modules/.pnpm/@smithy+querystring-parser@4.0.4/node_modules/@smithy/querystring-parser/dist-es/index.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+url-parser@4.0.4/node_modules/@smithy/url-parser/dist-es/index.js
var parseUrl;
var init_dist_es33 = __esm({
  "../node_modules/.pnpm/@smithy+url-parser@4.0.4/node_modules/@smithy/url-parser/dist-es/index.js"() {
    "use strict";
    init_dist_es32();
    parseUrl = (url) => {
      if (typeof url === "string") {
        return parseUrl(new URL(url));
      }
      const { hostname, pathname, port, protocol: protocol2, search } = url;
      let query;
      if (search) {
        query = parseQueryString(search);
      }
      return {
        hostname,
        port: port ? parseInt(port) : void 0,
        protocol: protocol2,
        path: pathname,
        query
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/toEndpointV1.js
var toEndpointV1;
var init_toEndpointV1 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/toEndpointV1.js"() {
    "use strict";
    init_dist_es33();
    toEndpointV1 = (endpoint) => {
      if (typeof endpoint === "object") {
        if ("url" in endpoint) {
          return parseUrl(endpoint.url);
        }
        return endpoint;
      }
      return parseUrl(endpoint);
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromInstructions.js
var getEndpointFromInstructions, resolveParams;
var init_getEndpointFromInstructions = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/getEndpointFromInstructions.js"() {
    "use strict";
    init_service_customizations();
    init_createConfigValueProvider();
    init_getEndpointFromConfig();
    init_toEndpointV1();
    getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => {
      if (!clientConfig.endpoint) {
        let endpointFromConfig;
        if (clientConfig.serviceConfiguredEndpoint) {
          endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
        } else {
          endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId);
        }
        if (endpointFromConfig) {
          clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
        }
      }
      const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
      if (typeof clientConfig.endpointProvider !== "function") {
        throw new Error("config.endpointProvider is not set.");
      }
      const endpoint = clientConfig.endpointProvider(endpointParams, context);
      return endpoint;
    };
    resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
      const endpointParams = {};
      const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
      for (const [name3, instruction] of Object.entries(instructions)) {
        switch (instruction.type) {
          case "staticContextParams":
            endpointParams[name3] = instruction.value;
            break;
          case "contextParams":
            endpointParams[name3] = commandInput[instruction.name];
            break;
          case "clientContextParams":
          case "builtInParams":
            endpointParams[name3] = await createConfigValueProvider(instruction.name, name3, clientConfig)();
            break;
          case "operationContextParams":
            endpointParams[name3] = instruction.get(commandInput);
            break;
          default:
            throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
        }
      }
      if (Object.keys(instructions).length === 0) {
        Object.assign(endpointParams, clientConfig);
      }
      if (String(clientConfig.serviceId).toLowerCase() === "s3") {
        await resolveParamsForS3(endpointParams);
      }
      return endpointParams;
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/index.js
var init_adaptors = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/adaptors/index.js"() {
    "use strict";
    init_getEndpointFromInstructions();
    init_toEndpointV1();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/endpointMiddleware.js
var endpointMiddleware;
var init_endpointMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/endpointMiddleware.js"() {
    "use strict";
    init_dist_es18();
    init_dist_es6();
    init_getEndpointFromInstructions();
    endpointMiddleware = ({ config, instructions }) => {
      return (next, context) => async (args2) => {
        if (config.endpoint) {
          setFeature(context, "ENDPOINT_OVERRIDE", "N");
        }
        const endpoint = await getEndpointFromInstructions(args2.input, {
          getEndpointParameterInstructions() {
            return instructions;
          }
        }, { ...config }, context);
        context.endpointV2 = endpoint;
        context.authSchemes = endpoint.properties?.authSchemes;
        const authScheme = context.authSchemes?.[0];
        if (authScheme) {
          context["signing_region"] = authScheme.signingRegion;
          context["signing_service"] = authScheme.signingName;
          const smithyContext = getSmithyContext(context);
          const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
          if (httpAuthOption) {
            httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
              signing_region: authScheme.signingRegion,
              signingRegion: authScheme.signingRegion,
              signing_service: authScheme.signingName,
              signingName: authScheme.signingName,
              signingRegionSet: authScheme.signingRegionSet
            }, authScheme.properties);
          }
        }
        return next({
          ...args2
        });
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/getEndpointPlugin.js
var endpointMiddlewareOptions, getEndpointPlugin;
var init_getEndpointPlugin = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/getEndpointPlugin.js"() {
    "use strict";
    init_dist_es7();
    init_endpointMiddleware();
    endpointMiddlewareOptions = {
      step: "serialize",
      tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
      name: "endpointV2Middleware",
      override: true,
      relation: "before",
      toMiddleware: serializerMiddlewareOption.name
    };
    getEndpointPlugin = (config, instructions) => ({
      applyToStack: (clientStack) => {
        clientStack.addRelativeTo(endpointMiddleware({
          config,
          instructions
        }), endpointMiddlewareOptions);
      }
    });
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/resolveEndpointConfig.js
var resolveEndpointConfig;
var init_resolveEndpointConfig = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/resolveEndpointConfig.js"() {
    "use strict";
    init_dist_es6();
    init_getEndpointFromConfig();
    init_toEndpointV1();
    resolveEndpointConfig = (input) => {
      const tls2 = input.tls ?? true;
      const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
      const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await normalizeProvider(endpoint)()) : void 0;
      const isCustomEndpoint = !!endpoint;
      const resolvedConfig = Object.assign(input, {
        endpoint: customEndpointProvider,
        tls: tls2,
        isCustomEndpoint,
        useDualstackEndpoint: normalizeProvider(useDualstackEndpoint ?? false),
        useFipsEndpoint: normalizeProvider(useFipsEndpoint ?? false)
      });
      let configuredEndpointPromise = void 0;
      resolvedConfig.serviceConfiguredEndpoint = async () => {
        if (input.serviceId && !configuredEndpointPromise) {
          configuredEndpointPromise = getEndpointFromConfig(input.serviceId);
        }
        return configuredEndpointPromise;
      };
      return resolvedConfig;
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/types.js
var init_types7 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/index.js
var init_dist_es34 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-endpoint@4.1.9/node_modules/@smithy/middleware-endpoint/dist-es/index.js"() {
    "use strict";
    init_adaptors();
    init_endpointMiddleware();
    init_getEndpointPlugin();
    init_resolveEndpointConfig();
    init_types7();
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/config.js
var RETRY_MODES, DEFAULT_MAX_ATTEMPTS, DEFAULT_RETRY_MODE;
var init_config3 = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/config.js"() {
    "use strict";
    (function(RETRY_MODES2) {
      RETRY_MODES2["STANDARD"] = "standard";
      RETRY_MODES2["ADAPTIVE"] = "adaptive";
    })(RETRY_MODES || (RETRY_MODES = {}));
    DEFAULT_MAX_ATTEMPTS = 3;
    DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
  }
});

// ../node_modules/.pnpm/@smithy+service-error-classification@4.0.5/node_modules/@smithy/service-error-classification/dist-es/constants.js
var THROTTLING_ERROR_CODES, TRANSIENT_ERROR_CODES, TRANSIENT_ERROR_STATUS_CODES, NODEJS_TIMEOUT_ERROR_CODES2;
var init_constants6 = __esm({
  "../node_modules/.pnpm/@smithy+service-error-classification@4.0.5/node_modules/@smithy/service-error-classification/dist-es/constants.js"() {
    "use strict";
    THROTTLING_ERROR_CODES = [
      "BandwidthLimitExceeded",
      "EC2ThrottledException",
      "LimitExceededException",
      "PriorRequestNotComplete",
      "ProvisionedThroughputExceededException",
      "RequestLimitExceeded",
      "RequestThrottled",
      "RequestThrottledException",
      "SlowDown",
      "ThrottledException",
      "Throttling",
      "ThrottlingException",
      "TooManyRequestsException",
      "TransactionInProgressException"
    ];
    TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
    TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
    NODEJS_TIMEOUT_ERROR_CODES2 = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
  }
});

// ../node_modules/.pnpm/@smithy+service-error-classification@4.0.5/node_modules/@smithy/service-error-classification/dist-es/index.js
var isClockSkewCorrectedError, isBrowserNetworkError, isThrottlingError, isTransientError, isServerError;
var init_dist_es35 = __esm({
  "../node_modules/.pnpm/@smithy+service-error-classification@4.0.5/node_modules/@smithy/service-error-classification/dist-es/index.js"() {
    "use strict";
    init_constants6();
    isClockSkewCorrectedError = (error2) => error2.$metadata?.clockSkewCorrected;
    isBrowserNetworkError = (error2) => {
      const errorMessages = /* @__PURE__ */ new Set([
        "Failed to fetch",
        "NetworkError when attempting to fetch resource",
        "The Internet connection appears to be offline",
        "Load failed",
        "Network request failed"
      ]);
      const isValid3 = error2 && error2 instanceof TypeError;
      if (!isValid3) {
        return false;
      }
      return errorMessages.has(error2.message);
    };
    isThrottlingError = (error2) => error2.$metadata?.httpStatusCode === 429 || THROTTLING_ERROR_CODES.includes(error2.name) || error2.$retryable?.throttling == true;
    isTransientError = (error2, depth = 0) => isClockSkewCorrectedError(error2) || TRANSIENT_ERROR_CODES.includes(error2.name) || NODEJS_TIMEOUT_ERROR_CODES2.includes(error2?.code || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error2.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error2) || error2.cause !== void 0 && depth <= 10 && isTransientError(error2.cause, depth + 1);
    isServerError = (error2) => {
      if (error2.$metadata?.httpStatusCode !== void 0) {
        const statusCode = error2.$metadata.httpStatusCode;
        if (500 <= statusCode && statusCode <= 599 && !isTransientError(error2)) {
          return true;
        }
        return false;
      }
      return false;
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js
var DefaultRateLimiter;
var init_DefaultRateLimiter = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/DefaultRateLimiter.js"() {
    "use strict";
    init_dist_es35();
    DefaultRateLimiter = class _DefaultRateLimiter {
      constructor(options) {
        this.currentCapacity = 0;
        this.enabled = false;
        this.lastMaxRate = 0;
        this.measuredTxRate = 0;
        this.requestCount = 0;
        this.lastTimestamp = 0;
        this.timeWindow = 0;
        this.beta = options?.beta ?? 0.7;
        this.minCapacity = options?.minCapacity ?? 1;
        this.minFillRate = options?.minFillRate ?? 0.5;
        this.scaleConstant = options?.scaleConstant ?? 0.4;
        this.smooth = options?.smooth ?? 0.8;
        const currentTimeInSeconds = this.getCurrentTimeInSeconds();
        this.lastThrottleTime = currentTimeInSeconds;
        this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
        this.fillRate = this.minFillRate;
        this.maxCapacity = this.minCapacity;
      }
      getCurrentTimeInSeconds() {
        return Date.now() / 1e3;
      }
      async getSendToken() {
        return this.acquireTokenBucket(1);
      }
      async acquireTokenBucket(amount) {
        if (!this.enabled) {
          return;
        }
        this.refillTokenBucket();
        if (amount > this.currentCapacity) {
          const delay = (amount - this.currentCapacity) / this.fillRate * 1e3;
          await new Promise((resolve2) => _DefaultRateLimiter.setTimeoutFn(resolve2, delay));
        }
        this.currentCapacity = this.currentCapacity - amount;
      }
      refillTokenBucket() {
        const timestamp4 = this.getCurrentTimeInSeconds();
        if (!this.lastTimestamp) {
          this.lastTimestamp = timestamp4;
          return;
        }
        const fillAmount = (timestamp4 - this.lastTimestamp) * this.fillRate;
        this.currentCapacity = Math.min(this.maxCapacity, this.currentCapacity + fillAmount);
        this.lastTimestamp = timestamp4;
      }
      updateClientSendingRate(response) {
        let calculatedRate;
        this.updateMeasuredRate();
        if (isThrottlingError(response)) {
          const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
          this.lastMaxRate = rateToUse;
          this.calculateTimeWindow();
          this.lastThrottleTime = this.getCurrentTimeInSeconds();
          calculatedRate = this.cubicThrottle(rateToUse);
          this.enableTokenBucket();
        } else {
          this.calculateTimeWindow();
          calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
        }
        const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
        this.updateTokenBucketRate(newRate);
      }
      calculateTimeWindow() {
        this.timeWindow = this.getPrecise(Math.pow(this.lastMaxRate * (1 - this.beta) / this.scaleConstant, 1 / 3));
      }
      cubicThrottle(rateToUse) {
        return this.getPrecise(rateToUse * this.beta);
      }
      cubicSuccess(timestamp4) {
        return this.getPrecise(this.scaleConstant * Math.pow(timestamp4 - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
      }
      enableTokenBucket() {
        this.enabled = true;
      }
      updateTokenBucketRate(newRate) {
        this.refillTokenBucket();
        this.fillRate = Math.max(newRate, this.minFillRate);
        this.maxCapacity = Math.max(newRate, this.minCapacity);
        this.currentCapacity = Math.min(this.currentCapacity, this.maxCapacity);
      }
      updateMeasuredRate() {
        const t6 = this.getCurrentTimeInSeconds();
        const timeBucket = Math.floor(t6 * 2) / 2;
        this.requestCount++;
        if (timeBucket > this.lastTxRateBucket) {
          const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
          this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
          this.requestCount = 0;
          this.lastTxRateBucket = timeBucket;
        }
      }
      getPrecise(num) {
        return parseFloat(num.toFixed(8));
      }
    };
    DefaultRateLimiter.setTimeoutFn = setTimeout;
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/constants.js
var DEFAULT_RETRY_DELAY_BASE, MAXIMUM_RETRY_DELAY, THROTTLING_RETRY_DELAY_BASE, INITIAL_RETRY_TOKENS, RETRY_COST, TIMEOUT_RETRY_COST, NO_RETRY_INCREMENT, INVOCATION_ID_HEADER, REQUEST_HEADER;
var init_constants7 = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/constants.js"() {
    "use strict";
    DEFAULT_RETRY_DELAY_BASE = 100;
    MAXIMUM_RETRY_DELAY = 20 * 1e3;
    THROTTLING_RETRY_DELAY_BASE = 500;
    INITIAL_RETRY_TOKENS = 500;
    RETRY_COST = 5;
    TIMEOUT_RETRY_COST = 10;
    NO_RETRY_INCREMENT = 1;
    INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
    REQUEST_HEADER = "amz-sdk-request";
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js
var getDefaultRetryBackoffStrategy;
var init_defaultRetryBackoffStrategy = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/defaultRetryBackoffStrategy.js"() {
    "use strict";
    init_constants7();
    getDefaultRetryBackoffStrategy = () => {
      let delayBase = DEFAULT_RETRY_DELAY_BASE;
      const computeNextBackoffDelay = (attempts) => {
        return Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
      };
      const setDelayBase = (delay) => {
        delayBase = delay;
      };
      return {
        computeNextBackoffDelay,
        setDelayBase
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/defaultRetryToken.js
var createDefaultRetryToken;
var init_defaultRetryToken = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/defaultRetryToken.js"() {
    "use strict";
    init_constants7();
    createDefaultRetryToken = ({ retryDelay, retryCount, retryCost }) => {
      const getRetryCount = () => retryCount;
      const getRetryDelay = () => Math.min(MAXIMUM_RETRY_DELAY, retryDelay);
      const getRetryCost = () => retryCost;
      return {
        getRetryCount,
        getRetryDelay,
        getRetryCost
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js
var StandardRetryStrategy;
var init_StandardRetryStrategy = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/StandardRetryStrategy.js"() {
    "use strict";
    init_config3();
    init_constants7();
    init_defaultRetryBackoffStrategy();
    init_defaultRetryToken();
    StandardRetryStrategy = class {
      constructor(maxAttempts) {
        this.maxAttempts = maxAttempts;
        this.mode = RETRY_MODES.STANDARD;
        this.capacity = INITIAL_RETRY_TOKENS;
        this.retryBackoffStrategy = getDefaultRetryBackoffStrategy();
        this.maxAttemptsProvider = typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts;
      }
      async acquireInitialRetryToken(retryTokenScope) {
        return createDefaultRetryToken({
          retryDelay: DEFAULT_RETRY_DELAY_BASE,
          retryCount: 0
        });
      }
      async refreshRetryTokenForRetry(token, errorInfo) {
        const maxAttempts = await this.getMaxAttempts();
        if (this.shouldRetry(token, errorInfo, maxAttempts)) {
          const errorType = errorInfo.errorType;
          this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE);
          const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
          const retryDelay = errorInfo.retryAfterHint ? Math.max(errorInfo.retryAfterHint.getTime() - Date.now() || 0, delayFromErrorType) : delayFromErrorType;
          const capacityCost = this.getCapacityCost(errorType);
          this.capacity -= capacityCost;
          return createDefaultRetryToken({
            retryDelay,
            retryCount: token.getRetryCount() + 1,
            retryCost: capacityCost
          });
        }
        throw new Error("No retry token available");
      }
      recordSuccess(token) {
        this.capacity = Math.max(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
      }
      getCapacity() {
        return this.capacity;
      }
      async getMaxAttempts() {
        try {
          return await this.maxAttemptsProvider();
        } catch (error2) {
          console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
          return DEFAULT_MAX_ATTEMPTS;
        }
      }
      shouldRetry(tokenToRenew, errorInfo, maxAttempts) {
        const attempts = tokenToRenew.getRetryCount() + 1;
        return attempts < maxAttempts && this.capacity >= this.getCapacityCost(errorInfo.errorType) && this.isRetryableError(errorInfo.errorType);
      }
      getCapacityCost(errorType) {
        return errorType === "TRANSIENT" ? TIMEOUT_RETRY_COST : RETRY_COST;
      }
      isRetryableError(errorType) {
        return errorType === "THROTTLING" || errorType === "TRANSIENT";
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js
var AdaptiveRetryStrategy;
var init_AdaptiveRetryStrategy = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/AdaptiveRetryStrategy.js"() {
    "use strict";
    init_config3();
    init_DefaultRateLimiter();
    init_StandardRetryStrategy();
    AdaptiveRetryStrategy = class {
      constructor(maxAttemptsProvider, options) {
        this.maxAttemptsProvider = maxAttemptsProvider;
        this.mode = RETRY_MODES.ADAPTIVE;
        const { rateLimiter } = options ?? {};
        this.rateLimiter = rateLimiter ?? new DefaultRateLimiter();
        this.standardRetryStrategy = new StandardRetryStrategy(maxAttemptsProvider);
      }
      async acquireInitialRetryToken(retryTokenScope) {
        await this.rateLimiter.getSendToken();
        return this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
      }
      async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
        this.rateLimiter.updateClientSendingRate(errorInfo);
        return this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
      }
      recordSuccess(token) {
        this.rateLimiter.updateClientSendingRate({});
        this.standardRetryStrategy.recordSuccess(token);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/ConfiguredRetryStrategy.js
var init_ConfiguredRetryStrategy = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/ConfiguredRetryStrategy.js"() {
    "use strict";
    init_constants7();
    init_StandardRetryStrategy();
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/types.js
var init_types8 = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/index.js
var init_dist_es36 = __esm({
  "../node_modules/.pnpm/@smithy+util-retry@4.0.5/node_modules/@smithy/util-retry/dist-es/index.js"() {
    "use strict";
    init_AdaptiveRetryStrategy();
    init_ConfiguredRetryStrategy();
    init_DefaultRateLimiter();
    init_StandardRetryStrategy();
    init_config3();
    init_constants7();
    init_types8();
  }
});

// ../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/rng.js
function rng() {
  if (poolPtr > rnds8Pool.length - 16) {
    import_crypto4.default.randomFillSync(rnds8Pool);
    poolPtr = 0;
  }
  return rnds8Pool.slice(poolPtr, poolPtr += 16);
}
var import_crypto4, rnds8Pool, poolPtr;
var init_rng = __esm({
  "../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/rng.js"() {
    "use strict";
    import_crypto4 = __toESM(require("crypto"));
    rnds8Pool = new Uint8Array(256);
    poolPtr = rnds8Pool.length;
  }
});

// ../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/stringify.js
function unsafeStringify(arr, offset = 0) {
  return byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]];
}
var byteToHex;
var init_stringify = __esm({
  "../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/stringify.js"() {
    "use strict";
    byteToHex = [];
    for (let i8 = 0; i8 < 256; ++i8) {
      byteToHex.push((i8 + 256).toString(16).slice(1));
    }
  }
});

// ../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/native.js
var import_crypto5, native_default;
var init_native = __esm({
  "../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/native.js"() {
    "use strict";
    import_crypto5 = __toESM(require("crypto"));
    native_default = {
      randomUUID: import_crypto5.default.randomUUID
    };
  }
});

// ../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/v4.js
function v4(options, buf, offset) {
  if (native_default.randomUUID && !buf && !options) {
    return native_default.randomUUID();
  }
  options = options || {};
  const rnds = options.random || (options.rng || rng)();
  rnds[6] = rnds[6] & 15 | 64;
  rnds[8] = rnds[8] & 63 | 128;
  if (buf) {
    offset = offset || 0;
    for (let i8 = 0; i8 < 16; ++i8) {
      buf[offset + i8] = rnds[i8];
    }
    return buf;
  }
  return unsafeStringify(rnds);
}
var v4_default;
var init_v4 = __esm({
  "../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/v4.js"() {
    "use strict";
    init_native();
    init_rng();
    init_stringify();
    v4_default = v4;
  }
});

// ../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/index.js
var init_esm_node = __esm({
  "../node_modules/.pnpm/uuid@9.0.1/node_modules/uuid/dist/esm-node/index.js"() {
    "use strict";
    init_v4();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/defaultRetryQuota.js
var init_defaultRetryQuota = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/defaultRetryQuota.js"() {
    "use strict";
    init_dist_es36();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/delayDecider.js
var init_delayDecider = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/delayDecider.js"() {
    "use strict";
    init_dist_es36();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/retryDecider.js
var init_retryDecider = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/retryDecider.js"() {
    "use strict";
    init_dist_es35();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/util.js
var asSdkError;
var init_util3 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/util.js"() {
    "use strict";
    asSdkError = (error2) => {
      if (error2 instanceof Error)
        return error2;
      if (error2 instanceof Object)
        return Object.assign(new Error(), error2);
      if (typeof error2 === "string")
        return new Error(error2);
      return new Error(`AWS SDK error wrapper for ${error2}`);
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/StandardRetryStrategy.js
var init_StandardRetryStrategy2 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/StandardRetryStrategy.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es35();
    init_dist_es36();
    init_defaultRetryQuota();
    init_delayDecider();
    init_retryDecider();
    init_util3();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/AdaptiveRetryStrategy.js
var init_AdaptiveRetryStrategy2 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/AdaptiveRetryStrategy.js"() {
    "use strict";
    init_dist_es36();
    init_StandardRetryStrategy2();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/configurations.js
var ENV_MAX_ATTEMPTS, CONFIG_MAX_ATTEMPTS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, ENV_RETRY_MODE, CONFIG_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS;
var init_configurations2 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/configurations.js"() {
    "use strict";
    init_dist_es6();
    init_dist_es36();
    ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
    CONFIG_MAX_ATTEMPTS = "max_attempts";
    NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => {
        const value = env4[ENV_MAX_ATTEMPTS];
        if (!value)
          return void 0;
        const maxAttempt = parseInt(value);
        if (Number.isNaN(maxAttempt)) {
          throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
        }
        return maxAttempt;
      },
      configFileSelector: (profile) => {
        const value = profile[CONFIG_MAX_ATTEMPTS];
        if (!value)
          return void 0;
        const maxAttempt = parseInt(value);
        if (Number.isNaN(maxAttempt)) {
          throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
        }
        return maxAttempt;
      },
      default: DEFAULT_MAX_ATTEMPTS
    };
    resolveRetryConfig = (input) => {
      const { retryStrategy, retryMode: _retryMode, maxAttempts: _maxAttempts } = input;
      const maxAttempts = normalizeProvider(_maxAttempts ?? DEFAULT_MAX_ATTEMPTS);
      return Object.assign(input, {
        maxAttempts,
        retryStrategy: async () => {
          if (retryStrategy) {
            return retryStrategy;
          }
          const retryMode = await normalizeProvider(_retryMode)();
          if (retryMode === RETRY_MODES.ADAPTIVE) {
            return new AdaptiveRetryStrategy(maxAttempts);
          }
          return new StandardRetryStrategy(maxAttempts);
        }
      });
    };
    ENV_RETRY_MODE = "AWS_RETRY_MODE";
    CONFIG_RETRY_MODE = "retry_mode";
    NODE_RETRY_MODE_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => env4[ENV_RETRY_MODE],
      configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
      default: DEFAULT_RETRY_MODE
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/omitRetryHeadersMiddleware.js
var init_omitRetryHeadersMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/omitRetryHeadersMiddleware.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es36();
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/isStreamingPayload/isStreamingPayload.js
var import_stream6, isStreamingPayload;
var init_isStreamingPayload = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/isStreamingPayload/isStreamingPayload.js"() {
    "use strict";
    import_stream6 = require("stream");
    isStreamingPayload = (request2) => request2?.body instanceof import_stream6.Readable || typeof ReadableStream !== "undefined" && request2?.body instanceof ReadableStream;
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/retryMiddleware.js
var retryMiddleware, isRetryStrategyV2, getRetryErrorInfo, getRetryErrorType, retryMiddlewareOptions, getRetryPlugin, getRetryAfterHint;
var init_retryMiddleware = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/retryMiddleware.js"() {
    "use strict";
    init_dist_es2();
    init_dist_es35();
    init_dist_es24();
    init_dist_es36();
    init_esm_node();
    init_isStreamingPayload();
    init_util3();
    retryMiddleware = (options) => (next, context) => async (args2) => {
      let retryStrategy = await options.retryStrategy();
      const maxAttempts = await options.maxAttempts();
      if (isRetryStrategyV2(retryStrategy)) {
        retryStrategy = retryStrategy;
        let retryToken = await retryStrategy.acquireInitialRetryToken(context["partition_id"]);
        let lastError = new Error();
        let attempts = 0;
        let totalRetryDelay = 0;
        const { request: request2 } = args2;
        const isRequest2 = HttpRequest.isInstance(request2);
        if (isRequest2) {
          request2.headers[INVOCATION_ID_HEADER] = v4_default();
        }
        while (true) {
          try {
            if (isRequest2) {
              request2.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
            }
            const { response, output } = await next(args2);
            retryStrategy.recordSuccess(retryToken);
            output.$metadata.attempts = attempts + 1;
            output.$metadata.totalRetryDelay = totalRetryDelay;
            return { response, output };
          } catch (e6) {
            const retryErrorInfo = getRetryErrorInfo(e6);
            lastError = asSdkError(e6);
            if (isRequest2 && isStreamingPayload(request2)) {
              (context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
              throw lastError;
            }
            try {
              retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
            } catch (refreshError) {
              if (!lastError.$metadata) {
                lastError.$metadata = {};
              }
              lastError.$metadata.attempts = attempts + 1;
              lastError.$metadata.totalRetryDelay = totalRetryDelay;
              throw lastError;
            }
            attempts = retryToken.getRetryCount();
            const delay = retryToken.getRetryDelay();
            totalRetryDelay += delay;
            await new Promise((resolve2) => setTimeout(resolve2, delay));
          }
        }
      } else {
        retryStrategy = retryStrategy;
        if (retryStrategy?.mode)
          context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
        return retryStrategy.retry(next, args2);
      }
    };
    isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined";
    getRetryErrorInfo = (error2) => {
      const errorInfo = {
        error: error2,
        errorType: getRetryErrorType(error2)
      };
      const retryAfterHint = getRetryAfterHint(error2.$response);
      if (retryAfterHint) {
        errorInfo.retryAfterHint = retryAfterHint;
      }
      return errorInfo;
    };
    getRetryErrorType = (error2) => {
      if (isThrottlingError(error2))
        return "THROTTLING";
      if (isTransientError(error2))
        return "TRANSIENT";
      if (isServerError(error2))
        return "SERVER_ERROR";
      return "CLIENT_ERROR";
    };
    retryMiddlewareOptions = {
      name: "retryMiddleware",
      tags: ["RETRY"],
      step: "finalizeRequest",
      priority: "high",
      override: true
    };
    getRetryPlugin = (options) => ({
      applyToStack: (clientStack) => {
        clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
      }
    });
    getRetryAfterHint = (response) => {
      if (!HttpResponse.isInstance(response))
        return;
      const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
      if (!retryAfterHeaderName)
        return;
      const retryAfter = response.headers[retryAfterHeaderName];
      const retryAfterSeconds = Number(retryAfter);
      if (!Number.isNaN(retryAfterSeconds))
        return new Date(retryAfterSeconds * 1e3);
      const retryAfterDate = new Date(retryAfter);
      return retryAfterDate;
    };
  }
});

// ../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/index.js
var init_dist_es37 = __esm({
  "../node_modules/.pnpm/@smithy+middleware-retry@4.1.10/node_modules/@smithy/middleware-retry/dist-es/index.js"() {
    "use strict";
    init_AdaptiveRetryStrategy2();
    init_StandardRetryStrategy2();
    init_configurations2();
    init_delayDecider();
    init_omitRetryHeadersMiddleware();
    init_retryDecider();
    init_retryMiddleware();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/auth/httpAuthSchemeProvider.js
function createAwsAuthSigv4HttpAuthOption(authParameters) {
  return {
    schemeId: "aws.auth#sigv4",
    signingProperties: {
      name: "rds-data",
      region: authParameters.region
    },
    propertiesExtractor: (config, context) => ({
      signingProperties: {
        config,
        context
      }
    })
  };
}
var defaultRDSDataHttpAuthSchemeParametersProvider, defaultRDSDataHttpAuthSchemeProvider, resolveHttpAuthSchemeConfig;
var init_httpAuthSchemeProvider = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/auth/httpAuthSchemeProvider.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es6();
    defaultRDSDataHttpAuthSchemeParametersProvider = async (config, context, input) => {
      return {
        operation: getSmithyContext(context).operation,
        region: await normalizeProvider(config.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
        })()
      };
    };
    defaultRDSDataHttpAuthSchemeProvider = (authParameters) => {
      const options = [];
      switch (authParameters.operation) {
        default: {
          options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
        }
      }
      return options;
    };
    resolveHttpAuthSchemeConfig = (config) => {
      const config_0 = resolveAwsSdkSigV4Config(config);
      return Object.assign(config_0, {
        authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
      });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/endpoint/EndpointParameters.js
var resolveClientEndpointParameters, commonParams;
var init_EndpointParameters = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/endpoint/EndpointParameters.js"() {
    "use strict";
    resolveClientEndpointParameters = (options) => {
      return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "rds-data"
      });
    };
    commonParams = {
      UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
      Endpoint: { type: "builtInParams", name: "endpoint" },
      Region: { type: "builtInParams", name: "region" },
      UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/package.json
var package_default;
var init_package = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/package.json"() {
    package_default = {
      name: "@aws-sdk/client-rds-data",
      description: "AWS SDK for JavaScript Rds Data Client for Node.js, Browser and React Native",
      version: "3.817.0",
      scripts: {
        build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
        "build:cjs": "node ../../scripts/compilation/inline client-rds-data",
        "build:es": "tsc -p tsconfig.es.json",
        "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
        "build:types": "tsc -p tsconfig.types.json",
        "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
        clean: "rimraf ./dist-* && rimraf *.tsbuildinfo",
        "extract:docs": "api-extractor run --local",
        "generate:client": "node ../../scripts/generate-clients/single-service --solo rds-data"
      },
      main: "./dist-cjs/index.js",
      types: "./dist-types/index.d.ts",
      module: "./dist-es/index.js",
      sideEffects: false,
      dependencies: {
        "@aws-crypto/sha256-browser": "5.2.0",
        "@aws-crypto/sha256-js": "5.2.0",
        "@aws-sdk/core": "3.816.0",
        "@aws-sdk/credential-provider-node": "3.817.0",
        "@aws-sdk/middleware-host-header": "3.804.0",
        "@aws-sdk/middleware-logger": "3.804.0",
        "@aws-sdk/middleware-recursion-detection": "3.804.0",
        "@aws-sdk/middleware-user-agent": "3.816.0",
        "@aws-sdk/region-config-resolver": "3.808.0",
        "@aws-sdk/types": "3.804.0",
        "@aws-sdk/util-endpoints": "3.808.0",
        "@aws-sdk/util-user-agent-browser": "3.804.0",
        "@aws-sdk/util-user-agent-node": "3.816.0",
        "@smithy/config-resolver": "^4.1.2",
        "@smithy/core": "^3.3.3",
        "@smithy/fetch-http-handler": "^5.0.2",
        "@smithy/hash-node": "^4.0.2",
        "@smithy/invalid-dependency": "^4.0.2",
        "@smithy/middleware-content-length": "^4.0.2",
        "@smithy/middleware-endpoint": "^4.1.6",
        "@smithy/middleware-retry": "^4.1.7",
        "@smithy/middleware-serde": "^4.0.5",
        "@smithy/middleware-stack": "^4.0.2",
        "@smithy/node-config-provider": "^4.1.1",
        "@smithy/node-http-handler": "^4.0.4",
        "@smithy/protocol-http": "^5.1.0",
        "@smithy/smithy-client": "^4.2.6",
        "@smithy/types": "^4.2.0",
        "@smithy/url-parser": "^4.0.2",
        "@smithy/util-base64": "^4.0.0",
        "@smithy/util-body-length-browser": "^4.0.0",
        "@smithy/util-body-length-node": "^4.0.0",
        "@smithy/util-defaults-mode-browser": "^4.0.14",
        "@smithy/util-defaults-mode-node": "^4.0.14",
        "@smithy/util-endpoints": "^3.0.4",
        "@smithy/util-middleware": "^4.0.2",
        "@smithy/util-retry": "^4.0.3",
        "@smithy/util-utf8": "^4.0.0",
        tslib: "^2.6.2"
      },
      devDependencies: {
        "@tsconfig/node18": "18.2.4",
        "@types/node": "^18.19.69",
        concurrently: "7.0.0",
        "downlevel-dts": "0.10.1",
        rimraf: "3.0.2",
        typescript: "~5.8.3"
      },
      engines: {
        node: ">=18.0.0"
      },
      typesVersions: {
        "<4.0": {
          "dist-types/*": [
            "dist-types/ts3.4/*"
          ]
        }
      },
      files: [
        "dist-*/**"
      ],
      author: {
        name: "AWS SDK for JavaScript Team",
        url: "https://aws.amazon.com/javascript/"
      },
      license: "Apache-2.0",
      browser: {
        "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
      },
      "react-native": {
        "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
      },
      homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-rds-data",
      repository: {
        type: "git",
        url: "https://github.com/aws/aws-sdk-js-v3.git",
        directory: "clients/client-rds-data"
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-env@3.816.0/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
var ENV_KEY, ENV_SECRET, ENV_SESSION, ENV_EXPIRATION, ENV_CREDENTIAL_SCOPE, ENV_ACCOUNT_ID, fromEnv2;
var init_fromEnv2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-env@3.816.0/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js"() {
    "use strict";
    init_client2();
    init_dist_es21();
    ENV_KEY = "AWS_ACCESS_KEY_ID";
    ENV_SECRET = "AWS_SECRET_ACCESS_KEY";
    ENV_SESSION = "AWS_SESSION_TOKEN";
    ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION";
    ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE";
    ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID";
    fromEnv2 = (init3) => async () => {
      init3?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
      const accessKeyId = process.env[ENV_KEY];
      const secretAccessKey = process.env[ENV_SECRET];
      const sessionToken = process.env[ENV_SESSION];
      const expiry = process.env[ENV_EXPIRATION];
      const credentialScope = process.env[ENV_CREDENTIAL_SCOPE];
      const accountId = process.env[ENV_ACCOUNT_ID];
      if (accessKeyId && secretAccessKey) {
        const credentials2 = {
          accessKeyId,
          secretAccessKey,
          ...sessionToken && { sessionToken },
          ...expiry && { expiration: new Date(expiry) },
          ...credentialScope && { credentialScope },
          ...accountId && { accountId }
        };
        setCredentialFeature(credentials2, "CREDENTIALS_ENV_VARS", "g");
        return credentials2;
      }
      throw new CredentialsProviderError("Unable to find environment variable credentials.", { logger: init3?.logger });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-env@3.816.0/node_modules/@aws-sdk/credential-provider-env/dist-es/index.js
var dist_es_exports = {};
__export(dist_es_exports, {
  ENV_ACCOUNT_ID: () => ENV_ACCOUNT_ID,
  ENV_CREDENTIAL_SCOPE: () => ENV_CREDENTIAL_SCOPE,
  ENV_EXPIRATION: () => ENV_EXPIRATION,
  ENV_KEY: () => ENV_KEY,
  ENV_SECRET: () => ENV_SECRET,
  ENV_SESSION: () => ENV_SESSION,
  fromEnv: () => fromEnv2
});
var init_dist_es38 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-env@3.816.0/node_modules/@aws-sdk/credential-provider-env/dist-es/index.js"() {
    "use strict";
    init_fromEnv2();
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/httpRequest.js
function httpRequest(options) {
  return new Promise((resolve2, reject) => {
    const req = (0, import_http4.request)({
      method: "GET",
      ...options,
      hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1")
    });
    req.on("error", (err3) => {
      reject(Object.assign(new ProviderError("Unable to connect to instance metadata service"), err3));
      req.destroy();
    });
    req.on("timeout", () => {
      reject(new ProviderError("TimeoutError from instance metadata service"));
      req.destroy();
    });
    req.on("response", (res) => {
      const { statusCode = 400 } = res;
      if (statusCode < 200 || 300 <= statusCode) {
        reject(Object.assign(new ProviderError("Error response received from instance metadata service"), { statusCode }));
        req.destroy();
      }
      const chunks = [];
      res.on("data", (chunk) => {
        chunks.push(chunk);
      });
      res.on("end", () => {
        resolve2(import_buffer3.Buffer.concat(chunks));
        req.destroy();
      });
    });
    req.end();
  });
}
var import_buffer3, import_http4;
var init_httpRequest2 = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/httpRequest.js"() {
    "use strict";
    init_dist_es21();
    import_buffer3 = require("buffer");
    import_http4 = require("http");
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/ImdsCredentials.js
var isImdsCredentials, fromImdsCredentials;
var init_ImdsCredentials = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/ImdsCredentials.js"() {
    "use strict";
    isImdsCredentials = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.AccessKeyId === "string" && typeof arg.SecretAccessKey === "string" && typeof arg.Token === "string" && typeof arg.Expiration === "string";
    fromImdsCredentials = (creds) => ({
      accessKeyId: creds.AccessKeyId,
      secretAccessKey: creds.SecretAccessKey,
      sessionToken: creds.Token,
      expiration: new Date(creds.Expiration),
      ...creds.AccountId && { accountId: creds.AccountId }
    });
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/RemoteProviderInit.js
var DEFAULT_TIMEOUT, DEFAULT_MAX_RETRIES, providerConfigFromInit;
var init_RemoteProviderInit = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/RemoteProviderInit.js"() {
    "use strict";
    DEFAULT_TIMEOUT = 1e3;
    DEFAULT_MAX_RETRIES = 0;
    providerConfigFromInit = ({ maxRetries = DEFAULT_MAX_RETRIES, timeout = DEFAULT_TIMEOUT }) => ({ maxRetries, timeout });
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/retry.js
var retry;
var init_retry3 = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/retry.js"() {
    "use strict";
    retry = (toRetry, maxRetries) => {
      let promise = toRetry();
      for (let i8 = 0; i8 < maxRetries; i8++) {
        promise = promise.catch(toRetry);
      }
      return promise;
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/fromContainerMetadata.js
var import_url8, ENV_CMDS_FULL_URI, ENV_CMDS_RELATIVE_URI, ENV_CMDS_AUTH_TOKEN, fromContainerMetadata, requestFromEcsImds, CMDS_IP, GREENGRASS_HOSTS, GREENGRASS_PROTOCOLS, getCmdsUri;
var init_fromContainerMetadata = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/fromContainerMetadata.js"() {
    "use strict";
    init_dist_es21();
    import_url8 = require("url");
    init_httpRequest2();
    init_ImdsCredentials();
    init_RemoteProviderInit();
    init_retry3();
    ENV_CMDS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI";
    ENV_CMDS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI";
    ENV_CMDS_AUTH_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN";
    fromContainerMetadata = (init3 = {}) => {
      const { timeout, maxRetries } = providerConfigFromInit(init3);
      return () => retry(async () => {
        const requestOptions = await getCmdsUri({ logger: init3.logger });
        const credsResponse = JSON.parse(await requestFromEcsImds(timeout, requestOptions));
        if (!isImdsCredentials(credsResponse)) {
          throw new CredentialsProviderError("Invalid response received from instance metadata service.", {
            logger: init3.logger
          });
        }
        return fromImdsCredentials(credsResponse);
      }, maxRetries);
    };
    requestFromEcsImds = async (timeout, options) => {
      if (process.env[ENV_CMDS_AUTH_TOKEN]) {
        options.headers = {
          ...options.headers,
          Authorization: process.env[ENV_CMDS_AUTH_TOKEN]
        };
      }
      const buffer2 = await httpRequest({
        ...options,
        timeout
      });
      return buffer2.toString();
    };
    CMDS_IP = "169.254.170.2";
    GREENGRASS_HOSTS = {
      localhost: true,
      "127.0.0.1": true
    };
    GREENGRASS_PROTOCOLS = {
      "http:": true,
      "https:": true
    };
    getCmdsUri = async ({ logger: logger2 }) => {
      if (process.env[ENV_CMDS_RELATIVE_URI]) {
        return {
          hostname: CMDS_IP,
          path: process.env[ENV_CMDS_RELATIVE_URI]
        };
      }
      if (process.env[ENV_CMDS_FULL_URI]) {
        const parsed = (0, import_url8.parse)(process.env[ENV_CMDS_FULL_URI]);
        if (!parsed.hostname || !(parsed.hostname in GREENGRASS_HOSTS)) {
          throw new CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
            tryNextLink: false,
            logger: logger2
          });
        }
        if (!parsed.protocol || !(parsed.protocol in GREENGRASS_PROTOCOLS)) {
          throw new CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
            tryNextLink: false,
            logger: logger2
          });
        }
        return {
          ...parsed,
          port: parsed.port ? parseInt(parsed.port, 10) : void 0
        };
      }
      throw new CredentialsProviderError(`The container metadata credential provider cannot be used unless the ${ENV_CMDS_RELATIVE_URI} or ${ENV_CMDS_FULL_URI} environment variable is set`, {
        tryNextLink: false,
        logger: logger2
      });
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/error/InstanceMetadataV1FallbackError.js
var InstanceMetadataV1FallbackError;
var init_InstanceMetadataV1FallbackError = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/error/InstanceMetadataV1FallbackError.js"() {
    "use strict";
    init_dist_es21();
    InstanceMetadataV1FallbackError = class _InstanceMetadataV1FallbackError extends CredentialsProviderError {
      constructor(message, tryNextLink = true) {
        super(message, tryNextLink);
        this.tryNextLink = tryNextLink;
        this.name = "InstanceMetadataV1FallbackError";
        Object.setPrototypeOf(this, _InstanceMetadataV1FallbackError.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/Endpoint.js
var Endpoint;
var init_Endpoint = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/Endpoint.js"() {
    "use strict";
    (function(Endpoint2) {
      Endpoint2["IPv4"] = "http://169.254.169.254";
      Endpoint2["IPv6"] = "http://[fd00:ec2::254]";
    })(Endpoint || (Endpoint = {}));
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointConfigOptions.js
var ENV_ENDPOINT_NAME, CONFIG_ENDPOINT_NAME, ENDPOINT_CONFIG_OPTIONS;
var init_EndpointConfigOptions = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointConfigOptions.js"() {
    "use strict";
    ENV_ENDPOINT_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT";
    CONFIG_ENDPOINT_NAME = "ec2_metadata_service_endpoint";
    ENDPOINT_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => env4[ENV_ENDPOINT_NAME],
      configFileSelector: (profile) => profile[CONFIG_ENDPOINT_NAME],
      default: void 0
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointMode.js
var EndpointMode;
var init_EndpointMode = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointMode.js"() {
    "use strict";
    (function(EndpointMode2) {
      EndpointMode2["IPv4"] = "IPv4";
      EndpointMode2["IPv6"] = "IPv6";
    })(EndpointMode || (EndpointMode = {}));
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointModeConfigOptions.js
var ENV_ENDPOINT_MODE_NAME, CONFIG_ENDPOINT_MODE_NAME, ENDPOINT_MODE_CONFIG_OPTIONS;
var init_EndpointModeConfigOptions = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointModeConfigOptions.js"() {
    "use strict";
    init_EndpointMode();
    ENV_ENDPOINT_MODE_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE";
    CONFIG_ENDPOINT_MODE_NAME = "ec2_metadata_service_endpoint_mode";
    ENDPOINT_MODE_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => env4[ENV_ENDPOINT_MODE_NAME],
      configFileSelector: (profile) => profile[CONFIG_ENDPOINT_MODE_NAME],
      default: EndpointMode.IPv4
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/utils/getInstanceMetadataEndpoint.js
var getInstanceMetadataEndpoint, getFromEndpointConfig, getFromEndpointModeConfig;
var init_getInstanceMetadataEndpoint = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/utils/getInstanceMetadataEndpoint.js"() {
    "use strict";
    init_dist_es31();
    init_dist_es33();
    init_Endpoint();
    init_EndpointConfigOptions();
    init_EndpointMode();
    init_EndpointModeConfigOptions();
    getInstanceMetadataEndpoint = async () => parseUrl(await getFromEndpointConfig() || await getFromEndpointModeConfig());
    getFromEndpointConfig = async () => loadConfig(ENDPOINT_CONFIG_OPTIONS)();
    getFromEndpointModeConfig = async () => {
      const endpointMode = await loadConfig(ENDPOINT_MODE_CONFIG_OPTIONS)();
      switch (endpointMode) {
        case EndpointMode.IPv4:
          return Endpoint.IPv4;
        case EndpointMode.IPv6:
          return Endpoint.IPv6;
        default:
          throw new Error(`Unsupported endpoint mode: ${endpointMode}. Select from ${Object.values(EndpointMode)}`);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/utils/getExtendedInstanceMetadataCredentials.js
var STATIC_STABILITY_REFRESH_INTERVAL_SECONDS, STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS, STATIC_STABILITY_DOC_URL, getExtendedInstanceMetadataCredentials;
var init_getExtendedInstanceMetadataCredentials = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/utils/getExtendedInstanceMetadataCredentials.js"() {
    "use strict";
    STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 5 * 60;
    STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 5 * 60;
    STATIC_STABILITY_DOC_URL = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html";
    getExtendedInstanceMetadataCredentials = (credentials2, logger2) => {
      const refreshInterval = STATIC_STABILITY_REFRESH_INTERVAL_SECONDS + Math.floor(Math.random() * STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS);
      const newExpiration = new Date(Date.now() + refreshInterval * 1e3);
      logger2.warn(`Attempting credential expiration extension due to a credential service availability issue. A refresh of these credentials will be attempted after ${new Date(newExpiration)}.
For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
      const originalExpiration = credentials2.originalExpiration ?? credentials2.expiration;
      return {
        ...credentials2,
        ...originalExpiration ? { originalExpiration } : {},
        expiration: newExpiration
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/utils/staticStabilityProvider.js
var staticStabilityProvider;
var init_staticStabilityProvider = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/utils/staticStabilityProvider.js"() {
    "use strict";
    init_getExtendedInstanceMetadataCredentials();
    staticStabilityProvider = (provider, options = {}) => {
      const logger2 = options?.logger || console;
      let pastCredentials;
      return async () => {
        let credentials2;
        try {
          credentials2 = await provider();
          if (credentials2.expiration && credentials2.expiration.getTime() < Date.now()) {
            credentials2 = getExtendedInstanceMetadataCredentials(credentials2, logger2);
          }
        } catch (e6) {
          if (pastCredentials) {
            logger2.warn("Credential renew failed: ", e6);
            credentials2 = getExtendedInstanceMetadataCredentials(pastCredentials, logger2);
          } else {
            throw e6;
          }
        }
        pastCredentials = credentials2;
        return credentials2;
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/fromInstanceMetadata.js
var IMDS_PATH, IMDS_TOKEN_PATH, AWS_EC2_METADATA_V1_DISABLED, PROFILE_AWS_EC2_METADATA_V1_DISABLED, X_AWS_EC2_METADATA_TOKEN, fromInstanceMetadata, getInstanceMetadataProvider, getMetadataToken, getProfile, getCredentialsFromProfile;
var init_fromInstanceMetadata = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/fromInstanceMetadata.js"() {
    "use strict";
    init_dist_es31();
    init_dist_es21();
    init_InstanceMetadataV1FallbackError();
    init_httpRequest2();
    init_ImdsCredentials();
    init_RemoteProviderInit();
    init_retry3();
    init_getInstanceMetadataEndpoint();
    init_staticStabilityProvider();
    IMDS_PATH = "/latest/meta-data/iam/security-credentials/";
    IMDS_TOKEN_PATH = "/latest/api/token";
    AWS_EC2_METADATA_V1_DISABLED = "AWS_EC2_METADATA_V1_DISABLED";
    PROFILE_AWS_EC2_METADATA_V1_DISABLED = "ec2_metadata_v1_disabled";
    X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token";
    fromInstanceMetadata = (init3 = {}) => staticStabilityProvider(getInstanceMetadataProvider(init3), { logger: init3.logger });
    getInstanceMetadataProvider = (init3 = {}) => {
      let disableFetchToken = false;
      const { logger: logger2, profile } = init3;
      const { timeout, maxRetries } = providerConfigFromInit(init3);
      const getCredentials2 = async (maxRetries2, options) => {
        const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null;
        if (isImdsV1Fallback) {
          let fallbackBlockedFromProfile = false;
          let fallbackBlockedFromProcessEnv = false;
          const configValue = await loadConfig({
            environmentVariableSelector: (env4) => {
              const envValue = env4[AWS_EC2_METADATA_V1_DISABLED];
              fallbackBlockedFromProcessEnv = !!envValue && envValue !== "false";
              if (envValue === void 0) {
                throw new CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init3.logger });
              }
              return fallbackBlockedFromProcessEnv;
            },
            configFileSelector: (profile2) => {
              const profileValue = profile2[PROFILE_AWS_EC2_METADATA_V1_DISABLED];
              fallbackBlockedFromProfile = !!profileValue && profileValue !== "false";
              return fallbackBlockedFromProfile;
            },
            default: false
          }, {
            profile
          })();
          if (init3.ec2MetadataV1Disabled || configValue) {
            const causes = [];
            if (init3.ec2MetadataV1Disabled)
              causes.push("credential provider initialization (runtime option ec2MetadataV1Disabled)");
            if (fallbackBlockedFromProfile)
              causes.push(`config file profile (${PROFILE_AWS_EC2_METADATA_V1_DISABLED})`);
            if (fallbackBlockedFromProcessEnv)
              causes.push(`process environment variable (${AWS_EC2_METADATA_V1_DISABLED})`);
            throw new InstanceMetadataV1FallbackError(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${causes.join(", ")}].`);
          }
        }
        const imdsProfile = (await retry(async () => {
          let profile2;
          try {
            profile2 = await getProfile(options);
          } catch (err3) {
            if (err3.statusCode === 401) {
              disableFetchToken = false;
            }
            throw err3;
          }
          return profile2;
        }, maxRetries2)).trim();
        return retry(async () => {
          let creds;
          try {
            creds = await getCredentialsFromProfile(imdsProfile, options, init3);
          } catch (err3) {
            if (err3.statusCode === 401) {
              disableFetchToken = false;
            }
            throw err3;
          }
          return creds;
        }, maxRetries2);
      };
      return async () => {
        const endpoint = await getInstanceMetadataEndpoint();
        if (disableFetchToken) {
          logger2?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)");
          return getCredentials2(maxRetries, { ...endpoint, timeout });
        } else {
          let token;
          try {
            token = (await getMetadataToken({ ...endpoint, timeout })).toString();
          } catch (error2) {
            if (error2?.statusCode === 400) {
              throw Object.assign(error2, {
                message: "EC2 Metadata token request returned error"
              });
            } else if (error2.message === "TimeoutError" || [403, 404, 405].includes(error2.statusCode)) {
              disableFetchToken = true;
            }
            logger2?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)");
            return getCredentials2(maxRetries, { ...endpoint, timeout });
          }
          return getCredentials2(maxRetries, {
            ...endpoint,
            headers: {
              [X_AWS_EC2_METADATA_TOKEN]: token
            },
            timeout
          });
        }
      };
    };
    getMetadataToken = async (options) => httpRequest({
      ...options,
      path: IMDS_TOKEN_PATH,
      method: "PUT",
      headers: {
        "x-aws-ec2-metadata-token-ttl-seconds": "21600"
      }
    });
    getProfile = async (options) => (await httpRequest({ ...options, path: IMDS_PATH })).toString();
    getCredentialsFromProfile = async (profile, options, init3) => {
      const credentialsResponse = JSON.parse((await httpRequest({
        ...options,
        path: IMDS_PATH + profile
      })).toString());
      if (!isImdsCredentials(credentialsResponse)) {
        throw new CredentialsProviderError("Invalid response received from instance metadata service.", {
          logger: init3.logger
        });
      }
      return fromImdsCredentials(credentialsResponse);
    };
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/types.js
var init_types9 = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/index.js
var dist_es_exports2 = {};
__export(dist_es_exports2, {
  DEFAULT_MAX_RETRIES: () => DEFAULT_MAX_RETRIES,
  DEFAULT_TIMEOUT: () => DEFAULT_TIMEOUT,
  ENV_CMDS_AUTH_TOKEN: () => ENV_CMDS_AUTH_TOKEN,
  ENV_CMDS_FULL_URI: () => ENV_CMDS_FULL_URI,
  ENV_CMDS_RELATIVE_URI: () => ENV_CMDS_RELATIVE_URI,
  Endpoint: () => Endpoint,
  fromContainerMetadata: () => fromContainerMetadata,
  fromInstanceMetadata: () => fromInstanceMetadata,
  getInstanceMetadataEndpoint: () => getInstanceMetadataEndpoint,
  httpRequest: () => httpRequest,
  providerConfigFromInit: () => providerConfigFromInit
});
var init_dist_es39 = __esm({
  "../node_modules/.pnpm/@smithy+credential-provider-imds@4.0.6/node_modules/@smithy/credential-provider-imds/dist-es/index.js"() {
    "use strict";
    init_fromContainerMetadata();
    init_fromInstanceMetadata();
    init_RemoteProviderInit();
    init_types9();
    init_httpRequest2();
    init_getInstanceMetadataEndpoint();
    init_Endpoint();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/checkUrl.js
var ECS_CONTAINER_HOST, EKS_CONTAINER_HOST_IPv4, EKS_CONTAINER_HOST_IPv6, checkUrl;
var init_checkUrl = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/checkUrl.js"() {
    "use strict";
    init_dist_es21();
    ECS_CONTAINER_HOST = "169.254.170.2";
    EKS_CONTAINER_HOST_IPv4 = "169.254.170.23";
    EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]";
    checkUrl = (url, logger2) => {
      if (url.protocol === "https:") {
        return;
      }
      if (url.hostname === ECS_CONTAINER_HOST || url.hostname === EKS_CONTAINER_HOST_IPv4 || url.hostname === EKS_CONTAINER_HOST_IPv6) {
        return;
      }
      if (url.hostname.includes("[")) {
        if (url.hostname === "[::1]" || url.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") {
          return;
        }
      } else {
        if (url.hostname === "localhost") {
          return;
        }
        const ipComponents = url.hostname.split(".");
        const inRange = (component) => {
          const num = parseInt(component, 10);
          return 0 <= num && num <= 255;
        };
        if (ipComponents[0] === "127" && inRange(ipComponents[1]) && inRange(ipComponents[2]) && inRange(ipComponents[3]) && ipComponents.length === 4) {
          return;
        }
      }
      throw new CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
  - loopback CIDR 127.0.0.0/8 or [::1/128]
  - ECS container host 169.254.170.2
  - EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger: logger2 });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/requestHelpers.js
function createGetRequest(url) {
  return new HttpRequest({
    protocol: url.protocol,
    hostname: url.hostname,
    port: Number(url.port),
    path: url.pathname,
    query: Array.from(url.searchParams.entries()).reduce((acc, [k9, v11]) => {
      acc[k9] = v11;
      return acc;
    }, {}),
    fragment: url.hash
  });
}
async function getCredentials(response, logger2) {
  const stream = sdkStreamMixin2(response.body);
  const str = await stream.transformToString();
  if (response.statusCode === 200) {
    const parsed = JSON.parse(str);
    if (typeof parsed.AccessKeyId !== "string" || typeof parsed.SecretAccessKey !== "string" || typeof parsed.Token !== "string" || typeof parsed.Expiration !== "string") {
      throw new CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: { AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger: logger2 });
    }
    return {
      accessKeyId: parsed.AccessKeyId,
      secretAccessKey: parsed.SecretAccessKey,
      sessionToken: parsed.Token,
      expiration: parseRfc3339DateTime(parsed.Expiration)
    };
  }
  if (response.statusCode >= 400 && response.statusCode < 500) {
    let parsedBody = {};
    try {
      parsedBody = JSON.parse(str);
    } catch (e6) {
    }
    throw Object.assign(new CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger: logger2 }), {
      Code: parsedBody.Code,
      Message: parsedBody.Message
    });
  }
  throw new CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger: logger2 });
}
var init_requestHelpers = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/requestHelpers.js"() {
    "use strict";
    init_dist_es21();
    init_dist_es2();
    init_dist_es24();
    init_dist_es17();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/retry-wrapper.js
var retryWrapper;
var init_retry_wrapper = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/retry-wrapper.js"() {
    "use strict";
    retryWrapper = (toRetry, maxRetries, delayMs) => {
      return async () => {
        for (let i8 = 0; i8 < maxRetries; ++i8) {
          try {
            return await toRetry();
          } catch (e6) {
            await new Promise((resolve2) => setTimeout(resolve2, delayMs));
          }
        }
        return await toRetry();
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
var import_promises2, AWS_CONTAINER_CREDENTIALS_RELATIVE_URI, DEFAULT_LINK_LOCAL_HOST, AWS_CONTAINER_CREDENTIALS_FULL_URI, AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE, AWS_CONTAINER_AUTHORIZATION_TOKEN, fromHttp;
var init_fromHttp = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js"() {
    "use strict";
    init_client2();
    init_dist_es14();
    init_dist_es21();
    import_promises2 = __toESM(require("fs/promises"));
    init_checkUrl();
    init_requestHelpers();
    init_retry_wrapper();
    AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI";
    DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2";
    AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI";
    AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE";
    AWS_CONTAINER_AUTHORIZATION_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN";
    fromHttp = (options = {}) => {
      options.logger?.debug("@aws-sdk/credential-provider-http - fromHttp");
      let host;
      const relative = options.awsContainerCredentialsRelativeUri ?? process.env[AWS_CONTAINER_CREDENTIALS_RELATIVE_URI];
      const full = options.awsContainerCredentialsFullUri ?? process.env[AWS_CONTAINER_CREDENTIALS_FULL_URI];
      const token = options.awsContainerAuthorizationToken ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN];
      const tokenFile = options.awsContainerAuthorizationTokenFile ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE];
      const warn = options.logger?.constructor?.name === "NoOpLogger" || !options.logger ? console.warn : options.logger.warn;
      if (relative && full) {
        warn("@aws-sdk/credential-provider-http: you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri.");
        warn("awsContainerCredentialsFullUri will take precedence.");
      }
      if (token && tokenFile) {
        warn("@aws-sdk/credential-provider-http: you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile.");
        warn("awsContainerAuthorizationToken will take precedence.");
      }
      if (full) {
        host = full;
      } else if (relative) {
        host = `${DEFAULT_LINK_LOCAL_HOST}${relative}`;
      } else {
        throw new CredentialsProviderError(`No HTTP credential provider host provided.
Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`, { logger: options.logger });
      }
      const url = new URL(host);
      checkUrl(url, options.logger);
      const requestHandler = new NodeHttpHandler({
        requestTimeout: options.timeout ?? 1e3,
        connectionTimeout: options.timeout ?? 1e3
      });
      return retryWrapper(async () => {
        const request2 = createGetRequest(url);
        if (token) {
          request2.headers.Authorization = token;
        } else if (tokenFile) {
          request2.headers.Authorization = (await import_promises2.default.readFile(tokenFile)).toString();
        }
        try {
          const result = await requestHandler.handle(request2);
          return getCredentials(result.response).then((creds) => setCredentialFeature(creds, "CREDENTIALS_HTTP", "z"));
        } catch (e6) {
          throw new CredentialsProviderError(String(e6), { logger: options.logger });
        }
      }, options.maxRetries ?? 3, options.timeout ?? 1e3);
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/index.js
var dist_es_exports3 = {};
__export(dist_es_exports3, {
  fromHttp: () => fromHttp
});
var init_dist_es40 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-http@3.816.0/node_modules/@aws-sdk/credential-provider-http/dist-es/index.js"() {
    "use strict";
    init_fromHttp();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.817.0/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
var ENV_IMDS_DISABLED, remoteProvider;
var init_remoteProvider = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.817.0/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js"() {
    "use strict";
    init_dist_es21();
    ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
    remoteProvider = async (init3) => {
      const { ENV_CMDS_FULL_URI: ENV_CMDS_FULL_URI2, ENV_CMDS_RELATIVE_URI: ENV_CMDS_RELATIVE_URI2, fromContainerMetadata: fromContainerMetadata2, fromInstanceMetadata: fromInstanceMetadata2 } = await Promise.resolve().then(() => (init_dist_es39(), dist_es_exports2));
      if (process.env[ENV_CMDS_RELATIVE_URI2] || process.env[ENV_CMDS_FULL_URI2]) {
        init3.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
        const { fromHttp: fromHttp2 } = await Promise.resolve().then(() => (init_dist_es40(), dist_es_exports3));
        return chain(fromHttp2(init3), fromContainerMetadata2(init3));
      }
      if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") {
        return async () => {
          throw new CredentialsProviderError("EC2 Instance Metadata Service access disabled", { logger: init3.logger });
        };
      }
      init3.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata");
      return fromInstanceMetadata2(init3);
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/isSsoProfile.js
var isSsoProfile;
var init_isSsoProfile = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/isSsoProfile.js"() {
    "use strict";
    isSsoProfile = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/fromEnvSigningName.js
var init_fromEnvSigningName = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/fromEnvSigningName.js"() {
    "use strict";
    init_dist_es21();
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/constants.js
var EXPIRE_WINDOW_MS, REFRESH_MESSAGE;
var init_constants8 = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/constants.js"() {
    "use strict";
    EXPIRE_WINDOW_MS = 5 * 60 * 1e3;
    REFRESH_MESSAGE = `To refresh this SSO session run 'aws sso login' with the corresponding profile.`;
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/auth/httpAuthSchemeProvider.js
function createAwsAuthSigv4HttpAuthOption2(authParameters) {
  return {
    schemeId: "aws.auth#sigv4",
    signingProperties: {
      name: "sso-oauth",
      region: authParameters.region
    },
    propertiesExtractor: (config, context) => ({
      signingProperties: {
        config,
        context
      }
    })
  };
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
  return {
    schemeId: "smithy.api#noAuth"
  };
}
var defaultSSOOIDCHttpAuthSchemeParametersProvider, defaultSSOOIDCHttpAuthSchemeProvider, resolveHttpAuthSchemeConfig2;
var init_httpAuthSchemeProvider2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/auth/httpAuthSchemeProvider.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es6();
    defaultSSOOIDCHttpAuthSchemeParametersProvider = async (config, context, input) => {
      return {
        operation: getSmithyContext(context).operation,
        region: await normalizeProvider(config.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
        })()
      };
    };
    defaultSSOOIDCHttpAuthSchemeProvider = (authParameters) => {
      const options = [];
      switch (authParameters.operation) {
        case "CreateToken": {
          options.push(createSmithyApiNoAuthHttpAuthOption(authParameters));
          break;
        }
        default: {
          options.push(createAwsAuthSigv4HttpAuthOption2(authParameters));
        }
      }
      return options;
    };
    resolveHttpAuthSchemeConfig2 = (config) => {
      const config_0 = resolveAwsSdkSigV4Config(config);
      return Object.assign(config_0, {
        authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
      });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/EndpointParameters.js
var resolveClientEndpointParameters2, commonParams2;
var init_EndpointParameters2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/EndpointParameters.js"() {
    "use strict";
    resolveClientEndpointParameters2 = (options) => {
      return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "sso-oauth"
      });
    };
    commonParams2 = {
      UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
      Endpoint: { type: "builtInParams", name: "endpoint" },
      Region: { type: "builtInParams", name: "region" },
      UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/package.json
var package_default2;
var init_package2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/package.json"() {
    package_default2 = {
      name: "@aws-sdk/nested-clients",
      version: "3.817.0",
      description: "Nested clients for AWS SDK packages.",
      main: "./dist-cjs/index.js",
      module: "./dist-es/index.js",
      types: "./dist-types/index.d.ts",
      scripts: {
        build: "yarn lint && concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
        "build:cjs": "node ../../scripts/compilation/inline nested-clients",
        "build:es": "tsc -p tsconfig.es.json",
        "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
        "build:types": "tsc -p tsconfig.types.json",
        "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
        clean: "rimraf ./dist-* && rimraf *.tsbuildinfo",
        lint: "node ../../scripts/validation/submodules-linter.js --pkg nested-clients",
        test: "yarn g:vitest run",
        "test:watch": "yarn g:vitest watch"
      },
      engines: {
        node: ">=18.0.0"
      },
      author: {
        name: "AWS SDK for JavaScript Team",
        url: "https://aws.amazon.com/javascript/"
      },
      license: "Apache-2.0",
      dependencies: {
        "@aws-crypto/sha256-browser": "5.2.0",
        "@aws-crypto/sha256-js": "5.2.0",
        "@aws-sdk/core": "3.816.0",
        "@aws-sdk/middleware-host-header": "3.804.0",
        "@aws-sdk/middleware-logger": "3.804.0",
        "@aws-sdk/middleware-recursion-detection": "3.804.0",
        "@aws-sdk/middleware-user-agent": "3.816.0",
        "@aws-sdk/region-config-resolver": "3.808.0",
        "@aws-sdk/types": "3.804.0",
        "@aws-sdk/util-endpoints": "3.808.0",
        "@aws-sdk/util-user-agent-browser": "3.804.0",
        "@aws-sdk/util-user-agent-node": "3.816.0",
        "@smithy/config-resolver": "^4.1.2",
        "@smithy/core": "^3.3.3",
        "@smithy/fetch-http-handler": "^5.0.2",
        "@smithy/hash-node": "^4.0.2",
        "@smithy/invalid-dependency": "^4.0.2",
        "@smithy/middleware-content-length": "^4.0.2",
        "@smithy/middleware-endpoint": "^4.1.6",
        "@smithy/middleware-retry": "^4.1.7",
        "@smithy/middleware-serde": "^4.0.5",
        "@smithy/middleware-stack": "^4.0.2",
        "@smithy/node-config-provider": "^4.1.1",
        "@smithy/node-http-handler": "^4.0.4",
        "@smithy/protocol-http": "^5.1.0",
        "@smithy/smithy-client": "^4.2.6",
        "@smithy/types": "^4.2.0",
        "@smithy/url-parser": "^4.0.2",
        "@smithy/util-base64": "^4.0.0",
        "@smithy/util-body-length-browser": "^4.0.0",
        "@smithy/util-body-length-node": "^4.0.0",
        "@smithy/util-defaults-mode-browser": "^4.0.14",
        "@smithy/util-defaults-mode-node": "^4.0.14",
        "@smithy/util-endpoints": "^3.0.4",
        "@smithy/util-middleware": "^4.0.2",
        "@smithy/util-retry": "^4.0.3",
        "@smithy/util-utf8": "^4.0.0",
        tslib: "^2.6.2"
      },
      devDependencies: {
        concurrently: "7.0.0",
        "downlevel-dts": "0.10.1",
        rimraf: "3.0.2",
        typescript: "~5.8.3"
      },
      typesVersions: {
        "<4.0": {
          "dist-types/*": [
            "dist-types/ts3.4/*"
          ]
        }
      },
      files: [
        "./sso-oidc.d.ts",
        "./sso-oidc.js",
        "./sts.d.ts",
        "./sts.js",
        "dist-*/**"
      ],
      browser: {
        "./dist-es/submodules/sso-oidc/runtimeConfig": "./dist-es/submodules/sso-oidc/runtimeConfig.browser",
        "./dist-es/submodules/sts/runtimeConfig": "./dist-es/submodules/sts/runtimeConfig.browser"
      },
      "react-native": {},
      homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/packages/nested-clients",
      repository: {
        type: "git",
        url: "https://github.com/aws/aws-sdk-js-v3.git",
        directory: "packages/nested-clients"
      },
      exports: {
        "./sso-oidc": {
          types: "./dist-types/submodules/sso-oidc/index.d.ts",
          module: "./dist-es/submodules/sso-oidc/index.js",
          node: "./dist-cjs/submodules/sso-oidc/index.js",
          import: "./dist-es/submodules/sso-oidc/index.js",
          require: "./dist-cjs/submodules/sso-oidc/index.js"
        },
        "./sts": {
          types: "./dist-types/submodules/sts/index.d.ts",
          module: "./dist-es/submodules/sts/index.js",
          node: "./dist-cjs/submodules/sts/index.js",
          import: "./dist-es/submodules/sts/index.js",
          require: "./dist-cjs/submodules/sts/index.js"
        }
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/crt-availability.js
var crtAvailability;
var init_crt_availability = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/crt-availability.js"() {
    "use strict";
    crtAvailability = {
      isCrtAvailable: false
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/is-crt-available.js
var isCrtAvailable;
var init_is_crt_available = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/is-crt-available.js"() {
    "use strict";
    init_crt_availability();
    isCrtAvailable = () => {
      if (crtAvailability.isCrtAvailable) {
        return ["md/crt-avail"];
      }
      return null;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js
var import_os2, import_process, createDefaultUserAgentProvider;
var init_defaultUserAgent = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/defaultUserAgent.js"() {
    "use strict";
    import_os2 = require("os");
    import_process = require("process");
    init_is_crt_available();
    init_crt_availability();
    createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
      return async (config) => {
        const sections = [
          ["aws-sdk-js", clientVersion],
          ["ua", "2.1"],
          [`os/${(0, import_os2.platform)()}`, (0, import_os2.release)()],
          ["lang/js"],
          ["md/nodejs", `${import_process.versions.node}`]
        ];
        const crtAvailable = isCrtAvailable();
        if (crtAvailable) {
          sections.push(crtAvailable);
        }
        if (serviceId) {
          sections.push([`api/${serviceId}`, clientVersion]);
        }
        if (import_process.env.AWS_EXECUTION_ENV) {
          sections.push([`exec-env/${import_process.env.AWS_EXECUTION_ENV}`]);
        }
        const appId = await config?.userAgentAppId?.();
        const resolvedUserAgent = appId ? [...sections, [`app/${appId}`]] : [...sections];
        return resolvedUserAgent;
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/nodeAppIdConfigOptions.js
var UA_APP_ID_ENV_NAME, UA_APP_ID_INI_NAME, UA_APP_ID_INI_NAME_DEPRECATED, NODE_APP_ID_CONFIG_OPTIONS;
var init_nodeAppIdConfigOptions = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/nodeAppIdConfigOptions.js"() {
    "use strict";
    init_dist_es26();
    UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
    UA_APP_ID_INI_NAME = "sdk_ua_app_id";
    UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
    NODE_APP_ID_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => env4[UA_APP_ID_ENV_NAME],
      configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED],
      default: DEFAULT_UA_APP_ID
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/index.js
var init_dist_es41 = __esm({
  "../node_modules/.pnpm/@aws-sdk+util-user-agent-node@3.816.0/node_modules/@aws-sdk/util-user-agent-node/dist-es/index.js"() {
    "use strict";
    init_defaultUserAgent();
    init_nodeAppIdConfigOptions();
  }
});

// ../node_modules/.pnpm/@smithy+hash-node@4.0.4/node_modules/@smithy/hash-node/dist-es/index.js
function castSourceData(toCast, encoding) {
  if (import_buffer4.Buffer.isBuffer(toCast)) {
    return toCast;
  }
  if (typeof toCast === "string") {
    return fromString(toCast, encoding);
  }
  if (ArrayBuffer.isView(toCast)) {
    return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
  }
  return fromArrayBuffer(toCast);
}
var import_buffer4, import_crypto6, Hash;
var init_dist_es42 = __esm({
  "../node_modules/.pnpm/@smithy+hash-node@4.0.4/node_modules/@smithy/hash-node/dist-es/index.js"() {
    "use strict";
    init_dist_es9();
    init_dist_es10();
    import_buffer4 = require("buffer");
    import_crypto6 = require("crypto");
    Hash = class {
      constructor(algorithmIdentifier, secret) {
        this.algorithmIdentifier = algorithmIdentifier;
        this.secret = secret;
        this.reset();
      }
      update(toHash, encoding) {
        this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
      }
      digest() {
        return Promise.resolve(this.hash.digest());
      }
      reset() {
        this.hash = this.secret ? (0, import_crypto6.createHmac)(this.algorithmIdentifier, castSourceData(this.secret)) : (0, import_crypto6.createHash)(this.algorithmIdentifier);
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-body-length-node@4.0.0/node_modules/@smithy/util-body-length-node/dist-es/calculateBodyLength.js
var import_fs5, calculateBodyLength;
var init_calculateBodyLength = __esm({
  "../node_modules/.pnpm/@smithy+util-body-length-node@4.0.0/node_modules/@smithy/util-body-length-node/dist-es/calculateBodyLength.js"() {
    "use strict";
    import_fs5 = require("fs");
    calculateBodyLength = (body2) => {
      if (!body2) {
        return 0;
      }
      if (typeof body2 === "string") {
        return Buffer.byteLength(body2);
      } else if (typeof body2.byteLength === "number") {
        return body2.byteLength;
      } else if (typeof body2.size === "number") {
        return body2.size;
      } else if (typeof body2.start === "number" && typeof body2.end === "number") {
        return body2.end + 1 - body2.start;
      } else if (typeof body2.path === "string" || Buffer.isBuffer(body2.path)) {
        return (0, import_fs5.lstatSync)(body2.path).size;
      } else if (typeof body2.fd === "number") {
        return (0, import_fs5.fstatSync)(body2.fd).size;
      }
      throw new Error(`Body Length computation failed for ${body2}`);
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-body-length-node@4.0.0/node_modules/@smithy/util-body-length-node/dist-es/index.js
var init_dist_es43 = __esm({
  "../node_modules/.pnpm/@smithy+util-body-length-node@4.0.0/node_modules/@smithy/util-body-length-node/dist-es/index.js"() {
    "use strict";
    init_calculateBodyLength();
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/ruleset.js
var u, v, w, x2, a, b, c, d, e2, f3, g, h2, i3, j, k, l, m2, n, o, p, q, r2, s2, t2, _data, ruleSet;
var init_ruleset = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/ruleset.js"() {
    "use strict";
    u = "required";
    v = "fn";
    w = "argv";
    x2 = "ref";
    a = true;
    b = "isSet";
    c = "booleanEquals";
    d = "error";
    e2 = "endpoint";
    f3 = "tree";
    g = "PartitionResult";
    h2 = "getAttr";
    i3 = { [u]: false, "type": "String" };
    j = { [u]: true, "default": false, "type": "Boolean" };
    k = { [x2]: "Endpoint" };
    l = { [v]: c, [w]: [{ [x2]: "UseFIPS" }, true] };
    m2 = { [v]: c, [w]: [{ [x2]: "UseDualStack" }, true] };
    n = {};
    o = { [v]: h2, [w]: [{ [x2]: g }, "supportsFIPS"] };
    p = { [x2]: g };
    q = { [v]: c, [w]: [true, { [v]: h2, [w]: [p, "supportsDualStack"] }] };
    r2 = [l];
    s2 = [m2];
    t2 = [{ [x2]: "Region" }];
    _data = { version: "1.0", parameters: { Region: i3, UseDualStack: j, UseFIPS: j, Endpoint: i3 }, rules: [{ conditions: [{ [v]: b, [w]: [k] }], rules: [{ conditions: r2, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d }, { conditions: s2, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d }, { endpoint: { url: k, properties: n, headers: n }, type: e2 }], type: f3 }, { conditions: [{ [v]: b, [w]: t2 }], rules: [{ conditions: [{ [v]: "aws.partition", [w]: t2, assign: g }], rules: [{ conditions: [l, m2], rules: [{ conditions: [{ [v]: c, [w]: [a, o] }, q], rules: [{ endpoint: { url: "https://oidc-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e2 }], type: f3 }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d }], type: f3 }, { conditions: r2, rules: [{ conditions: [{ [v]: c, [w]: [o, a] }], rules: [{ conditions: [{ [v]: "stringEquals", [w]: [{ [v]: h2, [w]: [p, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://oidc.{Region}.amazonaws.com", properties: n, headers: n }, type: e2 }, { endpoint: { url: "https://oidc-fips.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e2 }], type: f3 }, { error: "FIPS is enabled but this partition does not support FIPS", type: d }], type: f3 }, { conditions: s2, rules: [{ conditions: [q], rules: [{ endpoint: { url: "https://oidc.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n, headers: n }, type: e2 }], type: f3 }, { error: "DualStack is enabled but this partition does not support DualStack", type: d }], type: f3 }, { endpoint: { url: "https://oidc.{Region}.{PartitionResult#dnsSuffix}", properties: n, headers: n }, type: e2 }], type: f3 }], type: f3 }, { error: "Invalid Configuration: Missing Region", type: d }] };
    ruleSet = _data;
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/endpointResolver.js
var cache, defaultEndpointResolver;
var init_endpointResolver = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/endpoint/endpointResolver.js"() {
    "use strict";
    init_dist_es20();
    init_dist_es19();
    init_ruleset();
    cache = new EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
    });
    defaultEndpointResolver = (endpointParams, context = {}) => {
      return cache.get(endpointParams, () => resolveEndpoint(ruleSet, {
        endpointParams,
        logger: context.logger
      }));
    };
    customEndpointFunctions.aws = awsEndpointFunctions;
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/runtimeConfig.shared.js
var getRuntimeConfig;
var init_runtimeConfig_shared = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/runtimeConfig.shared.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es18();
    init_dist_es24();
    init_dist_es33();
    init_dist_es11();
    init_dist_es10();
    init_httpAuthSchemeProvider2();
    init_endpointResolver();
    getRuntimeConfig = (config) => {
      return {
        apiVersion: "2019-06-10",
        base64Decoder: config?.base64Decoder ?? fromBase64,
        base64Encoder: config?.base64Encoder ?? toBase64,
        disableHostPrefix: config?.disableHostPrefix ?? false,
        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
        extensions: config?.extensions ?? [],
        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSSOOIDCHttpAuthSchemeProvider,
        httpAuthSchemes: config?.httpAuthSchemes ?? [
          {
            schemeId: "aws.auth#sigv4",
            identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
            signer: new AwsSdkSigV4Signer()
          },
          {
            schemeId: "smithy.api#noAuth",
            identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
            signer: new NoAuthSigner()
          }
        ],
        logger: config?.logger ?? new NoOpLogger(),
        serviceId: config?.serviceId ?? "SSO OIDC",
        urlParser: config?.urlParser ?? parseUrl,
        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
        utf8Encoder: config?.utf8Encoder ?? toUtf8
      };
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/constants.js
var AWS_EXECUTION_ENV, AWS_REGION_ENV, AWS_DEFAULT_REGION_ENV, ENV_IMDS_DISABLED2, DEFAULTS_MODE_OPTIONS, IMDS_REGION_PATH;
var init_constants9 = __esm({
  "../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/constants.js"() {
    "use strict";
    AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV";
    AWS_REGION_ENV = "AWS_REGION";
    AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION";
    ENV_IMDS_DISABLED2 = "AWS_EC2_METADATA_DISABLED";
    DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"];
    IMDS_REGION_PATH = "/latest/meta-data/placement/region";
  }
});

// ../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/defaultsModeConfig.js
var AWS_DEFAULTS_MODE_ENV, AWS_DEFAULTS_MODE_CONFIG, NODE_DEFAULTS_MODE_CONFIG_OPTIONS;
var init_defaultsModeConfig = __esm({
  "../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/defaultsModeConfig.js"() {
    "use strict";
    AWS_DEFAULTS_MODE_ENV = "AWS_DEFAULTS_MODE";
    AWS_DEFAULTS_MODE_CONFIG = "defaults_mode";
    NODE_DEFAULTS_MODE_CONFIG_OPTIONS = {
      environmentVariableSelector: (env4) => {
        return env4[AWS_DEFAULTS_MODE_ENV];
      },
      configFileSelector: (profile) => {
        return profile[AWS_DEFAULTS_MODE_CONFIG];
      },
      default: "legacy"
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/resolveDefaultsModeConfig.js
var resolveDefaultsModeConfig, resolveNodeDefaultsModeAuto, inferPhysicalRegion;
var init_resolveDefaultsModeConfig = __esm({
  "../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/resolveDefaultsModeConfig.js"() {
    "use strict";
    init_dist_es28();
    init_dist_es31();
    init_dist_es21();
    init_constants9();
    init_defaultsModeConfig();
    resolveDefaultsModeConfig = ({ region = loadConfig(NODE_REGION_CONFIG_OPTIONS), defaultsMode = loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS) } = {}) => memoize(async () => {
      const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
      switch (mode?.toLowerCase()) {
        case "auto":
          return resolveNodeDefaultsModeAuto(region);
        case "in-region":
        case "cross-region":
        case "mobile":
        case "standard":
        case "legacy":
          return Promise.resolve(mode?.toLocaleLowerCase());
        case void 0:
          return Promise.resolve("legacy");
        default:
          throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`);
      }
    });
    resolveNodeDefaultsModeAuto = async (clientRegion) => {
      if (clientRegion) {
        const resolvedRegion = typeof clientRegion === "function" ? await clientRegion() : clientRegion;
        const inferredRegion = await inferPhysicalRegion();
        if (!inferredRegion) {
          return "standard";
        }
        if (resolvedRegion === inferredRegion) {
          return "in-region";
        } else {
          return "cross-region";
        }
      }
      return "standard";
    };
    inferPhysicalRegion = async () => {
      if (process.env[AWS_EXECUTION_ENV] && (process.env[AWS_REGION_ENV] || process.env[AWS_DEFAULT_REGION_ENV])) {
        return process.env[AWS_REGION_ENV] ?? process.env[AWS_DEFAULT_REGION_ENV];
      }
      if (!process.env[ENV_IMDS_DISABLED2]) {
        try {
          const { getInstanceMetadataEndpoint: getInstanceMetadataEndpoint2, httpRequest: httpRequest2 } = await Promise.resolve().then(() => (init_dist_es39(), dist_es_exports2));
          const endpoint = await getInstanceMetadataEndpoint2();
          return (await httpRequest2({ ...endpoint, path: IMDS_REGION_PATH })).toString();
        } catch (e6) {
        }
      }
    };
  }
});

// ../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/index.js
var init_dist_es44 = __esm({
  "../node_modules/.pnpm/@smithy+util-defaults-mode-node@4.0.17/node_modules/@smithy/util-defaults-mode-node/dist-es/index.js"() {
    "use strict";
    init_resolveDefaultsModeConfig();
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/runtimeConfig.js
var getRuntimeConfig2;
var init_runtimeConfig = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/runtimeConfig.js"() {
    "use strict";
    init_package2();
    init_dist_es25();
    init_dist_es41();
    init_dist_es28();
    init_dist_es42();
    init_dist_es37();
    init_dist_es31();
    init_dist_es14();
    init_dist_es43();
    init_dist_es36();
    init_runtimeConfig_shared();
    init_dist_es24();
    init_dist_es44();
    init_dist_es24();
    getRuntimeConfig2 = (config) => {
      emitWarningIfUnsupportedVersion2(process.version);
      const defaultsMode = resolveDefaultsModeConfig(config);
      const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
      const clientSharedValues = getRuntimeConfig(config);
      emitWarningIfUnsupportedVersion(process.version);
      const loaderConfig = {
        profile: config?.profile,
        logger: clientSharedValues.logger
      };
      return {
        ...clientSharedValues,
        ...config,
        runtime: "node",
        defaultsMode,
        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default2.version }),
        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
        retryMode: config?.retryMode ?? loadConfig({
          ...NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
        }, config),
        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
        streamCollector: config?.streamCollector ?? streamCollector,
        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/extensions/index.js
var getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration;
var init_extensions4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/extensions/index.js"() {
    "use strict";
    getAwsRegionExtensionConfiguration = (runtimeConfig) => {
      return {
        setRegion(region) {
          runtimeConfig.region = region;
        },
        region() {
          return runtimeConfig.region;
        }
      };
    };
    resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => {
      return {
        region: awsRegionExtensionConfiguration.region()
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/config.js
var init_config4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/config.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/isFipsRegion.js
var init_isFipsRegion2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/isFipsRegion.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/getRealRegion.js
var init_getRealRegion2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/getRealRegion.js"() {
    "use strict";
    init_isFipsRegion2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/resolveRegionConfig.js
var init_resolveRegionConfig2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/resolveRegionConfig.js"() {
    "use strict";
    init_getRealRegion2();
    init_isFipsRegion2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/index.js
var init_regionConfig2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/regionConfig/index.js"() {
    "use strict";
    init_config4();
    init_resolveRegionConfig2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/index.js
var init_dist_es45 = __esm({
  "../node_modules/.pnpm/@aws-sdk+region-config-resolver@3.808.0/node_modules/@aws-sdk/region-config-resolver/dist-es/index.js"() {
    "use strict";
    init_extensions4();
    init_regionConfig2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration, resolveHttpAuthRuntimeConfig;
var init_httpAuthExtensionConfiguration = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/auth/httpAuthExtensionConfiguration.js"() {
    "use strict";
    getHttpAuthExtensionConfiguration = (runtimeConfig) => {
      const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
      let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
      let _credentials = runtimeConfig.credentials;
      return {
        setHttpAuthScheme(httpAuthScheme) {
          const index7 = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
          if (index7 === -1) {
            _httpAuthSchemes.push(httpAuthScheme);
          } else {
            _httpAuthSchemes.splice(index7, 1, httpAuthScheme);
          }
        },
        httpAuthSchemes() {
          return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
          _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
          return _httpAuthSchemeProvider;
        },
        setCredentials(credentials2) {
          _credentials = credentials2;
        },
        credentials() {
          return _credentials;
        }
      };
    };
    resolveHttpAuthRuntimeConfig = (config) => {
      return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials()
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/runtimeExtensions.js
var resolveRuntimeExtensions;
var init_runtimeExtensions = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/runtimeExtensions.js"() {
    "use strict";
    init_dist_es45();
    init_dist_es2();
    init_dist_es24();
    init_httpAuthExtensionConfiguration();
    resolveRuntimeExtensions = (runtimeConfig, extensions) => {
      const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
      extensions.forEach((extension) => extension.configure(extensionConfiguration));
      return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/SSOOIDCClient.js
var SSOOIDCClient;
var init_SSOOIDCClient = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/SSOOIDCClient.js"() {
    "use strict";
    init_dist_es3();
    init_dist_es4();
    init_dist_es5();
    init_dist_es26();
    init_dist_es28();
    init_dist_es18();
    init_dist_es29();
    init_dist_es34();
    init_dist_es37();
    init_dist_es24();
    init_httpAuthSchemeProvider2();
    init_EndpointParameters2();
    init_runtimeConfig();
    init_runtimeExtensions();
    SSOOIDCClient = class extends Client {
      constructor(...[configuration]) {
        const _config_0 = getRuntimeConfig2(configuration || {});
        super(_config_0);
        __publicField(this, "config");
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters2(_config_0);
        const _config_2 = resolveUserAgentConfig(_config_1);
        const _config_3 = resolveRetryConfig(_config_2);
        const _config_4 = resolveRegionConfig(_config_3);
        const _config_5 = resolveHostHeaderConfig(_config_4);
        const _config_6 = resolveEndpointConfig(_config_5);
        const _config_7 = resolveHttpAuthSchemeConfig2(_config_6);
        const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(getUserAgentPlugin(this.config));
        this.middlewareStack.use(getRetryPlugin(this.config));
        this.middlewareStack.use(getContentLengthPlugin(this.config));
        this.middlewareStack.use(getHostHeaderPlugin(this.config));
        this.middlewareStack.use(getLoggerPlugin(this.config));
        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
          httpAuthSchemeParametersProvider: defaultSSOOIDCHttpAuthSchemeParametersProvider,
          identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
            "aws.auth#sigv4": config.credentials
          })
        }));
        this.middlewareStack.use(getHttpSigningPlugin(this.config));
      }
      destroy() {
        super.destroy();
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/SSOOIDCServiceException.js
var SSOOIDCServiceException;
var init_SSOOIDCServiceException = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/SSOOIDCServiceException.js"() {
    "use strict";
    init_dist_es24();
    SSOOIDCServiceException = class _SSOOIDCServiceException extends ServiceException {
      constructor(options) {
        super(options);
        Object.setPrototypeOf(this, _SSOOIDCServiceException.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/models_0.js
var AccessDeniedException, AuthorizationPendingException, CreateTokenRequestFilterSensitiveLog, CreateTokenResponseFilterSensitiveLog, ExpiredTokenException, InternalServerException, InvalidClientException, InvalidGrantException, InvalidRequestException, InvalidScopeException, SlowDownException, UnauthorizedClientException, UnsupportedGrantTypeException;
var init_models_0 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/models_0.js"() {
    "use strict";
    init_dist_es24();
    init_SSOOIDCServiceException();
    AccessDeniedException = class _AccessDeniedException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "AccessDeniedException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "AccessDeniedException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _AccessDeniedException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    AuthorizationPendingException = class _AuthorizationPendingException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "AuthorizationPendingException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "AuthorizationPendingException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _AuthorizationPendingException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    CreateTokenRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.clientSecret && { clientSecret: SENSITIVE_STRING },
      ...obj.refreshToken && { refreshToken: SENSITIVE_STRING },
      ...obj.codeVerifier && { codeVerifier: SENSITIVE_STRING }
    });
    CreateTokenResponseFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.accessToken && { accessToken: SENSITIVE_STRING },
      ...obj.refreshToken && { refreshToken: SENSITIVE_STRING },
      ...obj.idToken && { idToken: SENSITIVE_STRING }
    });
    ExpiredTokenException = class _ExpiredTokenException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "ExpiredTokenException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "ExpiredTokenException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _ExpiredTokenException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    InternalServerException = class _InternalServerException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "InternalServerException",
          $fault: "server",
          ...opts
        });
        __publicField(this, "name", "InternalServerException");
        __publicField(this, "$fault", "server");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _InternalServerException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    InvalidClientException = class _InvalidClientException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "InvalidClientException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidClientException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _InvalidClientException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    InvalidGrantException = class _InvalidGrantException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "InvalidGrantException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidGrantException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _InvalidGrantException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    InvalidRequestException = class _InvalidRequestException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "InvalidRequestException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidRequestException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _InvalidRequestException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    InvalidScopeException = class _InvalidScopeException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "InvalidScopeException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidScopeException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _InvalidScopeException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    SlowDownException = class _SlowDownException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "SlowDownException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "SlowDownException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _SlowDownException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    UnauthorizedClientException = class _UnauthorizedClientException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "UnauthorizedClientException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "UnauthorizedClientException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _UnauthorizedClientException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
    UnsupportedGrantTypeException = class _UnsupportedGrantTypeException extends SSOOIDCServiceException {
      constructor(opts) {
        super({
          name: "UnsupportedGrantTypeException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "UnsupportedGrantTypeException");
        __publicField(this, "$fault", "client");
        __publicField(this, "error");
        __publicField(this, "error_description");
        Object.setPrototypeOf(this, _UnsupportedGrantTypeException.prototype);
        this.error = opts.error;
        this.error_description = opts.error_description;
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/protocols/Aws_restJson1.js
var se_CreateTokenCommand, de_CreateTokenCommand, de_CommandError, throwDefaultError2, de_AccessDeniedExceptionRes, de_AuthorizationPendingExceptionRes, de_ExpiredTokenExceptionRes, de_InternalServerExceptionRes, de_InvalidClientExceptionRes, de_InvalidGrantExceptionRes, de_InvalidRequestExceptionRes, de_InvalidScopeExceptionRes, de_SlowDownExceptionRes, de_UnauthorizedClientExceptionRes, de_UnsupportedGrantTypeExceptionRes, deserializeMetadata2;
var init_Aws_restJson1 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/protocols/Aws_restJson1.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es18();
    init_dist_es24();
    init_models_0();
    init_SSOOIDCServiceException();
    se_CreateTokenCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = {
        "content-type": "application/json"
      };
      b9.bp("/token");
      let body2;
      body2 = JSON.stringify(take(input, {
        clientId: [],
        clientSecret: [],
        code: [],
        codeVerifier: [],
        deviceCode: [],
        grantType: [],
        redirectUri: [],
        refreshToken: [],
        scope: (_7) => _json(_7)
      }));
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    de_CreateTokenCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata2(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        accessToken: expectString,
        expiresIn: expectInt32,
        idToken: expectString,
        refreshToken: expectString,
        tokenType: expectString
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_CommandError = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseJsonErrorBody(output.body, context)
      };
      const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "AccessDeniedException":
        case "com.amazonaws.ssooidc#AccessDeniedException":
          throw await de_AccessDeniedExceptionRes(parsedOutput, context);
        case "AuthorizationPendingException":
        case "com.amazonaws.ssooidc#AuthorizationPendingException":
          throw await de_AuthorizationPendingExceptionRes(parsedOutput, context);
        case "ExpiredTokenException":
        case "com.amazonaws.ssooidc#ExpiredTokenException":
          throw await de_ExpiredTokenExceptionRes(parsedOutput, context);
        case "InternalServerException":
        case "com.amazonaws.ssooidc#InternalServerException":
          throw await de_InternalServerExceptionRes(parsedOutput, context);
        case "InvalidClientException":
        case "com.amazonaws.ssooidc#InvalidClientException":
          throw await de_InvalidClientExceptionRes(parsedOutput, context);
        case "InvalidGrantException":
        case "com.amazonaws.ssooidc#InvalidGrantException":
          throw await de_InvalidGrantExceptionRes(parsedOutput, context);
        case "InvalidRequestException":
        case "com.amazonaws.ssooidc#InvalidRequestException":
          throw await de_InvalidRequestExceptionRes(parsedOutput, context);
        case "InvalidScopeException":
        case "com.amazonaws.ssooidc#InvalidScopeException":
          throw await de_InvalidScopeExceptionRes(parsedOutput, context);
        case "SlowDownException":
        case "com.amazonaws.ssooidc#SlowDownException":
          throw await de_SlowDownExceptionRes(parsedOutput, context);
        case "UnauthorizedClientException":
        case "com.amazonaws.ssooidc#UnauthorizedClientException":
          throw await de_UnauthorizedClientExceptionRes(parsedOutput, context);
        case "UnsupportedGrantTypeException":
        case "com.amazonaws.ssooidc#UnsupportedGrantTypeException":
          throw await de_UnsupportedGrantTypeExceptionRes(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          return throwDefaultError2({
            output,
            parsedBody,
            errorCode
          });
      }
    };
    throwDefaultError2 = withBaseException(SSOOIDCServiceException);
    de_AccessDeniedExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new AccessDeniedException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_AuthorizationPendingExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new AuthorizationPendingException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_ExpiredTokenExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new ExpiredTokenException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InternalServerExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new InternalServerException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InvalidClientExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new InvalidClientException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InvalidGrantExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new InvalidGrantException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InvalidRequestExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new InvalidRequestException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InvalidScopeExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new InvalidScopeException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_SlowDownExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new SlowDownException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_UnauthorizedClientExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new UnauthorizedClientException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_UnsupportedGrantTypeExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        error: expectString,
        error_description: expectString
      });
      Object.assign(contents, doc);
      const exception = new UnsupportedGrantTypeException({
        $metadata: deserializeMetadata2(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    deserializeMetadata2 = (output) => ({
      httpStatusCode: output.statusCode,
      requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
      extendedRequestId: output.headers["x-amz-id-2"],
      cfId: output.headers["x-amz-cf-id"]
    });
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/commands/CreateTokenCommand.js
var CreateTokenCommand;
var init_CreateTokenCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/commands/CreateTokenCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters2();
    init_models_0();
    init_Aws_restJson1();
    CreateTokenCommand = class extends Command.classBuilder().ep(commonParams2).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("AWSSSOOIDCService", "CreateToken", {}).n("SSOOIDCClient", "CreateTokenCommand").f(CreateTokenRequestFilterSensitiveLog, CreateTokenResponseFilterSensitiveLog).ser(se_CreateTokenCommand).de(de_CreateTokenCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/SSOOIDC.js
var commands, SSOOIDC;
var init_SSOOIDC = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/SSOOIDC.js"() {
    "use strict";
    init_dist_es24();
    init_CreateTokenCommand();
    init_SSOOIDCClient();
    commands = {
      CreateTokenCommand
    };
    SSOOIDC = class extends SSOOIDCClient {
    };
    createAggregatedClient(commands, SSOOIDC);
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/commands/index.js
var init_commands = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/commands/index.js"() {
    "use strict";
    init_CreateTokenCommand();
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/index.js
var init_models = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/models/index.js"() {
    "use strict";
    init_models_0();
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/index.js
var sso_oidc_exports = {};
__export(sso_oidc_exports, {
  $Command: () => Command,
  AccessDeniedException: () => AccessDeniedException,
  AuthorizationPendingException: () => AuthorizationPendingException,
  CreateTokenCommand: () => CreateTokenCommand,
  CreateTokenRequestFilterSensitiveLog: () => CreateTokenRequestFilterSensitiveLog,
  CreateTokenResponseFilterSensitiveLog: () => CreateTokenResponseFilterSensitiveLog,
  ExpiredTokenException: () => ExpiredTokenException,
  InternalServerException: () => InternalServerException,
  InvalidClientException: () => InvalidClientException,
  InvalidGrantException: () => InvalidGrantException,
  InvalidRequestException: () => InvalidRequestException,
  InvalidScopeException: () => InvalidScopeException,
  SSOOIDC: () => SSOOIDC,
  SSOOIDCClient: () => SSOOIDCClient,
  SSOOIDCServiceException: () => SSOOIDCServiceException,
  SlowDownException: () => SlowDownException,
  UnauthorizedClientException: () => UnauthorizedClientException,
  UnsupportedGrantTypeException: () => UnsupportedGrantTypeException,
  __Client: () => Client
});
var init_sso_oidc = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sso-oidc/index.js"() {
    "use strict";
    init_SSOOIDCClient();
    init_SSOOIDC();
    init_commands();
    init_models();
    init_SSOOIDCServiceException();
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/getSsoOidcClient.js
var getSsoOidcClient;
var init_getSsoOidcClient = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/getSsoOidcClient.js"() {
    "use strict";
    getSsoOidcClient = async (ssoRegion, init3 = {}) => {
      const { SSOOIDCClient: SSOOIDCClient2 } = await Promise.resolve().then(() => (init_sso_oidc(), sso_oidc_exports));
      const ssoOidcClient = new SSOOIDCClient2(Object.assign({}, init3.clientConfig ?? {}, {
        region: ssoRegion ?? init3.clientConfig?.region,
        logger: init3.clientConfig?.logger ?? init3.parentClientConfig?.logger
      }));
      return ssoOidcClient;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/getNewSsoOidcToken.js
var getNewSsoOidcToken;
var init_getNewSsoOidcToken = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/getNewSsoOidcToken.js"() {
    "use strict";
    init_getSsoOidcClient();
    getNewSsoOidcToken = async (ssoToken, ssoRegion, init3 = {}) => {
      const { CreateTokenCommand: CreateTokenCommand2 } = await Promise.resolve().then(() => (init_sso_oidc(), sso_oidc_exports));
      const ssoOidcClient = await getSsoOidcClient(ssoRegion, init3);
      return ssoOidcClient.send(new CreateTokenCommand2({
        clientId: ssoToken.clientId,
        clientSecret: ssoToken.clientSecret,
        refreshToken: ssoToken.refreshToken,
        grantType: "refresh_token"
      }));
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenExpiry.js
var validateTokenExpiry;
var init_validateTokenExpiry = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenExpiry.js"() {
    "use strict";
    init_dist_es21();
    init_constants8();
    validateTokenExpiry = (token) => {
      if (token.expiration && token.expiration.getTime() < Date.now()) {
        throw new TokenProviderError(`Token is expired. ${REFRESH_MESSAGE}`, false);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenKey.js
var validateTokenKey;
var init_validateTokenKey = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenKey.js"() {
    "use strict";
    init_dist_es21();
    init_constants8();
    validateTokenKey = (key, value, forRefresh = false) => {
      if (typeof value === "undefined") {
        throw new TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/writeSSOTokenToFile.js
var import_fs6, writeFile, writeSSOTokenToFile;
var init_writeSSOTokenToFile = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/writeSSOTokenToFile.js"() {
    "use strict";
    init_dist_es30();
    import_fs6 = require("fs");
    ({ writeFile } = import_fs6.promises);
    writeSSOTokenToFile = (id, ssoToken) => {
      const tokenFilepath = getSSOTokenFilepath(id);
      const tokenString = JSON.stringify(ssoToken, null, 2);
      return writeFile(tokenFilepath, tokenString);
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/fromSso.js
var lastRefreshAttemptTime, fromSso;
var init_fromSso = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/fromSso.js"() {
    "use strict";
    init_dist_es21();
    init_dist_es30();
    init_constants8();
    init_getNewSsoOidcToken();
    init_validateTokenExpiry();
    init_validateTokenKey();
    init_writeSSOTokenToFile();
    lastRefreshAttemptTime = /* @__PURE__ */ new Date(0);
    fromSso = (_init2 = {}) => async ({ callerClientConfig } = {}) => {
      const init3 = {
        ..._init2,
        parentClientConfig: {
          ...callerClientConfig,
          ..._init2.parentClientConfig
        }
      };
      init3.logger?.debug("@aws-sdk/token-providers - fromSso");
      const profiles = await parseKnownFiles(init3);
      const profileName = getProfileName({
        profile: init3.profile ?? callerClientConfig?.profile
      });
      const profile = profiles[profileName];
      if (!profile) {
        throw new TokenProviderError(`Profile '${profileName}' could not be found in shared credentials file.`, false);
      } else if (!profile["sso_session"]) {
        throw new TokenProviderError(`Profile '${profileName}' is missing required property 'sso_session'.`);
      }
      const ssoSessionName = profile["sso_session"];
      const ssoSessions = await loadSsoSessionData(init3);
      const ssoSession = ssoSessions[ssoSessionName];
      if (!ssoSession) {
        throw new TokenProviderError(`Sso session '${ssoSessionName}' could not be found in shared credentials file.`, false);
      }
      for (const ssoSessionRequiredKey of ["sso_start_url", "sso_region"]) {
        if (!ssoSession[ssoSessionRequiredKey]) {
          throw new TokenProviderError(`Sso session '${ssoSessionName}' is missing required property '${ssoSessionRequiredKey}'.`, false);
        }
      }
      const ssoStartUrl = ssoSession["sso_start_url"];
      const ssoRegion = ssoSession["sso_region"];
      let ssoToken;
      try {
        ssoToken = await getSSOTokenFromFile(ssoSessionName);
      } catch (e6) {
        throw new TokenProviderError(`The SSO session token associated with profile=${profileName} was not found or is invalid. ${REFRESH_MESSAGE}`, false);
      }
      validateTokenKey("accessToken", ssoToken.accessToken);
      validateTokenKey("expiresAt", ssoToken.expiresAt);
      const { accessToken, expiresAt } = ssoToken;
      const existingToken = { token: accessToken, expiration: new Date(expiresAt) };
      if (existingToken.expiration.getTime() - Date.now() > EXPIRE_WINDOW_MS) {
        return existingToken;
      }
      if (Date.now() - lastRefreshAttemptTime.getTime() < 30 * 1e3) {
        validateTokenExpiry(existingToken);
        return existingToken;
      }
      validateTokenKey("clientId", ssoToken.clientId, true);
      validateTokenKey("clientSecret", ssoToken.clientSecret, true);
      validateTokenKey("refreshToken", ssoToken.refreshToken, true);
      try {
        lastRefreshAttemptTime.setTime(Date.now());
        const newSsoOidcToken = await getNewSsoOidcToken(ssoToken, ssoRegion, init3);
        validateTokenKey("accessToken", newSsoOidcToken.accessToken);
        validateTokenKey("expiresIn", newSsoOidcToken.expiresIn);
        const newTokenExpiration = new Date(Date.now() + newSsoOidcToken.expiresIn * 1e3);
        try {
          await writeSSOTokenToFile(ssoSessionName, {
            ...ssoToken,
            accessToken: newSsoOidcToken.accessToken,
            expiresAt: newTokenExpiration.toISOString(),
            refreshToken: newSsoOidcToken.refreshToken
          });
        } catch (error2) {
        }
        return {
          token: newSsoOidcToken.accessToken,
          expiration: newTokenExpiration
        };
      } catch (error2) {
        validateTokenExpiry(existingToken);
        return existingToken;
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/fromStatic.js
var init_fromStatic3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/fromStatic.js"() {
    "use strict";
    init_dist_es21();
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/nodeProvider.js
var init_nodeProvider = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/nodeProvider.js"() {
    "use strict";
    init_dist_es21();
  }
});

// ../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/index.js
var init_dist_es46 = __esm({
  "../node_modules/.pnpm/@aws-sdk+token-providers@3.817.0/node_modules/@aws-sdk/token-providers/dist-es/index.js"() {
    "use strict";
    init_fromEnvSigningName();
    init_fromSso();
    init_fromStatic3();
    init_nodeProvider();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/auth/httpAuthSchemeProvider.js
function createAwsAuthSigv4HttpAuthOption3(authParameters) {
  return {
    schemeId: "aws.auth#sigv4",
    signingProperties: {
      name: "awsssoportal",
      region: authParameters.region
    },
    propertiesExtractor: (config, context) => ({
      signingProperties: {
        config,
        context
      }
    })
  };
}
function createSmithyApiNoAuthHttpAuthOption2(authParameters) {
  return {
    schemeId: "smithy.api#noAuth"
  };
}
var defaultSSOHttpAuthSchemeParametersProvider, defaultSSOHttpAuthSchemeProvider, resolveHttpAuthSchemeConfig3;
var init_httpAuthSchemeProvider3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/auth/httpAuthSchemeProvider.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es6();
    defaultSSOHttpAuthSchemeParametersProvider = async (config, context, input) => {
      return {
        operation: getSmithyContext(context).operation,
        region: await normalizeProvider(config.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
        })()
      };
    };
    defaultSSOHttpAuthSchemeProvider = (authParameters) => {
      const options = [];
      switch (authParameters.operation) {
        case "GetRoleCredentials": {
          options.push(createSmithyApiNoAuthHttpAuthOption2(authParameters));
          break;
        }
        case "ListAccountRoles": {
          options.push(createSmithyApiNoAuthHttpAuthOption2(authParameters));
          break;
        }
        case "ListAccounts": {
          options.push(createSmithyApiNoAuthHttpAuthOption2(authParameters));
          break;
        }
        case "Logout": {
          options.push(createSmithyApiNoAuthHttpAuthOption2(authParameters));
          break;
        }
        default: {
          options.push(createAwsAuthSigv4HttpAuthOption3(authParameters));
        }
      }
      return options;
    };
    resolveHttpAuthSchemeConfig3 = (config) => {
      const config_0 = resolveAwsSdkSigV4Config(config);
      return Object.assign(config_0, {
        authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
      });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/endpoint/EndpointParameters.js
var resolveClientEndpointParameters3, commonParams3;
var init_EndpointParameters3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/endpoint/EndpointParameters.js"() {
    "use strict";
    resolveClientEndpointParameters3 = (options) => {
      return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        defaultSigningName: "awsssoportal"
      });
    };
    commonParams3 = {
      UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
      Endpoint: { type: "builtInParams", name: "endpoint" },
      Region: { type: "builtInParams", name: "region" },
      UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/package.json
var package_default3;
var init_package3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/package.json"() {
    package_default3 = {
      name: "@aws-sdk/client-sso",
      description: "AWS SDK for JavaScript Sso Client for Node.js, Browser and React Native",
      version: "3.817.0",
      scripts: {
        build: "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
        "build:cjs": "node ../../scripts/compilation/inline client-sso",
        "build:es": "tsc -p tsconfig.es.json",
        "build:include:deps": "lerna run --scope $npm_package_name --include-dependencies build",
        "build:types": "tsc -p tsconfig.types.json",
        "build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
        clean: "rimraf ./dist-* && rimraf *.tsbuildinfo",
        "extract:docs": "api-extractor run --local",
        "generate:client": "node ../../scripts/generate-clients/single-service --solo sso"
      },
      main: "./dist-cjs/index.js",
      types: "./dist-types/index.d.ts",
      module: "./dist-es/index.js",
      sideEffects: false,
      dependencies: {
        "@aws-crypto/sha256-browser": "5.2.0",
        "@aws-crypto/sha256-js": "5.2.0",
        "@aws-sdk/core": "3.816.0",
        "@aws-sdk/middleware-host-header": "3.804.0",
        "@aws-sdk/middleware-logger": "3.804.0",
        "@aws-sdk/middleware-recursion-detection": "3.804.0",
        "@aws-sdk/middleware-user-agent": "3.816.0",
        "@aws-sdk/region-config-resolver": "3.808.0",
        "@aws-sdk/types": "3.804.0",
        "@aws-sdk/util-endpoints": "3.808.0",
        "@aws-sdk/util-user-agent-browser": "3.804.0",
        "@aws-sdk/util-user-agent-node": "3.816.0",
        "@smithy/config-resolver": "^4.1.2",
        "@smithy/core": "^3.3.3",
        "@smithy/fetch-http-handler": "^5.0.2",
        "@smithy/hash-node": "^4.0.2",
        "@smithy/invalid-dependency": "^4.0.2",
        "@smithy/middleware-content-length": "^4.0.2",
        "@smithy/middleware-endpoint": "^4.1.6",
        "@smithy/middleware-retry": "^4.1.7",
        "@smithy/middleware-serde": "^4.0.5",
        "@smithy/middleware-stack": "^4.0.2",
        "@smithy/node-config-provider": "^4.1.1",
        "@smithy/node-http-handler": "^4.0.4",
        "@smithy/protocol-http": "^5.1.0",
        "@smithy/smithy-client": "^4.2.6",
        "@smithy/types": "^4.2.0",
        "@smithy/url-parser": "^4.0.2",
        "@smithy/util-base64": "^4.0.0",
        "@smithy/util-body-length-browser": "^4.0.0",
        "@smithy/util-body-length-node": "^4.0.0",
        "@smithy/util-defaults-mode-browser": "^4.0.14",
        "@smithy/util-defaults-mode-node": "^4.0.14",
        "@smithy/util-endpoints": "^3.0.4",
        "@smithy/util-middleware": "^4.0.2",
        "@smithy/util-retry": "^4.0.3",
        "@smithy/util-utf8": "^4.0.0",
        tslib: "^2.6.2"
      },
      devDependencies: {
        "@tsconfig/node18": "18.2.4",
        "@types/node": "^18.19.69",
        concurrently: "7.0.0",
        "downlevel-dts": "0.10.1",
        rimraf: "3.0.2",
        typescript: "~5.8.3"
      },
      engines: {
        node: ">=18.0.0"
      },
      typesVersions: {
        "<4.0": {
          "dist-types/*": [
            "dist-types/ts3.4/*"
          ]
        }
      },
      files: [
        "dist-*/**"
      ],
      author: {
        name: "AWS SDK for JavaScript Team",
        url: "https://aws.amazon.com/javascript/"
      },
      license: "Apache-2.0",
      browser: {
        "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
      },
      "react-native": {
        "./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
      },
      homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-sso",
      repository: {
        type: "git",
        url: "https://github.com/aws/aws-sdk-js-v3.git",
        directory: "clients/client-sso"
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/endpoint/ruleset.js
var u2, v2, w2, x3, a2, b2, c2, d2, e3, f4, g2, h3, i4, j2, k2, l2, m3, n2, o2, p2, q2, r3, s3, t3, _data2, ruleSet2;
var init_ruleset2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/endpoint/ruleset.js"() {
    "use strict";
    u2 = "required";
    v2 = "fn";
    w2 = "argv";
    x3 = "ref";
    a2 = true;
    b2 = "isSet";
    c2 = "booleanEquals";
    d2 = "error";
    e3 = "endpoint";
    f4 = "tree";
    g2 = "PartitionResult";
    h3 = "getAttr";
    i4 = { [u2]: false, "type": "String" };
    j2 = { [u2]: true, "default": false, "type": "Boolean" };
    k2 = { [x3]: "Endpoint" };
    l2 = { [v2]: c2, [w2]: [{ [x3]: "UseFIPS" }, true] };
    m3 = { [v2]: c2, [w2]: [{ [x3]: "UseDualStack" }, true] };
    n2 = {};
    o2 = { [v2]: h3, [w2]: [{ [x3]: g2 }, "supportsFIPS"] };
    p2 = { [x3]: g2 };
    q2 = { [v2]: c2, [w2]: [true, { [v2]: h3, [w2]: [p2, "supportsDualStack"] }] };
    r3 = [l2];
    s3 = [m3];
    t3 = [{ [x3]: "Region" }];
    _data2 = { version: "1.0", parameters: { Region: i4, UseDualStack: j2, UseFIPS: j2, Endpoint: i4 }, rules: [{ conditions: [{ [v2]: b2, [w2]: [k2] }], rules: [{ conditions: r3, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d2 }, { conditions: s3, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d2 }, { endpoint: { url: k2, properties: n2, headers: n2 }, type: e3 }], type: f4 }, { conditions: [{ [v2]: b2, [w2]: t3 }], rules: [{ conditions: [{ [v2]: "aws.partition", [w2]: t3, assign: g2 }], rules: [{ conditions: [l2, m3], rules: [{ conditions: [{ [v2]: c2, [w2]: [a2, o2] }, q2], rules: [{ endpoint: { url: "https://portal.sso-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n2, headers: n2 }, type: e3 }], type: f4 }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d2 }], type: f4 }, { conditions: r3, rules: [{ conditions: [{ [v2]: c2, [w2]: [o2, a2] }], rules: [{ conditions: [{ [v2]: "stringEquals", [w2]: [{ [v2]: h3, [w2]: [p2, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://portal.sso.{Region}.amazonaws.com", properties: n2, headers: n2 }, type: e3 }, { endpoint: { url: "https://portal.sso-fips.{Region}.{PartitionResult#dnsSuffix}", properties: n2, headers: n2 }, type: e3 }], type: f4 }, { error: "FIPS is enabled but this partition does not support FIPS", type: d2 }], type: f4 }, { conditions: s3, rules: [{ conditions: [q2], rules: [{ endpoint: { url: "https://portal.sso.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: n2, headers: n2 }, type: e3 }], type: f4 }, { error: "DualStack is enabled but this partition does not support DualStack", type: d2 }], type: f4 }, { endpoint: { url: "https://portal.sso.{Region}.{PartitionResult#dnsSuffix}", properties: n2, headers: n2 }, type: e3 }], type: f4 }], type: f4 }, { error: "Invalid Configuration: Missing Region", type: d2 }] };
    ruleSet2 = _data2;
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/endpoint/endpointResolver.js
var cache2, defaultEndpointResolver2;
var init_endpointResolver2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/endpoint/endpointResolver.js"() {
    "use strict";
    init_dist_es20();
    init_dist_es19();
    init_ruleset2();
    cache2 = new EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
    });
    defaultEndpointResolver2 = (endpointParams, context = {}) => {
      return cache2.get(endpointParams, () => resolveEndpoint(ruleSet2, {
        endpointParams,
        logger: context.logger
      }));
    };
    customEndpointFunctions.aws = awsEndpointFunctions;
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/runtimeConfig.shared.js
var getRuntimeConfig3;
var init_runtimeConfig_shared2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/runtimeConfig.shared.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es18();
    init_dist_es24();
    init_dist_es33();
    init_dist_es11();
    init_dist_es10();
    init_httpAuthSchemeProvider3();
    init_endpointResolver2();
    getRuntimeConfig3 = (config) => {
      return {
        apiVersion: "2019-06-10",
        base64Decoder: config?.base64Decoder ?? fromBase64,
        base64Encoder: config?.base64Encoder ?? toBase64,
        disableHostPrefix: config?.disableHostPrefix ?? false,
        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver2,
        extensions: config?.extensions ?? [],
        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSSOHttpAuthSchemeProvider,
        httpAuthSchemes: config?.httpAuthSchemes ?? [
          {
            schemeId: "aws.auth#sigv4",
            identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
            signer: new AwsSdkSigV4Signer()
          },
          {
            schemeId: "smithy.api#noAuth",
            identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
            signer: new NoAuthSigner()
          }
        ],
        logger: config?.logger ?? new NoOpLogger(),
        serviceId: config?.serviceId ?? "SSO",
        urlParser: config?.urlParser ?? parseUrl,
        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
        utf8Encoder: config?.utf8Encoder ?? toUtf8
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/runtimeConfig.js
var getRuntimeConfig4;
var init_runtimeConfig2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/runtimeConfig.js"() {
    "use strict";
    init_package3();
    init_dist_es25();
    init_dist_es41();
    init_dist_es28();
    init_dist_es42();
    init_dist_es37();
    init_dist_es31();
    init_dist_es14();
    init_dist_es43();
    init_dist_es36();
    init_runtimeConfig_shared2();
    init_dist_es24();
    init_dist_es44();
    init_dist_es24();
    getRuntimeConfig4 = (config) => {
      emitWarningIfUnsupportedVersion2(process.version);
      const defaultsMode = resolveDefaultsModeConfig(config);
      const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
      const clientSharedValues = getRuntimeConfig3(config);
      emitWarningIfUnsupportedVersion(process.version);
      const loaderConfig = {
        profile: config?.profile,
        logger: clientSharedValues.logger
      };
      return {
        ...clientSharedValues,
        ...config,
        runtime: "node",
        defaultsMode,
        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default3.version }),
        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
        retryMode: config?.retryMode ?? loadConfig({
          ...NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
        }, config),
        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
        streamCollector: config?.streamCollector ?? streamCollector,
        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration2, resolveHttpAuthRuntimeConfig2;
var init_httpAuthExtensionConfiguration2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/auth/httpAuthExtensionConfiguration.js"() {
    "use strict";
    getHttpAuthExtensionConfiguration2 = (runtimeConfig) => {
      const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
      let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
      let _credentials = runtimeConfig.credentials;
      return {
        setHttpAuthScheme(httpAuthScheme) {
          const index7 = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
          if (index7 === -1) {
            _httpAuthSchemes.push(httpAuthScheme);
          } else {
            _httpAuthSchemes.splice(index7, 1, httpAuthScheme);
          }
        },
        httpAuthSchemes() {
          return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
          _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
          return _httpAuthSchemeProvider;
        },
        setCredentials(credentials2) {
          _credentials = credentials2;
        },
        credentials() {
          return _credentials;
        }
      };
    };
    resolveHttpAuthRuntimeConfig2 = (config) => {
      return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials()
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/runtimeExtensions.js
var resolveRuntimeExtensions2;
var init_runtimeExtensions2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/runtimeExtensions.js"() {
    "use strict";
    init_dist_es45();
    init_dist_es2();
    init_dist_es24();
    init_httpAuthExtensionConfiguration2();
    resolveRuntimeExtensions2 = (runtimeConfig, extensions) => {
      const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration2(runtimeConfig));
      extensions.forEach((extension) => extension.configure(extensionConfiguration));
      return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig2(extensionConfiguration));
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/SSOClient.js
var SSOClient;
var init_SSOClient = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/SSOClient.js"() {
    "use strict";
    init_dist_es3();
    init_dist_es4();
    init_dist_es5();
    init_dist_es26();
    init_dist_es28();
    init_dist_es18();
    init_dist_es29();
    init_dist_es34();
    init_dist_es37();
    init_dist_es24();
    init_httpAuthSchemeProvider3();
    init_EndpointParameters3();
    init_runtimeConfig2();
    init_runtimeExtensions2();
    SSOClient = class extends Client {
      constructor(...[configuration]) {
        const _config_0 = getRuntimeConfig4(configuration || {});
        super(_config_0);
        __publicField(this, "config");
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters3(_config_0);
        const _config_2 = resolveUserAgentConfig(_config_1);
        const _config_3 = resolveRetryConfig(_config_2);
        const _config_4 = resolveRegionConfig(_config_3);
        const _config_5 = resolveHostHeaderConfig(_config_4);
        const _config_6 = resolveEndpointConfig(_config_5);
        const _config_7 = resolveHttpAuthSchemeConfig3(_config_6);
        const _config_8 = resolveRuntimeExtensions2(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(getUserAgentPlugin(this.config));
        this.middlewareStack.use(getRetryPlugin(this.config));
        this.middlewareStack.use(getContentLengthPlugin(this.config));
        this.middlewareStack.use(getHostHeaderPlugin(this.config));
        this.middlewareStack.use(getLoggerPlugin(this.config));
        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
          httpAuthSchemeParametersProvider: defaultSSOHttpAuthSchemeParametersProvider,
          identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
            "aws.auth#sigv4": config.credentials
          })
        }));
        this.middlewareStack.use(getHttpSigningPlugin(this.config));
      }
      destroy() {
        super.destroy();
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/models/SSOServiceException.js
var SSOServiceException;
var init_SSOServiceException = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/models/SSOServiceException.js"() {
    "use strict";
    init_dist_es24();
    SSOServiceException = class _SSOServiceException extends ServiceException {
      constructor(options) {
        super(options);
        Object.setPrototypeOf(this, _SSOServiceException.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/models/models_0.js
var InvalidRequestException2, ResourceNotFoundException, TooManyRequestsException, UnauthorizedException, GetRoleCredentialsRequestFilterSensitiveLog, RoleCredentialsFilterSensitiveLog, GetRoleCredentialsResponseFilterSensitiveLog, ListAccountRolesRequestFilterSensitiveLog, ListAccountsRequestFilterSensitiveLog, LogoutRequestFilterSensitiveLog;
var init_models_02 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/models/models_0.js"() {
    "use strict";
    init_dist_es24();
    init_SSOServiceException();
    InvalidRequestException2 = class _InvalidRequestException extends SSOServiceException {
      constructor(opts) {
        super({
          name: "InvalidRequestException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidRequestException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _InvalidRequestException.prototype);
      }
    };
    ResourceNotFoundException = class _ResourceNotFoundException extends SSOServiceException {
      constructor(opts) {
        super({
          name: "ResourceNotFoundException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "ResourceNotFoundException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
      }
    };
    TooManyRequestsException = class _TooManyRequestsException extends SSOServiceException {
      constructor(opts) {
        super({
          name: "TooManyRequestsException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "TooManyRequestsException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _TooManyRequestsException.prototype);
      }
    };
    UnauthorizedException = class _UnauthorizedException extends SSOServiceException {
      constructor(opts) {
        super({
          name: "UnauthorizedException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "UnauthorizedException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _UnauthorizedException.prototype);
      }
    };
    GetRoleCredentialsRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.accessToken && { accessToken: SENSITIVE_STRING }
    });
    RoleCredentialsFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.secretAccessKey && { secretAccessKey: SENSITIVE_STRING },
      ...obj.sessionToken && { sessionToken: SENSITIVE_STRING }
    });
    GetRoleCredentialsResponseFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.roleCredentials && { roleCredentials: RoleCredentialsFilterSensitiveLog(obj.roleCredentials) }
    });
    ListAccountRolesRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.accessToken && { accessToken: SENSITIVE_STRING }
    });
    ListAccountsRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.accessToken && { accessToken: SENSITIVE_STRING }
    });
    LogoutRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.accessToken && { accessToken: SENSITIVE_STRING }
    });
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/protocols/Aws_restJson1.js
var se_GetRoleCredentialsCommand, se_ListAccountRolesCommand, se_ListAccountsCommand, se_LogoutCommand, de_GetRoleCredentialsCommand, de_ListAccountRolesCommand, de_ListAccountsCommand, de_LogoutCommand, de_CommandError2, throwDefaultError3, de_InvalidRequestExceptionRes2, de_ResourceNotFoundExceptionRes, de_TooManyRequestsExceptionRes, de_UnauthorizedExceptionRes, deserializeMetadata3, _aI, _aT, _ai, _mR, _mr, _nT, _nt, _rN, _rn, _xasbt;
var init_Aws_restJson12 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/protocols/Aws_restJson1.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es18();
    init_dist_es24();
    init_models_02();
    init_SSOServiceException();
    se_GetRoleCredentialsCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = map({}, isSerializableHeaderValue, {
        [_xasbt]: input[_aT]
      });
      b9.bp("/federation/credentials");
      const query = map({
        [_rn]: [, expectNonNull(input[_rN], `roleName`)],
        [_ai]: [, expectNonNull(input[_aI], `accountId`)]
      });
      let body2;
      b9.m("GET").h(headers).q(query).b(body2);
      return b9.build();
    };
    se_ListAccountRolesCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = map({}, isSerializableHeaderValue, {
        [_xasbt]: input[_aT]
      });
      b9.bp("/assignment/roles");
      const query = map({
        [_nt]: [, input[_nT]],
        [_mr]: [() => input.maxResults !== void 0, () => input[_mR].toString()],
        [_ai]: [, expectNonNull(input[_aI], `accountId`)]
      });
      let body2;
      b9.m("GET").h(headers).q(query).b(body2);
      return b9.build();
    };
    se_ListAccountsCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = map({}, isSerializableHeaderValue, {
        [_xasbt]: input[_aT]
      });
      b9.bp("/assignment/accounts");
      const query = map({
        [_nt]: [, input[_nT]],
        [_mr]: [() => input.maxResults !== void 0, () => input[_mR].toString()]
      });
      let body2;
      b9.m("GET").h(headers).q(query).b(body2);
      return b9.build();
    };
    se_LogoutCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = map({}, isSerializableHeaderValue, {
        [_xasbt]: input[_aT]
      });
      b9.bp("/logout");
      let body2;
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    de_GetRoleCredentialsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError2(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata3(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        roleCredentials: _json
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_ListAccountRolesCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError2(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata3(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        nextToken: expectString,
        roleList: _json
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_ListAccountsCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError2(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata3(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        accountList: _json,
        nextToken: expectString
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_LogoutCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError2(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata3(output)
      });
      await collectBody(output.body, context);
      return contents;
    };
    de_CommandError2 = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseJsonErrorBody(output.body, context)
      };
      const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "InvalidRequestException":
        case "com.amazonaws.sso#InvalidRequestException":
          throw await de_InvalidRequestExceptionRes2(parsedOutput, context);
        case "ResourceNotFoundException":
        case "com.amazonaws.sso#ResourceNotFoundException":
          throw await de_ResourceNotFoundExceptionRes(parsedOutput, context);
        case "TooManyRequestsException":
        case "com.amazonaws.sso#TooManyRequestsException":
          throw await de_TooManyRequestsExceptionRes(parsedOutput, context);
        case "UnauthorizedException":
        case "com.amazonaws.sso#UnauthorizedException":
          throw await de_UnauthorizedExceptionRes(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          return throwDefaultError3({
            output,
            parsedBody,
            errorCode
          });
      }
    };
    throwDefaultError3 = withBaseException(SSOServiceException);
    de_InvalidRequestExceptionRes2 = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new InvalidRequestException2({
        $metadata: deserializeMetadata3(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_ResourceNotFoundExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new ResourceNotFoundException({
        $metadata: deserializeMetadata3(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_TooManyRequestsExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new TooManyRequestsException({
        $metadata: deserializeMetadata3(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_UnauthorizedExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new UnauthorizedException({
        $metadata: deserializeMetadata3(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    deserializeMetadata3 = (output) => ({
      httpStatusCode: output.statusCode,
      requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
      extendedRequestId: output.headers["x-amz-id-2"],
      cfId: output.headers["x-amz-cf-id"]
    });
    _aI = "accountId";
    _aT = "accessToken";
    _ai = "account_id";
    _mR = "maxResults";
    _mr = "max_result";
    _nT = "nextToken";
    _nt = "next_token";
    _rN = "roleName";
    _rn = "role_name";
    _xasbt = "x-amz-sso_bearer_token";
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/GetRoleCredentialsCommand.js
var GetRoleCredentialsCommand;
var init_GetRoleCredentialsCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/GetRoleCredentialsCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters3();
    init_models_02();
    init_Aws_restJson12();
    GetRoleCredentialsCommand = class extends Command.classBuilder().ep(commonParams3).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("SWBPortalService", "GetRoleCredentials", {}).n("SSOClient", "GetRoleCredentialsCommand").f(GetRoleCredentialsRequestFilterSensitiveLog, GetRoleCredentialsResponseFilterSensitiveLog).ser(se_GetRoleCredentialsCommand).de(de_GetRoleCredentialsCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/ListAccountRolesCommand.js
var ListAccountRolesCommand;
var init_ListAccountRolesCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/ListAccountRolesCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters3();
    init_models_02();
    init_Aws_restJson12();
    ListAccountRolesCommand = class extends Command.classBuilder().ep(commonParams3).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("SWBPortalService", "ListAccountRoles", {}).n("SSOClient", "ListAccountRolesCommand").f(ListAccountRolesRequestFilterSensitiveLog, void 0).ser(se_ListAccountRolesCommand).de(de_ListAccountRolesCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/ListAccountsCommand.js
var ListAccountsCommand;
var init_ListAccountsCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/ListAccountsCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters3();
    init_models_02();
    init_Aws_restJson12();
    ListAccountsCommand = class extends Command.classBuilder().ep(commonParams3).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("SWBPortalService", "ListAccounts", {}).n("SSOClient", "ListAccountsCommand").f(ListAccountsRequestFilterSensitiveLog, void 0).ser(se_ListAccountsCommand).de(de_ListAccountsCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/LogoutCommand.js
var LogoutCommand;
var init_LogoutCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/LogoutCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters3();
    init_models_02();
    init_Aws_restJson12();
    LogoutCommand = class extends Command.classBuilder().ep(commonParams3).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("SWBPortalService", "Logout", {}).n("SSOClient", "LogoutCommand").f(LogoutRequestFilterSensitiveLog, void 0).ser(se_LogoutCommand).de(de_LogoutCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/SSO.js
var commands2, SSO;
var init_SSO = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/SSO.js"() {
    "use strict";
    init_dist_es24();
    init_GetRoleCredentialsCommand();
    init_ListAccountRolesCommand();
    init_ListAccountsCommand();
    init_LogoutCommand();
    init_SSOClient();
    commands2 = {
      GetRoleCredentialsCommand,
      ListAccountRolesCommand,
      ListAccountsCommand,
      LogoutCommand
    };
    SSO = class extends SSOClient {
    };
    createAggregatedClient(commands2, SSO);
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/index.js
var init_commands2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/commands/index.js"() {
    "use strict";
    init_GetRoleCredentialsCommand();
    init_ListAccountRolesCommand();
    init_ListAccountsCommand();
    init_LogoutCommand();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/Interfaces.js
var init_Interfaces = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/Interfaces.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/ListAccountRolesPaginator.js
var paginateListAccountRoles;
var init_ListAccountRolesPaginator = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/ListAccountRolesPaginator.js"() {
    "use strict";
    init_dist_es18();
    init_ListAccountRolesCommand();
    init_SSOClient();
    paginateListAccountRoles = createPaginator(SSOClient, ListAccountRolesCommand, "nextToken", "nextToken", "maxResults");
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/ListAccountsPaginator.js
var paginateListAccounts;
var init_ListAccountsPaginator = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/ListAccountsPaginator.js"() {
    "use strict";
    init_dist_es18();
    init_ListAccountsCommand();
    init_SSOClient();
    paginateListAccounts = createPaginator(SSOClient, ListAccountsCommand, "nextToken", "nextToken", "maxResults");
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/index.js
var init_pagination2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/pagination/index.js"() {
    "use strict";
    init_Interfaces();
    init_ListAccountRolesPaginator();
    init_ListAccountsPaginator();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/models/index.js
var init_models2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/models/index.js"() {
    "use strict";
    init_models_02();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/index.js
var init_dist_es47 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-sso@3.817.0/node_modules/@aws-sdk/client-sso/dist-es/index.js"() {
    "use strict";
    init_SSOClient();
    init_SSO();
    init_commands2();
    init_pagination2();
    init_models2();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/loadSso.js
var loadSso_exports = {};
__export(loadSso_exports, {
  GetRoleCredentialsCommand: () => GetRoleCredentialsCommand,
  SSOClient: () => SSOClient
});
var init_loadSso = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/loadSso.js"() {
    "use strict";
    init_dist_es47();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/resolveSSOCredentials.js
var SHOULD_FAIL_CREDENTIAL_CHAIN, resolveSSOCredentials;
var init_resolveSSOCredentials = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/resolveSSOCredentials.js"() {
    "use strict";
    init_client2();
    init_dist_es46();
    init_dist_es21();
    init_dist_es30();
    SHOULD_FAIL_CREDENTIAL_CHAIN = false;
    resolveSSOCredentials = async ({ ssoStartUrl, ssoSession, ssoAccountId, ssoRegion, ssoRoleName, ssoClient, clientConfig, parentClientConfig, profile, logger: logger2 }) => {
      let token;
      const refreshMessage = `To refresh this SSO session run aws sso login with the corresponding profile.`;
      if (ssoSession) {
        try {
          const _token = await fromSso({ profile })();
          token = {
            accessToken: _token.token,
            expiresAt: new Date(_token.expiration).toISOString()
          };
        } catch (e6) {
          throw new CredentialsProviderError(e6.message, {
            tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
            logger: logger2
          });
        }
      } else {
        try {
          token = await getSSOTokenFromFile(ssoStartUrl);
        } catch (e6) {
          throw new CredentialsProviderError(`The SSO session associated with this profile is invalid. ${refreshMessage}`, {
            tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
            logger: logger2
          });
        }
      }
      if (new Date(token.expiresAt).getTime() - Date.now() <= 0) {
        throw new CredentialsProviderError(`The SSO session associated with this profile has expired. ${refreshMessage}`, {
          tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
          logger: logger2
        });
      }
      const { accessToken } = token;
      const { SSOClient: SSOClient2, GetRoleCredentialsCommand: GetRoleCredentialsCommand2 } = await Promise.resolve().then(() => (init_loadSso(), loadSso_exports));
      const sso = ssoClient || new SSOClient2(Object.assign({}, clientConfig ?? {}, {
        logger: clientConfig?.logger ?? parentClientConfig?.logger,
        region: clientConfig?.region ?? ssoRegion
      }));
      let ssoResp;
      try {
        ssoResp = await sso.send(new GetRoleCredentialsCommand2({
          accountId: ssoAccountId,
          roleName: ssoRoleName,
          accessToken
        }));
      } catch (e6) {
        throw new CredentialsProviderError(e6, {
          tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
          logger: logger2
        });
      }
      const { roleCredentials: { accessKeyId, secretAccessKey, sessionToken, expiration, credentialScope, accountId } = {} } = ssoResp;
      if (!accessKeyId || !secretAccessKey || !sessionToken || !expiration) {
        throw new CredentialsProviderError("SSO returns an invalid temporary credential.", {
          tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
          logger: logger2
        });
      }
      const credentials2 = {
        accessKeyId,
        secretAccessKey,
        sessionToken,
        expiration: new Date(expiration),
        ...credentialScope && { credentialScope },
        ...accountId && { accountId }
      };
      if (ssoSession) {
        setCredentialFeature(credentials2, "CREDENTIALS_SSO", "s");
      } else {
        setCredentialFeature(credentials2, "CREDENTIALS_SSO_LEGACY", "u");
      }
      return credentials2;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/validateSsoProfile.js
var validateSsoProfile;
var init_validateSsoProfile = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/validateSsoProfile.js"() {
    "use strict";
    init_dist_es21();
    validateSsoProfile = (profile, logger2) => {
      const { sso_start_url, sso_account_id, sso_region, sso_role_name } = profile;
      if (!sso_start_url || !sso_account_id || !sso_region || !sso_role_name) {
        throw new CredentialsProviderError(`Profile is configured with invalid SSO credentials. Required parameters "sso_account_id", "sso_region", "sso_role_name", "sso_start_url". Got ${Object.keys(profile).join(", ")}
Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, { tryNextLink: false, logger: logger2 });
      }
      return profile;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/fromSSO.js
var fromSSO;
var init_fromSSO = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/fromSSO.js"() {
    "use strict";
    init_dist_es21();
    init_dist_es30();
    init_isSsoProfile();
    init_resolveSSOCredentials();
    init_validateSsoProfile();
    fromSSO = (init3 = {}) => async ({ callerClientConfig } = {}) => {
      init3.logger?.debug("@aws-sdk/credential-provider-sso - fromSSO");
      const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init3;
      const { ssoClient } = init3;
      const profileName = getProfileName({
        profile: init3.profile ?? callerClientConfig?.profile
      });
      if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
        const profiles = await parseKnownFiles(init3);
        const profile = profiles[profileName];
        if (!profile) {
          throw new CredentialsProviderError(`Profile ${profileName} was not found.`, { logger: init3.logger });
        }
        if (!isSsoProfile(profile)) {
          throw new CredentialsProviderError(`Profile ${profileName} is not configured with SSO credentials.`, {
            logger: init3.logger
          });
        }
        if (profile?.sso_session) {
          const ssoSessions = await loadSsoSessionData(init3);
          const session = ssoSessions[profile.sso_session];
          const conflictMsg = ` configurations in profile ${profileName} and sso-session ${profile.sso_session}`;
          if (ssoRegion && ssoRegion !== session.sso_region) {
            throw new CredentialsProviderError(`Conflicting SSO region` + conflictMsg, {
              tryNextLink: false,
              logger: init3.logger
            });
          }
          if (ssoStartUrl && ssoStartUrl !== session.sso_start_url) {
            throw new CredentialsProviderError(`Conflicting SSO start_url` + conflictMsg, {
              tryNextLink: false,
              logger: init3.logger
            });
          }
          profile.sso_region = session.sso_region;
          profile.sso_start_url = session.sso_start_url;
        }
        const { sso_start_url, sso_account_id, sso_region, sso_role_name, sso_session } = validateSsoProfile(profile, init3.logger);
        return resolveSSOCredentials({
          ssoStartUrl: sso_start_url,
          ssoSession: sso_session,
          ssoAccountId: sso_account_id,
          ssoRegion: sso_region,
          ssoRoleName: sso_role_name,
          ssoClient,
          clientConfig: init3.clientConfig,
          parentClientConfig: init3.parentClientConfig,
          profile: profileName
        });
      } else if (!ssoStartUrl || !ssoAccountId || !ssoRegion || !ssoRoleName) {
        throw new CredentialsProviderError('Incomplete configuration. The fromSSO() argument hash must include "ssoStartUrl", "ssoAccountId", "ssoRegion", "ssoRoleName"', { tryNextLink: false, logger: init3.logger });
      } else {
        return resolveSSOCredentials({
          ssoStartUrl,
          ssoSession,
          ssoAccountId,
          ssoRegion,
          ssoRoleName,
          ssoClient,
          clientConfig: init3.clientConfig,
          parentClientConfig: init3.parentClientConfig,
          profile: profileName
        });
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/types.js
var init_types10 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/types.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/index.js
var dist_es_exports4 = {};
__export(dist_es_exports4, {
  fromSSO: () => fromSSO,
  isSsoProfile: () => isSsoProfile,
  validateSsoProfile: () => validateSsoProfile
});
var init_dist_es48 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-sso@3.817.0/node_modules/@aws-sdk/credential-provider-sso/dist-es/index.js"() {
    "use strict";
    init_fromSSO();
    init_isSsoProfile();
    init_types10();
    init_validateSsoProfile();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveCredentialSource.js
var resolveCredentialSource, setNamedProvider;
var init_resolveCredentialSource = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveCredentialSource.js"() {
    "use strict";
    init_client2();
    init_dist_es21();
    resolveCredentialSource = (credentialSource, profileName, logger2) => {
      const sourceProvidersMap = {
        EcsContainer: async (options) => {
          const { fromHttp: fromHttp2 } = await Promise.resolve().then(() => (init_dist_es40(), dist_es_exports3));
          const { fromContainerMetadata: fromContainerMetadata2 } = await Promise.resolve().then(() => (init_dist_es39(), dist_es_exports2));
          logger2?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer");
          return async () => chain(fromHttp2(options ?? {}), fromContainerMetadata2(options))().then(setNamedProvider);
        },
        Ec2InstanceMetadata: async (options) => {
          logger2?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
          const { fromInstanceMetadata: fromInstanceMetadata2 } = await Promise.resolve().then(() => (init_dist_es39(), dist_es_exports2));
          return async () => fromInstanceMetadata2(options)().then(setNamedProvider);
        },
        Environment: async (options) => {
          logger2?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
          const { fromEnv: fromEnv3 } = await Promise.resolve().then(() => (init_dist_es38(), dist_es_exports));
          return async () => fromEnv3(options)().then(setNamedProvider);
        }
      };
      if (credentialSource in sourceProvidersMap) {
        return sourceProvidersMap[credentialSource];
      } else {
        throw new CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger: logger2 });
      }
    };
    setNamedProvider = (creds) => setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p");
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/auth/httpAuthSchemeProvider.js
function createAwsAuthSigv4HttpAuthOption4(authParameters) {
  return {
    schemeId: "aws.auth#sigv4",
    signingProperties: {
      name: "sts",
      region: authParameters.region
    },
    propertiesExtractor: (config, context) => ({
      signingProperties: {
        config,
        context
      }
    })
  };
}
function createSmithyApiNoAuthHttpAuthOption3(authParameters) {
  return {
    schemeId: "smithy.api#noAuth"
  };
}
var defaultSTSHttpAuthSchemeParametersProvider, defaultSTSHttpAuthSchemeProvider, resolveStsAuthConfig, resolveHttpAuthSchemeConfig4;
var init_httpAuthSchemeProvider4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/auth/httpAuthSchemeProvider.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es6();
    init_STSClient();
    defaultSTSHttpAuthSchemeParametersProvider = async (config, context, input) => {
      return {
        operation: getSmithyContext(context).operation,
        region: await normalizeProvider(config.region)() || (() => {
          throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
        })()
      };
    };
    defaultSTSHttpAuthSchemeProvider = (authParameters) => {
      const options = [];
      switch (authParameters.operation) {
        case "AssumeRoleWithWebIdentity": {
          options.push(createSmithyApiNoAuthHttpAuthOption3(authParameters));
          break;
        }
        default: {
          options.push(createAwsAuthSigv4HttpAuthOption4(authParameters));
        }
      }
      return options;
    };
    resolveStsAuthConfig = (input) => Object.assign(input, {
      stsClientCtor: STSClient
    });
    resolveHttpAuthSchemeConfig4 = (config) => {
      const config_0 = resolveStsAuthConfig(config);
      const config_1 = resolveAwsSdkSigV4Config(config_0);
      return Object.assign(config_1, {
        authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
      });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/EndpointParameters.js
var resolveClientEndpointParameters4, commonParams4;
var init_EndpointParameters4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/EndpointParameters.js"() {
    "use strict";
    resolveClientEndpointParameters4 = (options) => {
      return Object.assign(options, {
        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
        useFipsEndpoint: options.useFipsEndpoint ?? false,
        useGlobalEndpoint: options.useGlobalEndpoint ?? false,
        defaultSigningName: "sts"
      });
    };
    commonParams4 = {
      UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
      UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
      Endpoint: { type: "builtInParams", name: "endpoint" },
      Region: { type: "builtInParams", name: "region" },
      UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/ruleset.js
var F2, G, H, I, J, a3, b3, c3, d3, e4, f5, g3, h4, i5, j3, k3, l3, m4, n3, o3, p3, q3, r4, s4, t4, u3, v3, w3, x4, y, z, A2, B, C, D, E, _data3, ruleSet3;
var init_ruleset3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/ruleset.js"() {
    "use strict";
    F2 = "required";
    G = "type";
    H = "fn";
    I = "argv";
    J = "ref";
    a3 = false;
    b3 = true;
    c3 = "booleanEquals";
    d3 = "stringEquals";
    e4 = "sigv4";
    f5 = "sts";
    g3 = "us-east-1";
    h4 = "endpoint";
    i5 = "https://sts.{Region}.{PartitionResult#dnsSuffix}";
    j3 = "tree";
    k3 = "error";
    l3 = "getAttr";
    m4 = { [F2]: false, [G]: "String" };
    n3 = { [F2]: true, "default": false, [G]: "Boolean" };
    o3 = { [J]: "Endpoint" };
    p3 = { [H]: "isSet", [I]: [{ [J]: "Region" }] };
    q3 = { [J]: "Region" };
    r4 = { [H]: "aws.partition", [I]: [q3], "assign": "PartitionResult" };
    s4 = { [J]: "UseFIPS" };
    t4 = { [J]: "UseDualStack" };
    u3 = { "url": "https://sts.amazonaws.com", "properties": { "authSchemes": [{ "name": e4, "signingName": f5, "signingRegion": g3 }] }, "headers": {} };
    v3 = {};
    w3 = { "conditions": [{ [H]: d3, [I]: [q3, "aws-global"] }], [h4]: u3, [G]: h4 };
    x4 = { [H]: c3, [I]: [s4, true] };
    y = { [H]: c3, [I]: [t4, true] };
    z = { [H]: l3, [I]: [{ [J]: "PartitionResult" }, "supportsFIPS"] };
    A2 = { [J]: "PartitionResult" };
    B = { [H]: c3, [I]: [true, { [H]: l3, [I]: [A2, "supportsDualStack"] }] };
    C = [{ [H]: "isSet", [I]: [o3] }];
    D = [x4];
    E = [y];
    _data3 = { version: "1.0", parameters: { Region: m4, UseDualStack: n3, UseFIPS: n3, Endpoint: m4, UseGlobalEndpoint: n3 }, rules: [{ conditions: [{ [H]: c3, [I]: [{ [J]: "UseGlobalEndpoint" }, b3] }, { [H]: "not", [I]: C }, p3, r4, { [H]: c3, [I]: [s4, a3] }, { [H]: c3, [I]: [t4, a3] }], rules: [{ conditions: [{ [H]: d3, [I]: [q3, "ap-northeast-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "ap-south-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "ap-southeast-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "ap-southeast-2"] }], endpoint: u3, [G]: h4 }, w3, { conditions: [{ [H]: d3, [I]: [q3, "ca-central-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "eu-central-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "eu-north-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "eu-west-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "eu-west-2"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "eu-west-3"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "sa-east-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, g3] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "us-east-2"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "us-west-1"] }], endpoint: u3, [G]: h4 }, { conditions: [{ [H]: d3, [I]: [q3, "us-west-2"] }], endpoint: u3, [G]: h4 }, { endpoint: { url: i5, properties: { authSchemes: [{ name: e4, signingName: f5, signingRegion: "{Region}" }] }, headers: v3 }, [G]: h4 }], [G]: j3 }, { conditions: C, rules: [{ conditions: D, error: "Invalid Configuration: FIPS and custom endpoint are not supported", [G]: k3 }, { conditions: E, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", [G]: k3 }, { endpoint: { url: o3, properties: v3, headers: v3 }, [G]: h4 }], [G]: j3 }, { conditions: [p3], rules: [{ conditions: [r4], rules: [{ conditions: [x4, y], rules: [{ conditions: [{ [H]: c3, [I]: [b3, z] }, B], rules: [{ endpoint: { url: "https://sts-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: v3, headers: v3 }, [G]: h4 }], [G]: j3 }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", [G]: k3 }], [G]: j3 }, { conditions: D, rules: [{ conditions: [{ [H]: c3, [I]: [z, b3] }], rules: [{ conditions: [{ [H]: d3, [I]: [{ [H]: l3, [I]: [A2, "name"] }, "aws-us-gov"] }], endpoint: { url: "https://sts.{Region}.amazonaws.com", properties: v3, headers: v3 }, [G]: h4 }, { endpoint: { url: "https://sts-fips.{Region}.{PartitionResult#dnsSuffix}", properties: v3, headers: v3 }, [G]: h4 }], [G]: j3 }, { error: "FIPS is enabled but this partition does not support FIPS", [G]: k3 }], [G]: j3 }, { conditions: E, rules: [{ conditions: [B], rules: [{ endpoint: { url: "https://sts.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: v3, headers: v3 }, [G]: h4 }], [G]: j3 }, { error: "DualStack is enabled but this partition does not support DualStack", [G]: k3 }], [G]: j3 }, w3, { endpoint: { url: i5, properties: v3, headers: v3 }, [G]: h4 }], [G]: j3 }], [G]: j3 }, { error: "Invalid Configuration: Missing Region", [G]: k3 }] };
    ruleSet3 = _data3;
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/endpointResolver.js
var cache3, defaultEndpointResolver3;
var init_endpointResolver3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/endpoint/endpointResolver.js"() {
    "use strict";
    init_dist_es20();
    init_dist_es19();
    init_ruleset3();
    cache3 = new EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS", "UseGlobalEndpoint"]
    });
    defaultEndpointResolver3 = (endpointParams, context = {}) => {
      return cache3.get(endpointParams, () => resolveEndpoint(ruleSet3, {
        endpointParams,
        logger: context.logger
      }));
    };
    customEndpointFunctions.aws = awsEndpointFunctions;
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/runtimeConfig.shared.js
var getRuntimeConfig5;
var init_runtimeConfig_shared3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/runtimeConfig.shared.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es18();
    init_dist_es24();
    init_dist_es33();
    init_dist_es11();
    init_dist_es10();
    init_httpAuthSchemeProvider4();
    init_endpointResolver3();
    getRuntimeConfig5 = (config) => {
      return {
        apiVersion: "2011-06-15",
        base64Decoder: config?.base64Decoder ?? fromBase64,
        base64Encoder: config?.base64Encoder ?? toBase64,
        disableHostPrefix: config?.disableHostPrefix ?? false,
        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver3,
        extensions: config?.extensions ?? [],
        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSTSHttpAuthSchemeProvider,
        httpAuthSchemes: config?.httpAuthSchemes ?? [
          {
            schemeId: "aws.auth#sigv4",
            identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
            signer: new AwsSdkSigV4Signer()
          },
          {
            schemeId: "smithy.api#noAuth",
            identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
            signer: new NoAuthSigner()
          }
        ],
        logger: config?.logger ?? new NoOpLogger(),
        serviceId: config?.serviceId ?? "STS",
        urlParser: config?.urlParser ?? parseUrl,
        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
        utf8Encoder: config?.utf8Encoder ?? toUtf8
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/runtimeConfig.js
var getRuntimeConfig6;
var init_runtimeConfig3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/runtimeConfig.js"() {
    "use strict";
    init_package2();
    init_dist_es25();
    init_dist_es41();
    init_dist_es28();
    init_dist_es18();
    init_dist_es42();
    init_dist_es37();
    init_dist_es31();
    init_dist_es14();
    init_dist_es43();
    init_dist_es36();
    init_runtimeConfig_shared3();
    init_dist_es24();
    init_dist_es44();
    init_dist_es24();
    getRuntimeConfig6 = (config) => {
      emitWarningIfUnsupportedVersion2(process.version);
      const defaultsMode = resolveDefaultsModeConfig(config);
      const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
      const clientSharedValues = getRuntimeConfig5(config);
      emitWarningIfUnsupportedVersion(process.version);
      const loaderConfig = {
        profile: config?.profile,
        logger: clientSharedValues.logger
      };
      return {
        ...clientSharedValues,
        ...config,
        runtime: "node",
        defaultsMode,
        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default2.version }),
        httpAuthSchemes: config?.httpAuthSchemes ?? [
          {
            schemeId: "aws.auth#sigv4",
            identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4") || (async (idProps) => await config.credentialDefaultProvider(idProps?.__config || {})()),
            signer: new AwsSdkSigV4Signer()
          },
          {
            schemeId: "smithy.api#noAuth",
            identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
            signer: new NoAuthSigner()
          }
        ],
        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
        retryMode: config?.retryMode ?? loadConfig({
          ...NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
        }, config),
        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
        streamCollector: config?.streamCollector ?? streamCollector,
        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration3, resolveHttpAuthRuntimeConfig3;
var init_httpAuthExtensionConfiguration3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/auth/httpAuthExtensionConfiguration.js"() {
    "use strict";
    getHttpAuthExtensionConfiguration3 = (runtimeConfig) => {
      const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
      let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
      let _credentials = runtimeConfig.credentials;
      return {
        setHttpAuthScheme(httpAuthScheme) {
          const index7 = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
          if (index7 === -1) {
            _httpAuthSchemes.push(httpAuthScheme);
          } else {
            _httpAuthSchemes.splice(index7, 1, httpAuthScheme);
          }
        },
        httpAuthSchemes() {
          return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
          _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
          return _httpAuthSchemeProvider;
        },
        setCredentials(credentials2) {
          _credentials = credentials2;
        },
        credentials() {
          return _credentials;
        }
      };
    };
    resolveHttpAuthRuntimeConfig3 = (config) => {
      return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials()
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/runtimeExtensions.js
var resolveRuntimeExtensions3;
var init_runtimeExtensions3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/runtimeExtensions.js"() {
    "use strict";
    init_dist_es45();
    init_dist_es2();
    init_dist_es24();
    init_httpAuthExtensionConfiguration3();
    resolveRuntimeExtensions3 = (runtimeConfig, extensions) => {
      const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration3(runtimeConfig));
      extensions.forEach((extension) => extension.configure(extensionConfiguration));
      return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig3(extensionConfiguration));
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/STSClient.js
var STSClient;
var init_STSClient = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/STSClient.js"() {
    "use strict";
    init_dist_es3();
    init_dist_es4();
    init_dist_es5();
    init_dist_es26();
    init_dist_es28();
    init_dist_es18();
    init_dist_es29();
    init_dist_es34();
    init_dist_es37();
    init_dist_es24();
    init_httpAuthSchemeProvider4();
    init_EndpointParameters4();
    init_runtimeConfig3();
    init_runtimeExtensions3();
    STSClient = class extends Client {
      constructor(...[configuration]) {
        const _config_0 = getRuntimeConfig6(configuration || {});
        super(_config_0);
        __publicField(this, "config");
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters4(_config_0);
        const _config_2 = resolveUserAgentConfig(_config_1);
        const _config_3 = resolveRetryConfig(_config_2);
        const _config_4 = resolveRegionConfig(_config_3);
        const _config_5 = resolveHostHeaderConfig(_config_4);
        const _config_6 = resolveEndpointConfig(_config_5);
        const _config_7 = resolveHttpAuthSchemeConfig4(_config_6);
        const _config_8 = resolveRuntimeExtensions3(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(getUserAgentPlugin(this.config));
        this.middlewareStack.use(getRetryPlugin(this.config));
        this.middlewareStack.use(getContentLengthPlugin(this.config));
        this.middlewareStack.use(getHostHeaderPlugin(this.config));
        this.middlewareStack.use(getLoggerPlugin(this.config));
        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
          httpAuthSchemeParametersProvider: defaultSTSHttpAuthSchemeParametersProvider,
          identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
            "aws.auth#sigv4": config.credentials
          })
        }));
        this.middlewareStack.use(getHttpSigningPlugin(this.config));
      }
      destroy() {
        super.destroy();
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/STSServiceException.js
var STSServiceException;
var init_STSServiceException = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/STSServiceException.js"() {
    "use strict";
    init_dist_es24();
    STSServiceException = class _STSServiceException extends ServiceException {
      constructor(options) {
        super(options);
        Object.setPrototypeOf(this, _STSServiceException.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/models_0.js
var CredentialsFilterSensitiveLog, AssumeRoleResponseFilterSensitiveLog, ExpiredTokenException2, MalformedPolicyDocumentException, PackedPolicyTooLargeException, RegionDisabledException, IDPRejectedClaimException, InvalidIdentityTokenException, AssumeRoleWithWebIdentityRequestFilterSensitiveLog, AssumeRoleWithWebIdentityResponseFilterSensitiveLog, IDPCommunicationErrorException;
var init_models_03 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/models_0.js"() {
    "use strict";
    init_dist_es24();
    init_STSServiceException();
    CredentialsFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.SecretAccessKey && { SecretAccessKey: SENSITIVE_STRING }
    });
    AssumeRoleResponseFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Credentials && { Credentials: CredentialsFilterSensitiveLog(obj.Credentials) }
    });
    ExpiredTokenException2 = class _ExpiredTokenException extends STSServiceException {
      constructor(opts) {
        super({
          name: "ExpiredTokenException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "ExpiredTokenException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _ExpiredTokenException.prototype);
      }
    };
    MalformedPolicyDocumentException = class _MalformedPolicyDocumentException extends STSServiceException {
      constructor(opts) {
        super({
          name: "MalformedPolicyDocumentException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "MalformedPolicyDocumentException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _MalformedPolicyDocumentException.prototype);
      }
    };
    PackedPolicyTooLargeException = class _PackedPolicyTooLargeException extends STSServiceException {
      constructor(opts) {
        super({
          name: "PackedPolicyTooLargeException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "PackedPolicyTooLargeException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _PackedPolicyTooLargeException.prototype);
      }
    };
    RegionDisabledException = class _RegionDisabledException extends STSServiceException {
      constructor(opts) {
        super({
          name: "RegionDisabledException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "RegionDisabledException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _RegionDisabledException.prototype);
      }
    };
    IDPRejectedClaimException = class _IDPRejectedClaimException extends STSServiceException {
      constructor(opts) {
        super({
          name: "IDPRejectedClaimException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "IDPRejectedClaimException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _IDPRejectedClaimException.prototype);
      }
    };
    InvalidIdentityTokenException = class _InvalidIdentityTokenException extends STSServiceException {
      constructor(opts) {
        super({
          name: "InvalidIdentityTokenException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidIdentityTokenException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _InvalidIdentityTokenException.prototype);
      }
    };
    AssumeRoleWithWebIdentityRequestFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.WebIdentityToken && { WebIdentityToken: SENSITIVE_STRING }
    });
    AssumeRoleWithWebIdentityResponseFilterSensitiveLog = (obj) => ({
      ...obj,
      ...obj.Credentials && { Credentials: CredentialsFilterSensitiveLog(obj.Credentials) }
    });
    IDPCommunicationErrorException = class _IDPCommunicationErrorException extends STSServiceException {
      constructor(opts) {
        super({
          name: "IDPCommunicationErrorException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "IDPCommunicationErrorException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _IDPCommunicationErrorException.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/protocols/Aws_query.js
var se_AssumeRoleCommand, se_AssumeRoleWithWebIdentityCommand, de_AssumeRoleCommand, de_AssumeRoleWithWebIdentityCommand, de_CommandError3, de_ExpiredTokenExceptionRes2, de_IDPCommunicationErrorExceptionRes, de_IDPRejectedClaimExceptionRes, de_InvalidIdentityTokenExceptionRes, de_MalformedPolicyDocumentExceptionRes, de_PackedPolicyTooLargeExceptionRes, de_RegionDisabledExceptionRes, se_AssumeRoleRequest, se_AssumeRoleWithWebIdentityRequest, se_policyDescriptorListType, se_PolicyDescriptorType, se_ProvidedContext, se_ProvidedContextsListType, se_Tag, se_tagKeyListType, se_tagListType, de_AssumedRoleUser, de_AssumeRoleResponse, de_AssumeRoleWithWebIdentityResponse, de_Credentials, de_ExpiredTokenException, de_IDPCommunicationErrorException, de_IDPRejectedClaimException, de_InvalidIdentityTokenException, de_MalformedPolicyDocumentException, de_PackedPolicyTooLargeException, de_RegionDisabledException, deserializeMetadata4, throwDefaultError4, buildHttpRpcRequest, SHARED_HEADERS, _2, _A, _AKI, _AR, _ARI, _ARU, _ARWWI, _Ar, _Au, _C, _CA, _DS, _E, _EI, _K, _P, _PA, _PAr, _PC, _PI, _PPS, _Pr, _RA, _RSN, _SAK, _SFWIT, _SI, _SN, _ST, _T, _TC, _TTK, _V, _Va, _WIT, _a450, _m, buildFormUrlencodedString, loadQueryErrorCode;
var init_Aws_query = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/protocols/Aws_query.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es2();
    init_dist_es24();
    init_models_03();
    init_STSServiceException();
    se_AssumeRoleCommand = async (input, context) => {
      const headers = SHARED_HEADERS;
      let body2;
      body2 = buildFormUrlencodedString({
        ...se_AssumeRoleRequest(input, context),
        [_A]: _AR,
        [_V]: _2
      });
      return buildHttpRpcRequest(context, headers, "/", void 0, body2);
    };
    se_AssumeRoleWithWebIdentityCommand = async (input, context) => {
      const headers = SHARED_HEADERS;
      let body2;
      body2 = buildFormUrlencodedString({
        ...se_AssumeRoleWithWebIdentityRequest(input, context),
        [_A]: _ARWWI,
        [_V]: _2
      });
      return buildHttpRpcRequest(context, headers, "/", void 0, body2);
    };
    de_AssumeRoleCommand = async (output, context) => {
      if (output.statusCode >= 300) {
        return de_CommandError3(output, context);
      }
      const data = await parseXmlBody(output.body, context);
      let contents = {};
      contents = de_AssumeRoleResponse(data.AssumeRoleResult, context);
      const response = {
        $metadata: deserializeMetadata4(output),
        ...contents
      };
      return response;
    };
    de_AssumeRoleWithWebIdentityCommand = async (output, context) => {
      if (output.statusCode >= 300) {
        return de_CommandError3(output, context);
      }
      const data = await parseXmlBody(output.body, context);
      let contents = {};
      contents = de_AssumeRoleWithWebIdentityResponse(data.AssumeRoleWithWebIdentityResult, context);
      const response = {
        $metadata: deserializeMetadata4(output),
        ...contents
      };
      return response;
    };
    de_CommandError3 = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseXmlErrorBody(output.body, context)
      };
      const errorCode = loadQueryErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "ExpiredTokenException":
        case "com.amazonaws.sts#ExpiredTokenException":
          throw await de_ExpiredTokenExceptionRes2(parsedOutput, context);
        case "MalformedPolicyDocument":
        case "com.amazonaws.sts#MalformedPolicyDocumentException":
          throw await de_MalformedPolicyDocumentExceptionRes(parsedOutput, context);
        case "PackedPolicyTooLarge":
        case "com.amazonaws.sts#PackedPolicyTooLargeException":
          throw await de_PackedPolicyTooLargeExceptionRes(parsedOutput, context);
        case "RegionDisabledException":
        case "com.amazonaws.sts#RegionDisabledException":
          throw await de_RegionDisabledExceptionRes(parsedOutput, context);
        case "IDPCommunicationError":
        case "com.amazonaws.sts#IDPCommunicationErrorException":
          throw await de_IDPCommunicationErrorExceptionRes(parsedOutput, context);
        case "IDPRejectedClaim":
        case "com.amazonaws.sts#IDPRejectedClaimException":
          throw await de_IDPRejectedClaimExceptionRes(parsedOutput, context);
        case "InvalidIdentityToken":
        case "com.amazonaws.sts#InvalidIdentityTokenException":
          throw await de_InvalidIdentityTokenExceptionRes(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          return throwDefaultError4({
            output,
            parsedBody: parsedBody.Error,
            errorCode
          });
      }
    };
    de_ExpiredTokenExceptionRes2 = async (parsedOutput, context) => {
      const body2 = parsedOutput.body;
      const deserialized = de_ExpiredTokenException(body2.Error, context);
      const exception = new ExpiredTokenException2({
        $metadata: deserializeMetadata4(parsedOutput),
        ...deserialized
      });
      return decorateServiceException(exception, body2);
    };
    de_IDPCommunicationErrorExceptionRes = async (parsedOutput, context) => {
      const body2 = parsedOutput.body;
      const deserialized = de_IDPCommunicationErrorException(body2.Error, context);
      const exception = new IDPCommunicationErrorException({
        $metadata: deserializeMetadata4(parsedOutput),
        ...deserialized
      });
      return decorateServiceException(exception, body2);
    };
    de_IDPRejectedClaimExceptionRes = async (parsedOutput, context) => {
      const body2 = parsedOutput.body;
      const deserialized = de_IDPRejectedClaimException(body2.Error, context);
      const exception = new IDPRejectedClaimException({
        $metadata: deserializeMetadata4(parsedOutput),
        ...deserialized
      });
      return decorateServiceException(exception, body2);
    };
    de_InvalidIdentityTokenExceptionRes = async (parsedOutput, context) => {
      const body2 = parsedOutput.body;
      const deserialized = de_InvalidIdentityTokenException(body2.Error, context);
      const exception = new InvalidIdentityTokenException({
        $metadata: deserializeMetadata4(parsedOutput),
        ...deserialized
      });
      return decorateServiceException(exception, body2);
    };
    de_MalformedPolicyDocumentExceptionRes = async (parsedOutput, context) => {
      const body2 = parsedOutput.body;
      const deserialized = de_MalformedPolicyDocumentException(body2.Error, context);
      const exception = new MalformedPolicyDocumentException({
        $metadata: deserializeMetadata4(parsedOutput),
        ...deserialized
      });
      return decorateServiceException(exception, body2);
    };
    de_PackedPolicyTooLargeExceptionRes = async (parsedOutput, context) => {
      const body2 = parsedOutput.body;
      const deserialized = de_PackedPolicyTooLargeException(body2.Error, context);
      const exception = new PackedPolicyTooLargeException({
        $metadata: deserializeMetadata4(parsedOutput),
        ...deserialized
      });
      return decorateServiceException(exception, body2);
    };
    de_RegionDisabledExceptionRes = async (parsedOutput, context) => {
      const body2 = parsedOutput.body;
      const deserialized = de_RegionDisabledException(body2.Error, context);
      const exception = new RegionDisabledException({
        $metadata: deserializeMetadata4(parsedOutput),
        ...deserialized
      });
      return decorateServiceException(exception, body2);
    };
    se_AssumeRoleRequest = (input, context) => {
      const entries = {};
      if (input[_RA] != null) {
        entries[_RA] = input[_RA];
      }
      if (input[_RSN] != null) {
        entries[_RSN] = input[_RSN];
      }
      if (input[_PA] != null) {
        const memberEntries = se_policyDescriptorListType(input[_PA], context);
        if (input[_PA]?.length === 0) {
          entries.PolicyArns = [];
        }
        Object.entries(memberEntries).forEach(([key, value]) => {
          const loc = `PolicyArns.${key}`;
          entries[loc] = value;
        });
      }
      if (input[_P] != null) {
        entries[_P] = input[_P];
      }
      if (input[_DS] != null) {
        entries[_DS] = input[_DS];
      }
      if (input[_T] != null) {
        const memberEntries = se_tagListType(input[_T], context);
        if (input[_T]?.length === 0) {
          entries.Tags = [];
        }
        Object.entries(memberEntries).forEach(([key, value]) => {
          const loc = `Tags.${key}`;
          entries[loc] = value;
        });
      }
      if (input[_TTK] != null) {
        const memberEntries = se_tagKeyListType(input[_TTK], context);
        if (input[_TTK]?.length === 0) {
          entries.TransitiveTagKeys = [];
        }
        Object.entries(memberEntries).forEach(([key, value]) => {
          const loc = `TransitiveTagKeys.${key}`;
          entries[loc] = value;
        });
      }
      if (input[_EI] != null) {
        entries[_EI] = input[_EI];
      }
      if (input[_SN] != null) {
        entries[_SN] = input[_SN];
      }
      if (input[_TC] != null) {
        entries[_TC] = input[_TC];
      }
      if (input[_SI] != null) {
        entries[_SI] = input[_SI];
      }
      if (input[_PC] != null) {
        const memberEntries = se_ProvidedContextsListType(input[_PC], context);
        if (input[_PC]?.length === 0) {
          entries.ProvidedContexts = [];
        }
        Object.entries(memberEntries).forEach(([key, value]) => {
          const loc = `ProvidedContexts.${key}`;
          entries[loc] = value;
        });
      }
      return entries;
    };
    se_AssumeRoleWithWebIdentityRequest = (input, context) => {
      const entries = {};
      if (input[_RA] != null) {
        entries[_RA] = input[_RA];
      }
      if (input[_RSN] != null) {
        entries[_RSN] = input[_RSN];
      }
      if (input[_WIT] != null) {
        entries[_WIT] = input[_WIT];
      }
      if (input[_PI] != null) {
        entries[_PI] = input[_PI];
      }
      if (input[_PA] != null) {
        const memberEntries = se_policyDescriptorListType(input[_PA], context);
        if (input[_PA]?.length === 0) {
          entries.PolicyArns = [];
        }
        Object.entries(memberEntries).forEach(([key, value]) => {
          const loc = `PolicyArns.${key}`;
          entries[loc] = value;
        });
      }
      if (input[_P] != null) {
        entries[_P] = input[_P];
      }
      if (input[_DS] != null) {
        entries[_DS] = input[_DS];
      }
      return entries;
    };
    se_policyDescriptorListType = (input, context) => {
      const entries = {};
      let counter = 1;
      for (const entry of input) {
        if (entry === null) {
          continue;
        }
        const memberEntries = se_PolicyDescriptorType(entry, context);
        Object.entries(memberEntries).forEach(([key, value]) => {
          entries[`member.${counter}.${key}`] = value;
        });
        counter++;
      }
      return entries;
    };
    se_PolicyDescriptorType = (input, context) => {
      const entries = {};
      if (input[_a450] != null) {
        entries[_a450] = input[_a450];
      }
      return entries;
    };
    se_ProvidedContext = (input, context) => {
      const entries = {};
      if (input[_PAr] != null) {
        entries[_PAr] = input[_PAr];
      }
      if (input[_CA] != null) {
        entries[_CA] = input[_CA];
      }
      return entries;
    };
    se_ProvidedContextsListType = (input, context) => {
      const entries = {};
      let counter = 1;
      for (const entry of input) {
        if (entry === null) {
          continue;
        }
        const memberEntries = se_ProvidedContext(entry, context);
        Object.entries(memberEntries).forEach(([key, value]) => {
          entries[`member.${counter}.${key}`] = value;
        });
        counter++;
      }
      return entries;
    };
    se_Tag = (input, context) => {
      const entries = {};
      if (input[_K] != null) {
        entries[_K] = input[_K];
      }
      if (input[_Va] != null) {
        entries[_Va] = input[_Va];
      }
      return entries;
    };
    se_tagKeyListType = (input, context) => {
      const entries = {};
      let counter = 1;
      for (const entry of input) {
        if (entry === null) {
          continue;
        }
        entries[`member.${counter}`] = entry;
        counter++;
      }
      return entries;
    };
    se_tagListType = (input, context) => {
      const entries = {};
      let counter = 1;
      for (const entry of input) {
        if (entry === null) {
          continue;
        }
        const memberEntries = se_Tag(entry, context);
        Object.entries(memberEntries).forEach(([key, value]) => {
          entries[`member.${counter}.${key}`] = value;
        });
        counter++;
      }
      return entries;
    };
    de_AssumedRoleUser = (output, context) => {
      const contents = {};
      if (output[_ARI] != null) {
        contents[_ARI] = expectString(output[_ARI]);
      }
      if (output[_Ar] != null) {
        contents[_Ar] = expectString(output[_Ar]);
      }
      return contents;
    };
    de_AssumeRoleResponse = (output, context) => {
      const contents = {};
      if (output[_C] != null) {
        contents[_C] = de_Credentials(output[_C], context);
      }
      if (output[_ARU] != null) {
        contents[_ARU] = de_AssumedRoleUser(output[_ARU], context);
      }
      if (output[_PPS] != null) {
        contents[_PPS] = strictParseInt32(output[_PPS]);
      }
      if (output[_SI] != null) {
        contents[_SI] = expectString(output[_SI]);
      }
      return contents;
    };
    de_AssumeRoleWithWebIdentityResponse = (output, context) => {
      const contents = {};
      if (output[_C] != null) {
        contents[_C] = de_Credentials(output[_C], context);
      }
      if (output[_SFWIT] != null) {
        contents[_SFWIT] = expectString(output[_SFWIT]);
      }
      if (output[_ARU] != null) {
        contents[_ARU] = de_AssumedRoleUser(output[_ARU], context);
      }
      if (output[_PPS] != null) {
        contents[_PPS] = strictParseInt32(output[_PPS]);
      }
      if (output[_Pr] != null) {
        contents[_Pr] = expectString(output[_Pr]);
      }
      if (output[_Au] != null) {
        contents[_Au] = expectString(output[_Au]);
      }
      if (output[_SI] != null) {
        contents[_SI] = expectString(output[_SI]);
      }
      return contents;
    };
    de_Credentials = (output, context) => {
      const contents = {};
      if (output[_AKI] != null) {
        contents[_AKI] = expectString(output[_AKI]);
      }
      if (output[_SAK] != null) {
        contents[_SAK] = expectString(output[_SAK]);
      }
      if (output[_ST] != null) {
        contents[_ST] = expectString(output[_ST]);
      }
      if (output[_E] != null) {
        contents[_E] = expectNonNull(parseRfc3339DateTimeWithOffset(output[_E]));
      }
      return contents;
    };
    de_ExpiredTokenException = (output, context) => {
      const contents = {};
      if (output[_m] != null) {
        contents[_m] = expectString(output[_m]);
      }
      return contents;
    };
    de_IDPCommunicationErrorException = (output, context) => {
      const contents = {};
      if (output[_m] != null) {
        contents[_m] = expectString(output[_m]);
      }
      return contents;
    };
    de_IDPRejectedClaimException = (output, context) => {
      const contents = {};
      if (output[_m] != null) {
        contents[_m] = expectString(output[_m]);
      }
      return contents;
    };
    de_InvalidIdentityTokenException = (output, context) => {
      const contents = {};
      if (output[_m] != null) {
        contents[_m] = expectString(output[_m]);
      }
      return contents;
    };
    de_MalformedPolicyDocumentException = (output, context) => {
      const contents = {};
      if (output[_m] != null) {
        contents[_m] = expectString(output[_m]);
      }
      return contents;
    };
    de_PackedPolicyTooLargeException = (output, context) => {
      const contents = {};
      if (output[_m] != null) {
        contents[_m] = expectString(output[_m]);
      }
      return contents;
    };
    de_RegionDisabledException = (output, context) => {
      const contents = {};
      if (output[_m] != null) {
        contents[_m] = expectString(output[_m]);
      }
      return contents;
    };
    deserializeMetadata4 = (output) => ({
      httpStatusCode: output.statusCode,
      requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
      extendedRequestId: output.headers["x-amz-id-2"],
      cfId: output.headers["x-amz-cf-id"]
    });
    throwDefaultError4 = withBaseException(STSServiceException);
    buildHttpRpcRequest = async (context, headers, path3, resolvedHostname, body2) => {
      const { hostname, protocol: protocol2 = "https", port, path: basePath } = await context.endpoint();
      const contents = {
        protocol: protocol2,
        hostname,
        port,
        method: "POST",
        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path3 : basePath + path3,
        headers
      };
      if (resolvedHostname !== void 0) {
        contents.hostname = resolvedHostname;
      }
      if (body2 !== void 0) {
        contents.body = body2;
      }
      return new HttpRequest(contents);
    };
    SHARED_HEADERS = {
      "content-type": "application/x-www-form-urlencoded"
    };
    _2 = "2011-06-15";
    _A = "Action";
    _AKI = "AccessKeyId";
    _AR = "AssumeRole";
    _ARI = "AssumedRoleId";
    _ARU = "AssumedRoleUser";
    _ARWWI = "AssumeRoleWithWebIdentity";
    _Ar = "Arn";
    _Au = "Audience";
    _C = "Credentials";
    _CA = "ContextAssertion";
    _DS = "DurationSeconds";
    _E = "Expiration";
    _EI = "ExternalId";
    _K = "Key";
    _P = "Policy";
    _PA = "PolicyArns";
    _PAr = "ProviderArn";
    _PC = "ProvidedContexts";
    _PI = "ProviderId";
    _PPS = "PackedPolicySize";
    _Pr = "Provider";
    _RA = "RoleArn";
    _RSN = "RoleSessionName";
    _SAK = "SecretAccessKey";
    _SFWIT = "SubjectFromWebIdentityToken";
    _SI = "SourceIdentity";
    _SN = "SerialNumber";
    _ST = "SessionToken";
    _T = "Tags";
    _TC = "TokenCode";
    _TTK = "TransitiveTagKeys";
    _V = "Version";
    _Va = "Value";
    _WIT = "WebIdentityToken";
    _a450 = "arn";
    _m = "message";
    buildFormUrlencodedString = (formEntries) => Object.entries(formEntries).map(([key, value]) => extendedEncodeURIComponent(key) + "=" + extendedEncodeURIComponent(value)).join("&");
    loadQueryErrorCode = (output, data) => {
      if (data.Error?.Code !== void 0) {
        return data.Error.Code;
      }
      if (output.statusCode == 404) {
        return "NotFound";
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/commands/AssumeRoleCommand.js
var AssumeRoleCommand;
var init_AssumeRoleCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/commands/AssumeRoleCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters4();
    init_models_03();
    init_Aws_query();
    AssumeRoleCommand = class extends Command.classBuilder().ep(commonParams4).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("AWSSecurityTokenServiceV20110615", "AssumeRole", {}).n("STSClient", "AssumeRoleCommand").f(void 0, AssumeRoleResponseFilterSensitiveLog).ser(se_AssumeRoleCommand).de(de_AssumeRoleCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/commands/AssumeRoleWithWebIdentityCommand.js
var AssumeRoleWithWebIdentityCommand;
var init_AssumeRoleWithWebIdentityCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/commands/AssumeRoleWithWebIdentityCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters4();
    init_models_03();
    init_Aws_query();
    AssumeRoleWithWebIdentityCommand = class extends Command.classBuilder().ep(commonParams4).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("AWSSecurityTokenServiceV20110615", "AssumeRoleWithWebIdentity", {}).n("STSClient", "AssumeRoleWithWebIdentityCommand").f(AssumeRoleWithWebIdentityRequestFilterSensitiveLog, AssumeRoleWithWebIdentityResponseFilterSensitiveLog).ser(se_AssumeRoleWithWebIdentityCommand).de(de_AssumeRoleWithWebIdentityCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/STS.js
var commands3, STS;
var init_STS = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/STS.js"() {
    "use strict";
    init_dist_es24();
    init_AssumeRoleCommand();
    init_AssumeRoleWithWebIdentityCommand();
    init_STSClient();
    commands3 = {
      AssumeRoleCommand,
      AssumeRoleWithWebIdentityCommand
    };
    STS = class extends STSClient {
    };
    createAggregatedClient(commands3, STS);
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/commands/index.js
var init_commands3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/commands/index.js"() {
    "use strict";
    init_AssumeRoleCommand();
    init_AssumeRoleWithWebIdentityCommand();
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/index.js
var init_models3 = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/models/index.js"() {
    "use strict";
    init_models_03();
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/defaultStsRoleAssumers.js
var ASSUME_ROLE_DEFAULT_REGION, getAccountIdFromAssumedRoleUser, resolveRegion, getDefaultRoleAssumer, getDefaultRoleAssumerWithWebIdentity, isH2;
var init_defaultStsRoleAssumers = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/defaultStsRoleAssumers.js"() {
    "use strict";
    init_client2();
    init_AssumeRoleCommand();
    init_AssumeRoleWithWebIdentityCommand();
    ASSUME_ROLE_DEFAULT_REGION = "us-east-1";
    getAccountIdFromAssumedRoleUser = (assumedRoleUser) => {
      if (typeof assumedRoleUser?.Arn === "string") {
        const arnComponents = assumedRoleUser.Arn.split(":");
        if (arnComponents.length > 4 && arnComponents[4] !== "") {
          return arnComponents[4];
        }
      }
      return void 0;
    };
    resolveRegion = async (_region, _parentRegion, credentialProviderLogger) => {
      const region = typeof _region === "function" ? await _region() : _region;
      const parentRegion = typeof _parentRegion === "function" ? await _parentRegion() : _parentRegion;
      credentialProviderLogger?.debug?.("@aws-sdk/client-sts::resolveRegion", "accepting first of:", `${region} (provider)`, `${parentRegion} (parent client)`, `${ASSUME_ROLE_DEFAULT_REGION} (STS default)`);
      return region ?? parentRegion ?? ASSUME_ROLE_DEFAULT_REGION;
    };
    getDefaultRoleAssumer = (stsOptions, STSClient2) => {
      let stsClient;
      let closureSourceCreds;
      return async (sourceCreds, params) => {
        closureSourceCreds = sourceCreds;
        if (!stsClient) {
          const { logger: logger2 = stsOptions?.parentClientConfig?.logger, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger } = stsOptions;
          const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger);
          const isCompatibleRequestHandler = !isH2(requestHandler);
          stsClient = new STSClient2({
            profile: stsOptions?.parentClientConfig?.profile,
            credentialDefaultProvider: () => async () => closureSourceCreds,
            region: resolvedRegion,
            requestHandler: isCompatibleRequestHandler ? requestHandler : void 0,
            logger: logger2
          });
        }
        const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleCommand(params));
        if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
          throw new Error(`Invalid response from STS.assumeRole call with role ${params.RoleArn}`);
        }
        const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser);
        const credentials2 = {
          accessKeyId: Credentials.AccessKeyId,
          secretAccessKey: Credentials.SecretAccessKey,
          sessionToken: Credentials.SessionToken,
          expiration: Credentials.Expiration,
          ...Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope },
          ...accountId && { accountId }
        };
        setCredentialFeature(credentials2, "CREDENTIALS_STS_ASSUME_ROLE", "i");
        return credentials2;
      };
    };
    getDefaultRoleAssumerWithWebIdentity = (stsOptions, STSClient2) => {
      let stsClient;
      return async (params) => {
        if (!stsClient) {
          const { logger: logger2 = stsOptions?.parentClientConfig?.logger, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger } = stsOptions;
          const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger);
          const isCompatibleRequestHandler = !isH2(requestHandler);
          stsClient = new STSClient2({
            profile: stsOptions?.parentClientConfig?.profile,
            region: resolvedRegion,
            requestHandler: isCompatibleRequestHandler ? requestHandler : void 0,
            logger: logger2
          });
        }
        const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleWithWebIdentityCommand(params));
        if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
          throw new Error(`Invalid response from STS.assumeRoleWithWebIdentity call with role ${params.RoleArn}`);
        }
        const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser);
        const credentials2 = {
          accessKeyId: Credentials.AccessKeyId,
          secretAccessKey: Credentials.SecretAccessKey,
          sessionToken: Credentials.SessionToken,
          expiration: Credentials.Expiration,
          ...Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope },
          ...accountId && { accountId }
        };
        if (accountId) {
          setCredentialFeature(credentials2, "RESOLVED_ACCOUNT_ID", "T");
        }
        setCredentialFeature(credentials2, "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID", "k");
        return credentials2;
      };
    };
    isH2 = (requestHandler) => {
      return requestHandler?.metadata?.handlerProtocol === "h2";
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/defaultRoleAssumers.js
var getCustomizableStsClientCtor, getDefaultRoleAssumer2, getDefaultRoleAssumerWithWebIdentity2, decorateDefaultCredentialProvider;
var init_defaultRoleAssumers = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/defaultRoleAssumers.js"() {
    "use strict";
    init_defaultStsRoleAssumers();
    init_STSClient();
    getCustomizableStsClientCtor = (baseCtor, customizations) => {
      if (!customizations)
        return baseCtor;
      else
        return class CustomizableSTSClient extends baseCtor {
          constructor(config) {
            super(config);
            for (const customization of customizations) {
              this.middlewareStack.use(customization);
            }
          }
        };
    };
    getDefaultRoleAssumer2 = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumer(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
    getDefaultRoleAssumerWithWebIdentity2 = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumerWithWebIdentity(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
    decorateDefaultCredentialProvider = (provider) => (input) => provider({
      roleAssumer: getDefaultRoleAssumer2(input),
      roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity2(input),
      ...input
    });
  }
});

// ../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/index.js
var sts_exports = {};
__export(sts_exports, {
  $Command: () => Command,
  AssumeRoleCommand: () => AssumeRoleCommand,
  AssumeRoleResponseFilterSensitiveLog: () => AssumeRoleResponseFilterSensitiveLog,
  AssumeRoleWithWebIdentityCommand: () => AssumeRoleWithWebIdentityCommand,
  AssumeRoleWithWebIdentityRequestFilterSensitiveLog: () => AssumeRoleWithWebIdentityRequestFilterSensitiveLog,
  AssumeRoleWithWebIdentityResponseFilterSensitiveLog: () => AssumeRoleWithWebIdentityResponseFilterSensitiveLog,
  CredentialsFilterSensitiveLog: () => CredentialsFilterSensitiveLog,
  ExpiredTokenException: () => ExpiredTokenException2,
  IDPCommunicationErrorException: () => IDPCommunicationErrorException,
  IDPRejectedClaimException: () => IDPRejectedClaimException,
  InvalidIdentityTokenException: () => InvalidIdentityTokenException,
  MalformedPolicyDocumentException: () => MalformedPolicyDocumentException,
  PackedPolicyTooLargeException: () => PackedPolicyTooLargeException,
  RegionDisabledException: () => RegionDisabledException,
  STS: () => STS,
  STSClient: () => STSClient,
  STSServiceException: () => STSServiceException,
  __Client: () => Client,
  decorateDefaultCredentialProvider: () => decorateDefaultCredentialProvider,
  getDefaultRoleAssumer: () => getDefaultRoleAssumer2,
  getDefaultRoleAssumerWithWebIdentity: () => getDefaultRoleAssumerWithWebIdentity2
});
var init_sts = __esm({
  "../node_modules/.pnpm/@aws-sdk+nested-clients@3.817.0/node_modules/@aws-sdk/nested-clients/dist-es/submodules/sts/index.js"() {
    "use strict";
    init_STSClient();
    init_STS();
    init_commands3();
    init_models3();
    init_defaultRoleAssumers();
    init_STSServiceException();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js
var isAssumeRoleProfile, isAssumeRoleWithSourceProfile, isCredentialSourceProfile, resolveAssumeRoleCredentials, isCredentialSourceWithoutRoleArn;
var init_resolveAssumeRoleCredentials = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js"() {
    "use strict";
    init_client2();
    init_dist_es21();
    init_dist_es30();
    init_resolveCredentialSource();
    init_resolveProfileData();
    isAssumeRoleProfile = (arg, { profile = "default", logger: logger2 } = {}) => {
      return Boolean(arg) && typeof arg === "object" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && (isAssumeRoleWithSourceProfile(arg, { profile, logger: logger2 }) || isCredentialSourceProfile(arg, { profile, logger: logger2 }));
    };
    isAssumeRoleWithSourceProfile = (arg, { profile, logger: logger2 }) => {
      const withSourceProfile = typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined";
      if (withSourceProfile) {
        logger2?.debug?.(`    ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`);
      }
      return withSourceProfile;
    };
    isCredentialSourceProfile = (arg, { profile, logger: logger2 }) => {
      const withProviderProfile = typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined";
      if (withProviderProfile) {
        logger2?.debug?.(`    ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`);
      }
      return withProviderProfile;
    };
    resolveAssumeRoleCredentials = async (profileName, profiles, options, visitedProfiles = {}) => {
      options.logger?.debug("@aws-sdk/credential-provider-ini - resolveAssumeRoleCredentials (STS)");
      const profileData = profiles[profileName];
      const { source_profile, region } = profileData;
      if (!options.roleAssumer) {
        const { getDefaultRoleAssumer: getDefaultRoleAssumer3 } = await Promise.resolve().then(() => (init_sts(), sts_exports));
        options.roleAssumer = getDefaultRoleAssumer3({
          ...options.clientConfig,
          credentialProviderLogger: options.logger,
          parentClientConfig: {
            ...options?.parentClientConfig,
            region: region ?? options?.parentClientConfig?.region
          }
        }, options.clientPlugins);
      }
      if (source_profile && source_profile in visitedProfiles) {
        throw new CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile ${getProfileName(options)}. Profiles visited: ` + Object.keys(visitedProfiles).join(", "), { logger: options.logger });
      }
      options.logger?.debug(`@aws-sdk/credential-provider-ini - finding credential resolver using ${source_profile ? `source_profile=[${source_profile}]` : `profile=[${profileName}]`}`);
      const sourceCredsProvider = source_profile ? resolveProfileData(source_profile, profiles, options, {
        ...visitedProfiles,
        [source_profile]: true
      }, isCredentialSourceWithoutRoleArn(profiles[source_profile] ?? {})) : (await resolveCredentialSource(profileData.credential_source, profileName, options.logger)(options))();
      if (isCredentialSourceWithoutRoleArn(profileData)) {
        return sourceCredsProvider.then((creds) => setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
      } else {
        const params = {
          RoleArn: profileData.role_arn,
          RoleSessionName: profileData.role_session_name || `aws-sdk-js-${Date.now()}`,
          ExternalId: profileData.external_id,
          DurationSeconds: parseInt(profileData.duration_seconds || "3600", 10)
        };
        const { mfa_serial } = profileData;
        if (mfa_serial) {
          if (!options.mfaCodeProvider) {
            throw new CredentialsProviderError(`Profile ${profileName} requires multi-factor authentication, but no MFA code callback was provided.`, { logger: options.logger, tryNextLink: false });
          }
          params.SerialNumber = mfa_serial;
          params.TokenCode = await options.mfaCodeProvider(mfa_serial);
        }
        const sourceCreds = await sourceCredsProvider;
        return options.roleAssumer(sourceCreds, params).then((creds) => setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
      }
    };
    isCredentialSourceWithoutRoleArn = (section) => {
      return !section.role_arn && !!section.credential_source;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/getValidatedProcessCredentials.js
var getValidatedProcessCredentials;
var init_getValidatedProcessCredentials = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/getValidatedProcessCredentials.js"() {
    "use strict";
    init_client2();
    getValidatedProcessCredentials = (profileName, data, profiles) => {
      if (data.Version !== 1) {
        throw Error(`Profile ${profileName} credential_process did not return Version 1.`);
      }
      if (data.AccessKeyId === void 0 || data.SecretAccessKey === void 0) {
        throw Error(`Profile ${profileName} credential_process returned invalid credentials.`);
      }
      if (data.Expiration) {
        const currentTime = /* @__PURE__ */ new Date();
        const expireTime = new Date(data.Expiration);
        if (expireTime < currentTime) {
          throw Error(`Profile ${profileName} credential_process returned expired credentials.`);
        }
      }
      let accountId = data.AccountId;
      if (!accountId && profiles?.[profileName]?.aws_account_id) {
        accountId = profiles[profileName].aws_account_id;
      }
      const credentials2 = {
        accessKeyId: data.AccessKeyId,
        secretAccessKey: data.SecretAccessKey,
        ...data.SessionToken && { sessionToken: data.SessionToken },
        ...data.Expiration && { expiration: new Date(data.Expiration) },
        ...data.CredentialScope && { credentialScope: data.CredentialScope },
        ...accountId && { accountId }
      };
      setCredentialFeature(credentials2, "CREDENTIALS_PROCESS", "w");
      return credentials2;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
var import_child_process, import_util6, resolveProcessCredentials;
var init_resolveProcessCredentials = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js"() {
    "use strict";
    init_dist_es21();
    import_child_process = require("child_process");
    import_util6 = require("util");
    init_getValidatedProcessCredentials();
    resolveProcessCredentials = async (profileName, profiles, logger2) => {
      const profile = profiles[profileName];
      if (profiles[profileName]) {
        const credentialProcess = profile["credential_process"];
        if (credentialProcess !== void 0) {
          const execPromise = (0, import_util6.promisify)(import_child_process.exec);
          try {
            const { stdout } = await execPromise(credentialProcess);
            let data;
            try {
              data = JSON.parse(stdout.trim());
            } catch {
              throw Error(`Profile ${profileName} credential_process returned invalid JSON.`);
            }
            return getValidatedProcessCredentials(profileName, data, profiles);
          } catch (error2) {
            throw new CredentialsProviderError(error2.message, { logger: logger2 });
          }
        } else {
          throw new CredentialsProviderError(`Profile ${profileName} did not contain credential_process.`, { logger: logger2 });
        }
      } else {
        throw new CredentialsProviderError(`Profile ${profileName} could not be found in shared credentials file.`, {
          logger: logger2
        });
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/fromProcess.js
var fromProcess;
var init_fromProcess = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/fromProcess.js"() {
    "use strict";
    init_dist_es30();
    init_resolveProcessCredentials();
    fromProcess = (init3 = {}) => async ({ callerClientConfig } = {}) => {
      init3.logger?.debug("@aws-sdk/credential-provider-process - fromProcess");
      const profiles = await parseKnownFiles(init3);
      return resolveProcessCredentials(getProfileName({
        profile: init3.profile ?? callerClientConfig?.profile
      }), profiles, init3.logger);
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/index.js
var dist_es_exports5 = {};
__export(dist_es_exports5, {
  fromProcess: () => fromProcess
});
var init_dist_es49 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-process@3.816.0/node_modules/@aws-sdk/credential-provider-process/dist-es/index.js"() {
    "use strict";
    init_fromProcess();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProcessCredentials.js
var isProcessProfile, resolveProcessCredentials2;
var init_resolveProcessCredentials2 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProcessCredentials.js"() {
    "use strict";
    init_client2();
    isProcessProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.credential_process === "string";
    resolveProcessCredentials2 = async (options, profile) => Promise.resolve().then(() => (init_dist_es49(), dist_es_exports5)).then(({ fromProcess: fromProcess2 }) => fromProcess2({
      ...options,
      profile
    })().then((creds) => setCredentialFeature(creds, "CREDENTIALS_PROFILE_PROCESS", "v")));
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveSsoCredentials.js
var resolveSsoCredentials, isSsoProfile2;
var init_resolveSsoCredentials = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveSsoCredentials.js"() {
    "use strict";
    init_client2();
    resolveSsoCredentials = async (profile, profileData, options = {}) => {
      const { fromSSO: fromSSO2 } = await Promise.resolve().then(() => (init_dist_es48(), dist_es_exports4));
      return fromSSO2({
        profile,
        logger: options.logger,
        parentClientConfig: options.parentClientConfig,
        clientConfig: options.clientConfig
      })().then((creds) => {
        if (profileData.sso_session) {
          return setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO", "r");
        } else {
          return setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO_LEGACY", "t");
        }
      });
    };
    isSsoProfile2 = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveStaticCredentials.js
var isStaticCredsProfile, resolveStaticCredentials;
var init_resolveStaticCredentials = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveStaticCredentials.js"() {
    "use strict";
    init_client2();
    isStaticCredsProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.aws_access_key_id === "string" && typeof arg.aws_secret_access_key === "string" && ["undefined", "string"].indexOf(typeof arg.aws_session_token) > -1 && ["undefined", "string"].indexOf(typeof arg.aws_account_id) > -1;
    resolveStaticCredentials = async (profile, options) => {
      options?.logger?.debug("@aws-sdk/credential-provider-ini - resolveStaticCredentials");
      const credentials2 = {
        accessKeyId: profile.aws_access_key_id,
        secretAccessKey: profile.aws_secret_access_key,
        sessionToken: profile.aws_session_token,
        ...profile.aws_credential_scope && { credentialScope: profile.aws_credential_scope },
        ...profile.aws_account_id && { accountId: profile.aws_account_id }
      };
      return setCredentialFeature(credentials2, "CREDENTIALS_PROFILE", "n");
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.817.0/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js
var fromWebToken;
var init_fromWebToken = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.817.0/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js"() {
    "use strict";
    fromWebToken = (init3) => async (awsIdentityProperties) => {
      init3.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
      const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy: policy5, durationSeconds } = init3;
      let { roleAssumerWithWebIdentity } = init3;
      if (!roleAssumerWithWebIdentity) {
        const { getDefaultRoleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity3 } = await Promise.resolve().then(() => (init_sts(), sts_exports));
        roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity3({
          ...init3.clientConfig,
          credentialProviderLogger: init3.logger,
          parentClientConfig: {
            ...awsIdentityProperties?.callerClientConfig,
            ...init3.parentClientConfig
          }
        }, init3.clientPlugins);
      }
      return roleAssumerWithWebIdentity({
        RoleArn: roleArn,
        RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
        WebIdentityToken: webIdentityToken,
        ProviderId: providerId,
        PolicyArns: policyArns,
        Policy: policy5,
        DurationSeconds: durationSeconds
      });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.817.0/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
var import_fs7, ENV_TOKEN_FILE, ENV_ROLE_ARN, ENV_ROLE_SESSION_NAME, fromTokenFile;
var init_fromTokenFile = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.817.0/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js"() {
    "use strict";
    init_client2();
    init_dist_es21();
    import_fs7 = require("fs");
    init_fromWebToken();
    ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE";
    ENV_ROLE_ARN = "AWS_ROLE_ARN";
    ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME";
    fromTokenFile = (init3 = {}) => async () => {
      init3.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
      const webIdentityTokenFile = init3?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
      const roleArn = init3?.roleArn ?? process.env[ENV_ROLE_ARN];
      const roleSessionName = init3?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
      if (!webIdentityTokenFile || !roleArn) {
        throw new CredentialsProviderError("Web identity configuration not specified", {
          logger: init3.logger
        });
      }
      const credentials2 = await fromWebToken({
        ...init3,
        webIdentityToken: (0, import_fs7.readFileSync)(webIdentityTokenFile, { encoding: "ascii" }),
        roleArn,
        roleSessionName
      })();
      if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) {
        setCredentialFeature(credentials2, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
      }
      return credentials2;
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.817.0/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/index.js
var dist_es_exports6 = {};
__export(dist_es_exports6, {
  fromTokenFile: () => fromTokenFile,
  fromWebToken: () => fromWebToken
});
var init_dist_es50 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-web-identity@3.817.0/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/index.js"() {
    "use strict";
    init_fromTokenFile();
    init_fromWebToken();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveWebIdentityCredentials.js
var isWebIdentityProfile, resolveWebIdentityCredentials;
var init_resolveWebIdentityCredentials = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveWebIdentityCredentials.js"() {
    "use strict";
    init_client2();
    isWebIdentityProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.web_identity_token_file === "string" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1;
    resolveWebIdentityCredentials = async (profile, options) => Promise.resolve().then(() => (init_dist_es50(), dist_es_exports6)).then(({ fromTokenFile: fromTokenFile2 }) => fromTokenFile2({
      webIdentityTokenFile: profile.web_identity_token_file,
      roleArn: profile.role_arn,
      roleSessionName: profile.role_session_name,
      roleAssumerWithWebIdentity: options.roleAssumerWithWebIdentity,
      logger: options.logger,
      parentClientConfig: options.parentClientConfig
    })().then((creds) => setCredentialFeature(creds, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q")));
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js
var resolveProfileData;
var init_resolveProfileData = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js"() {
    "use strict";
    init_dist_es21();
    init_resolveAssumeRoleCredentials();
    init_resolveProcessCredentials2();
    init_resolveSsoCredentials();
    init_resolveStaticCredentials();
    init_resolveWebIdentityCredentials();
    resolveProfileData = async (profileName, profiles, options, visitedProfiles = {}, isAssumeRoleRecursiveCall = false) => {
      const data = profiles[profileName];
      if (Object.keys(visitedProfiles).length > 0 && isStaticCredsProfile(data)) {
        return resolveStaticCredentials(data, options);
      }
      if (isAssumeRoleRecursiveCall || isAssumeRoleProfile(data, { profile: profileName, logger: options.logger })) {
        return resolveAssumeRoleCredentials(profileName, profiles, options, visitedProfiles);
      }
      if (isStaticCredsProfile(data)) {
        return resolveStaticCredentials(data, options);
      }
      if (isWebIdentityProfile(data)) {
        return resolveWebIdentityCredentials(data, options);
      }
      if (isProcessProfile(data)) {
        return resolveProcessCredentials2(options, profileName);
      }
      if (isSsoProfile2(data)) {
        return await resolveSsoCredentials(profileName, data, options);
      }
      throw new CredentialsProviderError(`Could not resolve credentials using profile: [${profileName}] in configuration/credentials file(s).`, { logger: options.logger });
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js
var fromIni;
var init_fromIni = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js"() {
    "use strict";
    init_dist_es30();
    init_resolveProfileData();
    fromIni = (_init2 = {}) => async ({ callerClientConfig } = {}) => {
      const init3 = {
        ..._init2,
        parentClientConfig: {
          ...callerClientConfig,
          ..._init2.parentClientConfig
        }
      };
      init3.logger?.debug("@aws-sdk/credential-provider-ini - fromIni");
      const profiles = await parseKnownFiles(init3);
      return resolveProfileData(getProfileName({
        profile: _init2.profile ?? callerClientConfig?.profile
      }), profiles, init3);
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/index.js
var dist_es_exports7 = {};
__export(dist_es_exports7, {
  fromIni: () => fromIni
});
var init_dist_es51 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-ini@3.817.0/node_modules/@aws-sdk/credential-provider-ini/dist-es/index.js"() {
    "use strict";
    init_fromIni();
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.817.0/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
var multipleCredentialSourceWarningEmitted, defaultProvider, credentialsWillNeedRefresh, credentialsTreatedAsExpired;
var init_defaultProvider = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.817.0/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js"() {
    "use strict";
    init_dist_es38();
    init_dist_es21();
    init_dist_es30();
    init_remoteProvider();
    multipleCredentialSourceWarningEmitted = false;
    defaultProvider = (init3 = {}) => memoize(chain(async () => {
      const profile = init3.profile ?? process.env[ENV_PROFILE];
      if (profile) {
        const envStaticCredentialsAreSet = process.env[ENV_KEY] && process.env[ENV_SECRET];
        if (envStaticCredentialsAreSet) {
          if (!multipleCredentialSourceWarningEmitted) {
            const warnFn = init3.logger?.warn && init3.logger?.constructor?.name !== "NoOpLogger" ? init3.logger.warn : console.warn;
            warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
    Multiple credential sources detected: 
    Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
    This SDK will proceed with the AWS_PROFILE value.
    
    However, a future version may change this behavior to prefer the ENV static credentials.
    Please ensure that your environment only sets either the AWS_PROFILE or the
    AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
`);
            multipleCredentialSourceWarningEmitted = true;
          }
        }
        throw new CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
          logger: init3.logger,
          tryNextLink: true
        });
      }
      init3.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
      return fromEnv2(init3)();
    }, async () => {
      init3.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
      const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init3;
      if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
        throw new CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", { logger: init3.logger });
      }
      const { fromSSO: fromSSO2 } = await Promise.resolve().then(() => (init_dist_es48(), dist_es_exports4));
      return fromSSO2(init3)();
    }, async () => {
      init3.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
      const { fromIni: fromIni2 } = await Promise.resolve().then(() => (init_dist_es51(), dist_es_exports7));
      return fromIni2(init3)();
    }, async () => {
      init3.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
      const { fromProcess: fromProcess2 } = await Promise.resolve().then(() => (init_dist_es49(), dist_es_exports5));
      return fromProcess2(init3)();
    }, async () => {
      init3.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
      const { fromTokenFile: fromTokenFile2 } = await Promise.resolve().then(() => (init_dist_es50(), dist_es_exports6));
      return fromTokenFile2(init3)();
    }, async () => {
      init3.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
      return (await remoteProvider(init3))();
    }, async () => {
      throw new CredentialsProviderError("Could not load credentials from any providers", {
        tryNextLink: false,
        logger: init3.logger
      });
    }), credentialsTreatedAsExpired, credentialsWillNeedRefresh);
    credentialsWillNeedRefresh = (credentials2) => credentials2?.expiration !== void 0;
    credentialsTreatedAsExpired = (credentials2) => credentials2?.expiration !== void 0 && credentials2.expiration.getTime() - Date.now() < 3e5;
  }
});

// ../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.817.0/node_modules/@aws-sdk/credential-provider-node/dist-es/index.js
var init_dist_es52 = __esm({
  "../node_modules/.pnpm/@aws-sdk+credential-provider-node@3.817.0/node_modules/@aws-sdk/credential-provider-node/dist-es/index.js"() {
    "use strict";
    init_defaultProvider();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/endpoint/ruleset.js
var s5, t5, u4, v5, a4, b4, c4, d4, e5, f6, g4, h5, i6, j4, k4, l4, m5, n4, o4, p4, q4, r5, _data4, ruleSet4;
var init_ruleset4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/endpoint/ruleset.js"() {
    "use strict";
    s5 = "required";
    t5 = "fn";
    u4 = "argv";
    v5 = "ref";
    a4 = true;
    b4 = "isSet";
    c4 = "booleanEquals";
    d4 = "error";
    e5 = "endpoint";
    f6 = "tree";
    g4 = "PartitionResult";
    h5 = { [s5]: false, "type": "String" };
    i6 = { [s5]: true, "default": false, "type": "Boolean" };
    j4 = { [v5]: "Endpoint" };
    k4 = { [t5]: c4, [u4]: [{ [v5]: "UseFIPS" }, true] };
    l4 = { [t5]: c4, [u4]: [{ [v5]: "UseDualStack" }, true] };
    m5 = {};
    n4 = { [t5]: "getAttr", [u4]: [{ [v5]: g4 }, "supportsFIPS"] };
    o4 = { [t5]: c4, [u4]: [true, { [t5]: "getAttr", [u4]: [{ [v5]: g4 }, "supportsDualStack"] }] };
    p4 = [k4];
    q4 = [l4];
    r5 = [{ [v5]: "Region" }];
    _data4 = { version: "1.0", parameters: { Region: h5, UseDualStack: i6, UseFIPS: i6, Endpoint: h5 }, rules: [{ conditions: [{ [t5]: b4, [u4]: [j4] }], rules: [{ conditions: p4, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: d4 }, { conditions: q4, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: d4 }, { endpoint: { url: j4, properties: m5, headers: m5 }, type: e5 }], type: f6 }, { conditions: [{ [t5]: b4, [u4]: r5 }], rules: [{ conditions: [{ [t5]: "aws.partition", [u4]: r5, assign: g4 }], rules: [{ conditions: [k4, l4], rules: [{ conditions: [{ [t5]: c4, [u4]: [a4, n4] }, o4], rules: [{ endpoint: { url: "https://rds-data-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m5, headers: m5 }, type: e5 }], type: f6 }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: d4 }], type: f6 }, { conditions: p4, rules: [{ conditions: [{ [t5]: c4, [u4]: [n4, a4] }], rules: [{ endpoint: { url: "https://rds-data-fips.{Region}.{PartitionResult#dnsSuffix}", properties: m5, headers: m5 }, type: e5 }], type: f6 }, { error: "FIPS is enabled but this partition does not support FIPS", type: d4 }], type: f6 }, { conditions: q4, rules: [{ conditions: [o4], rules: [{ endpoint: { url: "https://rds-data.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: m5, headers: m5 }, type: e5 }], type: f6 }, { error: "DualStack is enabled but this partition does not support DualStack", type: d4 }], type: f6 }, { endpoint: { url: "https://rds-data.{Region}.{PartitionResult#dnsSuffix}", properties: m5, headers: m5 }, type: e5 }], type: f6 }], type: f6 }, { error: "Invalid Configuration: Missing Region", type: d4 }] };
    ruleSet4 = _data4;
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/endpoint/endpointResolver.js
var cache4, defaultEndpointResolver4;
var init_endpointResolver4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/endpoint/endpointResolver.js"() {
    "use strict";
    init_dist_es20();
    init_dist_es19();
    init_ruleset4();
    cache4 = new EndpointCache({
      size: 50,
      params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
    });
    defaultEndpointResolver4 = (endpointParams, context = {}) => {
      return cache4.get(endpointParams, () => resolveEndpoint(ruleSet4, {
        endpointParams,
        logger: context.logger
      }));
    };
    customEndpointFunctions.aws = awsEndpointFunctions;
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/runtimeConfig.shared.js
var getRuntimeConfig7;
var init_runtimeConfig_shared4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/runtimeConfig.shared.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es24();
    init_dist_es33();
    init_dist_es11();
    init_dist_es10();
    init_httpAuthSchemeProvider();
    init_endpointResolver4();
    getRuntimeConfig7 = (config) => {
      return {
        apiVersion: "2018-08-01",
        base64Decoder: config?.base64Decoder ?? fromBase64,
        base64Encoder: config?.base64Encoder ?? toBase64,
        disableHostPrefix: config?.disableHostPrefix ?? false,
        endpointProvider: config?.endpointProvider ?? defaultEndpointResolver4,
        extensions: config?.extensions ?? [],
        httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultRDSDataHttpAuthSchemeProvider,
        httpAuthSchemes: config?.httpAuthSchemes ?? [
          {
            schemeId: "aws.auth#sigv4",
            identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
            signer: new AwsSdkSigV4Signer()
          }
        ],
        logger: config?.logger ?? new NoOpLogger(),
        serviceId: config?.serviceId ?? "RDS Data",
        urlParser: config?.urlParser ?? parseUrl,
        utf8Decoder: config?.utf8Decoder ?? fromUtf8,
        utf8Encoder: config?.utf8Encoder ?? toUtf8
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/runtimeConfig.js
var getRuntimeConfig8;
var init_runtimeConfig4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/runtimeConfig.js"() {
    "use strict";
    init_package();
    init_dist_es25();
    init_dist_es52();
    init_dist_es41();
    init_dist_es28();
    init_dist_es42();
    init_dist_es37();
    init_dist_es31();
    init_dist_es14();
    init_dist_es43();
    init_dist_es36();
    init_runtimeConfig_shared4();
    init_dist_es24();
    init_dist_es44();
    init_dist_es24();
    getRuntimeConfig8 = (config) => {
      emitWarningIfUnsupportedVersion2(process.version);
      const defaultsMode = resolveDefaultsModeConfig(config);
      const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
      const clientSharedValues = getRuntimeConfig7(config);
      emitWarningIfUnsupportedVersion(process.version);
      const loaderConfig = {
        profile: config?.profile,
        logger: clientSharedValues.logger
      };
      return {
        ...clientSharedValues,
        ...config,
        runtime: "node",
        defaultsMode,
        authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
        bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
        credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
        defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default.version }),
        maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
        region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
        requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
        retryMode: config?.retryMode ?? loadConfig({
          ...NODE_RETRY_MODE_CONFIG_OPTIONS,
          default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
        }, config),
        sha256: config?.sha256 ?? Hash.bind(null, "sha256"),
        streamCollector: config?.streamCollector ?? streamCollector,
        useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
        userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration4, resolveHttpAuthRuntimeConfig4;
var init_httpAuthExtensionConfiguration4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/auth/httpAuthExtensionConfiguration.js"() {
    "use strict";
    getHttpAuthExtensionConfiguration4 = (runtimeConfig) => {
      const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
      let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
      let _credentials = runtimeConfig.credentials;
      return {
        setHttpAuthScheme(httpAuthScheme) {
          const index7 = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
          if (index7 === -1) {
            _httpAuthSchemes.push(httpAuthScheme);
          } else {
            _httpAuthSchemes.splice(index7, 1, httpAuthScheme);
          }
        },
        httpAuthSchemes() {
          return _httpAuthSchemes;
        },
        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
          _httpAuthSchemeProvider = httpAuthSchemeProvider;
        },
        httpAuthSchemeProvider() {
          return _httpAuthSchemeProvider;
        },
        setCredentials(credentials2) {
          _credentials = credentials2;
        },
        credentials() {
          return _credentials;
        }
      };
    };
    resolveHttpAuthRuntimeConfig4 = (config) => {
      return {
        httpAuthSchemes: config.httpAuthSchemes(),
        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
        credentials: config.credentials()
      };
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/runtimeExtensions.js
var resolveRuntimeExtensions4;
var init_runtimeExtensions4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/runtimeExtensions.js"() {
    "use strict";
    init_dist_es45();
    init_dist_es2();
    init_dist_es24();
    init_httpAuthExtensionConfiguration4();
    resolveRuntimeExtensions4 = (runtimeConfig, extensions) => {
      const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration4(runtimeConfig));
      extensions.forEach((extension) => extension.configure(extensionConfiguration));
      return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig4(extensionConfiguration));
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/RDSDataClient.js
var RDSDataClient;
var init_RDSDataClient = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/RDSDataClient.js"() {
    "use strict";
    init_dist_es3();
    init_dist_es4();
    init_dist_es5();
    init_dist_es26();
    init_dist_es28();
    init_dist_es18();
    init_dist_es29();
    init_dist_es34();
    init_dist_es37();
    init_dist_es24();
    init_httpAuthSchemeProvider();
    init_EndpointParameters();
    init_runtimeConfig4();
    init_runtimeExtensions4();
    RDSDataClient = class extends Client {
      constructor(...[configuration]) {
        const _config_0 = getRuntimeConfig8(configuration || {});
        super(_config_0);
        __publicField(this, "config");
        this.initConfig = _config_0;
        const _config_1 = resolveClientEndpointParameters(_config_0);
        const _config_2 = resolveUserAgentConfig(_config_1);
        const _config_3 = resolveRetryConfig(_config_2);
        const _config_4 = resolveRegionConfig(_config_3);
        const _config_5 = resolveHostHeaderConfig(_config_4);
        const _config_6 = resolveEndpointConfig(_config_5);
        const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
        const _config_8 = resolveRuntimeExtensions4(_config_7, configuration?.extensions || []);
        this.config = _config_8;
        this.middlewareStack.use(getUserAgentPlugin(this.config));
        this.middlewareStack.use(getRetryPlugin(this.config));
        this.middlewareStack.use(getContentLengthPlugin(this.config));
        this.middlewareStack.use(getHostHeaderPlugin(this.config));
        this.middlewareStack.use(getLoggerPlugin(this.config));
        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
          httpAuthSchemeParametersProvider: defaultRDSDataHttpAuthSchemeParametersProvider,
          identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
            "aws.auth#sigv4": config.credentials
          })
        }));
        this.middlewareStack.use(getHttpSigningPlugin(this.config));
      }
      destroy() {
        super.destroy();
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/models/RDSDataServiceException.js
var RDSDataServiceException;
var init_RDSDataServiceException = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/models/RDSDataServiceException.js"() {
    "use strict";
    init_dist_es24();
    RDSDataServiceException = class _RDSDataServiceException extends ServiceException {
      constructor(options) {
        super(options);
        Object.setPrototypeOf(this, _RDSDataServiceException.prototype);
      }
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/models/models_0.js
var AccessDeniedException2, BadRequestException, TypeHint, DatabaseErrorException, DatabaseNotFoundException, DatabaseResumingException, DatabaseUnavailableException, ForbiddenException, HttpEndpointNotEnabledException, InternalServerErrorException, InvalidResourceStateException, InvalidSecretException, SecretsErrorException, ServiceUnavailableError, StatementTimeoutException, TransactionNotFoundException, NotFoundException, DecimalReturnType, RecordsFormatType, LongReturnType, UnsupportedResultException, ArrayValue, Field, Value;
var init_models_04 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/models/models_0.js"() {
    "use strict";
    init_RDSDataServiceException();
    AccessDeniedException2 = class _AccessDeniedException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "AccessDeniedException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "AccessDeniedException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _AccessDeniedException.prototype);
      }
    };
    BadRequestException = class _BadRequestException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "BadRequestException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "BadRequestException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _BadRequestException.prototype);
      }
    };
    TypeHint = {
      DATE: "DATE",
      DECIMAL: "DECIMAL",
      JSON: "JSON",
      TIME: "TIME",
      TIMESTAMP: "TIMESTAMP",
      UUID: "UUID"
    };
    DatabaseErrorException = class _DatabaseErrorException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "DatabaseErrorException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "DatabaseErrorException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _DatabaseErrorException.prototype);
      }
    };
    DatabaseNotFoundException = class _DatabaseNotFoundException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "DatabaseNotFoundException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "DatabaseNotFoundException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _DatabaseNotFoundException.prototype);
      }
    };
    DatabaseResumingException = class _DatabaseResumingException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "DatabaseResumingException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "DatabaseResumingException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _DatabaseResumingException.prototype);
      }
    };
    DatabaseUnavailableException = class _DatabaseUnavailableException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "DatabaseUnavailableException",
          $fault: "server",
          ...opts
        });
        __publicField(this, "name", "DatabaseUnavailableException");
        __publicField(this, "$fault", "server");
        Object.setPrototypeOf(this, _DatabaseUnavailableException.prototype);
      }
    };
    ForbiddenException = class _ForbiddenException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "ForbiddenException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "ForbiddenException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _ForbiddenException.prototype);
      }
    };
    HttpEndpointNotEnabledException = class _HttpEndpointNotEnabledException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "HttpEndpointNotEnabledException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "HttpEndpointNotEnabledException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _HttpEndpointNotEnabledException.prototype);
      }
    };
    InternalServerErrorException = class _InternalServerErrorException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "InternalServerErrorException",
          $fault: "server",
          ...opts
        });
        __publicField(this, "name", "InternalServerErrorException");
        __publicField(this, "$fault", "server");
        Object.setPrototypeOf(this, _InternalServerErrorException.prototype);
      }
    };
    InvalidResourceStateException = class _InvalidResourceStateException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "InvalidResourceStateException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidResourceStateException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _InvalidResourceStateException.prototype);
      }
    };
    InvalidSecretException = class _InvalidSecretException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "InvalidSecretException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "InvalidSecretException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _InvalidSecretException.prototype);
      }
    };
    SecretsErrorException = class _SecretsErrorException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "SecretsErrorException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "SecretsErrorException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _SecretsErrorException.prototype);
      }
    };
    ServiceUnavailableError = class _ServiceUnavailableError extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "ServiceUnavailableError",
          $fault: "server",
          ...opts
        });
        __publicField(this, "name", "ServiceUnavailableError");
        __publicField(this, "$fault", "server");
        Object.setPrototypeOf(this, _ServiceUnavailableError.prototype);
      }
    };
    StatementTimeoutException = class _StatementTimeoutException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "StatementTimeoutException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "StatementTimeoutException");
        __publicField(this, "$fault", "client");
        __publicField(this, "dbConnectionId");
        Object.setPrototypeOf(this, _StatementTimeoutException.prototype);
        this.dbConnectionId = opts.dbConnectionId;
      }
    };
    TransactionNotFoundException = class _TransactionNotFoundException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "TransactionNotFoundException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "TransactionNotFoundException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _TransactionNotFoundException.prototype);
      }
    };
    NotFoundException = class _NotFoundException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "NotFoundException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "NotFoundException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _NotFoundException.prototype);
      }
    };
    DecimalReturnType = {
      DOUBLE_OR_LONG: "DOUBLE_OR_LONG",
      STRING: "STRING"
    };
    RecordsFormatType = {
      JSON: "JSON",
      NONE: "NONE"
    };
    LongReturnType = {
      LONG: "LONG",
      STRING: "STRING"
    };
    UnsupportedResultException = class _UnsupportedResultException extends RDSDataServiceException {
      constructor(opts) {
        super({
          name: "UnsupportedResultException",
          $fault: "client",
          ...opts
        });
        __publicField(this, "name", "UnsupportedResultException");
        __publicField(this, "$fault", "client");
        Object.setPrototypeOf(this, _UnsupportedResultException.prototype);
      }
    };
    (function(ArrayValue2) {
      ArrayValue2.visit = (value, visitor) => {
        if (value.booleanValues !== void 0)
          return visitor.booleanValues(value.booleanValues);
        if (value.longValues !== void 0)
          return visitor.longValues(value.longValues);
        if (value.doubleValues !== void 0)
          return visitor.doubleValues(value.doubleValues);
        if (value.stringValues !== void 0)
          return visitor.stringValues(value.stringValues);
        if (value.arrayValues !== void 0)
          return visitor.arrayValues(value.arrayValues);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(ArrayValue || (ArrayValue = {}));
    (function(Field2) {
      Field2.visit = (value, visitor) => {
        if (value.isNull !== void 0)
          return visitor.isNull(value.isNull);
        if (value.booleanValue !== void 0)
          return visitor.booleanValue(value.booleanValue);
        if (value.longValue !== void 0)
          return visitor.longValue(value.longValue);
        if (value.doubleValue !== void 0)
          return visitor.doubleValue(value.doubleValue);
        if (value.stringValue !== void 0)
          return visitor.stringValue(value.stringValue);
        if (value.blobValue !== void 0)
          return visitor.blobValue(value.blobValue);
        if (value.arrayValue !== void 0)
          return visitor.arrayValue(value.arrayValue);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(Field || (Field = {}));
    (function(Value6) {
      Value6.visit = (value, visitor) => {
        if (value.isNull !== void 0)
          return visitor.isNull(value.isNull);
        if (value.bitValue !== void 0)
          return visitor.bitValue(value.bitValue);
        if (value.bigIntValue !== void 0)
          return visitor.bigIntValue(value.bigIntValue);
        if (value.intValue !== void 0)
          return visitor.intValue(value.intValue);
        if (value.doubleValue !== void 0)
          return visitor.doubleValue(value.doubleValue);
        if (value.realValue !== void 0)
          return visitor.realValue(value.realValue);
        if (value.stringValue !== void 0)
          return visitor.stringValue(value.stringValue);
        if (value.blobValue !== void 0)
          return visitor.blobValue(value.blobValue);
        if (value.arrayValues !== void 0)
          return visitor.arrayValues(value.arrayValues);
        if (value.structValue !== void 0)
          return visitor.structValue(value.structValue);
        return visitor._(value.$unknown[0], value.$unknown[1]);
      };
    })(Value || (Value = {}));
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/protocols/Aws_restJson1.js
var se_BatchExecuteStatementCommand, se_BeginTransactionCommand, se_CommitTransactionCommand, se_ExecuteSqlCommand, se_ExecuteStatementCommand, se_RollbackTransactionCommand, de_BatchExecuteStatementCommand, de_BeginTransactionCommand, de_CommitTransactionCommand, de_ExecuteSqlCommand, de_ExecuteStatementCommand, de_RollbackTransactionCommand, de_CommandError4, throwDefaultError5, de_AccessDeniedExceptionRes2, de_BadRequestExceptionRes, de_DatabaseErrorExceptionRes, de_DatabaseNotFoundExceptionRes, de_DatabaseResumingExceptionRes, de_DatabaseUnavailableExceptionRes, de_ForbiddenExceptionRes, de_HttpEndpointNotEnabledExceptionRes, de_InternalServerErrorExceptionRes, de_InvalidResourceStateExceptionRes, de_InvalidSecretExceptionRes, de_NotFoundExceptionRes, de_SecretsErrorExceptionRes, de_ServiceUnavailableErrorRes, de_StatementTimeoutExceptionRes, de_TransactionNotFoundExceptionRes, de_UnsupportedResultExceptionRes, se_ArrayOfArray, se_ArrayValue, se_DoubleArray, se_Field, se_SqlParameter, se_SqlParameterSets, se_SqlParametersList, de_ArrayOfArray, de_ArrayValue, de_ArrayValueList, de_DoubleArray, de_Field, de_FieldList, de__Record, de_Records, de_ResultFrame, de_Row, de_SqlRecords, de_SqlStatementResult, de_SqlStatementResults, de_StructValue, de_UpdateResult, de_UpdateResults, de_Value, deserializeMetadata5;
var init_Aws_restJson13 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/protocols/Aws_restJson1.js"() {
    "use strict";
    init_dist_es25();
    init_dist_es18();
    init_dist_es24();
    init_models_04();
    init_RDSDataServiceException();
    se_BatchExecuteStatementCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = {
        "content-type": "application/json"
      };
      b9.bp("/BatchExecute");
      let body2;
      body2 = JSON.stringify(take(input, {
        database: [],
        parameterSets: (_7) => se_SqlParameterSets(_7, context),
        resourceArn: [],
        schema: [],
        secretArn: [],
        sql: [],
        transactionId: []
      }));
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    se_BeginTransactionCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = {
        "content-type": "application/json"
      };
      b9.bp("/BeginTransaction");
      let body2;
      body2 = JSON.stringify(take(input, {
        database: [],
        resourceArn: [],
        schema: [],
        secretArn: []
      }));
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    se_CommitTransactionCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = {
        "content-type": "application/json"
      };
      b9.bp("/CommitTransaction");
      let body2;
      body2 = JSON.stringify(take(input, {
        resourceArn: [],
        secretArn: [],
        transactionId: []
      }));
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    se_ExecuteSqlCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = {
        "content-type": "application/json"
      };
      b9.bp("/ExecuteSql");
      let body2;
      body2 = JSON.stringify(take(input, {
        awsSecretStoreArn: [],
        database: [],
        dbClusterOrInstanceArn: [],
        schema: [],
        sqlStatements: []
      }));
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    se_ExecuteStatementCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = {
        "content-type": "application/json"
      };
      b9.bp("/Execute");
      let body2;
      body2 = JSON.stringify(take(input, {
        continueAfterTimeout: [],
        database: [],
        formatRecordsAs: [],
        includeResultMetadata: [],
        parameters: (_7) => se_SqlParametersList(_7, context),
        resourceArn: [],
        resultSetOptions: (_7) => _json(_7),
        schema: [],
        secretArn: [],
        sql: [],
        transactionId: []
      }));
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    se_RollbackTransactionCommand = async (input, context) => {
      const b9 = requestBuilder(input, context);
      const headers = {
        "content-type": "application/json"
      };
      b9.bp("/RollbackTransaction");
      let body2;
      body2 = JSON.stringify(take(input, {
        resourceArn: [],
        secretArn: [],
        transactionId: []
      }));
      b9.m("POST").h(headers).b(body2);
      return b9.build();
    };
    de_BatchExecuteStatementCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError4(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata5(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        updateResults: (_7) => de_UpdateResults(_7, context)
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_BeginTransactionCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError4(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata5(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        transactionId: expectString
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_CommitTransactionCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError4(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata5(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        transactionStatus: expectString
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_ExecuteSqlCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError4(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata5(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        sqlStatementResults: (_7) => de_SqlStatementResults(_7, context)
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_ExecuteStatementCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError4(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata5(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        columnMetadata: _json,
        formattedRecords: expectString,
        generatedFields: (_7) => de_FieldList(_7, context),
        numberOfRecordsUpdated: expectLong,
        records: (_7) => de_SqlRecords(_7, context)
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_RollbackTransactionCommand = async (output, context) => {
      if (output.statusCode !== 200 && output.statusCode >= 300) {
        return de_CommandError4(output, context);
      }
      const contents = map({
        $metadata: deserializeMetadata5(output)
      });
      const data = expectNonNull(expectObject(await parseJsonBody(output.body, context)), "body");
      const doc = take(data, {
        transactionStatus: expectString
      });
      Object.assign(contents, doc);
      return contents;
    };
    de_CommandError4 = async (output, context) => {
      const parsedOutput = {
        ...output,
        body: await parseJsonErrorBody(output.body, context)
      };
      const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
      switch (errorCode) {
        case "AccessDeniedException":
        case "com.amazonaws.rdsdata#AccessDeniedException":
          throw await de_AccessDeniedExceptionRes2(parsedOutput, context);
        case "BadRequestException":
        case "com.amazonaws.rdsdata#BadRequestException":
          throw await de_BadRequestExceptionRes(parsedOutput, context);
        case "DatabaseErrorException":
        case "com.amazonaws.rdsdata#DatabaseErrorException":
          throw await de_DatabaseErrorExceptionRes(parsedOutput, context);
        case "DatabaseNotFoundException":
        case "com.amazonaws.rdsdata#DatabaseNotFoundException":
          throw await de_DatabaseNotFoundExceptionRes(parsedOutput, context);
        case "DatabaseResumingException":
        case "com.amazonaws.rdsdata#DatabaseResumingException":
          throw await de_DatabaseResumingExceptionRes(parsedOutput, context);
        case "DatabaseUnavailableException":
        case "com.amazonaws.rdsdata#DatabaseUnavailableException":
          throw await de_DatabaseUnavailableExceptionRes(parsedOutput, context);
        case "ForbiddenException":
        case "com.amazonaws.rdsdata#ForbiddenException":
          throw await de_ForbiddenExceptionRes(parsedOutput, context);
        case "HttpEndpointNotEnabledException":
        case "com.amazonaws.rdsdata#HttpEndpointNotEnabledException":
          throw await de_HttpEndpointNotEnabledExceptionRes(parsedOutput, context);
        case "InternalServerErrorException":
        case "com.amazonaws.rdsdata#InternalServerErrorException":
          throw await de_InternalServerErrorExceptionRes(parsedOutput, context);
        case "InvalidResourceStateException":
        case "com.amazonaws.rdsdata#InvalidResourceStateException":
          throw await de_InvalidResourceStateExceptionRes(parsedOutput, context);
        case "InvalidSecretException":
        case "com.amazonaws.rdsdata#InvalidSecretException":
          throw await de_InvalidSecretExceptionRes(parsedOutput, context);
        case "SecretsErrorException":
        case "com.amazonaws.rdsdata#SecretsErrorException":
          throw await de_SecretsErrorExceptionRes(parsedOutput, context);
        case "ServiceUnavailableError":
        case "com.amazonaws.rdsdata#ServiceUnavailableError":
          throw await de_ServiceUnavailableErrorRes(parsedOutput, context);
        case "StatementTimeoutException":
        case "com.amazonaws.rdsdata#StatementTimeoutException":
          throw await de_StatementTimeoutExceptionRes(parsedOutput, context);
        case "TransactionNotFoundException":
        case "com.amazonaws.rdsdata#TransactionNotFoundException":
          throw await de_TransactionNotFoundExceptionRes(parsedOutput, context);
        case "NotFoundException":
        case "com.amazonaws.rdsdata#NotFoundException":
          throw await de_NotFoundExceptionRes(parsedOutput, context);
        case "UnsupportedResultException":
        case "com.amazonaws.rdsdata#UnsupportedResultException":
          throw await de_UnsupportedResultExceptionRes(parsedOutput, context);
        default:
          const parsedBody = parsedOutput.body;
          return throwDefaultError5({
            output,
            parsedBody,
            errorCode
          });
      }
    };
    throwDefaultError5 = withBaseException(RDSDataServiceException);
    de_AccessDeniedExceptionRes2 = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new AccessDeniedException2({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_BadRequestExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new BadRequestException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_DatabaseErrorExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new DatabaseErrorException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_DatabaseNotFoundExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new DatabaseNotFoundException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_DatabaseResumingExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new DatabaseResumingException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_DatabaseUnavailableExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {});
      Object.assign(contents, doc);
      const exception = new DatabaseUnavailableException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_ForbiddenExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new ForbiddenException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_HttpEndpointNotEnabledExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new HttpEndpointNotEnabledException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InternalServerErrorExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {});
      Object.assign(contents, doc);
      const exception = new InternalServerErrorException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InvalidResourceStateExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new InvalidResourceStateException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_InvalidSecretExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new InvalidSecretException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_NotFoundExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new NotFoundException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_SecretsErrorExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new SecretsErrorException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_ServiceUnavailableErrorRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {});
      Object.assign(contents, doc);
      const exception = new ServiceUnavailableError({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_StatementTimeoutExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        dbConnectionId: expectLong,
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new StatementTimeoutException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_TransactionNotFoundExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new TransactionNotFoundException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    de_UnsupportedResultExceptionRes = async (parsedOutput, context) => {
      const contents = map({});
      const data = parsedOutput.body;
      const doc = take(data, {
        message: expectString
      });
      Object.assign(contents, doc);
      const exception = new UnsupportedResultException({
        $metadata: deserializeMetadata5(parsedOutput),
        ...contents
      });
      return decorateServiceException(exception, parsedOutput.body);
    };
    se_ArrayOfArray = (input, context) => {
      return input.filter((e6) => e6 != null).map((entry) => {
        return se_ArrayValue(entry, context);
      });
    };
    se_ArrayValue = (input, context) => {
      return ArrayValue.visit(input, {
        arrayValues: (value) => ({ arrayValues: se_ArrayOfArray(value, context) }),
        booleanValues: (value) => ({ booleanValues: _json(value) }),
        doubleValues: (value) => ({ doubleValues: se_DoubleArray(value, context) }),
        longValues: (value) => ({ longValues: _json(value) }),
        stringValues: (value) => ({ stringValues: _json(value) }),
        _: (name3, value) => ({ [name3]: value })
      });
    };
    se_DoubleArray = (input, context) => {
      return input.filter((e6) => e6 != null).map((entry) => {
        return serializeFloat(entry);
      });
    };
    se_Field = (input, context) => {
      return Field.visit(input, {
        arrayValue: (value) => ({ arrayValue: se_ArrayValue(value, context) }),
        blobValue: (value) => ({ blobValue: context.base64Encoder(value) }),
        booleanValue: (value) => ({ booleanValue: value }),
        doubleValue: (value) => ({ doubleValue: serializeFloat(value) }),
        isNull: (value) => ({ isNull: value }),
        longValue: (value) => ({ longValue: value }),
        stringValue: (value) => ({ stringValue: value }),
        _: (name3, value) => ({ [name3]: value })
      });
    };
    se_SqlParameter = (input, context) => {
      return take(input, {
        name: [],
        typeHint: [],
        value: (_7) => se_Field(_7, context)
      });
    };
    se_SqlParameterSets = (input, context) => {
      return input.filter((e6) => e6 != null).map((entry) => {
        return se_SqlParametersList(entry, context);
      });
    };
    se_SqlParametersList = (input, context) => {
      return input.filter((e6) => e6 != null).map((entry) => {
        return se_SqlParameter(entry, context);
      });
    };
    de_ArrayOfArray = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de_ArrayValue(awsExpectUnion(entry), context);
      });
      return retVal;
    };
    de_ArrayValue = (output, context) => {
      if (output.arrayValues != null) {
        return {
          arrayValues: de_ArrayOfArray(output.arrayValues, context)
        };
      }
      if (output.booleanValues != null) {
        return {
          booleanValues: _json(output.booleanValues)
        };
      }
      if (output.doubleValues != null) {
        return {
          doubleValues: de_DoubleArray(output.doubleValues, context)
        };
      }
      if (output.longValues != null) {
        return {
          longValues: _json(output.longValues)
        };
      }
      if (output.stringValues != null) {
        return {
          stringValues: _json(output.stringValues)
        };
      }
      return { $unknown: Object.entries(output)[0] };
    };
    de_ArrayValueList = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de_Value(awsExpectUnion(entry), context);
      });
      return retVal;
    };
    de_DoubleArray = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return limitedParseDouble(entry);
      });
      return retVal;
    };
    de_Field = (output, context) => {
      if (output.arrayValue != null) {
        return {
          arrayValue: de_ArrayValue(awsExpectUnion(output.arrayValue), context)
        };
      }
      if (output.blobValue != null) {
        return {
          blobValue: context.base64Decoder(output.blobValue)
        };
      }
      if (expectBoolean(output.booleanValue) !== void 0) {
        return { booleanValue: expectBoolean(output.booleanValue) };
      }
      if (limitedParseDouble(output.doubleValue) !== void 0) {
        return { doubleValue: limitedParseDouble(output.doubleValue) };
      }
      if (expectBoolean(output.isNull) !== void 0) {
        return { isNull: expectBoolean(output.isNull) };
      }
      if (expectLong(output.longValue) !== void 0) {
        return { longValue: expectLong(output.longValue) };
      }
      if (expectString(output.stringValue) !== void 0) {
        return { stringValue: expectString(output.stringValue) };
      }
      return { $unknown: Object.entries(output)[0] };
    };
    de_FieldList = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de_Field(awsExpectUnion(entry), context);
      });
      return retVal;
    };
    de__Record = (output, context) => {
      return take(output, {
        values: (_7) => de_Row(_7, context)
      });
    };
    de_Records = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de__Record(entry, context);
      });
      return retVal;
    };
    de_ResultFrame = (output, context) => {
      return take(output, {
        records: (_7) => de_Records(_7, context),
        resultSetMetadata: _json
      });
    };
    de_Row = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de_Value(awsExpectUnion(entry), context);
      });
      return retVal;
    };
    de_SqlRecords = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de_FieldList(entry, context);
      });
      return retVal;
    };
    de_SqlStatementResult = (output, context) => {
      return take(output, {
        numberOfRecordsUpdated: expectLong,
        resultFrame: (_7) => de_ResultFrame(_7, context)
      });
    };
    de_SqlStatementResults = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de_SqlStatementResult(entry, context);
      });
      return retVal;
    };
    de_StructValue = (output, context) => {
      return take(output, {
        attributes: (_7) => de_ArrayValueList(_7, context)
      });
    };
    de_UpdateResult = (output, context) => {
      return take(output, {
        generatedFields: (_7) => de_FieldList(_7, context)
      });
    };
    de_UpdateResults = (output, context) => {
      const retVal = (output || []).filter((e6) => e6 != null).map((entry) => {
        return de_UpdateResult(entry, context);
      });
      return retVal;
    };
    de_Value = (output, context) => {
      if (output.arrayValues != null) {
        return {
          arrayValues: de_ArrayValueList(output.arrayValues, context)
        };
      }
      if (expectLong(output.bigIntValue) !== void 0) {
        return { bigIntValue: expectLong(output.bigIntValue) };
      }
      if (expectBoolean(output.bitValue) !== void 0) {
        return { bitValue: expectBoolean(output.bitValue) };
      }
      if (output.blobValue != null) {
        return {
          blobValue: context.base64Decoder(output.blobValue)
        };
      }
      if (limitedParseDouble(output.doubleValue) !== void 0) {
        return { doubleValue: limitedParseDouble(output.doubleValue) };
      }
      if (expectInt32(output.intValue) !== void 0) {
        return { intValue: expectInt32(output.intValue) };
      }
      if (expectBoolean(output.isNull) !== void 0) {
        return { isNull: expectBoolean(output.isNull) };
      }
      if (limitedParseFloat32(output.realValue) !== void 0) {
        return { realValue: limitedParseFloat32(output.realValue) };
      }
      if (expectString(output.stringValue) !== void 0) {
        return { stringValue: expectString(output.stringValue) };
      }
      if (output.structValue != null) {
        return {
          structValue: de_StructValue(output.structValue, context)
        };
      }
      return { $unknown: Object.entries(output)[0] };
    };
    deserializeMetadata5 = (output) => ({
      httpStatusCode: output.statusCode,
      requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
      extendedRequestId: output.headers["x-amz-id-2"],
      cfId: output.headers["x-amz-cf-id"]
    });
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/BatchExecuteStatementCommand.js
var BatchExecuteStatementCommand;
var init_BatchExecuteStatementCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/BatchExecuteStatementCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters();
    init_Aws_restJson13();
    BatchExecuteStatementCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("RdsDataService", "BatchExecuteStatement", {}).n("RDSDataClient", "BatchExecuteStatementCommand").f(void 0, void 0).ser(se_BatchExecuteStatementCommand).de(de_BatchExecuteStatementCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/BeginTransactionCommand.js
var BeginTransactionCommand;
var init_BeginTransactionCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/BeginTransactionCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters();
    init_Aws_restJson13();
    BeginTransactionCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("RdsDataService", "BeginTransaction", {}).n("RDSDataClient", "BeginTransactionCommand").f(void 0, void 0).ser(se_BeginTransactionCommand).de(de_BeginTransactionCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/CommitTransactionCommand.js
var CommitTransactionCommand;
var init_CommitTransactionCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/CommitTransactionCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters();
    init_Aws_restJson13();
    CommitTransactionCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("RdsDataService", "CommitTransaction", {}).n("RDSDataClient", "CommitTransactionCommand").f(void 0, void 0).ser(se_CommitTransactionCommand).de(de_CommitTransactionCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/ExecuteSqlCommand.js
var ExecuteSqlCommand;
var init_ExecuteSqlCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/ExecuteSqlCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters();
    init_Aws_restJson13();
    ExecuteSqlCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("RdsDataService", "ExecuteSql", {}).n("RDSDataClient", "ExecuteSqlCommand").f(void 0, void 0).ser(se_ExecuteSqlCommand).de(de_ExecuteSqlCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/ExecuteStatementCommand.js
var ExecuteStatementCommand;
var init_ExecuteStatementCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/ExecuteStatementCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters();
    init_Aws_restJson13();
    ExecuteStatementCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("RdsDataService", "ExecuteStatement", {}).n("RDSDataClient", "ExecuteStatementCommand").f(void 0, void 0).ser(se_ExecuteStatementCommand).de(de_ExecuteStatementCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/RollbackTransactionCommand.js
var RollbackTransactionCommand;
var init_RollbackTransactionCommand = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/RollbackTransactionCommand.js"() {
    "use strict";
    init_dist_es34();
    init_dist_es7();
    init_dist_es24();
    init_EndpointParameters();
    init_Aws_restJson13();
    RollbackTransactionCommand = class extends Command.classBuilder().ep(commonParams).m(function(Command2, cs2, config, o9) {
      return [
        getSerdePlugin(config, this.serialize, this.deserialize),
        getEndpointPlugin(config, Command2.getEndpointParameterInstructions())
      ];
    }).s("RdsDataService", "RollbackTransaction", {}).n("RDSDataClient", "RollbackTransactionCommand").f(void 0, void 0).ser(se_RollbackTransactionCommand).de(de_RollbackTransactionCommand).build() {
    };
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/RDSData.js
var commands4, RDSData;
var init_RDSData = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/RDSData.js"() {
    "use strict";
    init_dist_es24();
    init_BatchExecuteStatementCommand();
    init_BeginTransactionCommand();
    init_CommitTransactionCommand();
    init_ExecuteSqlCommand();
    init_ExecuteStatementCommand();
    init_RollbackTransactionCommand();
    init_RDSDataClient();
    commands4 = {
      BatchExecuteStatementCommand,
      BeginTransactionCommand,
      CommitTransactionCommand,
      ExecuteSqlCommand,
      ExecuteStatementCommand,
      RollbackTransactionCommand
    };
    RDSData = class extends RDSDataClient {
    };
    createAggregatedClient(commands4, RDSData);
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/index.js
var init_commands4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/commands/index.js"() {
    "use strict";
    init_BatchExecuteStatementCommand();
    init_BeginTransactionCommand();
    init_CommitTransactionCommand();
    init_ExecuteSqlCommand();
    init_ExecuteStatementCommand();
    init_RollbackTransactionCommand();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/models/index.js
var init_models4 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/models/index.js"() {
    "use strict";
    init_models_04();
  }
});

// ../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/index.js
var dist_es_exports8 = {};
__export(dist_es_exports8, {
  $Command: () => Command,
  AccessDeniedException: () => AccessDeniedException2,
  ArrayValue: () => ArrayValue,
  BadRequestException: () => BadRequestException,
  BatchExecuteStatementCommand: () => BatchExecuteStatementCommand,
  BeginTransactionCommand: () => BeginTransactionCommand,
  CommitTransactionCommand: () => CommitTransactionCommand,
  DatabaseErrorException: () => DatabaseErrorException,
  DatabaseNotFoundException: () => DatabaseNotFoundException,
  DatabaseResumingException: () => DatabaseResumingException,
  DatabaseUnavailableException: () => DatabaseUnavailableException,
  DecimalReturnType: () => DecimalReturnType,
  ExecuteSqlCommand: () => ExecuteSqlCommand,
  ExecuteStatementCommand: () => ExecuteStatementCommand,
  Field: () => Field,
  ForbiddenException: () => ForbiddenException,
  HttpEndpointNotEnabledException: () => HttpEndpointNotEnabledException,
  InternalServerErrorException: () => InternalServerErrorException,
  InvalidResourceStateException: () => InvalidResourceStateException,
  InvalidSecretException: () => InvalidSecretException,
  LongReturnType: () => LongReturnType,
  NotFoundException: () => NotFoundException,
  RDSData: () => RDSData,
  RDSDataClient: () => RDSDataClient,
  RDSDataServiceException: () => RDSDataServiceException,
  RecordsFormatType: () => RecordsFormatType,
  RollbackTransactionCommand: () => RollbackTransactionCommand,
  SecretsErrorException: () => SecretsErrorException,
  ServiceUnavailableError: () => ServiceUnavailableError,
  StatementTimeoutException: () => StatementTimeoutException,
  TransactionNotFoundException: () => TransactionNotFoundException,
  TypeHint: () => TypeHint,
  UnsupportedResultException: () => UnsupportedResultException,
  Value: () => Value,
  __Client: () => Client
});
var init_dist_es53 = __esm({
  "../node_modules/.pnpm/@aws-sdk+client-rds-data@3.817.0/node_modules/@aws-sdk/client-rds-data/dist-es/index.js"() {
    "use strict";
    init_RDSDataClient();
    init_RDSData();
    init_commands4();
    init_models4();
    init_RDSDataServiceException();
  }
});

// ../drizzle-orm/dist/aws-data-api/common/index.js
function getValueFromDataApi(field) {
  if (field.stringValue !== void 0) {
    return field.stringValue;
  } else if (field.booleanValue !== void 0) {
    return field.booleanValue;
  } else if (field.doubleValue !== void 0) {
    return field.doubleValue;
  } else if (field.isNull !== void 0) {
    return null;
  } else if (field.longValue !== void 0) {
    return field.longValue;
  } else if (field.blobValue !== void 0) {
    return field.blobValue;
  } else if (field.arrayValue !== void 0) {
    if (field.arrayValue.stringValues !== void 0) {
      return field.arrayValue.stringValues;
    }
    if (field.arrayValue.longValues !== void 0) {
      return field.arrayValue.longValues;
    }
    if (field.arrayValue.doubleValues !== void 0) {
      return field.arrayValue.doubleValues;
    }
    if (field.arrayValue.booleanValues !== void 0) {
      return field.arrayValue.booleanValues;
    }
    if (field.arrayValue.arrayValues !== void 0) {
      return field.arrayValue.arrayValues;
    }
    throw new Error("Unknown array type");
  } else {
    throw new Error("Unknown type");
  }
}
function typingsToAwsTypeHint(typings) {
  if (typings === "date") {
    return TypeHint.DATE;
  } else if (typings === "decimal") {
    return TypeHint.DECIMAL;
  } else if (typings === "json") {
    return TypeHint.JSON;
  } else if (typings === "time") {
    return TypeHint.TIME;
  } else if (typings === "timestamp") {
    return TypeHint.TIMESTAMP;
  } else if (typings === "uuid") {
    return TypeHint.UUID;
  } else {
    return void 0;
  }
}
function toValueParam(value, typings) {
  const response = {
    value: {},
    typeHint: typingsToAwsTypeHint(typings)
  };
  if (value === null) {
    response.value = { isNull: true };
  } else if (typeof value === "string") {
    switch (response.typeHint) {
      case TypeHint.DATE: {
        response.value = { stringValue: value.split("T")[0] };
        break;
      }
      case TypeHint.TIMESTAMP: {
        response.value = { stringValue: value.replace("T", " ").replace("Z", "") };
        break;
      }
      default: {
        response.value = { stringValue: value };
        break;
      }
    }
  } else if (typeof value === "number" && Number.isInteger(value)) {
    response.value = { longValue: value };
  } else if (typeof value === "number" && !Number.isInteger(value)) {
    response.value = { doubleValue: value };
  } else if (typeof value === "boolean") {
    response.value = { booleanValue: value };
  } else if (value instanceof Date) {
    response.value = { stringValue: value.toISOString().replace("T", " ").replace("Z", "") };
  } else {
    throw new Error(`Unknown type for ${value}`);
  }
  return response;
}
var init_common7 = __esm({
  "../drizzle-orm/dist/aws-data-api/common/index.js"() {
    "use strict";
    init_dist_es53();
  }
});

// ../drizzle-orm/dist/aws-data-api/pg/session.js
var _a451, _b326, AwsDataApiPreparedQuery, _a452, _b327, _AwsDataApiSession, AwsDataApiSession, _a453, _b328, _AwsDataApiTransaction, AwsDataApiTransaction;
var init_session5 = __esm({
  "../drizzle-orm/dist/aws-data-api/pg/session.js"() {
    "use strict";
    init_dist_es53();
    init_cache();
    init_entity();
    init_pg_core();
    init_sql();
    init_utils();
    init_common7();
    AwsDataApiPreparedQuery = class extends (_b326 = PgPreparedQuery, _a451 = entityKind, _b326) {
      constructor(client, queryString, params, typings, options, cache5, queryMetadata, cacheConfig, fields, transactionId, _isResponseInArrayMode, customResultMapper) {
        super({ sql: queryString, params }, cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQuery");
        this.client = client;
        this.queryString = queryString;
        this.params = params;
        this.typings = typings;
        this.options = options;
        this.fields = fields;
        this.transactionId = transactionId;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
        this.rawQuery = new ExecuteStatementCommand({
          sql: queryString,
          parameters: [],
          secretArn: options.secretArn,
          resourceArn: options.resourceArn,
          database: options.database,
          transactionId,
          includeResultMetadata: !fields && !customResultMapper
        });
      }
      async execute(placeholderValues = {}) {
        const { fields, joinsNotNullableMap, customResultMapper } = this;
        const result = await this.values(placeholderValues);
        if (!fields && !customResultMapper) {
          const { columnMetadata, rows } = result;
          if (!columnMetadata) {
            return result;
          }
          const mappedRows = rows.map((sourceRow) => {
            const row = {};
            for (const [index7, value] of sourceRow.entries()) {
              const metadata2 = columnMetadata[index7];
              if (!metadata2) {
                throw new Error(
                  `Unexpected state: no column metadata found for index ${index7}. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`
                );
              }
              if (!metadata2.name) {
                throw new Error(
                  `Unexpected state: no column name for index ${index7} found in the column metadata. Please report this issue on GitHub: https://github.com/drizzle-team/drizzle-orm/issues/new/choose`
                );
              }
              row[metadata2.name] = value;
            }
            return row;
          });
          return Object.assign(result, { rows: mappedRows });
        }
        return customResultMapper ? customResultMapper(result.rows) : result.rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      async all(placeholderValues) {
        const result = await this.execute(placeholderValues);
        if (!this.fields && !this.customResultMapper) {
          return result.rows;
        }
        return result;
      }
      async values(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues ?? {});
        this.rawQuery.input.parameters = params.map((param2, index7) => ({
          name: `${index7 + 1}`,
          ...toValueParam(param2, this.typings[index7])
        }));
        this.options.logger?.logQuery(this.rawQuery.input.sql, this.rawQuery.input.parameters);
        const result = await this.queryWithCache(this.queryString, params, async () => {
          return await this.client.send(this.rawQuery);
        });
        const rows = result.records?.map((row) => {
          return row.map((field) => getValueFromDataApi(field));
        }) ?? [];
        return {
          ...result,
          rows
        };
      }
      /** @internal */
      mapResultRows(records, columnMetadata) {
        return records.map((record) => {
          const row = {};
          for (const [index7, field] of record.entries()) {
            const { name: name3 } = columnMetadata[index7];
            row[name3 ?? index7] = getValueFromDataApi(field);
          }
          return row;
        });
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(AwsDataApiPreparedQuery, _a451, "AwsDataApiPreparedQuery");
    _AwsDataApiSession = class _AwsDataApiSession extends (_b327 = PgSession, _a452 = entityKind, _b327) {
      constructor(client, dialect6, schema6, options, transactionId) {
        super(dialect6);
        /** @internal */
        __publicField(this, "rawQuery");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.transactionId = transactionId;
        this.rawQuery = {
          secretArn: options.secretArn,
          resourceArn: options.resourceArn,
          database: options.database
        };
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, name3, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig, transactionId) {
        return new AwsDataApiPreparedQuery(
          this.client,
          query.sql,
          query.params,
          query.typings ?? [],
          this.options,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          transactionId ?? this.transactionId,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      execute(query) {
        return this.prepareQuery(
          this.dialect.sqlToQuery(query),
          void 0,
          void 0,
          false,
          void 0,
          void 0,
          void 0,
          this.transactionId
        ).execute();
      }
      async transaction(transaction, config) {
        const { transactionId } = await this.client.send(new BeginTransactionCommand(this.rawQuery));
        const session = new _AwsDataApiSession(this.client, this.dialect, this.schema, this.options, transactionId);
        const tx = new AwsDataApiTransaction(this.dialect, session, this.schema);
        if (config) {
          await tx.setTransaction(config);
        }
        try {
          const result = await transaction(tx);
          await this.client.send(new CommitTransactionCommand({ ...this.rawQuery, transactionId }));
          return result;
        } catch (e6) {
          await this.client.send(new RollbackTransactionCommand({ ...this.rawQuery, transactionId }));
          throw e6;
        }
      }
    };
    __publicField(_AwsDataApiSession, _a452, "AwsDataApiSession");
    AwsDataApiSession = _AwsDataApiSession;
    _AwsDataApiTransaction = class _AwsDataApiTransaction extends (_b328 = PgTransaction, _a453 = entityKind, _b328) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _AwsDataApiTransaction(
          this.dialect,
          this.session,
          this.schema,
          this.nestedIndex + 1
        );
        await this.session.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await this.session.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (e6) {
          await this.session.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw e6;
        }
      }
    };
    __publicField(_AwsDataApiTransaction, _a453, "AwsDataApiTransaction");
    AwsDataApiTransaction = _AwsDataApiTransaction;
  }
});

// ../drizzle-orm/dist/aws-data-api/pg/driver.js
function construct(client, config) {
  const dialect6 = new AwsPgDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const session = new AwsDataApiSession(client, dialect6, schema6, { ...config, logger: logger2, cache: config.cache }, void 0);
  const db2 = new AwsDataApiPgDatabase(dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function drizzle(...params) {
  if (params[0] instanceof RDSDataClient || params[0].constructor.name !== "Object") {
    return construct(params[0], params[1]);
  }
  if (params[0].client) {
    const { client, ...drizzleConfig2 } = params[0];
    return construct(client, drizzleConfig2);
  }
  const { connection: connection2, ...drizzleConfig } = params[0];
  const { resourceArn, database, secretArn, ...rdsConfig } = connection2;
  const instance2 = new RDSDataClient(rdsConfig);
  return construct(instance2, { resourceArn, database, secretArn, ...drizzleConfig });
}
var _a454, _b329, AwsDataApiPgDatabase, _a455, _b330, AwsPgDialect;
var init_driver = __esm({
  "../drizzle-orm/dist/aws-data-api/pg/driver.js"() {
    "use strict";
    init_dist_es53();
    init_entity();
    init_logger();
    init_db2();
    init_dialect2();
    init_pg_core();
    init_relations();
    init_sql();
    init_table();
    init_session5();
    AwsDataApiPgDatabase = class extends (_b329 = PgDatabase, _a454 = entityKind, _b329) {
      execute(query) {
        return super.execute(query);
      }
    };
    __publicField(AwsDataApiPgDatabase, _a454, "AwsDataApiPgDatabase");
    AwsPgDialect = class extends (_b330 = PgDialect, _a455 = entityKind, _b330) {
      escapeParam(num) {
        return `:${num + 1}`;
      }
      buildInsertQuery({ table: table6, values: values2, onConflict, returning, select: select2, withList }) {
        const columns = table6[Table.Symbol.Columns];
        if (!select2) {
          for (const value of values2) {
            for (const fieldName of Object.keys(columns)) {
              const colValue = value[fieldName];
              if (is(colValue, Param) && colValue.value !== void 0 && is(colValue.encoder, PgArray) && Array.isArray(colValue.value)) {
                value[fieldName] = sql`cast(${colValue} as ${sql.raw(colValue.encoder.getSQLType())})`;
              }
            }
          }
        }
        return super.buildInsertQuery({ table: table6, values: values2, onConflict, returning, withList });
      }
      buildUpdateSet(table6, set) {
        const columns = table6[Table.Symbol.Columns];
        for (const [colName, colValue] of Object.entries(set)) {
          const currentColumn = columns[colName];
          if (currentColumn && is(colValue, Param) && colValue.value !== void 0 && is(colValue.encoder, PgArray) && Array.isArray(colValue.value)) {
            set[colName] = sql`cast(${colValue} as ${sql.raw(colValue.encoder.getSQLType())})`;
          }
        }
        return super.buildUpdateSet(table6, set);
      }
    };
    __publicField(AwsPgDialect, _a455, "AwsPgDialect");
    ((drizzle22) => {
      function mock(config) {
        return construct({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle || (drizzle = {}));
  }
});

// ../drizzle-orm/dist/aws-data-api/pg/index.js
var pg_exports = {};
__export(pg_exports, {
  AwsDataApiPgDatabase: () => AwsDataApiPgDatabase,
  AwsDataApiPreparedQuery: () => AwsDataApiPreparedQuery,
  AwsDataApiSession: () => AwsDataApiSession,
  AwsDataApiTransaction: () => AwsDataApiTransaction,
  AwsPgDialect: () => AwsPgDialect,
  drizzle: () => drizzle
});
var init_pg = __esm({
  "../drizzle-orm/dist/aws-data-api/pg/index.js"() {
    "use strict";
    init_driver();
    init_session5();
  }
});

// ../drizzle-orm/dist/migrator.js
function readMigrationFiles(config) {
  const migrationFolderTo = config.migrationsFolder;
  const migrationQueries = [];
  const journalPath = `${migrationFolderTo}/meta/_journal.json`;
  if (!import_node_fs2.default.existsSync(journalPath)) {
    throw new Error(`Can't find meta/_journal.json file`);
  }
  const journalAsString = import_node_fs2.default.readFileSync(`${migrationFolderTo}/meta/_journal.json`).toString();
  const journal = JSON.parse(journalAsString);
  for (const journalEntry of journal.entries) {
    const migrationPath = `${migrationFolderTo}/${journalEntry.tag}.sql`;
    try {
      const query = import_node_fs2.default.readFileSync(`${migrationFolderTo}/${journalEntry.tag}.sql`).toString();
      const result = query.split("--> statement-breakpoint").map((it2) => {
        return it2;
      });
      migrationQueries.push({
        sql: result,
        bps: journalEntry.breakpoints,
        folderMillis: journalEntry.when,
        hash: import_node_crypto.default.createHash("sha256").update(query).digest("hex")
      });
    } catch {
      throw new Error(`No file ${migrationPath} found in ${migrationFolderTo} folder`);
    }
  }
  return migrationQueries;
}
var import_node_crypto, import_node_fs2;
var init_migrator = __esm({
  "../drizzle-orm/dist/migrator.js"() {
    "use strict";
    import_node_crypto = __toESM(require("crypto"), 1);
    import_node_fs2 = __toESM(require("fs"), 1);
  }
});

// ../drizzle-orm/dist/aws-data-api/pg/migrator.js
var migrator_exports = {};
__export(migrator_exports, {
  migrate: () => migrate
});
async function migrate(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator2 = __esm({
  "../drizzle-orm/dist/aws-data-api/pg/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-Y3AVQXKT.js
var p5, i7, c5, f7, l5, s6, a5, _3, u5, D2, d5, F3, n5, g5, L, h6, P, R, x5;
var init_chunk_Y3AVQXKT = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-Y3AVQXKT.js"() {
    "use strict";
    p5 = Object.create;
    i7 = Object.defineProperty;
    c5 = Object.getOwnPropertyDescriptor;
    f7 = Object.getOwnPropertyNames;
    l5 = Object.getPrototypeOf;
    s6 = Object.prototype.hasOwnProperty;
    a5 = (t6) => {
      throw TypeError(t6);
    };
    _3 = (t6, e6) => () => (t6 && (e6 = t6(t6 = 0)), e6);
    u5 = (t6, e6) => () => (e6 || t6((e6 = { exports: {} }).exports, e6), e6.exports);
    D2 = (t6, e6) => {
      for (var o9 in e6) i7(t6, o9, { get: e6[o9], enumerable: true });
    };
    d5 = (t6, e6, o9, m12) => {
      if (e6 && typeof e6 == "object" || typeof e6 == "function") for (let r6 of f7(e6)) !s6.call(t6, r6) && r6 !== o9 && i7(t6, r6, { get: () => e6[r6], enumerable: !(m12 = c5(e6, r6)) || m12.enumerable });
      return t6;
    };
    F3 = (t6, e6, o9) => (o9 = t6 != null ? p5(l5(t6)) : {}, d5(e6 || !t6 || !t6.__esModule ? i7(o9, "default", { value: t6, enumerable: true }) : o9, t6));
    n5 = (t6, e6, o9) => e6.has(t6) || a5("Cannot " + o9);
    g5 = (t6, e6, o9) => (n5(t6, e6, "read from private field"), o9 ? o9.call(t6) : e6.get(t6));
    L = (t6, e6, o9) => e6.has(t6) ? a5("Cannot add the same private member more than once") : e6 instanceof WeakSet ? e6.add(t6) : e6.set(t6, o9);
    h6 = (t6, e6, o9, m12) => (n5(t6, e6, "write to private field"), m12 ? m12.call(t6, o9) : e6.set(t6, o9), o9);
    P = (t6, e6, o9) => (n5(t6, e6, "access private method"), o9);
    R = (t6, e6, o9, m12) => ({ set _(r6) {
      h6(t6, e6, r6, o9);
    }, get _() {
      return g5(t6, e6, m12);
    } });
    x5 = _3(() => {
      "use strict";
    });
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-RBN4KMJ6.js
async function H2(r6, e6, t6 = "pgdata", s10 = "auto") {
  let o9 = jr(r6, e6), [n7, a9] = await Br(o9, s10), i8 = t6 + (a9 ? ".tar.gz" : ".tar"), u7 = a9 ? "application/x-gzip" : "application/x-tar";
  return typeof File < "u" ? new File([n7], i8, { type: u7 }) : new Blob([n7], { type: u7 });
}
async function ce(r6, e6, t6) {
  let s10 = new Uint8Array(await e6.arrayBuffer()), o9 = typeof File < "u" && e6 instanceof File ? e6.name : void 0;
  (Gr.includes(e6.type) || o9?.endsWith(".tgz") || o9?.endsWith(".tar.gz")) && (s10 = await Wr(s10));
  let a9 = (0, h7.untar)(s10);
  for (let i8 of a9) {
    let u7 = t6 + i8.name, c6 = u7.split("/").slice(0, -1);
    for (let m12 = 1; m12 <= c6.length; m12++) {
      let y7 = c6.slice(0, m12).join("/");
      r6.analyzePath(y7).exists || r6.mkdir(y7);
    }
    i8.type === h7.REGTYPE ? (r6.writeFile(u7, i8.data), r6.utime(u7, ar(i8.modifyTime), ar(i8.modifyTime))) : i8.type === h7.DIRTYPE && r6.mkdir(u7);
  }
}
function Hr(r6, e6) {
  let t6 = [], s10 = (o9) => {
    r6.readdir(o9).forEach((a9) => {
      if (a9 === "." || a9 === "..") return;
      let i8 = o9 + "/" + a9, u7 = r6.stat(i8), c6 = r6.isFile(u7.mode) ? r6.readFile(i8, { encoding: "binary" }) : new Uint8Array(0);
      t6.push({ name: i8.substring(e6.length), mode: u7.mode, size: u7.size, type: r6.isFile(u7.mode) ? h7.REGTYPE : h7.DIRTYPE, modifyTime: u7.mtime, data: c6 }), r6.isDir(u7.mode) && s10(i8);
    });
  };
  return s10(e6), t6;
}
function jr(r6, e6) {
  let t6 = Hr(r6, e6);
  return (0, h7.tar)(t6);
}
async function Br(r6, e6 = "auto") {
  if (e6 === "none") return [r6, false];
  if (typeof CompressionStream < "u") return [await qr(r6), true];
  if (typeof process < "u" && process.versions && process.versions.node) return [await Yr(r6), true];
  if (e6 === "auto") return [r6, false];
  throw new Error("Compression not supported in this environment");
}
async function qr(r6) {
  let e6 = new CompressionStream("gzip"), t6 = e6.writable.getWriter(), s10 = e6.readable.getReader();
  t6.write(r6), t6.close();
  let o9 = [];
  for (; ; ) {
    let { value: i8, done: u7 } = await s10.read();
    if (u7) break;
    i8 && o9.push(i8);
  }
  let n7 = new Uint8Array(o9.reduce((i8, u7) => i8 + u7.length, 0)), a9 = 0;
  return o9.forEach((i8) => {
    n7.set(i8, a9), a9 += i8.length;
  }), n7;
}
async function Yr(r6) {
  let { promisify: e6 } = require("util"), { gzip: t6 } = require("zlib");
  return await e6(t6)(r6);
}
async function Wr(r6) {
  if (typeof CompressionStream < "u") return await Xr(r6);
  if (typeof process < "u" && process.versions && process.versions.node) return await Kr(r6);
  throw new Error("Unsupported environment for decompression");
}
async function Xr(r6) {
  let e6 = new DecompressionStream("gzip"), t6 = e6.writable.getWriter(), s10 = e6.readable.getReader();
  t6.write(r6), t6.close();
  let o9 = [];
  for (; ; ) {
    let { value: i8, done: u7 } = await s10.read();
    if (u7) break;
    i8 && o9.push(i8);
  }
  let n7 = new Uint8Array(o9.reduce((i8, u7) => i8 + u7.length, 0)), a9 = 0;
  return o9.forEach((i8) => {
    n7.set(i8, a9), a9 += i8.length;
  }), n7;
}
async function Kr(r6) {
  let { promisify: e6 } = require("util"), { gunzip: t6 } = require("zlib");
  return await e6(t6)(r6);
}
function ar(r6) {
  return r6 ? typeof r6 == "number" ? r6 : Math.floor(r6.getTime() / 1e3) : Math.floor(Date.now() / 1e3);
}
var w4, x6, L2, er, nr, or2, h7, Gr, Vr, C2, sr, ur, cr, Zr;
var init_chunk_RBN4KMJ6 = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-RBN4KMJ6.js"() {
    "use strict";
    init_chunk_Y3AVQXKT();
    w4 = u5(($r, l7) => {
      "use strict";
      x5();
      var j7 = 9007199254740991, B3 = /* @__PURE__ */ function(r6) {
        return r6;
      }();
      function dr2(r6) {
        return r6 === B3;
      }
      function q7(r6) {
        return typeof r6 == "string" || Object.prototype.toString.call(r6) == "[object String]";
      }
      function mr(r6) {
        return Object.prototype.toString.call(r6) == "[object Date]";
      }
      function N5(r6) {
        return r6 !== null && typeof r6 == "object";
      }
      function U4(r6) {
        return typeof r6 == "function";
      }
      function lr2(r6) {
        return typeof r6 == "number" && r6 > -1 && r6 % 1 == 0 && r6 <= j7;
      }
      function fr3(r6) {
        return Object.prototype.toString.call(r6) == "[object Array]";
      }
      function Y3(r6) {
        return N5(r6) && !U4(r6) && lr2(r6.length);
      }
      function D6(r6) {
        return Object.prototype.toString.call(r6) == "[object ArrayBuffer]";
      }
      function yr2(r6, e6) {
        return Array.prototype.map.call(r6, e6);
      }
      function gr(r6, e6) {
        var t6 = B3;
        return U4(e6) && Array.prototype.every.call(r6, function(s10, o9, n7) {
          var a9 = e6(s10, o9, n7);
          return a9 && (t6 = s10), !a9;
        }), t6;
      }
      function hr3(r6) {
        return Object.assign.apply(null, arguments);
      }
      function W4(r6) {
        var e6, t6, s10;
        if (q7(r6)) {
          for (t6 = r6.length, s10 = new Uint8Array(t6), e6 = 0; e6 < t6; e6++) s10[e6] = r6.charCodeAt(e6) & 255;
          return s10;
        }
        return D6(r6) ? new Uint8Array(r6) : N5(r6) && D6(r6.buffer) ? new Uint8Array(r6.buffer) : Y3(r6) ? new Uint8Array(r6) : N5(r6) && U4(r6.toString) ? W4(r6.toString()) : new Uint8Array();
      }
      l7.exports.MAX_SAFE_INTEGER = j7;
      l7.exports.isUndefined = dr2;
      l7.exports.isString = q7;
      l7.exports.isObject = N5;
      l7.exports.isDateTime = mr;
      l7.exports.isFunction = U4;
      l7.exports.isArray = fr3;
      l7.exports.isArrayLike = Y3;
      l7.exports.isArrayBuffer = D6;
      l7.exports.map = yr2;
      l7.exports.find = gr;
      l7.exports.extend = hr3;
      l7.exports.toUint8Array = W4;
    });
    x6 = u5((Qr, X4) => {
      "use strict";
      x5();
      var M3 = "\0";
      X4.exports = { NULL_CHAR: M3, TMAGIC: "ustar" + M3 + "00", OLDGNU_MAGIC: "ustar  " + M3, REGTYPE: 0, LNKTYPE: 1, SYMTYPE: 2, CHRTYPE: 3, BLKTYPE: 4, DIRTYPE: 5, FIFOTYPE: 6, CONTTYPE: 7, TSUID: parseInt("4000", 8), TSGID: parseInt("2000", 8), TSVTX: parseInt("1000", 8), TUREAD: parseInt("0400", 8), TUWRITE: parseInt("0200", 8), TUEXEC: parseInt("0100", 8), TGREAD: parseInt("0040", 8), TGWRITE: parseInt("0020", 8), TGEXEC: parseInt("0010", 8), TOREAD: parseInt("0004", 8), TOWRITE: parseInt("0002", 8), TOEXEC: parseInt("0001", 8), TPERMALL: parseInt("0777", 8), TPERMMASK: parseInt("0777", 8) };
    });
    L2 = u5((ee3, f9) => {
      "use strict";
      x5();
      var K4 = w4(), p11 = x6(), Sr = 512, I7 = p11.TPERMALL, V2 = 0, Z4 = 0, _7 = [["name", 100, 0, function(r6, e6) {
        return v11(r6[e6[0]], e6[1]);
      }, function(r6, e6, t6) {
        return A5(r6.slice(e6, e6 + t6[1]));
      }], ["mode", 8, 100, function(r6, e6) {
        var t6 = r6[e6[0]] || I7;
        return t6 = t6 & p11.TPERMMASK, P5(t6, e6[1], I7);
      }, function(r6, e6, t6) {
        var s10 = S7(r6.slice(e6, e6 + t6[1]));
        return s10 &= p11.TPERMMASK, s10;
      }], ["uid", 8, 108, function(r6, e6) {
        return P5(r6[e6[0]], e6[1], V2);
      }, function(r6, e6, t6) {
        return S7(r6.slice(e6, e6 + t6[1]));
      }], ["gid", 8, 116, function(r6, e6) {
        return P5(r6[e6[0]], e6[1], Z4);
      }, function(r6, e6, t6) {
        return S7(r6.slice(e6, e6 + t6[1]));
      }], ["size", 12, 124, function(r6, e6) {
        return P5(r6.data.length, e6[1]);
      }, function(r6, e6, t6) {
        return S7(r6.slice(e6, e6 + t6[1]));
      }], ["modifyTime", 12, 136, function(r6, e6) {
        return k9(r6[e6[0]], e6[1]);
      }, function(r6, e6, t6) {
        return z6(r6.slice(e6, e6 + t6[1]));
      }], ["checksum", 8, 148, function(r6, e6) {
        return "        ";
      }, function(r6, e6, t6) {
        return S7(r6.slice(e6, e6 + t6[1]));
      }], ["type", 1, 156, function(r6, e6) {
        return "" + (parseInt(r6[e6[0]], 10) || 0) % 8;
      }, function(r6, e6, t6) {
        return (parseInt(String.fromCharCode(r6[e6]), 10) || 0) % 8;
      }], ["linkName", 100, 157, function(r6, e6) {
        return "";
      }, function(r6, e6, t6) {
        return A5(r6.slice(e6, e6 + t6[1]));
      }], ["ustar", 8, 257, function(r6, e6) {
        return p11.TMAGIC;
      }, function(r6, e6, t6) {
        return Fr(A5(r6.slice(e6, e6 + t6[1]), true));
      }, function(r6, e6) {
        return r6[e6[0]] == p11.TMAGIC || r6[e6[0]] == p11.OLDGNU_MAGIC;
      }], ["owner", 32, 265, function(r6, e6) {
        return v11(r6[e6[0]], e6[1]);
      }, function(r6, e6, t6) {
        return A5(r6.slice(e6, e6 + t6[1]));
      }], ["group", 32, 297, function(r6, e6) {
        return v11(r6[e6[0]], e6[1]);
      }, function(r6, e6, t6) {
        return A5(r6.slice(e6, e6 + t6[1]));
      }], ["majorNumber", 8, 329, function(r6, e6) {
        return "";
      }, function(r6, e6, t6) {
        return S7(r6.slice(e6, e6 + t6[1]));
      }], ["minorNumber", 8, 337, function(r6, e6) {
        return "";
      }, function(r6, e6, t6) {
        return S7(r6.slice(e6, e6 + t6[1]));
      }], ["prefix", 131, 345, function(r6, e6) {
        return v11(r6[e6[0]], e6[1]);
      }, function(r6, e6, t6) {
        return A5(r6.slice(e6, e6 + t6[1]));
      }], ["accessTime", 12, 476, function(r6, e6) {
        return k9(r6[e6[0]], e6[1]);
      }, function(r6, e6, t6) {
        return z6(r6.slice(e6, e6 + t6[1]));
      }], ["createTime", 12, 488, function(r6, e6) {
        return k9(r6[e6[0]], e6[1]);
      }, function(r6, e6, t6) {
        return z6(r6.slice(e6, e6 + t6[1]));
      }]], $4 = function(r6) {
        var e6 = r6[r6.length - 1];
        return e6[2] + e6[1];
      }(_7);
      function Fr(r6) {
        if (r6.length == 8) {
          var e6 = r6.split("");
          if (e6[5] == p11.NULL_CHAR) return (e6[6] == " " || e6[6] == p11.NULL_CHAR) && (e6[6] = "0"), (e6[7] == " " || e6[7] == p11.NULL_CHAR) && (e6[7] = "0"), e6 = e6.join(""), e6 == p11.TMAGIC ? e6 : r6;
          if (e6[7] == p11.NULL_CHAR) return e6[5] == p11.NULL_CHAR && (e6[5] = " "), e6[6] == p11.NULL_CHAR && (e6[6] = " "), e6 == p11.OLDGNU_MAGIC ? e6 : r6;
        }
        return r6;
      }
      function v11(r6, e6) {
        return e6 -= 1, K4.isUndefined(r6) && (r6 = ""), r6 = ("" + r6).substr(0, e6), r6 + p11.NULL_CHAR;
      }
      function P5(r6, e6, t6) {
        for (t6 = parseInt(t6) || 0, e6 -= 1, r6 = (parseInt(r6) || t6).toString(8).substr(-e6, e6); r6.length < e6; ) r6 = "0" + r6;
        return r6 + p11.NULL_CHAR;
      }
      function k9(r6, e6) {
        if (K4.isDateTime(r6)) r6 = Math.floor(1 * r6 / 1e3);
        else if (r6 = parseInt(r6, 10), isFinite(r6)) {
          if (r6 <= 0) return "";
        } else r6 = Math.floor(1 * /* @__PURE__ */ new Date() / 1e3);
        return P5(r6, e6, 0);
      }
      function A5(r6, e6) {
        var t6 = String.fromCharCode.apply(null, r6);
        if (e6) return t6;
        var s10 = t6.indexOf(p11.NULL_CHAR);
        return s10 >= 0 ? t6.substr(0, s10) : t6;
      }
      function S7(r6) {
        var e6 = String.fromCharCode.apply(null, r6);
        return parseInt(e6.replace(/^0+$/g, ""), 8) || 0;
      }
      function z6(r6) {
        return r6.length == 0 || r6[0] == 0 ? null : new Date(1e3 * S7(r6));
      }
      function br(r6, e6, t6) {
        var s10 = parseInt(e6, 10) || 0, o9 = Math.min(s10 + $4, r6.length), n7 = 0, a9 = 0, i8 = 0;
        t6 && _7.every(function(y7) {
          return y7[0] == "checksum" ? (a9 = s10 + y7[2], i8 = a9 + y7[1], false) : true;
        });
        for (var u7 = 32, c6 = s10; c6 < o9; c6++) {
          var m12 = c6 >= a9 && c6 < i8 ? u7 : r6[c6];
          n7 = (n7 + m12) % 262144;
        }
        return n7;
      }
      f9.exports.recordSize = Sr;
      f9.exports.defaultFileMode = I7;
      f9.exports.defaultUid = V2;
      f9.exports.defaultGid = Z4;
      f9.exports.posixHeader = _7;
      f9.exports.effectiveHeaderSize = $4;
      f9.exports.calculateChecksum = br;
      f9.exports.formatTarString = v11;
      f9.exports.formatTarNumber = P5;
      f9.exports.formatTarDateTime = k9;
      f9.exports.parseTarString = A5;
      f9.exports.parseTarNumber = S7;
      f9.exports.parseTarDateTime = z6;
    });
    er = u5((ne3, rr3) => {
      "use strict";
      x5();
      var Tr = x6(), O6 = w4(), F6 = L2();
      function J3(r6) {
        return F6.recordSize;
      }
      function Q3(r6) {
        return Math.ceil(r6.data.length / F6.recordSize) * F6.recordSize;
      }
      function Ar(r6) {
        var e6 = 0;
        return r6.forEach(function(t6) {
          e6 += J3(t6) + Q3(t6);
        }), e6 += F6.recordSize * 2, new Uint8Array(e6);
      }
      function Er2(r6, e6, t6) {
        t6 = parseInt(t6) || 0;
        var s10 = t6;
        F6.posixHeader.forEach(function(u7) {
          for (var c6 = u7[3](e6, u7), m12 = c6.length, y7 = 0; y7 < m12; y7 += 1) r6[s10 + y7] = c6.charCodeAt(y7) & 255;
          s10 += u7[1];
        });
        var o9 = O6.find(F6.posixHeader, function(u7) {
          return u7[0] == "checksum";
        });
        if (o9) {
          var n7 = F6.calculateChecksum(r6, t6, true), a9 = F6.formatTarNumber(n7, o9[1] - 2) + Tr.NULL_CHAR + " ";
          s10 = t6 + o9[2];
          for (var i8 = 0; i8 < a9.length; i8 += 1) r6[s10] = a9.charCodeAt(i8) & 255, s10++;
        }
        return t6 + J3(e6);
      }
      function Pr2(r6, e6, t6) {
        return t6 = parseInt(t6, 10) || 0, r6.set(e6.data, t6), t6 + Q3(e6);
      }
      function wr(r6) {
        r6 = O6.map(r6, function(s10) {
          return O6.extend({}, s10, { data: O6.toUint8Array(s10.data) });
        });
        var e6 = Ar(r6), t6 = 0;
        return r6.forEach(function(s10) {
          t6 = Er2(e6, s10, t6), t6 = Pr2(e6, s10, t6);
        }), e6;
      }
      rr3.exports.tar = wr;
    });
    nr = u5((oe, tr3) => {
      "use strict";
      x5();
      var xr = x6(), G4 = w4(), g10 = L2(), vr = { extractData: true, checkHeader: true, checkChecksum: true, checkFileSize: true }, Nr2 = { size: true, checksum: true, ustar: true }, R5 = { unexpectedEndOfFile: "Unexpected end of file.", fileCorrupted: "File is corrupted.", checksumCheckFailed: "Checksum check failed." };
      function Ur2(r6) {
        return g10.recordSize;
      }
      function kr(r6) {
        return Math.ceil(r6 / g10.recordSize) * g10.recordSize;
      }
      function zr2(r6, e6) {
        for (var t6 = e6, s10 = Math.min(r6.length, e6 + g10.recordSize * 2), o9 = t6; o9 < s10; o9++) if (r6[o9] != 0) return false;
        return true;
      }
      function Or(r6, e6, t6) {
        if (r6.length - e6 < g10.recordSize) {
          if (t6.checkFileSize) throw new Error(R5.unexpectedEndOfFile);
          return null;
        }
        e6 = parseInt(e6) || 0;
        var s10 = {}, o9 = e6;
        if (g10.posixHeader.forEach(function(i8) {
          s10[i8[0]] = i8[4](r6, o9, i8), o9 += i8[1];
        }), s10.type != 0 && (s10.size = 0), t6.checkHeader && g10.posixHeader.forEach(function(i8) {
          if (G4.isFunction(i8[5]) && !i8[5](s10, i8)) {
            var u7 = new Error(R5.fileCorrupted);
            throw u7.data = { offset: e6 + i8[2], field: i8[0] }, u7;
          }
        }), t6.checkChecksum) {
          var n7 = g10.calculateChecksum(r6, e6, true);
          if (n7 != s10.checksum) {
            var a9 = new Error(R5.checksumCheckFailed);
            throw a9.data = { offset: e6, header: s10, checksum: n7 }, a9;
          }
        }
        return s10;
      }
      function Cr2(r6, e6, t6, s10) {
        return s10.extractData ? t6.size <= 0 ? new Uint8Array() : r6.slice(e6, e6 + t6.size) : null;
      }
      function Dr(r6, e6) {
        var t6 = {};
        return g10.posixHeader.forEach(function(s10) {
          var o9 = s10[0];
          Nr2[o9] || (t6[o9] = r6[o9]);
        }), t6.isOldGNUFormat = r6.ustar == xr.OLDGNU_MAGIC, e6 && (t6.data = e6), t6;
      }
      function Mr(r6, e6) {
        e6 = G4.extend({}, vr, e6);
        for (var t6 = [], s10 = 0, o9 = r6.length; o9 - s10 >= g10.recordSize; ) {
          r6 = G4.toUint8Array(r6);
          var n7 = Or(r6, s10, e6);
          if (!n7) break;
          s10 += Ur2(n7);
          var a9 = Cr2(r6, s10, n7, e6);
          if (t6.push(Dr(n7, a9)), s10 += kr(n7.size), zr2(r6, s10)) break;
        }
        return t6;
      }
      tr3.exports.untar = Mr;
    });
    or2 = u5((se2, ir4) => {
      "use strict";
      x5();
      var Ir = w4(), _r = x6(), Lr = er(), Rr = nr();
      Ir.extend(ir4.exports, Lr, Rr, _r);
    });
    x5();
    x5();
    h7 = F3(or2(), 1);
    Gr = ["application/x-gtar", "application/x-tar+gzip", "application/x-gzip", "application/gzip"];
    Vr = "/tmp/pglite";
    C2 = Vr + "/base";
    sr = class {
      constructor(e6) {
        this.dataDir = e6;
      }
      async init(e6, t6) {
        return this.pg = e6, { emscriptenOpts: t6 };
      }
      async syncToFs(e6) {
      }
      async initialSyncFs() {
      }
      async closeFs() {
      }
      async dumpTar(e6, t6) {
        return H2(this.pg.Module.FS, C2, e6, t6);
      }
    };
    ur = class {
      constructor(e6, { debug: t6 = false } = {}) {
        this.dataDir = e6, this.debug = t6;
      }
      async syncToFs(e6) {
      }
      async initialSyncFs() {
      }
      async closeFs() {
      }
      async dumpTar(e6, t6) {
        return H2(this.pg.Module.FS, C2, e6, t6);
      }
      async init(e6, t6) {
        return this.pg = e6, { emscriptenOpts: { ...t6, preRun: [...t6.preRun || [], (o9) => {
          let n7 = Zr(o9, this);
          o9.FS.mkdir(C2), o9.FS.mount(n7, {}, C2);
        }] } };
      }
    };
    cr = { EBADF: 8, EBADFD: 127, EEXIST: 20, EINVAL: 28, EISDIR: 31, ENODEV: 43, ENOENT: 44, ENOTDIR: 54, ENOTEMPTY: 55 };
    Zr = (r6, e6) => {
      let t6 = r6.FS, s10 = e6.debug ? console.log : null, o9 = { tryFSOperation(n7) {
        try {
          return n7();
        } catch (a9) {
          throw a9.code ? a9.code === "UNKNOWN" ? new t6.ErrnoError(cr.EINVAL) : new t6.ErrnoError(a9.code) : a9;
        }
      }, mount(n7) {
        return o9.createNode(null, "/", 16895, 0);
      }, syncfs(n7, a9, i8) {
      }, createNode(n7, a9, i8, u7) {
        if (!t6.isDir(i8) && !t6.isFile(i8)) throw new t6.ErrnoError(28);
        let c6 = t6.createNode(n7, a9, i8);
        return c6.node_ops = o9.node_ops, c6.stream_ops = o9.stream_ops, c6;
      }, getMode: function(n7) {
        return s10?.("getMode", n7), o9.tryFSOperation(() => e6.lstat(n7).mode);
      }, realPath: function(n7) {
        let a9 = [];
        for (; n7.parent !== n7; ) a9.push(n7.name), n7 = n7.parent;
        return a9.push(n7.mount.opts.root), a9.reverse(), a9.join("/");
      }, node_ops: { getattr(n7) {
        s10?.("getattr", o9.realPath(n7));
        let a9 = o9.realPath(n7);
        return o9.tryFSOperation(() => {
          let i8 = e6.lstat(a9);
          return { ...i8, dev: 0, ino: n7.id, nlink: 1, rdev: n7.rdev, atime: new Date(i8.atime), mtime: new Date(i8.mtime), ctime: new Date(i8.ctime) };
        });
      }, setattr(n7, a9) {
        s10?.("setattr", o9.realPath(n7), a9);
        let i8 = o9.realPath(n7);
        o9.tryFSOperation(() => {
          a9.mode !== void 0 && e6.chmod(i8, a9.mode), a9.size !== void 0 && e6.truncate(i8, a9.size), a9.timestamp !== void 0 && e6.utimes(i8, a9.timestamp, a9.timestamp), a9.size !== void 0 && e6.truncate(i8, a9.size);
        });
      }, lookup(n7, a9) {
        s10?.("lookup", o9.realPath(n7), a9);
        let i8 = [o9.realPath(n7), a9].join("/"), u7 = o9.getMode(i8);
        return o9.createNode(n7, a9, u7);
      }, mknod(n7, a9, i8, u7) {
        s10?.("mknod", o9.realPath(n7), a9, i8, u7);
        let c6 = o9.createNode(n7, a9, i8, u7), m12 = o9.realPath(c6);
        return o9.tryFSOperation(() => (t6.isDir(c6.mode) ? e6.mkdir(m12, { mode: i8 }) : e6.writeFile(m12, "", { mode: i8 }), c6));
      }, rename(n7, a9, i8) {
        s10?.("rename", o9.realPath(n7), o9.realPath(a9), i8);
        let u7 = o9.realPath(n7), c6 = [o9.realPath(a9), i8].join("/");
        o9.tryFSOperation(() => {
          e6.rename(u7, c6);
        }), n7.name = i8;
      }, unlink(n7, a9) {
        s10?.("unlink", o9.realPath(n7), a9);
        let i8 = [o9.realPath(n7), a9].join("/");
        try {
          e6.unlink(i8);
        } catch {
        }
      }, rmdir(n7, a9) {
        s10?.("rmdir", o9.realPath(n7), a9);
        let i8 = [o9.realPath(n7), a9].join("/");
        return o9.tryFSOperation(() => {
          e6.rmdir(i8);
        });
      }, readdir(n7) {
        s10?.("readdir", o9.realPath(n7));
        let a9 = o9.realPath(n7);
        return o9.tryFSOperation(() => e6.readdir(a9));
      }, symlink(n7, a9, i8) {
        throw s10?.("symlink", o9.realPath(n7), a9, i8), new t6.ErrnoError(63);
      }, readlink(n7) {
        throw s10?.("readlink", o9.realPath(n7)), new t6.ErrnoError(63);
      } }, stream_ops: { open(n7) {
        s10?.("open stream", o9.realPath(n7.node));
        let a9 = o9.realPath(n7.node);
        return o9.tryFSOperation(() => {
          t6.isFile(n7.node.mode) && (n7.shared.refcount = 1, n7.nfd = e6.open(a9));
        });
      }, close(n7) {
        return s10?.("close stream", o9.realPath(n7.node)), o9.tryFSOperation(() => {
          t6.isFile(n7.node.mode) && n7.nfd && --n7.shared.refcount === 0 && e6.close(n7.nfd);
        });
      }, dup(n7) {
        s10?.("dup stream", o9.realPath(n7.node)), n7.shared.refcount++;
      }, read(n7, a9, i8, u7, c6) {
        return s10?.("read stream", o9.realPath(n7.node), i8, u7, c6), u7 === 0 ? 0 : o9.tryFSOperation(() => e6.read(n7.nfd, a9, i8, u7, c6));
      }, write(n7, a9, i8, u7, c6) {
        return s10?.("write stream", o9.realPath(n7.node), i8, u7, c6), o9.tryFSOperation(() => e6.write(n7.nfd, a9.buffer, i8, u7, c6));
      }, llseek(n7, a9, i8) {
        s10?.("llseek stream", o9.realPath(n7.node), a9, i8);
        let u7 = a9;
        if (i8 === 1 ? u7 += n7.position : i8 === 2 && t6.isFile(n7.node.mode) && o9.tryFSOperation(() => {
          let c6 = e6.fstat(n7.nfd);
          u7 += c6.size;
        }), u7 < 0) throw new t6.ErrnoError(28);
        return u7;
      }, mmap(n7, a9, i8, u7, c6) {
        if (s10?.("mmap stream", o9.realPath(n7.node), a9, i8, u7, c6), !t6.isFile(n7.node.mode)) throw new t6.ErrnoError(cr.ENODEV);
        let m12 = r6.mmapAlloc(a9);
        return o9.stream_ops.read(n7, r6.HEAP8, m12, a9, i8), { ptr: m12, allocated: true };
      }, msync(n7, a9, i8, u7, c6) {
        return s10?.("msync stream", o9.realPath(n7.node), i8, u7, c6), o9.stream_ops.write(n7, a9, 0, u7, i8), 0;
      } } };
      return o9;
    };
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-EL7DUS2A.js
function s7(t6, r6, ...e6) {
  let a9 = t6.length - 1, p11 = e6.length - 1;
  if (p11 !== -1) {
    if (p11 === 0) {
      t6[a9] = t6[a9] + e6[0] + r6;
      return;
    }
    t6[a9] = t6[a9] + e6[0], t6.push(...e6.slice(1, p11)), t6.push(e6[p11] + r6);
  }
}
function y2(t6, ...r6) {
  let e6 = [t6[0]];
  e6.raw = [t6.raw[0]];
  let a9 = [];
  for (let p11 = 0; p11 < r6.length; p11++) {
    let n7 = r6[p11], i8 = p11 + 1;
    if (n7?._templateType === o5.part) {
      s7(e6, t6[i8], n7.str), s7(e6.raw, t6.raw[i8], n7.str);
      continue;
    }
    if (n7?._templateType === o5.container) {
      s7(e6, t6[i8], ...n7.strings), s7(e6.raw, t6.raw[i8], ...n7.strings.raw), a9.push(...n7.values);
      continue;
    }
    e6.push(t6[i8]), e6.raw.push(t6.raw[i8]), a9.push(n7);
  }
  return { _templateType: "container", strings: e6, values: a9 };
}
function g6(t6, ...r6) {
  let { strings: e6, values: a9 } = y2(t6, ...r6);
  return { query: [e6[0], ...a9.flatMap((p11, n7) => [`$${n7 + 1}`, e6[n7 + 1]])].join(""), params: a9 };
}
var o5;
var init_chunk_EL7DUS2A = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-EL7DUS2A.js"() {
    "use strict";
    init_chunk_Y3AVQXKT();
    x5();
    o5 = { part: "part", container: "container" };
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-IZM3GSNN.js
function P2(e6) {
  let t6 = e6.length;
  for (let n7 = e6.length - 1; n7 >= 0; n7--) {
    let r6 = e6.charCodeAt(n7);
    r6 > 127 && r6 <= 2047 ? t6++ : r6 > 2047 && r6 <= 65535 && (t6 += 2), r6 >= 56320 && r6 <= 57343 && n7--;
  }
  return t6;
}
function he(e6, t6, n7) {
  if (e6 === null) return null;
  let r6 = n7?.[t6] ?? Ve.parsers[t6];
  return r6 ? r6(e6, t6) : e6;
}
function Gn(e6) {
  return Object.keys(e6).reduce(({ parsers: t6, serializers: n7 }, r6) => {
    let { to: i8, from: a9, serialize: u7, parse: f9 } = e6[r6];
    return n7[i8] = u7, n7[r6] = u7, t6[r6] = f9, Array.isArray(a9) ? a9.forEach((c6) => {
      t6[c6] = f9, n7[c6] = u7;
    }) : (t6[a9] = f9, n7[a9] = u7), { parsers: t6, serializers: n7 };
  }, { parsers: {}, serializers: {} });
}
function Wn(e6) {
  return e6.replace(vn, "\\\\").replace(Qn, '\\"');
}
function yt(e6, t6, n7) {
  if (Array.isArray(e6) === false) return e6;
  if (!e6.length) return "{}";
  let r6 = e6[0], i8 = n7 === 1020 ? ";" : ",";
  return Array.isArray(r6) ? `{${e6.map((a9) => yt(a9, t6, n7)).join(i8)}}` : `{${e6.map((a9) => (a9 === void 0 && (a9 = null), a9 === null ? "null" : '"' + Wn(t6 ? t6(a9) : a9.toString()) + '"')).join(i8)}}`;
}
function _n(e6, t6, n7) {
  return Pe.i = Pe.last = 0, ht(Pe, e6, t6, n7)[0];
}
function ht(e6, t6, n7, r6) {
  let i8 = [], a9 = r6 === 1020 ? ";" : ",";
  for (; e6.i < t6.length; e6.i++) {
    if (e6.char = t6[e6.i], e6.quoted) e6.char === "\\" ? e6.str += t6[++e6.i] : e6.char === '"' ? (i8.push(n7 ? n7(e6.str) : e6.str), e6.str = "", e6.quoted = t6[e6.i + 1] === '"', e6.last = e6.i + 2) : e6.str += e6.char;
    else if (e6.char === '"') e6.quoted = true;
    else if (e6.char === "{") e6.last = ++e6.i, i8.push(ht(e6, t6, n7, r6));
    else if (e6.char === "}") {
      e6.quoted = false, e6.last < e6.i && i8.push(n7 ? n7(t6.slice(e6.last, e6.i)) : t6.slice(e6.last, e6.i)), e6.last = e6.i + 1;
      break;
    } else e6.char === a9 && e6.p !== "}" && e6.p !== '"' && (i8.push(n7 ? n7(t6.slice(e6.last, e6.i)) : t6.slice(e6.last, e6.i)), e6.last = e6.i + 1);
    e6.p = e6.char;
  }
  return e6.last < e6.i && i8.push(n7 ? n7(t6.slice(e6.last, e6.i + 1)) : t6.slice(e6.last, e6.i + 1)), i8;
}
function zn(e6, t6, n7, r6) {
  let i8 = [], a9 = { rows: [], fields: [] }, u7 = 0, f9 = { ...t6, ...n7?.parsers }, c6 = e6.filter((x11) => x11.name === "rowDescription" || x11.name === "dataRow" || x11.name === "commandComplete");
  return c6.forEach((x11, bt2) => {
    if (x11.name === "rowDescription") {
      let F6 = x11;
      a9.fields = F6.fields.map((E4) => ({ name: E4.name, dataTypeID: E4.dataTypeID }));
    } else if (x11.name === "dataRow" && a9) {
      let F6 = x11;
      n7?.rowMode === "array" ? a9.rows.push(F6.fields.map((E4, ae) => he(E4, a9.fields[ae].dataTypeID, f9))) : a9.rows.push(Object.fromEntries(F6.fields.map((E4, ae) => [a9.fields[ae].name, he(E4, a9.fields[ae].dataTypeID, f9)])));
    } else x11.name === "commandComplete" && (u7 += Hn(x11), bt2 === c6.length - 1 ? i8.push({ ...a9, affectedRows: u7, ...r6 ? { blob: r6 } : {} }) : i8.push(a9), a9 = { rows: [], fields: [] });
  }), i8.length === 0 && i8.push({ rows: [], fields: [] }), i8;
}
function Hn(e6) {
  let t6 = e6.text.split(" ");
  switch (t6[0]) {
    case "INSERT":
      return parseInt(t6[2], 10);
    case "UPDATE":
    case "DELETE":
      return parseInt(t6[1], 10);
    default:
      return 0;
  }
}
function Fe(e6) {
  let t6 = e6.find((n7) => n7.name === "parameterDescription");
  return t6 ? t6.dataTypeIDs : [];
}
async function Er() {
  if (Ge || ie) return;
  let e6 = new URL("./postgres.wasm", import_meta.url);
  ie = fetch(e6);
}
async function Cr(e6, t6) {
  if (t6 || V) return WebAssembly.instantiate(t6 || V, e6), { instance: await WebAssembly.instantiate(t6 || V, e6), module: t6 || V };
  let n7 = new URL("./postgres.wasm", import_meta.url);
  if (Ge) {
    let i8 = await (require("fs/promises")).readFile(n7), { module: a9, instance: u7 } = await WebAssembly.instantiate(i8, e6);
    return V = a9, { instance: u7, module: a9 };
  } else {
    ie || (ie = fetch(n7));
    let r6 = await ie, { module: i8, instance: a9 } = await WebAssembly.instantiateStreaming(r6, e6);
    return V = i8, { instance: a9, module: i8 };
  }
}
async function Pr() {
  let e6 = new URL("./postgres.data", import_meta.url);
  return Ge ? (await (require("fs/promises")).readFile(e6)).buffer : (await fetch(e6)).arrayBuffer();
}
async function Nr(e6, t6, n7, r6) {
  if (!n7 || n7.length === 0) return t6;
  r6 = r6 ?? e6;
  let i8;
  try {
    await e6.execProtocol(k5.parse({ text: t6 }), { syncToFs: false }), i8 = Fe((await e6.execProtocol(k5.describe({ type: "S" }), { syncToFs: false })).map(([f9]) => f9));
  } finally {
    await e6.execProtocol(k5.sync(), { syncToFs: false });
  }
  let a9 = t6.replace(/\$([0-9]+)/g, (f9, c6) => "%" + c6 + "L");
  return (await r6.query(`SELECT format($1, ${n7.map((f9, c6) => `$${c6 + 2}`).join(", ")}) as query`, [a9, ...n7], { paramTypes: [se, ...i8] })).rows[0].query;
}
var import_meta, Ie, be, ge, we, Ae, Se, De, Be, xe, G2, v6, Q, W, _4, j5, C3, z2, H3, q5, $, Y, K, J2, X, Z2, ee, te, ne2, _t, b5, g7, N, ce2, L3, S2, le, U, ve, R2, m6, gt2, wt, At, St, Dt, Bt, xt, It, O, Mt, Tt, Rt, Et, Ct, Me, Pt, Ut, Nt, Lt, Ot, kt, pe, Vt, Ft, Gt, vt, k5, Te, Qt, T, w5, fe, me, re, de, Re, Wt, Qe, We, A3, D3, B2, o6, l6, _e5, je, ze, He, qe, $e, Ye, Ee, Ke, Je, Xe, Ze, et, tt, nt, rt, Ce, ye, jn, jt, zt, Ue, Ne, Ht, Le, st, it, qt, se, at, $t, Yt, Kt, Oe, Jt, Xt, Zt, en, tn, nn, ot, ut, rn, sn, an, on, un, ln, cn, pn, dn, lt2, ct, pt, fn, dt, ke, mn, yn, hn, bn, gn, wn, An, Sn, Dn, Bn, xn, In, Mn, Tn, Rn, En, Cn, Pn, Un, Nn, Ln, ft, On, kn, mt, Ve, Vn, Fn, vn, Qn, Pe, qn, Ge, ie, V, Ur;
var init_chunk_IZM3GSNN = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-IZM3GSNN.js"() {
    "use strict";
    init_chunk_Y3AVQXKT();
    import_meta = {};
    Ie = {};
    D2(Ie, { AuthenticationCleartextPassword: () => v6, AuthenticationMD5Password: () => Q, AuthenticationOk: () => G2, AuthenticationSASL: () => W, AuthenticationSASLContinue: () => _4, AuthenticationSASLFinal: () => j5, BackendKeyDataMessage: () => J2, CommandCompleteMessage: () => ee, CopyDataMessage: () => z2, CopyResponse: () => H3, DataRowMessage: () => te, DatabaseError: () => C3, Field: () => q5, NoticeMessage: () => ne2, NotificationResponseMessage: () => X, ParameterDescriptionMessage: () => Y, ParameterStatusMessage: () => K, ReadyForQueryMessage: () => Z2, RowDescriptionMessage: () => $, bindComplete: () => ge, closeComplete: () => we, copyDone: () => xe, emptyQuery: () => Be, noData: () => Ae, parseComplete: () => be, portalSuspended: () => Se, replicationStart: () => De });
    x5();
    be = { name: "parseComplete", length: 5 };
    ge = { name: "bindComplete", length: 5 };
    we = { name: "closeComplete", length: 5 };
    Ae = { name: "noData", length: 5 };
    Se = { name: "portalSuspended", length: 5 };
    De = { name: "replicationStart", length: 4 };
    Be = { name: "emptyQuery", length: 4 };
    xe = { name: "copyDone", length: 4 };
    G2 = class {
      constructor(t6) {
        this.length = t6;
        this.name = "authenticationOk";
      }
    };
    v6 = class {
      constructor(t6) {
        this.length = t6;
        this.name = "authenticationCleartextPassword";
      }
    };
    Q = class {
      constructor(t6, n7) {
        this.length = t6;
        this.salt = n7;
        this.name = "authenticationMD5Password";
      }
    };
    W = class {
      constructor(t6, n7) {
        this.length = t6;
        this.mechanisms = n7;
        this.name = "authenticationSASL";
      }
    };
    _4 = class {
      constructor(t6, n7) {
        this.length = t6;
        this.data = n7;
        this.name = "authenticationSASLContinue";
      }
    };
    j5 = class {
      constructor(t6, n7) {
        this.length = t6;
        this.data = n7;
        this.name = "authenticationSASLFinal";
      }
    };
    C3 = class extends Error {
      constructor(n7, r6, i8) {
        super(n7);
        this.length = r6;
        this.name = i8;
      }
    };
    z2 = class {
      constructor(t6, n7) {
        this.length = t6;
        this.chunk = n7;
        this.name = "copyData";
      }
    };
    H3 = class {
      constructor(t6, n7, r6, i8) {
        this.length = t6;
        this.name = n7;
        this.binary = r6;
        this.columnTypes = new Array(i8);
      }
    };
    q5 = class {
      constructor(t6, n7, r6, i8, a9, u7, f9) {
        this.name = t6;
        this.tableID = n7;
        this.columnID = r6;
        this.dataTypeID = i8;
        this.dataTypeSize = a9;
        this.dataTypeModifier = u7;
        this.format = f9;
      }
    };
    $ = class {
      constructor(t6, n7) {
        this.length = t6;
        this.fieldCount = n7;
        this.name = "rowDescription";
        this.fields = new Array(this.fieldCount);
      }
    };
    Y = class {
      constructor(t6, n7) {
        this.length = t6;
        this.parameterCount = n7;
        this.name = "parameterDescription";
        this.dataTypeIDs = new Array(this.parameterCount);
      }
    };
    K = class {
      constructor(t6, n7, r6) {
        this.length = t6;
        this.parameterName = n7;
        this.parameterValue = r6;
        this.name = "parameterStatus";
      }
    };
    J2 = class {
      constructor(t6, n7, r6) {
        this.length = t6;
        this.processID = n7;
        this.secretKey = r6;
        this.name = "backendKeyData";
      }
    };
    X = class {
      constructor(t6, n7, r6, i8) {
        this.length = t6;
        this.processId = n7;
        this.channel = r6;
        this.payload = i8;
        this.name = "notification";
      }
    };
    Z2 = class {
      constructor(t6, n7) {
        this.length = t6;
        this.status = n7;
        this.name = "readyForQuery";
      }
    };
    ee = class {
      constructor(t6, n7) {
        this.length = t6;
        this.text = n7;
        this.name = "commandComplete";
      }
    };
    te = class {
      constructor(t6, n7) {
        this.length = t6;
        this.fields = n7;
        this.name = "dataRow";
        this.fieldCount = n7.length;
      }
    };
    ne2 = class {
      constructor(t6, n7) {
        this.length = t6;
        this.message = n7;
        this.name = "notice";
      }
    };
    _t = {};
    D2(_t, { Parser: () => ye, messages: () => Ie, serialize: () => k5 });
    x5();
    x5();
    x5();
    x5();
    R2 = class {
      constructor(t6 = 256) {
        this.size = t6;
        L(this, S2);
        L(this, b5);
        L(this, g7, 5);
        L(this, N, false);
        L(this, ce2, new TextEncoder());
        L(this, L3, 0);
        h6(this, b5, P(this, S2, le).call(this, t6));
      }
      addInt32(t6) {
        return P(this, S2, U).call(this, 4), g5(this, b5).setInt32(g5(this, g7), t6, g5(this, N)), h6(this, g7, g5(this, g7) + 4), this;
      }
      addInt16(t6) {
        return P(this, S2, U).call(this, 2), g5(this, b5).setInt16(g5(this, g7), t6, g5(this, N)), h6(this, g7, g5(this, g7) + 2), this;
      }
      addCString(t6) {
        return t6 && this.addString(t6), P(this, S2, U).call(this, 1), g5(this, b5).setUint8(g5(this, g7), 0), R(this, g7)._++, this;
      }
      addString(t6 = "") {
        let n7 = P2(t6);
        return P(this, S2, U).call(this, n7), g5(this, ce2).encodeInto(t6, new Uint8Array(g5(this, b5).buffer, g5(this, g7))), h6(this, g7, g5(this, g7) + n7), this;
      }
      add(t6) {
        return P(this, S2, U).call(this, t6.byteLength), new Uint8Array(g5(this, b5).buffer).set(new Uint8Array(t6), g5(this, g7)), h6(this, g7, g5(this, g7) + t6.byteLength), this;
      }
      flush(t6) {
        let n7 = P(this, S2, ve).call(this, t6);
        return h6(this, g7, 5), h6(this, b5, P(this, S2, le).call(this, this.size)), new Uint8Array(n7);
      }
    };
    b5 = /* @__PURE__ */ new WeakMap(), g7 = /* @__PURE__ */ new WeakMap(), N = /* @__PURE__ */ new WeakMap(), ce2 = /* @__PURE__ */ new WeakMap(), L3 = /* @__PURE__ */ new WeakMap(), S2 = /* @__PURE__ */ new WeakSet(), le = function(t6) {
      return new DataView(new ArrayBuffer(t6));
    }, U = function(t6) {
      if (g5(this, b5).byteLength - g5(this, g7) < t6) {
        let r6 = g5(this, b5).buffer, i8 = r6.byteLength + (r6.byteLength >> 1) + t6;
        h6(this, b5, P(this, S2, le).call(this, i8)), new Uint8Array(g5(this, b5).buffer).set(new Uint8Array(r6));
      }
    }, ve = function(t6) {
      if (t6) {
        g5(this, b5).setUint8(g5(this, L3), t6);
        let n7 = g5(this, g7) - (g5(this, L3) + 1);
        g5(this, b5).setInt32(g5(this, L3) + 1, n7, g5(this, N));
      }
      return g5(this, b5).buffer.slice(t6 ? 0 : 5, g5(this, g7));
    };
    m6 = new R2();
    gt2 = (e6) => {
      m6.addInt16(3).addInt16(0);
      for (let r6 of Object.keys(e6)) m6.addCString(r6).addCString(e6[r6]);
      m6.addCString("client_encoding").addCString("UTF8");
      let t6 = m6.addCString("").flush(), n7 = t6.byteLength + 4;
      return new R2().addInt32(n7).add(t6).flush();
    };
    wt = () => {
      let e6 = new DataView(new ArrayBuffer(8));
      return e6.setInt32(0, 8, false), e6.setInt32(4, 80877103, false), new Uint8Array(e6.buffer);
    };
    At = (e6) => m6.addCString(e6).flush(112);
    St = (e6, t6) => (m6.addCString(e6).addInt32(P2(t6)).addString(t6), m6.flush(112));
    Dt = (e6) => m6.addString(e6).flush(112);
    Bt = (e6) => m6.addCString(e6).flush(81);
    xt = [];
    It = (e6) => {
      let t6 = e6.name ?? "";
      t6.length > 63 && (console.error("Warning! Postgres only supports 63 characters for query names."), console.error("You supplied %s (%s)", t6, t6.length), console.error("This can cause conflicts and silent errors executing queries"));
      let n7 = m6.addCString(t6).addCString(e6.text).addInt16(e6.types?.length ?? 0);
      return e6.types?.forEach((r6) => n7.addInt32(r6)), m6.flush(80);
    };
    O = new R2();
    Mt = (e6, t6) => {
      for (let n7 = 0; n7 < e6.length; n7++) {
        let r6 = t6 ? t6(e6[n7], n7) : e6[n7];
        if (r6 === null) m6.addInt16(0), O.addInt32(-1);
        else if (r6 instanceof ArrayBuffer || ArrayBuffer.isView(r6)) {
          let i8 = ArrayBuffer.isView(r6) ? r6.buffer.slice(r6.byteOffset, r6.byteOffset + r6.byteLength) : r6;
          m6.addInt16(1), O.addInt32(i8.byteLength), O.add(i8);
        } else m6.addInt16(0), O.addInt32(P2(r6)), O.addString(r6);
      }
    };
    Tt = (e6 = {}) => {
      let t6 = e6.portal ?? "", n7 = e6.statement ?? "", r6 = e6.binary ?? false, i8 = e6.values ?? xt, a9 = i8.length;
      return m6.addCString(t6).addCString(n7), m6.addInt16(a9), Mt(i8, e6.valueMapper), m6.addInt16(a9), m6.add(O.flush()), m6.addInt16(r6 ? 1 : 0), m6.flush(66);
    };
    Rt = new Uint8Array([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]);
    Et = (e6) => {
      if (!e6 || !e6.portal && !e6.rows) return Rt;
      let t6 = e6.portal ?? "", n7 = e6.rows ?? 0, r6 = P2(t6), i8 = 4 + r6 + 1 + 4, a9 = new DataView(new ArrayBuffer(1 + i8));
      return a9.setUint8(0, 69), a9.setInt32(1, i8, false), new TextEncoder().encodeInto(t6, new Uint8Array(a9.buffer, 5)), a9.setUint8(r6 + 5, 0), a9.setUint32(a9.byteLength - 4, n7, false), new Uint8Array(a9.buffer);
    };
    Ct = (e6, t6) => {
      let n7 = new DataView(new ArrayBuffer(16));
      return n7.setInt32(0, 16, false), n7.setInt16(4, 1234, false), n7.setInt16(6, 5678, false), n7.setInt32(8, e6, false), n7.setInt32(12, t6, false), new Uint8Array(n7.buffer);
    };
    Me = (e6, t6) => {
      let n7 = new R2();
      return n7.addCString(t6), n7.flush(e6);
    };
    Pt = m6.addCString("P").flush(68);
    Ut = m6.addCString("S").flush(68);
    Nt = (e6) => e6.name ? Me(68, `${e6.type}${e6.name ?? ""}`) : e6.type === "P" ? Pt : Ut;
    Lt = (e6) => {
      let t6 = `${e6.type}${e6.name ?? ""}`;
      return Me(67, t6);
    };
    Ot = (e6) => m6.add(e6).flush(100);
    kt = (e6) => Me(102, e6);
    pe = (e6) => new Uint8Array([e6, 0, 0, 0, 4]);
    Vt = pe(72);
    Ft = pe(83);
    Gt = pe(88);
    vt = pe(99);
    k5 = { startup: gt2, password: At, requestSsl: wt, sendSASLInitialResponseMessage: St, sendSCRAMClientFinalMessage: Dt, query: Bt, parse: It, bind: Tt, execute: Et, describe: Nt, close: Lt, flush: () => Vt, sync: () => Ft, end: () => Gt, copyData: Ot, copyDone: () => vt, copyFail: kt, cancel: Ct };
    x5();
    x5();
    Te = { text: 0, binary: 1 };
    x5();
    Qt = new ArrayBuffer(0);
    de = class {
      constructor(t6 = 0) {
        L(this, T, new DataView(Qt));
        L(this, w5);
        L(this, fe, "utf-8");
        L(this, me, new TextDecoder(g5(this, fe)));
        L(this, re, false);
        h6(this, w5, t6);
      }
      setBuffer(t6, n7) {
        h6(this, w5, t6), h6(this, T, new DataView(n7));
      }
      int16() {
        let t6 = g5(this, T).getInt16(g5(this, w5), g5(this, re));
        return h6(this, w5, g5(this, w5) + 2), t6;
      }
      byte() {
        let t6 = g5(this, T).getUint8(g5(this, w5));
        return R(this, w5)._++, t6;
      }
      int32() {
        let t6 = g5(this, T).getInt32(g5(this, w5), g5(this, re));
        return h6(this, w5, g5(this, w5) + 4), t6;
      }
      string(t6) {
        return g5(this, me).decode(this.bytes(t6));
      }
      cstring() {
        let t6 = g5(this, w5), n7 = t6;
        for (; g5(this, T).getUint8(n7++) !== 0; ) ;
        let r6 = this.string(n7 - t6 - 1);
        return h6(this, w5, n7), r6;
      }
      bytes(t6) {
        let n7 = g5(this, T).buffer.slice(g5(this, w5), g5(this, w5) + t6);
        return h6(this, w5, g5(this, w5) + t6), new Uint8Array(n7);
      }
    };
    T = /* @__PURE__ */ new WeakMap(), w5 = /* @__PURE__ */ new WeakMap(), fe = /* @__PURE__ */ new WeakMap(), me = /* @__PURE__ */ new WeakMap(), re = /* @__PURE__ */ new WeakMap();
    Re = 1;
    Wt = 4;
    Qe = Re + Wt;
    We = new ArrayBuffer(0);
    ye = class {
      constructor() {
        L(this, l6);
        L(this, A3, new DataView(We));
        L(this, D3, 0);
        L(this, B2, 0);
        L(this, o6, new de());
      }
      parse(t6, n7) {
        P(this, l6, _e5).call(this, ArrayBuffer.isView(t6) ? t6.buffer.slice(t6.byteOffset, t6.byteOffset + t6.byteLength) : t6);
        let r6 = g5(this, B2) + g5(this, D3), i8 = g5(this, B2);
        for (; i8 + Qe <= r6; ) {
          let a9 = g5(this, A3).getUint8(i8), u7 = g5(this, A3).getUint32(i8 + Re, false), f9 = Re + u7;
          if (f9 + i8 <= r6) {
            let c6 = P(this, l6, je).call(this, i8 + Qe, a9, u7, g5(this, A3).buffer);
            n7(c6), i8 += f9;
          } else break;
        }
        i8 === r6 ? (h6(this, A3, new DataView(We)), h6(this, D3, 0), h6(this, B2, 0)) : (h6(this, D3, r6 - i8), h6(this, B2, i8));
      }
    };
    A3 = /* @__PURE__ */ new WeakMap(), D3 = /* @__PURE__ */ new WeakMap(), B2 = /* @__PURE__ */ new WeakMap(), o6 = /* @__PURE__ */ new WeakMap(), l6 = /* @__PURE__ */ new WeakSet(), _e5 = function(t6) {
      if (g5(this, D3) > 0) {
        let n7 = g5(this, D3) + t6.byteLength;
        if (n7 + g5(this, B2) > g5(this, A3).byteLength) {
          let i8;
          if (n7 <= g5(this, A3).byteLength && g5(this, B2) >= g5(this, D3)) i8 = g5(this, A3).buffer;
          else {
            let a9 = g5(this, A3).byteLength * 2;
            for (; n7 >= a9; ) a9 *= 2;
            i8 = new ArrayBuffer(a9);
          }
          new Uint8Array(i8).set(new Uint8Array(g5(this, A3).buffer, g5(this, B2), g5(this, D3))), h6(this, A3, new DataView(i8)), h6(this, B2, 0);
        }
        new Uint8Array(g5(this, A3).buffer).set(new Uint8Array(t6), g5(this, B2) + g5(this, D3)), h6(this, D3, n7);
      } else h6(this, A3, new DataView(t6)), h6(this, B2, 0), h6(this, D3, t6.byteLength);
    }, je = function(t6, n7, r6, i8) {
      switch (n7) {
        case 50:
          return ge;
        case 49:
          return be;
        case 51:
          return we;
        case 110:
          return Ae;
        case 115:
          return Se;
        case 99:
          return xe;
        case 87:
          return De;
        case 73:
          return Be;
        case 68:
          return P(this, l6, et).call(this, t6, r6, i8);
        case 67:
          return P(this, l6, He).call(this, t6, r6, i8);
        case 90:
          return P(this, l6, ze).call(this, t6, r6, i8);
        case 65:
          return P(this, l6, Ke).call(this, t6, r6, i8);
        case 82:
          return P(this, l6, rt).call(this, t6, r6, i8);
        case 83:
          return P(this, l6, tt).call(this, t6, r6, i8);
        case 75:
          return P(this, l6, nt).call(this, t6, r6, i8);
        case 69:
          return P(this, l6, Ce).call(this, t6, r6, i8, "error");
        case 78:
          return P(this, l6, Ce).call(this, t6, r6, i8, "notice");
        case 84:
          return P(this, l6, Je).call(this, t6, r6, i8);
        case 116:
          return P(this, l6, Ze).call(this, t6, r6, i8);
        case 71:
          return P(this, l6, $e).call(this, t6, r6, i8);
        case 72:
          return P(this, l6, Ye).call(this, t6, r6, i8);
        case 100:
          return P(this, l6, qe).call(this, t6, r6, i8);
        default:
          return new C3("received invalid response: " + n7.toString(16), r6, "error");
      }
    }, ze = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).string(1);
      return new Z2(n7, i8);
    }, He = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).cstring();
      return new ee(n7, i8);
    }, qe = function(t6, n7, r6) {
      let i8 = r6.slice(t6, t6 + (n7 - 4));
      return new z2(n7, new Uint8Array(i8));
    }, $e = function(t6, n7, r6) {
      return P(this, l6, Ee).call(this, t6, n7, r6, "copyInResponse");
    }, Ye = function(t6, n7, r6) {
      return P(this, l6, Ee).call(this, t6, n7, r6, "copyOutResponse");
    }, Ee = function(t6, n7, r6, i8) {
      g5(this, o6).setBuffer(t6, r6);
      let a9 = g5(this, o6).byte() !== 0, u7 = g5(this, o6).int16(), f9 = new H3(n7, i8, a9, u7);
      for (let c6 = 0; c6 < u7; c6++) f9.columnTypes[c6] = g5(this, o6).int16();
      return f9;
    }, Ke = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).int32(), a9 = g5(this, o6).cstring(), u7 = g5(this, o6).cstring();
      return new X(n7, i8, a9, u7);
    }, Je = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).int16(), a9 = new $(n7, i8);
      for (let u7 = 0; u7 < i8; u7++) a9.fields[u7] = P(this, l6, Xe).call(this);
      return a9;
    }, Xe = function() {
      let t6 = g5(this, o6).cstring(), n7 = g5(this, o6).int32(), r6 = g5(this, o6).int16(), i8 = g5(this, o6).int32(), a9 = g5(this, o6).int16(), u7 = g5(this, o6).int32(), f9 = g5(this, o6).int16() === 0 ? Te.text : Te.binary;
      return new q5(t6, n7, r6, i8, a9, u7, f9);
    }, Ze = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).int16(), a9 = new Y(n7, i8);
      for (let u7 = 0; u7 < i8; u7++) a9.dataTypeIDs[u7] = g5(this, o6).int32();
      return a9;
    }, et = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).int16(), a9 = new Array(i8);
      for (let u7 = 0; u7 < i8; u7++) {
        let f9 = g5(this, o6).int32();
        a9[u7] = f9 === -1 ? null : g5(this, o6).string(f9);
      }
      return new te(n7, a9);
    }, tt = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).cstring(), a9 = g5(this, o6).cstring();
      return new K(n7, i8, a9);
    }, nt = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).int32(), a9 = g5(this, o6).int32();
      return new J2(n7, i8, a9);
    }, rt = function(t6, n7, r6) {
      g5(this, o6).setBuffer(t6, r6);
      let i8 = g5(this, o6).int32();
      switch (i8) {
        case 0:
          return new G2(n7);
        case 3:
          return new v6(n7);
        case 5:
          return new Q(n7, g5(this, o6).bytes(4));
        case 10: {
          let a9 = [];
          for (; ; ) {
            let u7 = g5(this, o6).cstring();
            if (u7.length === 0) return new W(n7, a9);
            a9.push(u7);
          }
        }
        case 11:
          return new _4(n7, g5(this, o6).string(n7 - 8));
        case 12:
          return new j5(n7, g5(this, o6).string(n7 - 8));
        default:
          throw new Error("Unknown authenticationOk message type " + i8);
      }
    }, Ce = function(t6, n7, r6, i8) {
      g5(this, o6).setBuffer(t6, r6);
      let a9 = {}, u7 = g5(this, o6).string(1);
      for (; u7 !== "\0"; ) a9[u7] = g5(this, o6).cstring(), u7 = g5(this, o6).string(1);
      let f9 = a9.M, c6 = i8 === "notice" ? new ne2(n7, f9) : new C3(f9, n7, i8);
      return c6.severity = a9.S, c6.code = a9.C, c6.detail = a9.D, c6.hint = a9.H, c6.position = a9.P, c6.internalPosition = a9.p, c6.internalQuery = a9.q, c6.where = a9.W, c6.schema = a9.s, c6.table = a9.t, c6.column = a9.c, c6.dataType = a9.d, c6.constraint = a9.n, c6.file = a9.F, c6.line = a9.L, c6.routine = a9.R, c6;
    };
    jn = {};
    D2(jn, { ABSTIME: () => rn, ACLITEM: () => dn, BIT: () => hn, BOOL: () => Ue, BPCHAR: () => lt2, BYTEA: () => Ne, CHAR: () => Ht, CID: () => Kt, CIDR: () => nn, CIRCLE: () => on, DATE: () => pt, FLOAT4: () => ot, FLOAT8: () => ut, GTSVECTOR: () => Un, INET: () => pn, INT2: () => st, INT4: () => it, INT8: () => Le, INTERVAL: () => mn, JSON: () => Oe, JSONB: () => ft, MACADDR: () => cn, MACADDR8: () => un, MONEY: () => ln, NUMERIC: () => gn, OID: () => at, PATH: () => en, PG_DEPENDENCIES: () => En, PG_LSN: () => Tn, PG_NDISTINCT: () => Rn, PG_NODE_TREE: () => Xt, POLYGON: () => tn, REFCURSOR: () => wn, REGCLASS: () => Bn, REGCONFIG: () => Nn, REGDICTIONARY: () => Ln, REGNAMESPACE: () => On, REGOPER: () => Sn, REGOPERATOR: () => Dn, REGPROC: () => qt, REGPROCEDURE: () => An, REGROLE: () => kn, REGTYPE: () => xn, RELTIME: () => sn, SMGR: () => Zt, TEXT: () => se, TID: () => $t, TIME: () => fn, TIMESTAMP: () => dt, TIMESTAMPTZ: () => ke, TIMETZ: () => yn, TINTERVAL: () => an, TSQUERY: () => Pn, TSVECTOR: () => Cn, TXID_SNAPSHOT: () => Mn, UUID: () => In, VARBIT: () => bn, VARCHAR: () => ct, XID: () => Yt, XML: () => Jt, arrayParser: () => _n, arraySerializer: () => yt, parseType: () => he, parsers: () => Vn, serializers: () => Fn, types: () => mt });
    x5();
    jt = globalThis.JSON.parse;
    zt = globalThis.JSON.stringify;
    Ue = 16;
    Ne = 17;
    Ht = 18;
    Le = 20;
    st = 21;
    it = 23;
    qt = 24;
    se = 25;
    at = 26;
    $t = 27;
    Yt = 28;
    Kt = 29;
    Oe = 114;
    Jt = 142;
    Xt = 194;
    Zt = 210;
    en = 602;
    tn = 604;
    nn = 650;
    ot = 700;
    ut = 701;
    rn = 702;
    sn = 703;
    an = 704;
    on = 718;
    un = 774;
    ln = 790;
    cn = 829;
    pn = 869;
    dn = 1033;
    lt2 = 1042;
    ct = 1043;
    pt = 1082;
    fn = 1083;
    dt = 1114;
    ke = 1184;
    mn = 1186;
    yn = 1266;
    hn = 1560;
    bn = 1562;
    gn = 1700;
    wn = 1790;
    An = 2202;
    Sn = 2203;
    Dn = 2204;
    Bn = 2205;
    xn = 2206;
    In = 2950;
    Mn = 2970;
    Tn = 3220;
    Rn = 3361;
    En = 3402;
    Cn = 3614;
    Pn = 3615;
    Un = 3642;
    Nn = 3734;
    Ln = 3769;
    ft = 3802;
    On = 4089;
    kn = 4096;
    mt = { string: { to: se, from: [se, ct, lt2], serialize: (e6) => {
      if (typeof e6 == "string") return e6;
      if (typeof e6 == "number") return e6.toString();
      throw new Error("Invalid input for string type");
    }, parse: (e6) => e6 }, number: { to: 0, from: [st, it, at, ot, ut], serialize: (e6) => e6.toString(), parse: (e6) => +e6 }, bigint: { to: Le, from: [Le], serialize: (e6) => e6.toString(), parse: (e6) => {
      let t6 = BigInt(e6);
      return t6 < Number.MIN_SAFE_INTEGER || t6 > Number.MAX_SAFE_INTEGER ? t6 : Number(t6);
    } }, json: { to: Oe, from: [Oe, ft], serialize: (e6) => typeof e6 == "string" ? e6 : zt(e6), parse: (e6) => jt(e6) }, boolean: { to: Ue, from: [Ue], serialize: (e6) => {
      if (typeof e6 != "boolean") throw new Error("Invalid input for boolean type");
      return e6 ? "t" : "f";
    }, parse: (e6) => e6 === "t" }, date: { to: ke, from: [pt, dt, ke], serialize: (e6) => {
      if (typeof e6 == "string") return e6;
      if (typeof e6 == "number") return new Date(e6).toISOString();
      if (e6 instanceof Date) return e6.toISOString();
      throw new Error("Invalid input for date type");
    }, parse: (e6) => new Date(e6) }, bytea: { to: Ne, from: [Ne], serialize: (e6) => {
      if (!(e6 instanceof Uint8Array)) throw new Error("Invalid input for bytea type");
      return "\\x" + Array.from(e6).map((t6) => t6.toString(16).padStart(2, "0")).join("");
    }, parse: (e6) => {
      let t6 = e6.slice(2);
      return Uint8Array.from({ length: t6.length / 2 }, (n7, r6) => parseInt(t6.substring(r6 * 2, (r6 + 1) * 2), 16));
    } } };
    Ve = Gn(mt);
    Vn = Ve.parsers;
    Fn = Ve.serializers;
    vn = /\\/g;
    Qn = /"/g;
    Pe = { i: 0, char: null, str: "", quoted: false, last: 0, p: null };
    qn = {};
    D2(qn, { parseDescribeStatementResults: () => Fe, parseResults: () => zn });
    x5();
    x5();
    Ge = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string";
    Ur = () => {
      if (globalThis.crypto?.randomUUID) return globalThis.crypto.randomUUID();
      let e6 = new Uint8Array(16);
      if (globalThis.crypto?.getRandomValues) globalThis.crypto.getRandomValues(e6);
      else for (let n7 = 0; n7 < e6.length; n7++) e6[n7] = Math.floor(Math.random() * 256);
      e6[6] = e6[6] & 15 | 64, e6[8] = e6[8] & 63 | 128;
      let t6 = [];
      return e6.forEach((n7) => {
        t6.push(n7.toString(16).padStart(2, "0"));
      }), t6.slice(0, 4).join("") + "-" + t6.slice(4, 6).join("") + "-" + t6.slice(6, 8).join("") + "-" + t6.slice(8, 10).join("") + "-" + t6.slice(10).join("");
    };
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-NMYRYYP2.js
var p6, y3, s8, o7, w6, u6, R3, z3;
var init_chunk_NMYRYYP2 = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/chunk-NMYRYYP2.js"() {
    "use strict";
    init_chunk_EL7DUS2A();
    init_chunk_IZM3GSNN();
    init_chunk_Y3AVQXKT();
    x5();
    z3 = class {
      constructor() {
        L(this, s8);
        this.serializers = { ...Fn };
        this.parsers = { ...Vn };
        L(this, p6, false);
        L(this, y3, false);
      }
      async _initArrayTypes() {
        if (g5(this, p6)) return;
        h6(this, p6, true);
        let a9 = await this.query(`
      SELECT b.oid, b.typarray
      FROM pg_catalog.pg_type a
      LEFT JOIN pg_catalog.pg_type b ON b.oid = a.typelem
      WHERE a.typcategory = 'A'
      GROUP BY b.oid, b.typarray
      ORDER BY b.oid
    `);
        for (let r6 of a9.rows) this.serializers[r6.typarray] = (t6) => yt(t6, this.serializers[r6.oid], r6.typarray), this.parsers[r6.typarray] = (t6) => _n(t6, this.parsers[r6.oid], r6.typarray);
      }
      async query(a9, r6, t6) {
        return await this._checkReady(), await this._runExclusiveTransaction(async () => await P(this, s8, w6).call(this, a9, r6, t6));
      }
      async sql(a9, ...r6) {
        let { query: t6, params: l7 } = g6(a9, ...r6);
        return await this.query(t6, l7);
      }
      async exec(a9, r6) {
        return await this._checkReady(), await this._runExclusiveTransaction(async () => await P(this, s8, u6).call(this, a9, r6));
      }
      async transaction(a9) {
        return await this._checkReady(), await this._runExclusiveTransaction(async () => {
          await P(this, s8, u6).call(this, "BEGIN"), h6(this, y3, true);
          let r6 = false, t6 = () => {
            if (r6) throw new Error("Transaction is closed");
          }, l7 = { query: async (i8, n7, b9) => (t6(), await P(this, s8, w6).call(this, i8, n7, b9)), sql: async (i8, ...n7) => {
            let { query: b9, params: P5 } = g6(i8, ...n7);
            return await P(this, s8, w6).call(this, b9, P5);
          }, exec: async (i8, n7) => (t6(), await P(this, s8, u6).call(this, i8, n7)), rollback: async () => {
            t6(), await P(this, s8, u6).call(this, "ROLLBACK"), r6 = true;
          }, get closed() {
            return r6;
          } };
          try {
            let i8 = await a9(l7);
            return r6 || (r6 = true, await P(this, s8, u6).call(this, "COMMIT")), h6(this, y3, false), i8;
          } catch (i8) {
            throw r6 || await P(this, s8, u6).call(this, "ROLLBACK"), h6(this, y3, false), i8;
          }
        });
      }
    };
    p6 = /* @__PURE__ */ new WeakMap(), y3 = /* @__PURE__ */ new WeakMap(), s8 = /* @__PURE__ */ new WeakSet(), o7 = async function(a9, r6 = {}) {
      return await this.execProtocol(a9, { ...r6, syncToFs: false });
    }, w6 = async function(a9, r6 = [], t6) {
      return await this._runExclusiveQuery(async () => {
        P(this, s8, R3).call(this, "runQuery", a9, r6, t6), await this._handleBlob(t6?.blob);
        let l7;
        try {
          let n7 = await P(this, s8, o7).call(this, k5.parse({ text: a9, types: t6?.paramTypes }), t6), b9 = Fe((await P(this, s8, o7).call(this, k5.describe({ type: "S" }), t6)).map(([h8]) => h8)), P5 = r6.map((h8, Q3) => {
            let q7 = b9[Q3];
            if (h8 == null) return null;
            let x11 = this.serializers[q7];
            return x11 ? x11(h8) : h8.toString();
          });
          l7 = [...n7, ...await P(this, s8, o7).call(this, k5.bind({ values: P5 }), t6), ...await P(this, s8, o7).call(this, k5.describe({ type: "P" }), t6), ...await P(this, s8, o7).call(this, k5.execute({}), t6)];
        } finally {
          await P(this, s8, o7).call(this, k5.sync(), t6);
        }
        await this._cleanupBlob(), g5(this, y3) || await this.syncToFs();
        let i8 = await this._getWrittenBlob();
        return zn(l7.map(([n7]) => n7), this.parsers, t6, i8)[0];
      });
    }, u6 = async function(a9, r6) {
      return await this._runExclusiveQuery(async () => {
        P(this, s8, R3).call(this, "runExec", a9, r6), await this._handleBlob(r6?.blob);
        let t6;
        try {
          t6 = await P(this, s8, o7).call(this, k5.query(a9), r6);
        } finally {
          await P(this, s8, o7).call(this, k5.sync(), r6);
        }
        this._cleanupBlob(), g5(this, y3) || await this.syncToFs();
        let l7 = await this._getWrittenBlob();
        return zn(t6.map(([i8]) => i8), this.parsers, r6, l7);
      });
    }, R3 = function(...a9) {
      this.debug > 0 && console.log(...a9);
    };
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/postgres.js
var import_meta2, Module2, postgres_default;
var init_postgres2 = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/postgres.js"() {
    "use strict";
    import_meta2 = {};
    Module2 = (() => {
      var _scriptName = import_meta2.url;
      return async function(moduleArg = {}) {
        var moduleRtn;
        var Module = moduleArg;
        var readyPromiseResolve, readyPromiseReject;
        var readyPromise = new Promise((resolve2, reject) => {
          readyPromiseResolve = resolve2;
          readyPromiseReject = reject;
        });
        var ENVIRONMENT_IS_WEB = typeof window == "object";
        var ENVIRONMENT_IS_WORKER = typeof importScripts == "function";
        var ENVIRONMENT_IS_NODE = typeof process == "object" && typeof process.versions == "object" && typeof process.versions.node == "string" && process.type != "renderer";
        var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;
        if (ENVIRONMENT_IS_NODE) {
          const { createRequire } = require("module");
          let dirname = import_meta2.url;
          if (dirname.startsWith("data:")) {
            dirname = "/";
          }
          var require = createRequire(dirname);
        }
        if (!Module["expectedDataFileDownloads"]) {
          Module["expectedDataFileDownloads"] = 0;
        }
        Module["expectedDataFileDownloads"]++;
        (() => {
          var isPthread = typeof ENVIRONMENT_IS_PTHREAD != "undefined" && ENVIRONMENT_IS_PTHREAD;
          var isWasmWorker = typeof ENVIRONMENT_IS_WASM_WORKER != "undefined" && ENVIRONMENT_IS_WASM_WORKER;
          if (isPthread || isWasmWorker) return;
          function loadPackage(metadata2) {
            var PACKAGE_PATH = "";
            if (typeof window === "object") {
              PACKAGE_PATH = window["encodeURIComponent"](window.location.pathname.toString().substring(0, window.location.pathname.toString().lastIndexOf("/")) + "/");
            } else if (typeof process === "undefined" && typeof location !== "undefined") {
              PACKAGE_PATH = encodeURIComponent(location.pathname.toString().substring(0, location.pathname.toString().lastIndexOf("/")) + "/");
            }
            var PACKAGE_NAME = "postgres.data";
            var REMOTE_PACKAGE_BASE = "postgres.data";
            if (typeof Module["locateFilePackage"] === "function" && !Module["locateFile"]) {
              Module["locateFile"] = Module["locateFilePackage"];
              err("warning: you defined Module.locateFilePackage, that has been renamed to Module.locateFile (using your locateFilePackage for now)");
            }
            var REMOTE_PACKAGE_NAME = Module["locateFile"] ? Module["locateFile"](REMOTE_PACKAGE_BASE, "") : REMOTE_PACKAGE_BASE;
            var REMOTE_PACKAGE_SIZE = metadata2["remote_package_size"];
            function fetchRemotePackage(packageName, packageSize, callback, errback) {
              if (typeof process === "object" && typeof process.versions === "object" && typeof process.versions.node === "string") {
                require("fs").readFile(packageName, (err3, contents) => {
                  if (err3) {
                    errback(err3);
                  } else {
                    callback(contents.buffer);
                  }
                });
                return;
              }
              Module["dataFileDownloads"] ??= {};
              fetch(packageName).catch((cause) => Promise.reject(new Error(`Network Error: ${packageName}`, { cause }))).then((response) => {
                if (!response.ok) {
                  return Promise.reject(new Error(`${response.status}: ${response.url}`));
                }
                if (!response.body && response.arrayBuffer) {
                  return response.arrayBuffer().then(callback);
                }
                const reader = response.body.getReader();
                const iterate = () => reader.read().then(handleChunk).catch((cause) => {
                  return Promise.reject(new Error(`Unexpected error while handling : ${response.url} ${cause}`, { cause }));
                });
                const chunks = [];
                const headers = response.headers;
                const total = Number(headers.get("Content-Length") ?? packageSize);
                let loaded = 0;
                const handleChunk = ({ done, value }) => {
                  if (!done) {
                    chunks.push(value);
                    loaded += value.length;
                    Module["dataFileDownloads"][packageName] = { loaded, total };
                    let totalLoaded = 0;
                    let totalSize = 0;
                    for (const download of Object.values(Module["dataFileDownloads"])) {
                      totalLoaded += download.loaded;
                      totalSize += download.total;
                    }
                    Module["setStatus"]?.(`Downloading data... (${totalLoaded}/${totalSize})`);
                    return iterate();
                  } else {
                    const packageData = new Uint8Array(chunks.map((c6) => c6.length).reduce((a9, b9) => a9 + b9, 0));
                    let offset = 0;
                    for (const chunk of chunks) {
                      packageData.set(chunk, offset);
                      offset += chunk.length;
                    }
                    callback(packageData.buffer);
                  }
                };
                Module["setStatus"]?.("Downloading data...");
                return iterate();
              });
            }
            ;
            function handleError(error2) {
              console.error("package error:", error2);
            }
            ;
            var fetchedCallback = null;
            var fetched = Module["getPreloadedPackage"] ? Module["getPreloadedPackage"](REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE) : null;
            if (!fetched) fetchRemotePackage(REMOTE_PACKAGE_NAME, REMOTE_PACKAGE_SIZE, (data) => {
              if (fetchedCallback) {
                fetchedCallback(data);
                fetchedCallback = null;
              } else {
                fetched = data;
              }
            }, handleError);
            function runWithFS(Module3) {
              function assert2(check2, msg) {
                if (!check2) throw msg + new Error().stack;
              }
              Module3["FS_createPath"]("/", "home", true, true);
              Module3["FS_createPath"]("/home", "web_user", true, true);
              Module3["FS_createPath"]("/", "tmp", true, true);
              Module3["FS_createPath"]("/tmp", "pglite", true, true);
              Module3["FS_createPath"]("/tmp/pglite", "bin", true, true);
              Module3["FS_createPath"]("/tmp/pglite", "lib", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib", "postgresql", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib/postgresql", "pgxs", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib/postgresql/pgxs", "config", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib/postgresql/pgxs", "src", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib/postgresql/pgxs/src", "makefiles", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib/postgresql/pgxs/src", "test", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib/postgresql/pgxs/src/test", "isolation", true, true);
              Module3["FS_createPath"]("/tmp/pglite/lib/postgresql/pgxs/src/test", "regress", true, true);
              Module3["FS_createPath"]("/tmp/pglite", "share", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share", "postgresql", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql", "extension", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql", "timezone", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Africa", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "America", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone/America", "Argentina", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone/America", "Indiana", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone/America", "Kentucky", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone/America", "North_Dakota", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Antarctica", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Arctic", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Asia", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Atlantic", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Australia", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Brazil", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Canada", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Chile", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Etc", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Europe", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Indian", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Mexico", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "Pacific", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql/timezone", "US", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql", "timezonesets", true, true);
              Module3["FS_createPath"]("/tmp/pglite/share/postgresql", "tsearch_data", true, true);
              function DataRequest(start2, end, audio) {
                this.start = start2;
                this.end = end;
                this.audio = audio;
              }
              DataRequest.prototype = {
                requests: {},
                open: function(mode, name3) {
                  this.name = name3;
                  this.requests[name3] = this;
                  Module3["addRunDependency"](`fp ${this.name}`);
                },
                send: function() {
                },
                onload: function() {
                  var byteArray = this.byteArray.subarray(this.start, this.end);
                  this.finish(byteArray);
                },
                finish: function(byteArray) {
                  var that = this;
                  Module3["FS_createDataFile"](this.name, null, byteArray, true, true, true);
                  Module3["removeRunDependency"](`fp ${that.name}`);
                  this.requests[this.name] = null;
                }
              };
              var files = metadata2["files"];
              for (var i8 = 0; i8 < files.length; ++i8) {
                new DataRequest(files[i8]["start"], files[i8]["end"], files[i8]["audio"] || 0).open("GET", files[i8]["filename"]);
              }
              function processPackageData(arrayBuffer) {
                assert2(arrayBuffer, "Loading data file failed.");
                assert2(arrayBuffer.constructor.name === ArrayBuffer.name, "bad input to processPackageData");
                var byteArray = new Uint8Array(arrayBuffer);
                var curr;
                DataRequest.prototype.byteArray = byteArray;
                var files2 = metadata2["files"];
                for (var i9 = 0; i9 < files2.length; ++i9) {
                  DataRequest.prototype.requests[files2[i9].filename].onload();
                }
                Module3["removeRunDependency"]("datafile_postgres.data");
              }
              ;
              Module3["addRunDependency"]("datafile_postgres.data");
              if (!Module3["preloadResults"]) Module3["preloadResults"] = {};
              Module3["preloadResults"][PACKAGE_NAME] = { fromCache: false };
              if (fetched) {
                processPackageData(fetched);
                fetched = null;
              } else {
                fetchedCallback = processPackageData;
              }
            }
            if (Module["calledRun"]) {
              runWithFS(Module);
            } else {
              if (!Module["preRun"]) Module["preRun"] = [];
              Module["preRun"].push(runWithFS);
            }
          }
          loadPackage({ "files": [{ "filename": "/home/web_user/.pgpass", "start": 0, "end": 135 }, { "filename": "/tmp/pglite/bin/initdb", "start": 135, "end": 147 }, { "filename": "/tmp/pglite/bin/postgres", "start": 147, "end": 159 }, { "filename": "/tmp/pglite/lib/postgresql/cyrillic_and_mic.so", "start": 159, "end": 5738 }, { "filename": "/tmp/pglite/lib/postgresql/dict_snowball.so", "start": 5738, "end": 580838 }, { "filename": "/tmp/pglite/lib/postgresql/euc2004_sjis2004.so", "start": 580838, "end": 583216 }, { "filename": "/tmp/pglite/lib/postgresql/euc_cn_and_mic.so", "start": 583216, "end": 584483 }, { "filename": "/tmp/pglite/lib/postgresql/euc_jp_and_sjis.so", "start": 584483, "end": 592223 }, { "filename": "/tmp/pglite/lib/postgresql/euc_kr_and_mic.so", "start": 592223, "end": 593530 }, { "filename": "/tmp/pglite/lib/postgresql/euc_tw_and_big5.so", "start": 593530, "end": 598650 }, { "filename": "/tmp/pglite/lib/postgresql/latin2_and_win1250.so", "start": 598650, "end": 600595 }, { "filename": "/tmp/pglite/lib/postgresql/latin_and_mic.so", "start": 600595, "end": 602068 }, { "filename": "/tmp/pglite/lib/postgresql/libpqwalreceiver.so", "start": 602068, "end": 725255 }, { "filename": "/tmp/pglite/lib/postgresql/pgoutput.so", "start": 725255, "end": 741345 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/config/install-sh", "start": 741345, "end": 755342 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/config/missing", "start": 755342, "end": 756690 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/Makefile.global", "start": 756690, "end": 792812 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/Makefile.port", "start": 792812, "end": 793088 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/Makefile.shlib", "start": 793088, "end": 809126 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/makefiles/pgxs.mk", "start": 809126, "end": 824054 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/nls-global.mk", "start": 824054, "end": 830939 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/test/isolation/isolationtester.cjs", "start": 830939, "end": 927086 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/test/isolation/pg_isolation_regress.cjs", "start": 927086, "end": 1003500 }, { "filename": "/tmp/pglite/lib/postgresql/pgxs/src/test/regress/pg_regress.cjs", "start": 1003500, "end": 1079904 }, { "filename": "/tmp/pglite/lib/postgresql/plpgsql.so", "start": 1079904, "end": 1239297 }, { "filename": "/tmp/pglite/password", "start": 1239297, "end": 1239306 }, { "filename": "/tmp/pglite/share/postgresql/errcodes.txt", "start": 1239306, "end": 1272764 }, { "filename": "/tmp/pglite/share/postgresql/extension/plpgsql--1.0.sql", "start": 1272764, "end": 1273422 }, { "filename": "/tmp/pglite/share/postgresql/extension/plpgsql.control", "start": 1273422, "end": 1273615 }, { "filename": "/tmp/pglite/share/postgresql/fix-CVE-2024-4317.sql", "start": 1273615, "end": 1279380 }, { "filename": "/tmp/pglite/share/postgresql/information_schema.sql", "start": 1279380, "end": 1394355 }, { "filename": "/tmp/pglite/share/postgresql/pg_hba.conf.sample", "start": 1394355, "end": 1399980 }, { "filename": "/tmp/pglite/share/postgresql/pg_ident.conf.sample", "start": 1399980, "end": 1402620 }, { "filename": "/tmp/pglite/share/postgresql/pg_service.conf.sample", "start": 1402620, "end": 1403224 }, { "filename": "/tmp/pglite/share/postgresql/postgres.bki", "start": 1403224, "end": 2347328 }, { "filename": "/tmp/pglite/share/postgresql/postgresql.conf.sample", "start": 2347328, "end": 2376975 }, { "filename": "/tmp/pglite/share/postgresql/psqlrc.sample", "start": 2376975, "end": 2377253 }, { "filename": "/tmp/pglite/share/postgresql/snowball_create.sql", "start": 2377253, "end": 2421429 }, { "filename": "/tmp/pglite/share/postgresql/sql_features.txt", "start": 2421429, "end": 2457110 }, { "filename": "/tmp/pglite/share/postgresql/system_constraints.sql", "start": 2457110, "end": 2466005 }, { "filename": "/tmp/pglite/share/postgresql/system_functions.sql", "start": 2466005, "end": 2489320 }, { "filename": "/tmp/pglite/share/postgresql/system_views.sql", "start": 2489320, "end": 2539593 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Abidjan", "start": 2539593, "end": 2539723 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Accra", "start": 2539723, "end": 2539853 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Addis_Ababa", "start": 2539853, "end": 2540044 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Algiers", "start": 2540044, "end": 2540514 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Asmara", "start": 2540514, "end": 2540705 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Asmera", "start": 2540705, "end": 2540896 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Bamako", "start": 2540896, "end": 2541026 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Bangui", "start": 2541026, "end": 2541206 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Banjul", "start": 2541206, "end": 2541336 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Bissau", "start": 2541336, "end": 2541485 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Blantyre", "start": 2541485, "end": 2541616 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Brazzaville", "start": 2541616, "end": 2541796 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Bujumbura", "start": 2541796, "end": 2541927 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Cairo", "start": 2541927, "end": 2543236 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Casablanca", "start": 2543236, "end": 2545155 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Ceuta", "start": 2545155, "end": 2545717 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Conakry", "start": 2545717, "end": 2545847 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Dakar", "start": 2545847, "end": 2545977 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Dar_es_Salaam", "start": 2545977, "end": 2546168 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Djibouti", "start": 2546168, "end": 2546359 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Douala", "start": 2546359, "end": 2546539 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/El_Aaiun", "start": 2546539, "end": 2548369 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Freetown", "start": 2548369, "end": 2548499 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Gaborone", "start": 2548499, "end": 2548630 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Harare", "start": 2548630, "end": 2548761 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Johannesburg", "start": 2548761, "end": 2548951 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Juba", "start": 2548951, "end": 2549409 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Kampala", "start": 2549409, "end": 2549600 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Khartoum", "start": 2549600, "end": 2550058 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Kigali", "start": 2550058, "end": 2550189 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Kinshasa", "start": 2550189, "end": 2550369 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Lagos", "start": 2550369, "end": 2550549 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Libreville", "start": 2550549, "end": 2550729 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Lome", "start": 2550729, "end": 2550859 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Luanda", "start": 2550859, "end": 2551039 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Lubumbashi", "start": 2551039, "end": 2551170 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Lusaka", "start": 2551170, "end": 2551301 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Malabo", "start": 2551301, "end": 2551481 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Maputo", "start": 2551481, "end": 2551612 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Maseru", "start": 2551612, "end": 2551802 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Mbabane", "start": 2551802, "end": 2551992 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Mogadishu", "start": 2551992, "end": 2552183 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Monrovia", "start": 2552183, "end": 2552347 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Nairobi", "start": 2552347, "end": 2552538 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Ndjamena", "start": 2552538, "end": 2552698 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Niamey", "start": 2552698, "end": 2552878 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Nouakchott", "start": 2552878, "end": 2553008 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Ouagadougou", "start": 2553008, "end": 2553138 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Porto-Novo", "start": 2553138, "end": 2553318 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Sao_Tome", "start": 2553318, "end": 2553491 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Timbuktu", "start": 2553491, "end": 2553621 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Tripoli", "start": 2553621, "end": 2554052 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Tunis", "start": 2554052, "end": 2554501 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Africa/Windhoek", "start": 2554501, "end": 2555139 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Adak", "start": 2555139, "end": 2556108 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Anchorage", "start": 2556108, "end": 2557085 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Anguilla", "start": 2557085, "end": 2557262 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Antigua", "start": 2557262, "end": 2557439 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Araguaina", "start": 2557439, "end": 2558031 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Buenos_Aires", "start": 2558031, "end": 2558739 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Catamarca", "start": 2558739, "end": 2559447 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/ComodRivadavia", "start": 2559447, "end": 2560155 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Cordoba", "start": 2560155, "end": 2560863 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Jujuy", "start": 2560863, "end": 2561553 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/La_Rioja", "start": 2561553, "end": 2562270 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Mendoza", "start": 2562270, "end": 2562978 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Rio_Gallegos", "start": 2562978, "end": 2563686 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Salta", "start": 2563686, "end": 2564376 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/San_Juan", "start": 2564376, "end": 2565093 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/San_Luis", "start": 2565093, "end": 2565810 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Tucuman", "start": 2565810, "end": 2566536 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Argentina/Ushuaia", "start": 2566536, "end": 2567244 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Aruba", "start": 2567244, "end": 2567421 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Asuncion", "start": 2567421, "end": 2568305 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Atikokan", "start": 2568305, "end": 2568454 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Atka", "start": 2568454, "end": 2569423 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Bahia", "start": 2569423, "end": 2570105 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Bahia_Banderas", "start": 2570105, "end": 2570833 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Barbados", "start": 2570833, "end": 2571111 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Belem", "start": 2571111, "end": 2571505 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Belize", "start": 2571505, "end": 2572550 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Blanc-Sablon", "start": 2572550, "end": 2572727 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Boa_Vista", "start": 2572727, "end": 2573157 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Bogota", "start": 2573157, "end": 2573336 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Boise", "start": 2573336, "end": 2574335 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Buenos_Aires", "start": 2574335, "end": 2575043 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Cambridge_Bay", "start": 2575043, "end": 2575926 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Campo_Grande", "start": 2575926, "end": 2576878 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Cancun", "start": 2576878, "end": 2577407 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Caracas", "start": 2577407, "end": 2577597 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Catamarca", "start": 2577597, "end": 2578305 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Cayenne", "start": 2578305, "end": 2578456 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Cayman", "start": 2578456, "end": 2578605 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Chicago", "start": 2578605, "end": 2580359 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Chihuahua", "start": 2580359, "end": 2581050 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Ciudad_Juarez", "start": 2581050, "end": 2581768 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Coral_Harbour", "start": 2581768, "end": 2581917 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Cordoba", "start": 2581917, "end": 2582625 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Costa_Rica", "start": 2582625, "end": 2582857 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Creston", "start": 2582857, "end": 2583097 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Cuiaba", "start": 2583097, "end": 2584031 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Curacao", "start": 2584031, "end": 2584208 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Danmarkshavn", "start": 2584208, "end": 2584655 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Dawson", "start": 2584655, "end": 2585684 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Dawson_Creek", "start": 2585684, "end": 2586367 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Denver", "start": 2586367, "end": 2587409 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Detroit", "start": 2587409, "end": 2588308 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Dominica", "start": 2588308, "end": 2588485 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Edmonton", "start": 2588485, "end": 2589455 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Eirunepe", "start": 2589455, "end": 2589891 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/El_Salvador", "start": 2589891, "end": 2590067 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Ensenada", "start": 2590067, "end": 2591092 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Fort_Nelson", "start": 2591092, "end": 2592540 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Fort_Wayne", "start": 2592540, "end": 2593071 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Fortaleza", "start": 2593071, "end": 2593555 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Glace_Bay", "start": 2593555, "end": 2594435 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Godthab", "start": 2594435, "end": 2595400 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Goose_Bay", "start": 2595400, "end": 2596980 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Grand_Turk", "start": 2596980, "end": 2597833 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Grenada", "start": 2597833, "end": 2598010 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Guadeloupe", "start": 2598010, "end": 2598187 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Guatemala", "start": 2598187, "end": 2598399 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Guayaquil", "start": 2598399, "end": 2598578 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Guyana", "start": 2598578, "end": 2598759 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Halifax", "start": 2598759, "end": 2600431 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Havana", "start": 2600431, "end": 2601548 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Hermosillo", "start": 2601548, "end": 2601834 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Indianapolis", "start": 2601834, "end": 2602365 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Knox", "start": 2602365, "end": 2603381 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Marengo", "start": 2603381, "end": 2603948 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Petersburg", "start": 2603948, "end": 2604631 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Tell_City", "start": 2604631, "end": 2605153 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Vevay", "start": 2605153, "end": 2605522 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Vincennes", "start": 2605522, "end": 2606080 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indiana/Winamac", "start": 2606080, "end": 2606692 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Indianapolis", "start": 2606692, "end": 2607223 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Inuvik", "start": 2607223, "end": 2608040 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Iqaluit", "start": 2608040, "end": 2608895 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Jamaica", "start": 2608895, "end": 2609234 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Jujuy", "start": 2609234, "end": 2609924 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Juneau", "start": 2609924, "end": 2610890 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Kentucky/Louisville", "start": 2610890, "end": 2612132 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Kentucky/Monticello", "start": 2612132, "end": 2613104 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Knox_IN", "start": 2613104, "end": 2614120 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Kralendijk", "start": 2614120, "end": 2614297 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/La_Paz", "start": 2614297, "end": 2614467 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Lima", "start": 2614467, "end": 2614750 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Los_Angeles", "start": 2614750, "end": 2616044 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Louisville", "start": 2616044, "end": 2617286 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Lower_Princes", "start": 2617286, "end": 2617463 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Maceio", "start": 2617463, "end": 2617965 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Managua", "start": 2617965, "end": 2618260 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Manaus", "start": 2618260, "end": 2618672 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Marigot", "start": 2618672, "end": 2618849 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Martinique", "start": 2618849, "end": 2619027 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Matamoros", "start": 2619027, "end": 2619464 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Mazatlan", "start": 2619464, "end": 2620182 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Mendoza", "start": 2620182, "end": 2620890 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Menominee", "start": 2620890, "end": 2621807 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Merida", "start": 2621807, "end": 2622461 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Metlakatla", "start": 2622461, "end": 2623056 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Mexico_City", "start": 2623056, "end": 2623829 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Miquelon", "start": 2623829, "end": 2624379 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Moncton", "start": 2624379, "end": 2625872 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Monterrey", "start": 2625872, "end": 2626516 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Montevideo", "start": 2626516, "end": 2627485 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Montreal", "start": 2627485, "end": 2629202 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Montserrat", "start": 2629202, "end": 2629379 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Nassau", "start": 2629379, "end": 2631096 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/New_York", "start": 2631096, "end": 2632840 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Nipigon", "start": 2632840, "end": 2634557 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Nome", "start": 2634557, "end": 2635532 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Noronha", "start": 2635532, "end": 2636016 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/North_Dakota/Beulah", "start": 2636016, "end": 2637059 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/North_Dakota/Center", "start": 2637059, "end": 2638049 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/North_Dakota/New_Salem", "start": 2638049, "end": 2639039 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Nuuk", "start": 2639039, "end": 2640004 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Ojinaga", "start": 2640004, "end": 2640713 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Panama", "start": 2640713, "end": 2640862 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Pangnirtung", "start": 2640862, "end": 2641717 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Paramaribo", "start": 2641717, "end": 2641904 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Phoenix", "start": 2641904, "end": 2642144 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Port-au-Prince", "start": 2642144, "end": 2642709 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Port_of_Spain", "start": 2642709, "end": 2642886 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Porto_Acre", "start": 2642886, "end": 2643304 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Porto_Velho", "start": 2643304, "end": 2643698 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Puerto_Rico", "start": 2643698, "end": 2643875 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Punta_Arenas", "start": 2643875, "end": 2645093 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Rainy_River", "start": 2645093, "end": 2646387 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Rankin_Inlet", "start": 2646387, "end": 2647194 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Recife", "start": 2647194, "end": 2647678 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Regina", "start": 2647678, "end": 2648316 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Resolute", "start": 2648316, "end": 2649123 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Rio_Branco", "start": 2649123, "end": 2649541 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Rosario", "start": 2649541, "end": 2650249 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Santa_Isabel", "start": 2650249, "end": 2651274 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Santarem", "start": 2651274, "end": 2651683 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Santiago", "start": 2651683, "end": 2653037 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Santo_Domingo", "start": 2653037, "end": 2653354 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Sao_Paulo", "start": 2653354, "end": 2654306 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Scoresbysund", "start": 2654306, "end": 2655290 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Shiprock", "start": 2655290, "end": 2656332 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Sitka", "start": 2656332, "end": 2657288 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/St_Barthelemy", "start": 2657288, "end": 2657465 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/St_Johns", "start": 2657465, "end": 2659343 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/St_Kitts", "start": 2659343, "end": 2659520 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/St_Lucia", "start": 2659520, "end": 2659697 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/St_Thomas", "start": 2659697, "end": 2659874 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/St_Vincent", "start": 2659874, "end": 2660051 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Swift_Current", "start": 2660051, "end": 2660419 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Tegucigalpa", "start": 2660419, "end": 2660613 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Thule", "start": 2660613, "end": 2661068 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Thunder_Bay", "start": 2661068, "end": 2662785 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Tijuana", "start": 2662785, "end": 2663810 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Toronto", "start": 2663810, "end": 2665527 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Tortola", "start": 2665527, "end": 2665704 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Vancouver", "start": 2665704, "end": 2667034 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Virgin", "start": 2667034, "end": 2667211 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Whitehorse", "start": 2667211, "end": 2668240 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Winnipeg", "start": 2668240, "end": 2669534 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Yakutat", "start": 2669534, "end": 2670480 }, { "filename": "/tmp/pglite/share/postgresql/timezone/America/Yellowknife", "start": 2670480, "end": 2671450 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Casey", "start": 2671450, "end": 2671737 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Davis", "start": 2671737, "end": 2671934 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/DumontDUrville", "start": 2671934, "end": 2672088 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Macquarie", "start": 2672088, "end": 2673064 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Mawson", "start": 2673064, "end": 2673216 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/McMurdo", "start": 2673216, "end": 2674259 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Palmer", "start": 2674259, "end": 2675146 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Rothera", "start": 2675146, "end": 2675278 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/South_Pole", "start": 2675278, "end": 2676321 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Syowa", "start": 2676321, "end": 2676454 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Troll", "start": 2676454, "end": 2676631 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Antarctica/Vostok", "start": 2676631, "end": 2676801 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Arctic/Longyearbyen", "start": 2676801, "end": 2677506 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Aden", "start": 2677506, "end": 2677639 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Almaty", "start": 2677639, "end": 2678257 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Amman", "start": 2678257, "end": 2679185 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Anadyr", "start": 2679185, "end": 2679928 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Aqtau", "start": 2679928, "end": 2680534 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Aqtobe", "start": 2680534, "end": 2681149 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Ashgabat", "start": 2681149, "end": 2681524 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Ashkhabad", "start": 2681524, "end": 2681899 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Atyrau", "start": 2681899, "end": 2682515 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Baghdad", "start": 2682515, "end": 2683145 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Bahrain", "start": 2683145, "end": 2683297 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Baku", "start": 2683297, "end": 2684041 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Bangkok", "start": 2684041, "end": 2684193 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Barnaul", "start": 2684193, "end": 2684946 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Beirut", "start": 2684946, "end": 2685678 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Bishkek", "start": 2685678, "end": 2686296 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Brunei", "start": 2686296, "end": 2686616 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Calcutta", "start": 2686616, "end": 2686836 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Chita", "start": 2686836, "end": 2687586 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Choibalsan", "start": 2687586, "end": 2688205 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Chongqing", "start": 2688205, "end": 2688598 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Chungking", "start": 2688598, "end": 2688991 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Colombo", "start": 2688991, "end": 2689238 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Dacca", "start": 2689238, "end": 2689469 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Damascus", "start": 2689469, "end": 2690703 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Dhaka", "start": 2690703, "end": 2690934 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Dili", "start": 2690934, "end": 2691104 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Dubai", "start": 2691104, "end": 2691237 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Dushanbe", "start": 2691237, "end": 2691603 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Famagusta", "start": 2691603, "end": 2692543 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Gaza", "start": 2692543, "end": 2694989 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Harbin", "start": 2694989, "end": 2695382 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Hebron", "start": 2695382, "end": 2697846 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Ho_Chi_Minh", "start": 2697846, "end": 2698082 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Hong_Kong", "start": 2698082, "end": 2698857 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Hovd", "start": 2698857, "end": 2699451 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Irkutsk", "start": 2699451, "end": 2700211 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Istanbul", "start": 2700211, "end": 2701411 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Jakarta", "start": 2701411, "end": 2701659 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Jayapura", "start": 2701659, "end": 2701830 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Jerusalem", "start": 2701830, "end": 2702904 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kabul", "start": 2702904, "end": 2703063 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kamchatka", "start": 2703063, "end": 2703790 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Karachi", "start": 2703790, "end": 2704056 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kashgar", "start": 2704056, "end": 2704189 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kathmandu", "start": 2704189, "end": 2704350 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Katmandu", "start": 2704350, "end": 2704511 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Khandyga", "start": 2704511, "end": 2705286 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kolkata", "start": 2705286, "end": 2705506 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Krasnoyarsk", "start": 2705506, "end": 2706247 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kuala_Lumpur", "start": 2706247, "end": 2706503 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kuching", "start": 2706503, "end": 2706823 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Kuwait", "start": 2706823, "end": 2706956 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Macao", "start": 2706956, "end": 2707747 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Macau", "start": 2707747, "end": 2708538 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Magadan", "start": 2708538, "end": 2709289 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Makassar", "start": 2709289, "end": 2709479 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Manila", "start": 2709479, "end": 2709717 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Muscat", "start": 2709717, "end": 2709850 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Nicosia", "start": 2709850, "end": 2710447 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Novokuznetsk", "start": 2710447, "end": 2711173 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Novosibirsk", "start": 2711173, "end": 2711926 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Omsk", "start": 2711926, "end": 2712667 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Oral", "start": 2712667, "end": 2713292 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Phnom_Penh", "start": 2713292, "end": 2713444 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Pontianak", "start": 2713444, "end": 2713691 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Pyongyang", "start": 2713691, "end": 2713874 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Qatar", "start": 2713874, "end": 2714026 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Qostanay", "start": 2714026, "end": 2714650 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Qyzylorda", "start": 2714650, "end": 2715274 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Rangoon", "start": 2715274, "end": 2715461 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Riyadh", "start": 2715461, "end": 2715594 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Saigon", "start": 2715594, "end": 2715830 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Sakhalin", "start": 2715830, "end": 2716585 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Samarkand", "start": 2716585, "end": 2716951 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Seoul", "start": 2716951, "end": 2717366 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Shanghai", "start": 2717366, "end": 2717759 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Singapore", "start": 2717759, "end": 2718015 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Srednekolymsk", "start": 2718015, "end": 2718757 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Taipei", "start": 2718757, "end": 2719268 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Tashkent", "start": 2719268, "end": 2719634 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Tbilisi", "start": 2719634, "end": 2720263 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Tehran", "start": 2720263, "end": 2721075 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Tel_Aviv", "start": 2721075, "end": 2722149 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Thimbu", "start": 2722149, "end": 2722303 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Thimphu", "start": 2722303, "end": 2722457 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Tokyo", "start": 2722457, "end": 2722670 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Tomsk", "start": 2722670, "end": 2723423 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Ujung_Pandang", "start": 2723423, "end": 2723613 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Ulaanbaatar", "start": 2723613, "end": 2724207 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Ulan_Bator", "start": 2724207, "end": 2724801 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Urumqi", "start": 2724801, "end": 2724934 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Ust-Nera", "start": 2724934, "end": 2725705 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Vientiane", "start": 2725705, "end": 2725857 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Vladivostok", "start": 2725857, "end": 2726599 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Yakutsk", "start": 2726599, "end": 2727340 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Yangon", "start": 2727340, "end": 2727527 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Yekaterinburg", "start": 2727527, "end": 2728287 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Asia/Yerevan", "start": 2728287, "end": 2728995 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Azores", "start": 2728995, "end": 2730448 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Bermuda", "start": 2730448, "end": 2731472 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Canary", "start": 2731472, "end": 2731950 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Cape_Verde", "start": 2731950, "end": 2732125 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Faeroe", "start": 2732125, "end": 2732566 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Faroe", "start": 2732566, "end": 2733007 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Jan_Mayen", "start": 2733007, "end": 2733712 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Madeira", "start": 2733712, "end": 2735165 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Reykjavik", "start": 2735165, "end": 2735295 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/South_Georgia", "start": 2735295, "end": 2735427 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/St_Helena", "start": 2735427, "end": 2735557 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Atlantic/Stanley", "start": 2735557, "end": 2736346 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/ACT", "start": 2736346, "end": 2737250 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Adelaide", "start": 2737250, "end": 2738171 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Brisbane", "start": 2738171, "end": 2738460 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Broken_Hill", "start": 2738460, "end": 2739401 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Canberra", "start": 2739401, "end": 2740305 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Currie", "start": 2740305, "end": 2741308 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Darwin", "start": 2741308, "end": 2741542 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Eucla", "start": 2741542, "end": 2741856 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Hobart", "start": 2741856, "end": 2742859 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/LHI", "start": 2742859, "end": 2743551 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Lindeman", "start": 2743551, "end": 2743876 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Lord_Howe", "start": 2743876, "end": 2744568 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Melbourne", "start": 2744568, "end": 2745472 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/NSW", "start": 2745472, "end": 2746376 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/North", "start": 2746376, "end": 2746610 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Perth", "start": 2746610, "end": 2746916 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Queensland", "start": 2746916, "end": 2747205 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/South", "start": 2747205, "end": 2748126 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Sydney", "start": 2748126, "end": 2749030 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Tasmania", "start": 2749030, "end": 2750033 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Victoria", "start": 2750033, "end": 2750937 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/West", "start": 2750937, "end": 2751243 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Australia/Yancowinna", "start": 2751243, "end": 2752184 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Brazil/Acre", "start": 2752184, "end": 2752602 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Brazil/DeNoronha", "start": 2752602, "end": 2753086 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Brazil/East", "start": 2753086, "end": 2754038 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Brazil/West", "start": 2754038, "end": 2754450 }, { "filename": "/tmp/pglite/share/postgresql/timezone/CET", "start": 2754450, "end": 2755071 }, { "filename": "/tmp/pglite/share/postgresql/timezone/CST6CDT", "start": 2755071, "end": 2756022 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Atlantic", "start": 2756022, "end": 2757694 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Central", "start": 2757694, "end": 2758988 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Eastern", "start": 2758988, "end": 2760705 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Mountain", "start": 2760705, "end": 2761675 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Newfoundland", "start": 2761675, "end": 2763553 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Pacific", "start": 2763553, "end": 2764883 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Saskatchewan", "start": 2764883, "end": 2765521 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Canada/Yukon", "start": 2765521, "end": 2766550 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Chile/Continental", "start": 2766550, "end": 2767904 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Chile/EasterIsland", "start": 2767904, "end": 2769078 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Cuba", "start": 2769078, "end": 2770195 }, { "filename": "/tmp/pglite/share/postgresql/timezone/EET", "start": 2770195, "end": 2770692 }, { "filename": "/tmp/pglite/share/postgresql/timezone/EST", "start": 2770692, "end": 2770803 }, { "filename": "/tmp/pglite/share/postgresql/timezone/EST5EDT", "start": 2770803, "end": 2771754 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Egypt", "start": 2771754, "end": 2773063 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Eire", "start": 2773063, "end": 2774559 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT", "start": 2774559, "end": 2774670 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+0", "start": 2774670, "end": 2774781 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+1", "start": 2774781, "end": 2774894 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+10", "start": 2774894, "end": 2775008 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+11", "start": 2775008, "end": 2775122 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+12", "start": 2775122, "end": 2775236 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+2", "start": 2775236, "end": 2775349 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+3", "start": 2775349, "end": 2775462 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+4", "start": 2775462, "end": 2775575 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+5", "start": 2775575, "end": 2775688 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+6", "start": 2775688, "end": 2775801 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+7", "start": 2775801, "end": 2775914 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+8", "start": 2775914, "end": 2776027 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT+9", "start": 2776027, "end": 2776140 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-0", "start": 2776140, "end": 2776251 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-1", "start": 2776251, "end": 2776365 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-10", "start": 2776365, "end": 2776480 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-11", "start": 2776480, "end": 2776595 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-12", "start": 2776595, "end": 2776710 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-13", "start": 2776710, "end": 2776825 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-14", "start": 2776825, "end": 2776940 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-2", "start": 2776940, "end": 2777054 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-3", "start": 2777054, "end": 2777168 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-4", "start": 2777168, "end": 2777282 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-5", "start": 2777282, "end": 2777396 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-6", "start": 2777396, "end": 2777510 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-7", "start": 2777510, "end": 2777624 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-8", "start": 2777624, "end": 2777738 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT-9", "start": 2777738, "end": 2777852 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/GMT0", "start": 2777852, "end": 2777963 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/Greenwich", "start": 2777963, "end": 2778074 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/UCT", "start": 2778074, "end": 2778185 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/UTC", "start": 2778185, "end": 2778296 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/Universal", "start": 2778296, "end": 2778407 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Etc/Zulu", "start": 2778407, "end": 2778518 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Amsterdam", "start": 2778518, "end": 2779621 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Andorra", "start": 2779621, "end": 2780010 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Astrakhan", "start": 2780010, "end": 2780736 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Athens", "start": 2780736, "end": 2781418 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Belfast", "start": 2781418, "end": 2783017 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Belgrade", "start": 2783017, "end": 2783495 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Berlin", "start": 2783495, "end": 2784200 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Bratislava", "start": 2784200, "end": 2784923 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Brussels", "start": 2784923, "end": 2786026 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Bucharest", "start": 2786026, "end": 2786687 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Budapest", "start": 2786687, "end": 2787453 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Busingen", "start": 2787453, "end": 2787950 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Chisinau", "start": 2787950, "end": 2788705 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Copenhagen", "start": 2788705, "end": 2789410 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Dublin", "start": 2789410, "end": 2790906 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Gibraltar", "start": 2790906, "end": 2792126 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Guernsey", "start": 2792126, "end": 2793725 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Helsinki", "start": 2793725, "end": 2794206 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Isle_of_Man", "start": 2794206, "end": 2795805 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Istanbul", "start": 2795805, "end": 2797005 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Jersey", "start": 2797005, "end": 2798604 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Kaliningrad", "start": 2798604, "end": 2799508 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Kiev", "start": 2799508, "end": 2800066 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Kirov", "start": 2800066, "end": 2800801 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Kyiv", "start": 2800801, "end": 2801359 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Lisbon", "start": 2801359, "end": 2802813 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Ljubljana", "start": 2802813, "end": 2803291 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/London", "start": 2803291, "end": 2804890 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Luxembourg", "start": 2804890, "end": 2805993 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Madrid", "start": 2805993, "end": 2806890 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Malta", "start": 2806890, "end": 2807818 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Mariehamn", "start": 2807818, "end": 2808299 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Minsk", "start": 2808299, "end": 2809107 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Monaco", "start": 2809107, "end": 2810212 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Moscow", "start": 2810212, "end": 2811120 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Nicosia", "start": 2811120, "end": 2811717 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Oslo", "start": 2811717, "end": 2812422 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Paris", "start": 2812422, "end": 2813527 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Podgorica", "start": 2813527, "end": 2814005 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Prague", "start": 2814005, "end": 2814728 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Riga", "start": 2814728, "end": 2815422 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Rome", "start": 2815422, "end": 2816369 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Samara", "start": 2816369, "end": 2817101 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/San_Marino", "start": 2817101, "end": 2818048 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Sarajevo", "start": 2818048, "end": 2818526 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Saratov", "start": 2818526, "end": 2819252 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Simferopol", "start": 2819252, "end": 2820117 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Skopje", "start": 2820117, "end": 2820595 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Sofia", "start": 2820595, "end": 2821187 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Stockholm", "start": 2821187, "end": 2821892 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Tallinn", "start": 2821892, "end": 2822567 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Tirane", "start": 2822567, "end": 2823171 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Tiraspol", "start": 2823171, "end": 2823926 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Ulyanovsk", "start": 2823926, "end": 2824686 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Uzhgorod", "start": 2824686, "end": 2825244 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Vaduz", "start": 2825244, "end": 2825741 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Vatican", "start": 2825741, "end": 2826688 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Vienna", "start": 2826688, "end": 2827346 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Vilnius", "start": 2827346, "end": 2828022 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Volgograd", "start": 2828022, "end": 2828775 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Warsaw", "start": 2828775, "end": 2829698 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Zagreb", "start": 2829698, "end": 2830176 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Zaporozhye", "start": 2830176, "end": 2830734 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Europe/Zurich", "start": 2830734, "end": 2831231 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Factory", "start": 2831231, "end": 2831344 }, { "filename": "/tmp/pglite/share/postgresql/timezone/GB", "start": 2831344, "end": 2832943 }, { "filename": "/tmp/pglite/share/postgresql/timezone/GB-Eire", "start": 2832943, "end": 2834542 }, { "filename": "/tmp/pglite/share/postgresql/timezone/GMT", "start": 2834542, "end": 2834653 }, { "filename": "/tmp/pglite/share/postgresql/timezone/GMT+0", "start": 2834653, "end": 2834764 }, { "filename": "/tmp/pglite/share/postgresql/timezone/GMT-0", "start": 2834764, "end": 2834875 }, { "filename": "/tmp/pglite/share/postgresql/timezone/GMT0", "start": 2834875, "end": 2834986 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Greenwich", "start": 2834986, "end": 2835097 }, { "filename": "/tmp/pglite/share/postgresql/timezone/HST", "start": 2835097, "end": 2835209 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Hongkong", "start": 2835209, "end": 2835984 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Iceland", "start": 2835984, "end": 2836114 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Antananarivo", "start": 2836114, "end": 2836305 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Chagos", "start": 2836305, "end": 2836457 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Christmas", "start": 2836457, "end": 2836609 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Cocos", "start": 2836609, "end": 2836796 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Comoro", "start": 2836796, "end": 2836987 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Kerguelen", "start": 2836987, "end": 2837139 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Mahe", "start": 2837139, "end": 2837272 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Maldives", "start": 2837272, "end": 2837424 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Mauritius", "start": 2837424, "end": 2837603 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Mayotte", "start": 2837603, "end": 2837794 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Indian/Reunion", "start": 2837794, "end": 2837927 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Iran", "start": 2837927, "end": 2838739 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Israel", "start": 2838739, "end": 2839813 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Jamaica", "start": 2839813, "end": 2840152 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Japan", "start": 2840152, "end": 2840365 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Kwajalein", "start": 2840365, "end": 2840584 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Libya", "start": 2840584, "end": 2841015 }, { "filename": "/tmp/pglite/share/postgresql/timezone/MET", "start": 2841015, "end": 2841636 }, { "filename": "/tmp/pglite/share/postgresql/timezone/MST", "start": 2841636, "end": 2841747 }, { "filename": "/tmp/pglite/share/postgresql/timezone/MST7MDT", "start": 2841747, "end": 2842698 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Mexico/BajaNorte", "start": 2842698, "end": 2843723 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Mexico/BajaSur", "start": 2843723, "end": 2844441 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Mexico/General", "start": 2844441, "end": 2845214 }, { "filename": "/tmp/pglite/share/postgresql/timezone/NZ", "start": 2845214, "end": 2846257 }, { "filename": "/tmp/pglite/share/postgresql/timezone/NZ-CHAT", "start": 2846257, "end": 2847065 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Navajo", "start": 2847065, "end": 2848107 }, { "filename": "/tmp/pglite/share/postgresql/timezone/PRC", "start": 2848107, "end": 2848500 }, { "filename": "/tmp/pglite/share/postgresql/timezone/PST8PDT", "start": 2848500, "end": 2849451 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Apia", "start": 2849451, "end": 2849858 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Auckland", "start": 2849858, "end": 2850901 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Bougainville", "start": 2850901, "end": 2851102 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Chatham", "start": 2851102, "end": 2851910 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Chuuk", "start": 2851910, "end": 2852064 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Easter", "start": 2852064, "end": 2853238 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Efate", "start": 2853238, "end": 2853580 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Enderbury", "start": 2853580, "end": 2853752 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Fakaofo", "start": 2853752, "end": 2853905 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Fiji", "start": 2853905, "end": 2854301 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Funafuti", "start": 2854301, "end": 2854435 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Galapagos", "start": 2854435, "end": 2854610 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Gambier", "start": 2854610, "end": 2854742 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Guadalcanal", "start": 2854742, "end": 2854876 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Guam", "start": 2854876, "end": 2855226 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Honolulu", "start": 2855226, "end": 2855447 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Johnston", "start": 2855447, "end": 2855668 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Kanton", "start": 2855668, "end": 2855840 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Kiritimati", "start": 2855840, "end": 2856014 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Kosrae", "start": 2856014, "end": 2856256 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Kwajalein", "start": 2856256, "end": 2856475 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Majuro", "start": 2856475, "end": 2856609 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Marquesas", "start": 2856609, "end": 2856748 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Midway", "start": 2856748, "end": 2856894 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Nauru", "start": 2856894, "end": 2857077 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Niue", "start": 2857077, "end": 2857231 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Norfolk", "start": 2857231, "end": 2857478 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Noumea", "start": 2857478, "end": 2857676 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Pago_Pago", "start": 2857676, "end": 2857822 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Palau", "start": 2857822, "end": 2857970 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Pitcairn", "start": 2857970, "end": 2858123 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Pohnpei", "start": 2858123, "end": 2858257 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Ponape", "start": 2858257, "end": 2858391 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Port_Moresby", "start": 2858391, "end": 2858545 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Rarotonga", "start": 2858545, "end": 2858951 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Saipan", "start": 2858951, "end": 2859301 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Samoa", "start": 2859301, "end": 2859447 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Tahiti", "start": 2859447, "end": 2859580 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Tarawa", "start": 2859580, "end": 2859714 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Tongatapu", "start": 2859714, "end": 2859951 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Truk", "start": 2859951, "end": 2860105 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Wake", "start": 2860105, "end": 2860239 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Wallis", "start": 2860239, "end": 2860373 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Pacific/Yap", "start": 2860373, "end": 2860527 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Poland", "start": 2860527, "end": 2861450 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Portugal", "start": 2861450, "end": 2862904 }, { "filename": "/tmp/pglite/share/postgresql/timezone/ROC", "start": 2862904, "end": 2863415 }, { "filename": "/tmp/pglite/share/postgresql/timezone/ROK", "start": 2863415, "end": 2863830 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Singapore", "start": 2863830, "end": 2864086 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Turkey", "start": 2864086, "end": 2865286 }, { "filename": "/tmp/pglite/share/postgresql/timezone/UCT", "start": 2865286, "end": 2865397 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Alaska", "start": 2865397, "end": 2866374 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Aleutian", "start": 2866374, "end": 2867343 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Arizona", "start": 2867343, "end": 2867583 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Central", "start": 2867583, "end": 2869337 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/East-Indiana", "start": 2869337, "end": 2869868 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Eastern", "start": 2869868, "end": 2871612 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Hawaii", "start": 2871612, "end": 2871833 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Indiana-Starke", "start": 2871833, "end": 2872849 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Michigan", "start": 2872849, "end": 2873748 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Mountain", "start": 2873748, "end": 2874790 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Pacific", "start": 2874790, "end": 2876084 }, { "filename": "/tmp/pglite/share/postgresql/timezone/US/Samoa", "start": 2876084, "end": 2876230 }, { "filename": "/tmp/pglite/share/postgresql/timezone/UTC", "start": 2876230, "end": 2876341 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Universal", "start": 2876341, "end": 2876452 }, { "filename": "/tmp/pglite/share/postgresql/timezone/W-SU", "start": 2876452, "end": 2877360 }, { "filename": "/tmp/pglite/share/postgresql/timezone/WET", "start": 2877360, "end": 2877854 }, { "filename": "/tmp/pglite/share/postgresql/timezone/Zulu", "start": 2877854, "end": 2877965 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Africa.txt", "start": 2877965, "end": 2884938 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/America.txt", "start": 2884938, "end": 2895945 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Antarctica.txt", "start": 2895945, "end": 2897079 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Asia.txt", "start": 2897079, "end": 2905390 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Atlantic.txt", "start": 2905390, "end": 2908923 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Australia", "start": 2908923, "end": 2910058 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Australia.txt", "start": 2910058, "end": 2913442 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Default", "start": 2913442, "end": 2940692 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Etc.txt", "start": 2940692, "end": 2941942 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Europe.txt", "start": 2941942, "end": 2950724 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/India", "start": 2950724, "end": 2951317 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Indian.txt", "start": 2951317, "end": 2952578 }, { "filename": "/tmp/pglite/share/postgresql/timezonesets/Pacific.txt", "start": 2952578, "end": 2956346 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/danish.stop", "start": 2956346, "end": 2956770 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/dutch.stop", "start": 2956770, "end": 2957223 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/english.stop", "start": 2957223, "end": 2957845 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/finnish.stop", "start": 2957845, "end": 2959424 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/french.stop", "start": 2959424, "end": 2960229 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/german.stop", "start": 2960229, "end": 2961578 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/hungarian.stop", "start": 2961578, "end": 2962805 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/hunspell_sample.affix", "start": 2962805, "end": 2963048 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/hunspell_sample_long.affix", "start": 2963048, "end": 2963681 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/hunspell_sample_long.dict", "start": 2963681, "end": 2963779 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/hunspell_sample_num.affix", "start": 2963779, "end": 2964241 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/hunspell_sample_num.dict", "start": 2964241, "end": 2964370 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/ispell_sample.affix", "start": 2964370, "end": 2964835 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/ispell_sample.dict", "start": 2964835, "end": 2964916 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/italian.stop", "start": 2964916, "end": 2966570 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/nepali.stop", "start": 2966570, "end": 2970831 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/norwegian.stop", "start": 2970831, "end": 2971682 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/portuguese.stop", "start": 2971682, "end": 2972949 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/russian.stop", "start": 2972949, "end": 2974184 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/spanish.stop", "start": 2974184, "end": 2976362 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/swedish.stop", "start": 2976362, "end": 2976921 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/synonym_sample.syn", "start": 2976921, "end": 2976994 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/thesaurus_sample.ths", "start": 2976994, "end": 2977467 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/turkish.stop", "start": 2977467, "end": 2977727 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/unaccent.rules", "start": 2977727, "end": 2987666 }, { "filename": "/tmp/pglite/share/postgresql/tsearch_data/xsyn_sample.rules", "start": 2987666, "end": 2987805 }], "remote_package_size": 2987805 });
        })();
        var moduleOverrides = Object.assign({}, Module);
        var arguments_ = [];
        var thisProgram = "./this.program";
        var quit_ = (status, toThrow) => {
          throw toThrow;
        };
        var scriptDirectory = "";
        function locateFile(path3) {
          if (Module["locateFile"]) {
            return Module["locateFile"](path3, scriptDirectory);
          }
          return scriptDirectory + path3;
        }
        var readAsync, readBinary;
        if (ENVIRONMENT_IS_NODE) {
          var fs = require("fs");
          var nodePath = require("path");
          if (!import_meta2.url.startsWith("data:")) {
            scriptDirectory = nodePath.dirname(require("url").fileURLToPath(import_meta2.url)) + "/";
          }
          readBinary = (filename) => {
            filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
            var ret = fs.readFileSync(filename);
            return ret;
          };
          readAsync = (filename, binary4 = true) => {
            filename = isFileURI(filename) ? new URL(filename) : nodePath.normalize(filename);
            return new Promise((resolve2, reject) => {
              fs.readFile(filename, binary4 ? void 0 : "utf8", (err3, data) => {
                if (err3) reject(err3);
                else resolve2(binary4 ? data.buffer : data);
              });
            });
          };
          if (!Module["thisProgram"] && process.argv.length > 1) {
            thisProgram = process.argv[1].replace(/\\/g, "/");
          }
          arguments_ = process.argv.slice(2);
          quit_ = (status, toThrow) => {
            process.exitCode = status;
            throw toThrow;
          };
        } else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {
          if (ENVIRONMENT_IS_WORKER) {
            scriptDirectory = self.location.href;
          } else if (typeof document != "undefined" && document.currentScript) {
            scriptDirectory = document.currentScript.src;
          }
          if (_scriptName) {
            scriptDirectory = _scriptName;
          }
          if (scriptDirectory.startsWith("blob:")) {
            scriptDirectory = "";
          } else {
            scriptDirectory = scriptDirectory.substr(0, scriptDirectory.replace(/[?#].*/, "").lastIndexOf("/") + 1);
          }
          {
            if (ENVIRONMENT_IS_WORKER) {
              readBinary = (url) => {
                var xhr = new XMLHttpRequest();
                xhr.open("GET", url, false);
                xhr.responseType = "arraybuffer";
                xhr.send(null);
                return new Uint8Array(
                  /** @type{!ArrayBuffer} */
                  xhr.response
                );
              };
            }
            readAsync = (url) => {
              if (isFileURI(url)) {
                return new Promise((resolve2, reject) => {
                  var xhr = new XMLHttpRequest();
                  xhr.open("GET", url, true);
                  xhr.responseType = "arraybuffer";
                  xhr.onload = () => {
                    if (xhr.status == 200 || xhr.status == 0 && xhr.response) {
                      resolve2(xhr.response);
                      return;
                    }
                    reject(xhr.status);
                  };
                  xhr.onerror = reject;
                  xhr.send(null);
                });
              }
              return fetch(url, { credentials: "same-origin" }).then((response) => {
                if (response.ok) {
                  return response.arrayBuffer();
                }
                return Promise.reject(new Error(response.status + " : " + response.url));
              });
            };
          }
        } else {
        }
        var out = Module["print"] || console.log.bind(console);
        var err = Module["printErr"] || console.error.bind(console);
        Object.assign(Module, moduleOverrides);
        moduleOverrides = null;
        if (Module["arguments"]) arguments_ = Module["arguments"];
        if (Module["thisProgram"]) thisProgram = Module["thisProgram"];
        var dynamicLibraries = Module["dynamicLibraries"] || [];
        var wasmBinary = Module["wasmBinary"];
        function intArrayFromBase64(s10) {
          if (typeof ENVIRONMENT_IS_NODE != "undefined" && ENVIRONMENT_IS_NODE) {
            var buf = Buffer.from(s10, "base64");
            return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
          }
          var decoded = atob(s10);
          var bytes2 = new Uint8Array(decoded.length);
          for (var i8 = 0; i8 < decoded.length; ++i8) {
            bytes2[i8] = decoded.charCodeAt(i8);
          }
          return bytes2;
        }
        function tryParseAsDataURI(filename) {
          if (!isDataURI(filename)) {
            return;
          }
          return intArrayFromBase64(filename.slice(dataURIPrefix.length));
        }
        var wasmMemory;
        var ABORT = false;
        var EXITSTATUS;
        function assert(condition, text5) {
          if (!condition) {
            abort(text5);
          }
        }
        var HEAP, HEAP8, HEAPU8, HEAP16, HEAPU16, HEAP32, HEAPU32, HEAPF32, HEAP64, HEAPU64, HEAPF64;
        function updateMemoryViews() {
          var b9 = wasmMemory.buffer;
          Module["HEAP8"] = HEAP8 = new Int8Array(b9);
          Module["HEAP16"] = HEAP16 = new Int16Array(b9);
          Module["HEAPU8"] = HEAPU8 = new Uint8Array(b9);
          Module["HEAPU16"] = HEAPU16 = new Uint16Array(b9);
          Module["HEAP32"] = HEAP32 = new Int32Array(b9);
          Module["HEAPU32"] = HEAPU32 = new Uint32Array(b9);
          Module["HEAPF32"] = HEAPF32 = new Float32Array(b9);
          Module["HEAPF64"] = HEAPF64 = new Float64Array(b9);
          Module["HEAP64"] = HEAP64 = new BigInt64Array(b9);
          Module["HEAPU64"] = HEAPU64 = new BigUint64Array(b9);
        }
        if (Module["wasmMemory"]) {
          wasmMemory = Module["wasmMemory"];
        } else {
          var INITIAL_MEMORY = Module["INITIAL_MEMORY"] || 134217728;
          wasmMemory = new WebAssembly.Memory({
            "initial": INITIAL_MEMORY / 65536,
            // In theory we should not need to emit the maximum if we want "unlimited"
            // or 4GB of memory, but VMs error on that atm, see
            // https://github.com/emscripten-core/emscripten/issues/14130
            // And in the pthreads case we definitely need to emit a maximum. So
            // always emit one.
            "maximum": 32768
          });
        }
        updateMemoryViews();
        var __ATPRERUN__ = [];
        var __ATINIT__ = [];
        var __ATMAIN__ = [];
        var __ATEXIT__ = [];
        var __ATPOSTRUN__ = [];
        var __RELOC_FUNCS__ = [];
        var runtimeInitialized = false;
        function preRun() {
          if (Module["preRun"]) {
            if (typeof Module["preRun"] == "function") Module["preRun"] = [Module["preRun"]];
            while (Module["preRun"].length) {
              addOnPreRun(Module["preRun"].shift());
            }
          }
          callRuntimeCallbacks(__ATPRERUN__);
        }
        function initRuntime() {
          runtimeInitialized = true;
          callRuntimeCallbacks(__RELOC_FUNCS__);
          if (!Module["noFSInit"] && !FS.initialized)
            FS.init();
          FS.ignorePermissions = false;
          TTY.init();
          SOCKFS.root = FS.mount(SOCKFS, {}, null);
          PIPEFS.root = FS.mount(PIPEFS, {}, null);
          callRuntimeCallbacks(__ATINIT__);
        }
        function preMain() {
          callRuntimeCallbacks(__ATMAIN__);
        }
        function postRun() {
          if (Module["postRun"]) {
            if (typeof Module["postRun"] == "function") Module["postRun"] = [Module["postRun"]];
            while (Module["postRun"].length) {
              addOnPostRun(Module["postRun"].shift());
            }
          }
          callRuntimeCallbacks(__ATPOSTRUN__);
        }
        function addOnPreRun(cb) {
          __ATPRERUN__.unshift(cb);
        }
        function addOnInit(cb) {
          __ATINIT__.unshift(cb);
        }
        function addOnPreMain(cb) {
          __ATMAIN__.unshift(cb);
        }
        function addOnExit(cb) {
        }
        function addOnPostRun(cb) {
          __ATPOSTRUN__.unshift(cb);
        }
        var runDependencies = 0;
        var runDependencyWatcher = null;
        var dependenciesFulfilled = null;
        function getUniqueRunDependency(id) {
          return id;
        }
        function addRunDependency(id) {
          runDependencies++;
          Module["monitorRunDependencies"]?.(runDependencies);
        }
        function removeRunDependency(id) {
          runDependencies--;
          Module["monitorRunDependencies"]?.(runDependencies);
          if (runDependencies == 0) {
            if (runDependencyWatcher !== null) {
              clearInterval(runDependencyWatcher);
              runDependencyWatcher = null;
            }
            if (dependenciesFulfilled) {
              var callback = dependenciesFulfilled;
              dependenciesFulfilled = null;
              callback();
            }
          }
        }
        function abort(what) {
          Module["onAbort"]?.(what);
          what = "Aborted(" + what + ")";
          err(what);
          ABORT = true;
          what += ". Build with -sASSERTIONS for more info.";
          var e6 = new WebAssembly.RuntimeError(what);
          readyPromiseReject(e6);
          throw e6;
        }
        var dataURIPrefix = "data:application/octet-stream;base64,";
        var isDataURI = (filename) => filename.startsWith(dataURIPrefix);
        var isFileURI = (filename) => filename.startsWith("file://");
        function findWasmBinary() {
          if (Module["locateFile"]) {
            var f9 = "postgres.wasm";
            if (!isDataURI(f9)) {
              return locateFile(f9);
            }
            return f9;
          }
          return new URL("postgres.wasm", import_meta2.url).href;
        }
        var wasmBinaryFile;
        function getBinarySync(file) {
          if (file == wasmBinaryFile && wasmBinary) {
            return new Uint8Array(wasmBinary);
          }
          if (readBinary) {
            return readBinary(file);
          }
          throw "both async and sync fetching of the wasm failed";
        }
        function getBinaryPromise(binaryFile) {
          if (!wasmBinary) {
            return readAsync(binaryFile).then(
              (response) => new Uint8Array(
                /** @type{!ArrayBuffer} */
                response
              ),
              // Fall back to getBinarySync if readAsync fails
              () => getBinarySync(binaryFile)
            );
          }
          return Promise.resolve().then(() => getBinarySync(binaryFile));
        }
        function instantiateArrayBuffer(binaryFile, imports, receiver) {
          return getBinaryPromise(binaryFile).then((binary4) => {
            return WebAssembly.instantiate(binary4, imports);
          }).then(receiver, (reason) => {
            err(`failed to asynchronously prepare wasm: ${reason}`);
            abort(reason);
          });
        }
        function instantiateAsync(binary4, binaryFile, imports, callback) {
          if (!binary4 && typeof WebAssembly.instantiateStreaming == "function" && !isDataURI(binaryFile) && // Don't use streaming for file:// delivered objects in a webview, fetch them synchronously.
          !isFileURI(binaryFile) && // Avoid instantiateStreaming() on Node.js environment for now, as while
          // Node.js v18.1.0 implements it, it does not have a full fetch()
          // implementation yet.
          //
          // Reference:
          //   https://github.com/emscripten-core/emscripten/pull/16917
          !ENVIRONMENT_IS_NODE && typeof fetch == "function") {
            return fetch(binaryFile, { credentials: "same-origin" }).then((response) => {
              var result = WebAssembly.instantiateStreaming(response, imports);
              return result.then(
                callback,
                function(reason) {
                  err(`wasm streaming compile failed: ${reason}`);
                  err("falling back to ArrayBuffer instantiation");
                  return instantiateArrayBuffer(binaryFile, imports, callback);
                }
              );
            });
          }
          return instantiateArrayBuffer(binaryFile, imports, callback);
        }
        function getWasmImports() {
          return {
            "env": wasmImports,
            "wasi_snapshot_preview1": wasmImports,
            "GOT.mem": new Proxy(wasmImports, GOTHandler),
            "GOT.func": new Proxy(wasmImports, GOTHandler)
          };
        }
        function createWasm() {
          var info3 = getWasmImports();
          function receiveInstance(instance2, module2) {
            wasmExports = instance2.exports;
            wasmExports = relocateExports(wasmExports, 67108864);
            var metadata2 = getDylinkMetadata(module2);
            if (metadata2.neededDynlibs) {
              dynamicLibraries = metadata2.neededDynlibs.concat(dynamicLibraries);
            }
            mergeLibSymbols(wasmExports, "main");
            LDSO.init();
            loadDylibs();
            addOnInit(wasmExports["__wasm_call_ctors"]);
            __RELOC_FUNCS__.push(wasmExports["__wasm_apply_data_relocs"]);
            removeRunDependency("wasm-instantiate");
            return wasmExports;
          }
          addRunDependency("wasm-instantiate");
          function receiveInstantiationResult(result) {
            receiveInstance(result["instance"], result["module"]);
          }
          if (Module["instantiateWasm"]) {
            try {
              return Module["instantiateWasm"](info3, receiveInstance);
            } catch (e6) {
              err(`Module.instantiateWasm callback failed with error: ${e6}`);
              readyPromiseReject(e6);
            }
          }
          wasmBinaryFile ??= findWasmBinary();
          instantiateAsync(wasmBinary, wasmBinaryFile, info3, receiveInstantiationResult).catch(readyPromiseReject);
          return {};
        }
        var ASM_CONSTS = {
          69124608: ($0) => {
            Module.is_worker = typeof WorkerGlobalScope !== "undefined" && self instanceof WorkerGlobalScope;
            Module.FD_BUFFER_MAX = $0;
            Module.emscripten_copy_to = console.warn;
          },
          69124781: () => {
            Module["postMessage"] = function custom_postMessage(event) {
              console.log("# 1252: onCustomMessage:", __FILE__, event);
            };
          },
          69124906: () => {
            if (Module.is_worker) {
              let onCustomMessage2 = function(event) {
                console.log("onCustomMessage:", event);
              };
              var onCustomMessage = onCustomMessage2;
              ;
              Module["onCustomMessage"] = onCustomMessage2;
            } else {
              Module["postMessage"] = function custom_postMessage(event) {
                switch (event.type) {
                  case "raw": {
                    stringToUTF8(event.data, shm_rawinput, Module.FD_BUFFER_MAX);
                    break;
                  }
                  case "stdin": {
                    stringToUTF8(event.data, 1, Module.FD_BUFFER_MAX);
                    break;
                  }
                  case "rcon": {
                    stringToUTF8(event.data, shm_rcon, Module.FD_BUFFER_MAX);
                    break;
                  }
                  default:
                    console.warn("custom_postMessage?", event);
                }
              };
            }
            ;
          }
        };
        function peek_fd(fd) {
          return test_data.length;
        }
        function fnc_getfd(fd) {
          return fnc_stdin();
        }
        function is_web_env() {
          try {
            if (window) return 1;
          } catch (x11) {
            return 0;
          }
        }
        is_web_env.sig = "i";
        function ExitStatus(status) {
          this.name = "ExitStatus";
          this.message = `Program terminated with exit(${status})`;
          this.status = status;
        }
        var GOT = {};
        var currentModuleWeakSymbols = /* @__PURE__ */ new Set([]);
        var GOTHandler = {
          get(obj, symName) {
            var rtn = GOT[symName];
            if (!rtn) {
              rtn = GOT[symName] = new WebAssembly.Global({ "value": "i32", "mutable": true });
            }
            if (!currentModuleWeakSymbols.has(symName)) {
              rtn.required = true;
            }
            return rtn;
          }
        };
        var callRuntimeCallbacks = (callbacks) => {
          while (callbacks.length > 0) {
            callbacks.shift()(Module);
          }
        };
        var UTF8Decoder = typeof TextDecoder != "undefined" ? new TextDecoder() : void 0;
        var UTF8ArrayToString = (heapOrArray, idx, maxBytesToRead) => {
          var endIdx = idx + maxBytesToRead;
          var endPtr = idx;
          while (heapOrArray[endPtr] && !(endPtr >= endIdx)) ++endPtr;
          if (endPtr - idx > 16 && heapOrArray.buffer && UTF8Decoder) {
            return UTF8Decoder.decode(heapOrArray.subarray(idx, endPtr));
          }
          var str = "";
          while (idx < endPtr) {
            var u0 = heapOrArray[idx++];
            if (!(u0 & 128)) {
              str += String.fromCharCode(u0);
              continue;
            }
            var u1 = heapOrArray[idx++] & 63;
            if ((u0 & 224) == 192) {
              str += String.fromCharCode((u0 & 31) << 6 | u1);
              continue;
            }
            var u22 = heapOrArray[idx++] & 63;
            if ((u0 & 240) == 224) {
              u0 = (u0 & 15) << 12 | u1 << 6 | u22;
            } else {
              u0 = (u0 & 7) << 18 | u1 << 12 | u22 << 6 | heapOrArray[idx++] & 63;
            }
            if (u0 < 65536) {
              str += String.fromCharCode(u0);
            } else {
              var ch = u0 - 65536;
              str += String.fromCharCode(55296 | ch >> 10, 56320 | ch & 1023);
            }
          }
          return str;
        };
        var getDylinkMetadata = (binary4) => {
          var offset = 0;
          var end = 0;
          function getU8() {
            return binary4[offset++];
          }
          function getLEB() {
            var ret = 0;
            var mul = 1;
            while (1) {
              var byte = binary4[offset++];
              ret += (byte & 127) * mul;
              mul *= 128;
              if (!(byte & 128)) break;
            }
            return ret;
          }
          function getString() {
            var len = getLEB();
            offset += len;
            return UTF8ArrayToString(binary4, offset - len, len);
          }
          function failIf(condition, message) {
            if (condition) throw new Error(message);
          }
          var name3 = "dylink.0";
          if (binary4 instanceof WebAssembly.Module) {
            var dylinkSection = WebAssembly.Module.customSections(binary4, name3);
            if (dylinkSection.length === 0) {
              name3 = "dylink";
              dylinkSection = WebAssembly.Module.customSections(binary4, name3);
            }
            failIf(dylinkSection.length === 0, "need dylink section");
            binary4 = new Uint8Array(dylinkSection[0]);
            end = binary4.length;
          } else {
            var int32View = new Uint32Array(new Uint8Array(binary4.subarray(0, 24)).buffer);
            var magicNumberFound = int32View[0] == 1836278016;
            failIf(!magicNumberFound, "need to see wasm magic number");
            failIf(binary4[8] !== 0, "need the dylink section to be first");
            offset = 9;
            var section_size = getLEB();
            end = offset + section_size;
            name3 = getString();
          }
          var customSection = { neededDynlibs: [], tlsExports: /* @__PURE__ */ new Set(), weakImports: /* @__PURE__ */ new Set() };
          if (name3 == "dylink") {
            customSection.memorySize = getLEB();
            customSection.memoryAlign = getLEB();
            customSection.tableSize = getLEB();
            customSection.tableAlign = getLEB();
            var neededDynlibsCount = getLEB();
            for (var i8 = 0; i8 < neededDynlibsCount; ++i8) {
              var libname = getString();
              customSection.neededDynlibs.push(libname);
            }
          } else {
            failIf(name3 !== "dylink.0");
            var WASM_DYLINK_MEM_INFO = 1;
            var WASM_DYLINK_NEEDED = 2;
            var WASM_DYLINK_EXPORT_INFO = 3;
            var WASM_DYLINK_IMPORT_INFO = 4;
            var WASM_SYMBOL_TLS = 256;
            var WASM_SYMBOL_BINDING_MASK = 3;
            var WASM_SYMBOL_BINDING_WEAK = 1;
            while (offset < end) {
              var subsectionType = getU8();
              var subsectionSize = getLEB();
              if (subsectionType === WASM_DYLINK_MEM_INFO) {
                customSection.memorySize = getLEB();
                customSection.memoryAlign = getLEB();
                customSection.tableSize = getLEB();
                customSection.tableAlign = getLEB();
              } else if (subsectionType === WASM_DYLINK_NEEDED) {
                var neededDynlibsCount = getLEB();
                for (var i8 = 0; i8 < neededDynlibsCount; ++i8) {
                  libname = getString();
                  customSection.neededDynlibs.push(libname);
                }
              } else if (subsectionType === WASM_DYLINK_EXPORT_INFO) {
                var count2 = getLEB();
                while (count2--) {
                  var symname = getString();
                  var flags2 = getLEB();
                  if (flags2 & WASM_SYMBOL_TLS) {
                    customSection.tlsExports.add(symname);
                  }
                }
              } else if (subsectionType === WASM_DYLINK_IMPORT_INFO) {
                var count2 = getLEB();
                while (count2--) {
                  var modname = getString();
                  var symname = getString();
                  var flags2 = getLEB();
                  if ((flags2 & WASM_SYMBOL_BINDING_MASK) == WASM_SYMBOL_BINDING_WEAK) {
                    customSection.weakImports.add(symname);
                  }
                }
              } else {
                offset += subsectionSize;
              }
            }
          }
          return customSection;
        };
        function getValue(ptr, type = "i8") {
          if (type.endsWith("*")) type = "*";
          switch (type) {
            case "i1":
              return HEAP8[ptr];
            case "i8":
              return HEAP8[ptr];
            case "i16":
              return HEAP16[ptr >> 1];
            case "i32":
              return HEAP32[ptr >> 2];
            case "i64":
              return HEAP64[ptr >> 3];
            case "float":
              return HEAPF32[ptr >> 2];
            case "double":
              return HEAPF64[ptr >> 3];
            case "*":
              return HEAPU32[ptr >> 2];
            default:
              abort(`invalid type for getValue: ${type}`);
          }
        }
        var newDSO = (name3, handle2, syms) => {
          var dso = {
            refcount: Infinity,
            name: name3,
            exports: syms,
            global: true
          };
          LDSO.loadedLibsByName[name3] = dso;
          if (handle2 != void 0) {
            LDSO.loadedLibsByHandle[handle2] = dso;
          }
          return dso;
        };
        var LDSO = {
          loadedLibsByName: {},
          loadedLibsByHandle: {},
          init() {
            newDSO("__main__", 0, wasmImports);
          }
        };
        var ___heap_base = 73476080;
        var alignMemory = (size2, alignment) => {
          return Math.ceil(size2 / alignment) * alignment;
        };
        var getMemory = (size2) => {
          if (runtimeInitialized) {
            return _calloc(size2, 1);
          }
          var ret = ___heap_base;
          var end = ret + alignMemory(size2, 16);
          ___heap_base = end;
          GOT["__heap_base"].value = end;
          return ret;
        };
        var isInternalSym = (symName) => {
          return [
            "__cpp_exception",
            "__c_longjmp",
            "__wasm_apply_data_relocs",
            "__dso_handle",
            "__tls_size",
            "__tls_align",
            "__set_stack_limits",
            "_emscripten_tls_init",
            "__wasm_init_tls",
            "__wasm_call_ctors",
            "__start_em_asm",
            "__stop_em_asm",
            "__start_em_js",
            "__stop_em_js"
          ].includes(symName) || symName.startsWith("__em_js__");
        };
        var uleb128Encode = (n7, target) => {
          if (n7 < 128) {
            target.push(n7);
          } else {
            target.push(n7 % 128 | 128, n7 >> 7);
          }
        };
        var sigToWasmTypes = (sig) => {
          var typeNames = {
            "i": "i32",
            "j": "i64",
            "f": "f32",
            "d": "f64",
            "e": "externref",
            "p": "i32"
          };
          var type = {
            parameters: [],
            results: sig[0] == "v" ? [] : [typeNames[sig[0]]]
          };
          for (var i8 = 1; i8 < sig.length; ++i8) {
            type.parameters.push(typeNames[sig[i8]]);
          }
          return type;
        };
        var generateFuncType = (sig, target) => {
          var sigRet = sig.slice(0, 1);
          var sigParam = sig.slice(1);
          var typeCodes = {
            "i": 127,
            // i32
            "p": 127,
            // i32
            "j": 126,
            // i64
            "f": 125,
            // f32
            "d": 124,
            // f64
            "e": 111
            // externref
          };
          target.push(
            96
            /* form: func */
          );
          uleb128Encode(sigParam.length, target);
          for (var i8 = 0; i8 < sigParam.length; ++i8) {
            target.push(typeCodes[sigParam[i8]]);
          }
          if (sigRet == "v") {
            target.push(0);
          } else {
            target.push(1, typeCodes[sigRet]);
          }
        };
        var convertJsFunctionToWasm = (func2, sig) => {
          if (typeof WebAssembly.Function == "function") {
            return new WebAssembly.Function(sigToWasmTypes(sig), func2);
          }
          var typeSectionBody = [
            1
            // count: 1
          ];
          generateFuncType(sig, typeSectionBody);
          var bytes2 = [
            0,
            97,
            115,
            109,
            // magic ("\0asm")
            1,
            0,
            0,
            0,
            // version: 1
            1
            // Type section code
          ];
          uleb128Encode(typeSectionBody.length, bytes2);
          bytes2.push(...typeSectionBody);
          bytes2.push(
            2,
            7,
            // import section
            // (import "e" "f" (func 0 (type 0)))
            1,
            1,
            101,
            1,
            102,
            0,
            0,
            7,
            5,
            // export section
            // (export "f" (func 0 (type 0)))
            1,
            1,
            102,
            0,
            0
          );
          var module2 = new WebAssembly.Module(new Uint8Array(bytes2));
          var instance2 = new WebAssembly.Instance(module2, { "e": { "f": func2 } });
          var wrappedFunc = instance2.exports["f"];
          return wrappedFunc;
        };
        var wasmTableMirror = [];
        var wasmTable = new WebAssembly.Table({
          "initial": 5358,
          "element": "anyfunc"
        });
        ;
        var getWasmTableEntry = (funcPtr) => {
          var func2 = wasmTableMirror[funcPtr];
          if (!func2) {
            if (funcPtr >= wasmTableMirror.length) wasmTableMirror.length = funcPtr + 1;
            wasmTableMirror[funcPtr] = func2 = wasmTable.get(funcPtr);
          }
          return func2;
        };
        var updateTableMap = (offset, count2) => {
          if (functionsInTableMap) {
            for (var i8 = offset; i8 < offset + count2; i8++) {
              var item = getWasmTableEntry(i8);
              if (item) {
                functionsInTableMap.set(item, i8);
              }
            }
          }
        };
        var functionsInTableMap;
        var getFunctionAddress = (func2) => {
          if (!functionsInTableMap) {
            functionsInTableMap = /* @__PURE__ */ new WeakMap();
            updateTableMap(0, wasmTable.length);
          }
          return functionsInTableMap.get(func2) || 0;
        };
        var freeTableIndexes = [];
        var getEmptyTableSlot = () => {
          if (freeTableIndexes.length) {
            return freeTableIndexes.pop();
          }
          try {
            wasmTable.grow(1);
          } catch (err3) {
            if (!(err3 instanceof RangeError)) {
              throw err3;
            }
            throw "Unable to grow wasm table. Set ALLOW_TABLE_GROWTH.";
          }
          return wasmTable.length - 1;
        };
        var setWasmTableEntry = (idx, func2) => {
          wasmTable.set(idx, func2);
          wasmTableMirror[idx] = wasmTable.get(idx);
        };
        var addFunction = (func2, sig) => {
          var rtn = getFunctionAddress(func2);
          if (rtn) {
            return rtn;
          }
          var ret = getEmptyTableSlot();
          try {
            setWasmTableEntry(ret, func2);
          } catch (err3) {
            if (!(err3 instanceof TypeError)) {
              throw err3;
            }
            var wrapped = convertJsFunctionToWasm(func2, sig);
            setWasmTableEntry(ret, wrapped);
          }
          functionsInTableMap.set(func2, ret);
          return ret;
        };
        var updateGOT = (exports2, replace) => {
          for (var symName in exports2) {
            if (isInternalSym(symName)) {
              continue;
            }
            var value = exports2[symName];
            GOT[symName] ||= new WebAssembly.Global({ "value": "i32", "mutable": true });
            if (replace || GOT[symName].value == 0) {
              if (typeof value == "function") {
                GOT[symName].value = addFunction(value);
              } else if (typeof value == "number") {
                GOT[symName].value = value;
              } else {
                err(`unhandled export type for '${symName}': ${typeof value}`);
              }
            }
          }
        };
        var relocateExports = (exports2, memoryBase2, replace) => {
          var relocated = {};
          for (var e6 in exports2) {
            var value = exports2[e6];
            if (typeof value == "object") {
              value = value.value;
            }
            if (typeof value == "number") {
              value += memoryBase2;
            }
            relocated[e6] = value;
          }
          updateGOT(relocated, replace);
          return relocated;
        };
        var isSymbolDefined = (symName) => {
          var existing = wasmImports[symName];
          if (!existing || existing.stub) {
            return false;
          }
          return true;
        };
        var dynCall = (sig, ptr, args2 = []) => {
          var rtn = getWasmTableEntry(ptr)(...args2);
          return rtn;
        };
        var stackSave = () => _emscripten_stack_get_current();
        var stackRestore = (val2) => __emscripten_stack_restore(val2);
        var createInvokeFunction = (sig) => (ptr, ...args2) => {
          var sp = stackSave();
          try {
            return dynCall(sig, ptr, args2);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
            if (sig[0] == "j") return 0n;
          }
        };
        var resolveGlobalSymbol = (symName, direct = false) => {
          var sym;
          if (isSymbolDefined(symName)) {
            sym = wasmImports[symName];
          } else if (symName.startsWith("invoke_")) {
            sym = wasmImports[symName] = createInvokeFunction(symName.split("_")[1]);
          }
          return { sym, name: symName };
        };
        var UTF8ToString = (ptr, maxBytesToRead) => {
          return ptr ? UTF8ArrayToString(HEAPU8, ptr, maxBytesToRead) : "";
        };
        var loadWebAssemblyModule = (binary, flags, libName, localScope, handle) => {
          var metadata = getDylinkMetadata(binary);
          currentModuleWeakSymbols = metadata.weakImports;
          function loadModule() {
            var firstLoad = !handle || !HEAP8[handle + 8];
            if (firstLoad) {
              var memAlign = Math.pow(2, metadata.memoryAlign);
              var memoryBase = metadata.memorySize ? alignMemory(getMemory(metadata.memorySize + memAlign), memAlign) : 0;
              var tableBase = metadata.tableSize ? wasmTable.length : 0;
              if (handle) {
                HEAP8[handle + 8] = 1;
                HEAPU32[handle + 12 >> 2] = memoryBase;
                HEAP32[handle + 16 >> 2] = metadata.memorySize;
                HEAPU32[handle + 20 >> 2] = tableBase;
                HEAP32[handle + 24 >> 2] = metadata.tableSize;
              }
            } else {
              memoryBase = HEAPU32[handle + 12 >> 2];
              tableBase = HEAPU32[handle + 20 >> 2];
            }
            var tableGrowthNeeded = tableBase + metadata.tableSize - wasmTable.length;
            if (tableGrowthNeeded > 0) {
              wasmTable.grow(tableGrowthNeeded);
            }
            var moduleExports;
            function resolveSymbol(sym) {
              var resolved = resolveGlobalSymbol(sym).sym;
              if (!resolved && localScope) {
                resolved = localScope[sym];
              }
              if (!resolved) {
                resolved = moduleExports[sym];
              }
              return resolved;
            }
            var proxyHandler = {
              get(stubs, prop) {
                switch (prop) {
                  case "__memory_base":
                    return memoryBase;
                  case "__table_base":
                    return tableBase;
                }
                if (prop in wasmImports && !wasmImports[prop].stub) {
                  return wasmImports[prop];
                }
                if (!(prop in stubs)) {
                  var resolved;
                  stubs[prop] = (...args2) => {
                    resolved ||= resolveSymbol(prop);
                    return resolved(...args2);
                  };
                }
                return stubs[prop];
              }
            };
            var proxy = new Proxy({}, proxyHandler);
            var info = {
              "GOT.mem": new Proxy({}, GOTHandler),
              "GOT.func": new Proxy({}, GOTHandler),
              "env": proxy,
              "wasi_snapshot_preview1": proxy
            };
            function postInstantiation(module, instance) {
              updateTableMap(tableBase, metadata.tableSize);
              moduleExports = relocateExports(instance.exports, memoryBase);
              if (!flags.allowUndefined) {
                reportUndefinedSymbols();
              }
              function addEmAsm(addr, body) {
                var args = [];
                var arity = 0;
                for (; arity < 16; arity++) {
                  if (body.indexOf("$" + arity) != -1) {
                    args.push("$" + arity);
                  } else {
                    break;
                  }
                }
                args = args.join(",");
                var func = `(${args}) => { ${body} };`;
                ASM_CONSTS[start] = eval(func);
              }
              if ("__start_em_asm" in moduleExports) {
                var start = moduleExports["__start_em_asm"];
                var stop = moduleExports["__stop_em_asm"];
                while (start < stop) {
                  var jsString = UTF8ToString(start);
                  addEmAsm(start, jsString);
                  start = HEAPU8.indexOf(0, start) + 1;
                }
              }
              function addEmJs(name, cSig, body) {
                var jsArgs = [];
                cSig = cSig.slice(1, -1);
                if (cSig != "void") {
                  cSig = cSig.split(",");
                  for (var i in cSig) {
                    var jsArg = cSig[i].split(" ").pop();
                    jsArgs.push(jsArg.replaceAll("*", ""));
                  }
                }
                var func = `(${jsArgs}) => ${body};`;
                moduleExports[name] = eval(func);
              }
              for (var name in moduleExports) {
                if (name.startsWith("__em_js__")) {
                  var start = moduleExports[name];
                  var jsString = UTF8ToString(start);
                  var parts = jsString.split("<::>");
                  addEmJs(name.replace("__em_js__", ""), parts[0], parts[1]);
                  delete moduleExports[name];
                }
              }
              var applyRelocs = moduleExports["__wasm_apply_data_relocs"];
              if (applyRelocs) {
                if (runtimeInitialized) {
                  applyRelocs();
                } else {
                  __RELOC_FUNCS__.push(applyRelocs);
                }
              }
              var init = moduleExports["__wasm_call_ctors"];
              if (init) {
                if (runtimeInitialized) {
                  init();
                } else {
                  __ATINIT__.push(init);
                }
              }
              return moduleExports;
            }
            if (flags.loadAsync) {
              if (binary instanceof WebAssembly.Module) {
                var instance = new WebAssembly.Instance(binary, info);
                return Promise.resolve(postInstantiation(binary, instance));
              }
              return WebAssembly.instantiate(binary, info).then(
                (result) => postInstantiation(result.module, result.instance)
              );
            }
            var module = binary instanceof WebAssembly.Module ? binary : new WebAssembly.Module(binary);
            var instance = new WebAssembly.Instance(module, info);
            return postInstantiation(module, instance);
          }
          if (flags.loadAsync) {
            return metadata.neededDynlibs.reduce((chain2, dynNeeded) => chain2.then(
              () => loadDynamicLibrary(dynNeeded, flags, localScope)
            ), Promise.resolve()).then(loadModule);
          }
          metadata.neededDynlibs.forEach((needed) => loadDynamicLibrary(needed, flags, localScope));
          return loadModule();
        };
        var mergeLibSymbols = (exports2, libName2) => {
          for (var [sym, exp] of Object.entries(exports2)) {
            const setImport = (target) => {
              if (!isSymbolDefined(target)) {
                wasmImports[target] = exp;
              }
            };
            setImport(sym);
            const main_alias = "__main_argc_argv";
            if (sym == "main") {
              setImport(main_alias);
            }
            if (sym == main_alias) {
              setImport("main");
            }
          }
        };
        var asyncLoad = (url, onload, onerror, noRunDep) => {
          var dep = !noRunDep ? getUniqueRunDependency(`al ${url}`) : "";
          readAsync(url).then(
            (arrayBuffer) => {
              onload(new Uint8Array(arrayBuffer));
              if (dep) removeRunDependency(dep);
            },
            (err3) => {
              if (onerror) {
                onerror();
              } else {
                throw `Loading data file "${url}" failed.`;
              }
            }
          );
          if (dep) addRunDependency(dep);
        };
        var preloadPlugins = Module["preloadPlugins"] || [];
        var registerWasmPlugin = () => {
          var wasmPlugin = {
            "promiseChainEnd": Promise.resolve(),
            "canHandle": (name3) => {
              return !Module["noWasmDecoding"] && name3.endsWith(".so");
            },
            "handle": (byteArray, name3, onload, onerror) => {
              wasmPlugin["promiseChainEnd"] = wasmPlugin["promiseChainEnd"].then(
                () => loadWebAssemblyModule(byteArray, { loadAsync: true, nodelete: true }, name3, {})
              ).then(
                (exports2) => {
                  preloadedWasm[name3] = exports2;
                  onload(byteArray);
                },
                (error2) => {
                  err(`failed to instantiate wasm: ${name3}: ${error2}`);
                  onerror();
                }
              );
            }
          };
          preloadPlugins.push(wasmPlugin);
        };
        var preloadedWasm = {};
        function loadDynamicLibrary(libName2, flags2 = { global: true, nodelete: true }, localScope2, handle2) {
          var dso = LDSO.loadedLibsByName[libName2];
          if (dso) {
            if (!flags2.global) {
              if (localScope2) {
                Object.assign(localScope2, dso.exports);
              }
            } else if (!dso.global) {
              dso.global = true;
              mergeLibSymbols(dso.exports, libName2);
            }
            if (flags2.nodelete && dso.refcount !== Infinity) {
              dso.refcount = Infinity;
            }
            dso.refcount++;
            if (handle2) {
              LDSO.loadedLibsByHandle[handle2] = dso;
            }
            return flags2.loadAsync ? Promise.resolve(true) : true;
          }
          dso = newDSO(libName2, handle2, "loading");
          dso.refcount = flags2.nodelete ? Infinity : 1;
          dso.global = flags2.global;
          function loadLibData() {
            if (handle2) {
              var data = HEAPU32[handle2 + 28 >> 2];
              var dataSize = HEAPU32[handle2 + 32 >> 2];
              if (data && dataSize) {
                var libData = HEAP8.slice(data, data + dataSize);
                return flags2.loadAsync ? Promise.resolve(libData) : libData;
              }
            }
            var libFile = locateFile(libName2);
            if (flags2.loadAsync) {
              return new Promise((resolve2, reject) => asyncLoad(libFile, resolve2, reject));
            }
            if (!readBinary) {
              throw new Error(`${libFile}: file not found, and synchronous loading of external files is not available`);
            }
            return readBinary(libFile);
          }
          function getExports() {
            var preloaded = preloadedWasm[libName2];
            if (preloaded) {
              return flags2.loadAsync ? Promise.resolve(preloaded) : preloaded;
            }
            if (flags2.loadAsync) {
              return loadLibData().then((libData) => loadWebAssemblyModule(libData, flags2, libName2, localScope2, handle2));
            }
            return loadWebAssemblyModule(loadLibData(), flags2, libName2, localScope2, handle2);
          }
          function moduleLoaded(exports2) {
            if (dso.global) {
              mergeLibSymbols(exports2, libName2);
            } else if (localScope2) {
              Object.assign(localScope2, exports2);
            }
            dso.exports = exports2;
          }
          if (flags2.loadAsync) {
            return getExports().then((exports2) => {
              moduleLoaded(exports2);
              return true;
            });
          }
          moduleLoaded(getExports());
          return true;
        }
        var reportUndefinedSymbols = () => {
          for (var [symName, entry] of Object.entries(GOT)) {
            if (entry.value == 0) {
              var value = resolveGlobalSymbol(symName, true).sym;
              if (!value && !entry.required) {
                continue;
              }
              if (typeof value == "function") {
                entry.value = addFunction(value, value.sig);
              } else if (typeof value == "number") {
                entry.value = value;
              } else {
                throw new Error(`bad export type for '${symName}': ${typeof value}`);
              }
            }
          }
        };
        var loadDylibs = () => {
          if (!dynamicLibraries.length) {
            reportUndefinedSymbols();
            return;
          }
          addRunDependency("loadDylibs");
          dynamicLibraries.reduce((chain2, lib) => chain2.then(
            () => loadDynamicLibrary(lib, { loadAsync: true, global: true, nodelete: true, allowUndefined: true })
          ), Promise.resolve()).then(() => {
            reportUndefinedSymbols();
            removeRunDependency("loadDylibs");
          });
        };
        var noExitRuntime = Module["noExitRuntime"] || true;
        function setValue(ptr, value, type = "i8") {
          if (type.endsWith("*")) type = "*";
          switch (type) {
            case "i1":
              HEAP8[ptr] = value;
              break;
            case "i8":
              HEAP8[ptr] = value;
              break;
            case "i16":
              HEAP16[ptr >> 1] = value;
              break;
            case "i32":
              HEAP32[ptr >> 2] = value;
              break;
            case "i64":
              HEAP64[ptr >> 3] = BigInt(value);
              break;
            case "float":
              HEAPF32[ptr >> 2] = value;
              break;
            case "double":
              HEAPF64[ptr >> 3] = value;
              break;
            case "*":
              HEAPU32[ptr >> 2] = value;
              break;
            default:
              abort(`invalid type for setValue: ${type}`);
          }
        }
        var ___assert_fail = (condition, filename, line2, func2) => {
          abort(`Assertion failed: ${UTF8ToString(condition)}, at: ` + [filename ? UTF8ToString(filename) : "unknown filename", line2, func2 ? UTF8ToString(func2) : "unknown function"]);
        };
        ___assert_fail.sig = "vppip";
        var ___call_sighandler = (fp, sig) => getWasmTableEntry(fp)(sig);
        ___call_sighandler.sig = "vpi";
        var ___memory_base = new WebAssembly.Global({ "value": "i32", "mutable": false }, 67108864);
        var ___stack_pointer = new WebAssembly.Global({ "value": "i32", "mutable": true }, 73476080);
        var PATH = {
          isAbs: (path3) => path3.charAt(0) === "/",
          splitPath: (filename) => {
            var splitPathRe = /^(\/?|)([\s\S]*?)((?:\.{1,2}|[^\/]+?|)(\.[^.\/]*|))(?:[\/]*)$/;
            return splitPathRe.exec(filename).slice(1);
          },
          normalizeArray: (parts2, allowAboveRoot) => {
            var up = 0;
            for (var i8 = parts2.length - 1; i8 >= 0; i8--) {
              var last = parts2[i8];
              if (last === ".") {
                parts2.splice(i8, 1);
              } else if (last === "..") {
                parts2.splice(i8, 1);
                up++;
              } else if (up) {
                parts2.splice(i8, 1);
                up--;
              }
            }
            if (allowAboveRoot) {
              for (; up; up--) {
                parts2.unshift("..");
              }
            }
            return parts2;
          },
          normalize: (path3) => {
            var isAbsolute = PATH.isAbs(path3), trailingSlash = path3.substr(-1) === "/";
            path3 = PATH.normalizeArray(path3.split("/").filter((p11) => !!p11), !isAbsolute).join("/");
            if (!path3 && !isAbsolute) {
              path3 = ".";
            }
            if (path3 && trailingSlash) {
              path3 += "/";
            }
            return (isAbsolute ? "/" : "") + path3;
          },
          dirname: (path3) => {
            var result = PATH.splitPath(path3), root = result[0], dir = result[1];
            if (!root && !dir) {
              return ".";
            }
            if (dir) {
              dir = dir.substr(0, dir.length - 1);
            }
            return root + dir;
          },
          basename: (path3) => {
            if (path3 === "/") return "/";
            path3 = PATH.normalize(path3);
            path3 = path3.replace(/\/$/, "");
            var lastSlash = path3.lastIndexOf("/");
            if (lastSlash === -1) return path3;
            return path3.substr(lastSlash + 1);
          },
          join: (...paths) => PATH.normalize(paths.join("/")),
          join2: (l7, r6) => PATH.normalize(l7 + "/" + r6)
        };
        var initRandomFill = () => {
          if (typeof crypto == "object" && typeof crypto["getRandomValues"] == "function") {
            return (view5) => crypto.getRandomValues(view5);
          } else if (ENVIRONMENT_IS_NODE) {
            try {
              var crypto_module = require("crypto");
              var randomFillSync = crypto_module["randomFillSync"];
              if (randomFillSync) {
                return (view5) => crypto_module["randomFillSync"](view5);
              }
              var randomBytes = crypto_module["randomBytes"];
              return (view5) => (view5.set(randomBytes(view5.byteLength)), // Return the original view to match modern native implementations.
              view5);
            } catch (e6) {
            }
          }
          abort("initRandomDevice");
        };
        var randomFill = (view5) => {
          return (randomFill = initRandomFill())(view5);
        };
        var PATH_FS = {
          resolve: (...args2) => {
            var resolvedPath2 = "", resolvedAbsolute = false;
            for (var i8 = args2.length - 1; i8 >= -1 && !resolvedAbsolute; i8--) {
              var path3 = i8 >= 0 ? args2[i8] : FS.cwd();
              if (typeof path3 != "string") {
                throw new TypeError("Arguments to path.resolve must be strings");
              } else if (!path3) {
                return "";
              }
              resolvedPath2 = path3 + "/" + resolvedPath2;
              resolvedAbsolute = PATH.isAbs(path3);
            }
            resolvedPath2 = PATH.normalizeArray(resolvedPath2.split("/").filter((p11) => !!p11), !resolvedAbsolute).join("/");
            return (resolvedAbsolute ? "/" : "") + resolvedPath2 || ".";
          },
          relative: (from, to3) => {
            from = PATH_FS.resolve(from).substr(1);
            to3 = PATH_FS.resolve(to3).substr(1);
            function trim(arr) {
              var start2 = 0;
              for (; start2 < arr.length; start2++) {
                if (arr[start2] !== "") break;
              }
              var end = arr.length - 1;
              for (; end >= 0; end--) {
                if (arr[end] !== "") break;
              }
              if (start2 > end) return [];
              return arr.slice(start2, end - start2 + 1);
            }
            var fromParts = trim(from.split("/"));
            var toParts = trim(to3.split("/"));
            var length = Math.min(fromParts.length, toParts.length);
            var samePartsLength = length;
            for (var i8 = 0; i8 < length; i8++) {
              if (fromParts[i8] !== toParts[i8]) {
                samePartsLength = i8;
                break;
              }
            }
            var outputParts = [];
            for (var i8 = samePartsLength; i8 < fromParts.length; i8++) {
              outputParts.push("..");
            }
            outputParts = outputParts.concat(toParts.slice(samePartsLength));
            return outputParts.join("/");
          }
        };
        var FS_stdin_getChar_buffer = [];
        var lengthBytesUTF8 = (str) => {
          var len = 0;
          for (var i8 = 0; i8 < str.length; ++i8) {
            var c6 = str.charCodeAt(i8);
            if (c6 <= 127) {
              len++;
            } else if (c6 <= 2047) {
              len += 2;
            } else if (c6 >= 55296 && c6 <= 57343) {
              len += 4;
              ++i8;
            } else {
              len += 3;
            }
          }
          return len;
        };
        var stringToUTF8Array = (str, heap, outIdx, maxBytesToWrite) => {
          if (!(maxBytesToWrite > 0))
            return 0;
          var startIdx = outIdx;
          var endIdx = outIdx + maxBytesToWrite - 1;
          for (var i8 = 0; i8 < str.length; ++i8) {
            var u7 = str.charCodeAt(i8);
            if (u7 >= 55296 && u7 <= 57343) {
              var u1 = str.charCodeAt(++i8);
              u7 = 65536 + ((u7 & 1023) << 10) | u1 & 1023;
            }
            if (u7 <= 127) {
              if (outIdx >= endIdx) break;
              heap[outIdx++] = u7;
            } else if (u7 <= 2047) {
              if (outIdx + 1 >= endIdx) break;
              heap[outIdx++] = 192 | u7 >> 6;
              heap[outIdx++] = 128 | u7 & 63;
            } else if (u7 <= 65535) {
              if (outIdx + 2 >= endIdx) break;
              heap[outIdx++] = 224 | u7 >> 12;
              heap[outIdx++] = 128 | u7 >> 6 & 63;
              heap[outIdx++] = 128 | u7 & 63;
            } else {
              if (outIdx + 3 >= endIdx) break;
              heap[outIdx++] = 240 | u7 >> 18;
              heap[outIdx++] = 128 | u7 >> 12 & 63;
              heap[outIdx++] = 128 | u7 >> 6 & 63;
              heap[outIdx++] = 128 | u7 & 63;
            }
          }
          heap[outIdx] = 0;
          return outIdx - startIdx;
        };
        function intArrayFromString(stringy, dontAddNull, length) {
          var len = length > 0 ? length : lengthBytesUTF8(stringy) + 1;
          var u8array = new Array(len);
          var numBytesWritten = stringToUTF8Array(stringy, u8array, 0, u8array.length);
          if (dontAddNull) u8array.length = numBytesWritten;
          return u8array;
        }
        var FS_stdin_getChar = () => {
          if (!FS_stdin_getChar_buffer.length) {
            var result = null;
            if (ENVIRONMENT_IS_NODE) {
              var BUFSIZE = 256;
              var buf = Buffer.alloc(BUFSIZE);
              var bytesRead = 0;
              var fd = process.stdin.fd;
              try {
                bytesRead = fs.readSync(fd, buf, 0, BUFSIZE);
              } catch (e6) {
                if (e6.toString().includes("EOF")) bytesRead = 0;
                else throw e6;
              }
              if (bytesRead > 0) {
                result = buf.slice(0, bytesRead).toString("utf-8");
              }
            } else if (typeof window != "undefined" && typeof window.prompt == "function") {
              result = window.prompt("Input: ");
              if (result !== null) {
                result += "\n";
              }
            } else {
            }
            if (!result) {
              return null;
            }
            FS_stdin_getChar_buffer = intArrayFromString(result, true);
          }
          return FS_stdin_getChar_buffer.shift();
        };
        var TTY = {
          ttys: [],
          init() {
          },
          shutdown() {
          },
          register(dev, ops) {
            TTY.ttys[dev] = { input: [], output: [], ops };
            FS.registerDevice(dev, TTY.stream_ops);
          },
          stream_ops: {
            open(stream) {
              var tty2 = TTY.ttys[stream.node.rdev];
              if (!tty2) {
                throw new FS.ErrnoError(43);
              }
              stream.tty = tty2;
              stream.seekable = false;
            },
            close(stream) {
              stream.tty.ops.fsync(stream.tty);
            },
            fsync(stream) {
              stream.tty.ops.fsync(stream.tty);
            },
            read(stream, buffer2, offset, length, pos) {
              if (!stream.tty || !stream.tty.ops.get_char) {
                throw new FS.ErrnoError(60);
              }
              var bytesRead = 0;
              for (var i8 = 0; i8 < length; i8++) {
                var result;
                try {
                  result = stream.tty.ops.get_char(stream.tty);
                } catch (e6) {
                  throw new FS.ErrnoError(29);
                }
                if (result === void 0 && bytesRead === 0) {
                  throw new FS.ErrnoError(6);
                }
                if (result === null || result === void 0) break;
                bytesRead++;
                buffer2[offset + i8] = result;
              }
              if (bytesRead) {
                stream.node.timestamp = Date.now();
              }
              return bytesRead;
            },
            write(stream, buffer2, offset, length, pos) {
              if (!stream.tty || !stream.tty.ops.put_char) {
                throw new FS.ErrnoError(60);
              }
              try {
                for (var i8 = 0; i8 < length; i8++) {
                  stream.tty.ops.put_char(stream.tty, buffer2[offset + i8]);
                }
              } catch (e6) {
                throw new FS.ErrnoError(29);
              }
              if (length) {
                stream.node.timestamp = Date.now();
              }
              return i8;
            }
          },
          default_tty_ops: {
            get_char(tty2) {
              return FS_stdin_getChar();
            },
            put_char(tty2, val2) {
              if (val2 === null || val2 === 10) {
                out(UTF8ArrayToString(tty2.output, 0));
                tty2.output = [];
              } else {
                if (val2 != 0) tty2.output.push(val2);
              }
            },
            fsync(tty2) {
              if (tty2.output && tty2.output.length > 0) {
                out(UTF8ArrayToString(tty2.output, 0));
                tty2.output = [];
              }
            },
            ioctl_tcgets(tty2) {
              return {
                c_iflag: 25856,
                c_oflag: 5,
                c_cflag: 191,
                c_lflag: 35387,
                c_cc: [
                  3,
                  28,
                  127,
                  21,
                  4,
                  0,
                  1,
                  0,
                  17,
                  19,
                  26,
                  0,
                  18,
                  15,
                  23,
                  22,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0,
                  0
                ]
              };
            },
            ioctl_tcsets(tty2, optional_actions, data) {
              return 0;
            },
            ioctl_tiocgwinsz(tty2) {
              return [24, 80];
            }
          },
          default_tty1_ops: {
            put_char(tty2, val2) {
              if (val2 === null || val2 === 10) {
                err(UTF8ArrayToString(tty2.output, 0));
                tty2.output = [];
              } else {
                if (val2 != 0) tty2.output.push(val2);
              }
            },
            fsync(tty2) {
              if (tty2.output && tty2.output.length > 0) {
                err(UTF8ArrayToString(tty2.output, 0));
                tty2.output = [];
              }
            }
          }
        };
        var zeroMemory = (address, size2) => {
          HEAPU8.fill(0, address, address + size2);
          return address;
        };
        var mmapAlloc = (size2) => {
          size2 = alignMemory(size2, 65536);
          var ptr = _emscripten_builtin_memalign(65536, size2);
          if (!ptr) return 0;
          return zeroMemory(ptr, size2);
        };
        var MEMFS = {
          ops_table: null,
          mount(mount) {
            return MEMFS.createNode(null, "/", 16384 | 511, 0);
          },
          createNode(parent, name3, mode, dev) {
            if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
              throw new FS.ErrnoError(63);
            }
            MEMFS.ops_table ||= {
              dir: {
                node: {
                  getattr: MEMFS.node_ops.getattr,
                  setattr: MEMFS.node_ops.setattr,
                  lookup: MEMFS.node_ops.lookup,
                  mknod: MEMFS.node_ops.mknod,
                  rename: MEMFS.node_ops.rename,
                  unlink: MEMFS.node_ops.unlink,
                  rmdir: MEMFS.node_ops.rmdir,
                  readdir: MEMFS.node_ops.readdir,
                  symlink: MEMFS.node_ops.symlink
                },
                stream: {
                  llseek: MEMFS.stream_ops.llseek
                }
              },
              file: {
                node: {
                  getattr: MEMFS.node_ops.getattr,
                  setattr: MEMFS.node_ops.setattr
                },
                stream: {
                  llseek: MEMFS.stream_ops.llseek,
                  read: MEMFS.stream_ops.read,
                  write: MEMFS.stream_ops.write,
                  allocate: MEMFS.stream_ops.allocate,
                  mmap: MEMFS.stream_ops.mmap,
                  msync: MEMFS.stream_ops.msync
                }
              },
              link: {
                node: {
                  getattr: MEMFS.node_ops.getattr,
                  setattr: MEMFS.node_ops.setattr,
                  readlink: MEMFS.node_ops.readlink
                },
                stream: {}
              },
              chrdev: {
                node: {
                  getattr: MEMFS.node_ops.getattr,
                  setattr: MEMFS.node_ops.setattr
                },
                stream: FS.chrdev_stream_ops
              }
            };
            var node = FS.createNode(parent, name3, mode, dev);
            if (FS.isDir(node.mode)) {
              node.node_ops = MEMFS.ops_table.dir.node;
              node.stream_ops = MEMFS.ops_table.dir.stream;
              node.contents = {};
            } else if (FS.isFile(node.mode)) {
              node.node_ops = MEMFS.ops_table.file.node;
              node.stream_ops = MEMFS.ops_table.file.stream;
              node.usedBytes = 0;
              node.contents = null;
            } else if (FS.isLink(node.mode)) {
              node.node_ops = MEMFS.ops_table.link.node;
              node.stream_ops = MEMFS.ops_table.link.stream;
            } else if (FS.isChrdev(node.mode)) {
              node.node_ops = MEMFS.ops_table.chrdev.node;
              node.stream_ops = MEMFS.ops_table.chrdev.stream;
            }
            node.timestamp = Date.now();
            if (parent) {
              parent.contents[name3] = node;
              parent.timestamp = node.timestamp;
            }
            return node;
          },
          getFileDataAsTypedArray(node) {
            if (!node.contents) return new Uint8Array(0);
            if (node.contents.subarray) return node.contents.subarray(0, node.usedBytes);
            return new Uint8Array(node.contents);
          },
          expandFileStorage(node, newCapacity) {
            var prevCapacity = node.contents ? node.contents.length : 0;
            if (prevCapacity >= newCapacity) return;
            var CAPACITY_DOUBLING_MAX = 1024 * 1024;
            newCapacity = Math.max(newCapacity, prevCapacity * (prevCapacity < CAPACITY_DOUBLING_MAX ? 2 : 1.125) >>> 0);
            if (prevCapacity != 0) newCapacity = Math.max(newCapacity, 256);
            var oldContents = node.contents;
            node.contents = new Uint8Array(newCapacity);
            if (node.usedBytes > 0) node.contents.set(oldContents.subarray(0, node.usedBytes), 0);
          },
          resizeFileStorage(node, newSize) {
            if (node.usedBytes == newSize) return;
            if (newSize == 0) {
              node.contents = null;
              node.usedBytes = 0;
            } else {
              var oldContents = node.contents;
              node.contents = new Uint8Array(newSize);
              if (oldContents) {
                node.contents.set(oldContents.subarray(0, Math.min(newSize, node.usedBytes)));
              }
              node.usedBytes = newSize;
            }
          },
          node_ops: {
            getattr(node) {
              var attr = {};
              attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
              attr.ino = node.id;
              attr.mode = node.mode;
              attr.nlink = 1;
              attr.uid = 0;
              attr.gid = 0;
              attr.rdev = node.rdev;
              if (FS.isDir(node.mode)) {
                attr.size = 4096;
              } else if (FS.isFile(node.mode)) {
                attr.size = node.usedBytes;
              } else if (FS.isLink(node.mode)) {
                attr.size = node.link.length;
              } else {
                attr.size = 0;
              }
              attr.atime = new Date(node.timestamp);
              attr.mtime = new Date(node.timestamp);
              attr.ctime = new Date(node.timestamp);
              attr.blksize = 4096;
              attr.blocks = Math.ceil(attr.size / attr.blksize);
              return attr;
            },
            setattr(node, attr) {
              if (attr.mode !== void 0) {
                node.mode = attr.mode;
              }
              if (attr.timestamp !== void 0) {
                node.timestamp = attr.timestamp;
              }
              if (attr.size !== void 0) {
                MEMFS.resizeFileStorage(node, attr.size);
              }
            },
            lookup(parent, name3) {
              throw FS.genericErrors[44];
            },
            mknod(parent, name3, mode, dev) {
              return MEMFS.createNode(parent, name3, mode, dev);
            },
            rename(old_node, new_dir, new_name) {
              if (FS.isDir(old_node.mode)) {
                var new_node;
                try {
                  new_node = FS.lookupNode(new_dir, new_name);
                } catch (e6) {
                }
                if (new_node) {
                  for (var i8 in new_node.contents) {
                    throw new FS.ErrnoError(55);
                  }
                }
              }
              delete old_node.parent.contents[old_node.name];
              old_node.parent.timestamp = Date.now();
              old_node.name = new_name;
              new_dir.contents[new_name] = old_node;
              new_dir.timestamp = old_node.parent.timestamp;
            },
            unlink(parent, name3) {
              delete parent.contents[name3];
              parent.timestamp = Date.now();
            },
            rmdir(parent, name3) {
              var node = FS.lookupNode(parent, name3);
              for (var i8 in node.contents) {
                throw new FS.ErrnoError(55);
              }
              delete parent.contents[name3];
              parent.timestamp = Date.now();
            },
            readdir(node) {
              var entries = [".", ".."];
              for (var key of Object.keys(node.contents)) {
                entries.push(key);
              }
              return entries;
            },
            symlink(parent, newname, oldpath) {
              var node = MEMFS.createNode(parent, newname, 511 | 40960, 0);
              node.link = oldpath;
              return node;
            },
            readlink(node) {
              if (!FS.isLink(node.mode)) {
                throw new FS.ErrnoError(28);
              }
              return node.link;
            }
          },
          stream_ops: {
            read(stream, buffer2, offset, length, position) {
              var contents = stream.node.contents;
              if (position >= stream.node.usedBytes) return 0;
              var size2 = Math.min(stream.node.usedBytes - position, length);
              if (size2 > 8 && contents.subarray) {
                buffer2.set(contents.subarray(position, position + size2), offset);
              } else {
                for (var i8 = 0; i8 < size2; i8++) buffer2[offset + i8] = contents[position + i8];
              }
              return size2;
            },
            write(stream, buffer2, offset, length, position, canOwn) {
              if (buffer2.buffer === HEAP8.buffer) {
                canOwn = false;
              }
              if (!length) return 0;
              var node = stream.node;
              node.timestamp = Date.now();
              if (buffer2.subarray && (!node.contents || node.contents.subarray)) {
                if (canOwn) {
                  node.contents = buffer2.subarray(offset, offset + length);
                  node.usedBytes = length;
                  return length;
                } else if (node.usedBytes === 0 && position === 0) {
                  node.contents = buffer2.slice(offset, offset + length);
                  node.usedBytes = length;
                  return length;
                } else if (position + length <= node.usedBytes) {
                  node.contents.set(buffer2.subarray(offset, offset + length), position);
                  return length;
                }
              }
              MEMFS.expandFileStorage(node, position + length);
              if (node.contents.subarray && buffer2.subarray) {
                node.contents.set(buffer2.subarray(offset, offset + length), position);
              } else {
                for (var i8 = 0; i8 < length; i8++) {
                  node.contents[position + i8] = buffer2[offset + i8];
                }
              }
              node.usedBytes = Math.max(node.usedBytes, position + length);
              return length;
            },
            llseek(stream, offset, whence) {
              var position = offset;
              if (whence === 1) {
                position += stream.position;
              } else if (whence === 2) {
                if (FS.isFile(stream.node.mode)) {
                  position += stream.node.usedBytes;
                }
              }
              if (position < 0) {
                throw new FS.ErrnoError(28);
              }
              return position;
            },
            allocate(stream, offset, length) {
              MEMFS.expandFileStorage(stream.node, offset + length);
              stream.node.usedBytes = Math.max(stream.node.usedBytes, offset + length);
            },
            mmap(stream, length, position, prot, flags2) {
              if (!FS.isFile(stream.node.mode)) {
                throw new FS.ErrnoError(43);
              }
              var ptr;
              var allocated;
              var contents = stream.node.contents;
              if (!(flags2 & 2) && contents && contents.buffer === HEAP8.buffer) {
                allocated = false;
                ptr = contents.byteOffset;
              } else {
                allocated = true;
                ptr = mmapAlloc(length);
                if (!ptr) {
                  throw new FS.ErrnoError(48);
                }
                if (contents) {
                  if (position > 0 || position + length < contents.length) {
                    if (contents.subarray) {
                      contents = contents.subarray(position, position + length);
                    } else {
                      contents = Array.prototype.slice.call(contents, position, position + length);
                    }
                  }
                  HEAP8.set(contents, ptr);
                }
              }
              return { ptr, allocated };
            },
            msync(stream, buffer2, offset, length, mmapFlags) {
              MEMFS.stream_ops.write(stream, buffer2, 0, length, offset, false);
              return 0;
            }
          }
        };
        var FS_createDataFile = (parent, name3, fileData, canRead, canWrite, canOwn) => {
          FS.createDataFile(parent, name3, fileData, canRead, canWrite, canOwn);
        };
        var FS_handledByPreloadPlugin = (byteArray, fullname, finish, onerror) => {
          if (typeof Browser != "undefined") Browser.init();
          var handled = false;
          preloadPlugins.forEach((plugin) => {
            if (handled) return;
            if (plugin["canHandle"](fullname)) {
              plugin["handle"](byteArray, fullname, finish, onerror);
              handled = true;
            }
          });
          return handled;
        };
        var FS_createPreloadedFile = (parent, name3, url, canRead, canWrite, onload, onerror, dontCreateFile, canOwn, preFinish) => {
          var fullname = name3 ? PATH_FS.resolve(PATH.join2(parent, name3)) : parent;
          var dep = getUniqueRunDependency(`cp ${fullname}`);
          function processData(byteArray) {
            function finish(byteArray2) {
              preFinish?.();
              if (!dontCreateFile) {
                FS_createDataFile(parent, name3, byteArray2, canRead, canWrite, canOwn);
              }
              onload?.();
              removeRunDependency(dep);
            }
            if (FS_handledByPreloadPlugin(byteArray, fullname, finish, () => {
              onerror?.();
              removeRunDependency(dep);
            })) {
              return;
            }
            finish(byteArray);
          }
          addRunDependency(dep);
          if (typeof url == "string") {
            asyncLoad(url, processData, onerror);
          } else {
            processData(url);
          }
        };
        var FS_modeStringToFlags = (str) => {
          var flagModes = {
            "r": 0,
            "r+": 2,
            "w": 512 | 64 | 1,
            "w+": 512 | 64 | 2,
            "a": 1024 | 64 | 1,
            "a+": 1024 | 64 | 2
          };
          var flags2 = flagModes[str];
          if (typeof flags2 == "undefined") {
            throw new Error(`Unknown file open mode: ${str}`);
          }
          return flags2;
        };
        var FS_getMode = (canRead, canWrite) => {
          var mode = 0;
          if (canRead) mode |= 292 | 73;
          if (canWrite) mode |= 146;
          return mode;
        };
        var IDBFS = {
          dbs: {},
          indexedDB: () => {
            if (typeof indexedDB != "undefined") return indexedDB;
            var ret = null;
            if (typeof window == "object") ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
            return ret;
          },
          DB_VERSION: 21,
          DB_STORE_NAME: "FILE_DATA",
          queuePersist: (mount) => {
            function onPersistComplete() {
              if (mount.idbPersistState === "again") startPersist();
              else mount.idbPersistState = 0;
            }
            function startPersist() {
              mount.idbPersistState = "idb";
              IDBFS.syncfs(
                mount,
                /*populate:*/
                false,
                onPersistComplete
              );
            }
            if (!mount.idbPersistState) {
              mount.idbPersistState = setTimeout(startPersist, 0);
            } else if (mount.idbPersistState === "idb") {
              mount.idbPersistState = "again";
            }
          },
          mount: (mount) => {
            var mnt = MEMFS.mount(mount);
            if (mount?.opts?.autoPersist) {
              mnt.idbPersistState = 0;
              var memfs_node_ops = mnt.node_ops;
              mnt.node_ops = Object.assign({}, mnt.node_ops);
              mnt.node_ops.mknod = (parent, name3, mode, dev) => {
                var node = memfs_node_ops.mknod(parent, name3, mode, dev);
                node.node_ops = mnt.node_ops;
                node.idbfs_mount = mnt.mount;
                node.memfs_stream_ops = node.stream_ops;
                node.stream_ops = Object.assign({}, node.stream_ops);
                node.stream_ops.write = (stream, buffer2, offset, length, position, canOwn) => {
                  stream.node.isModified = true;
                  return node.memfs_stream_ops.write(stream, buffer2, offset, length, position, canOwn);
                };
                node.stream_ops.close = (stream) => {
                  var n7 = stream.node;
                  if (n7.isModified) {
                    IDBFS.queuePersist(n7.idbfs_mount);
                    n7.isModified = false;
                  }
                  if (n7.memfs_stream_ops.close) return n7.memfs_stream_ops.close(stream);
                };
                return node;
              };
              mnt.node_ops.mkdir = (...args2) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.mkdir(...args2));
              mnt.node_ops.rmdir = (...args2) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.rmdir(...args2));
              mnt.node_ops.symlink = (...args2) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.symlink(...args2));
              mnt.node_ops.unlink = (...args2) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.unlink(...args2));
              mnt.node_ops.rename = (...args2) => (IDBFS.queuePersist(mnt.mount), memfs_node_ops.rename(...args2));
            }
            return mnt;
          },
          syncfs: (mount, populate, callback) => {
            IDBFS.getLocalSet(mount, (err3, local) => {
              if (err3) return callback(err3);
              IDBFS.getRemoteSet(mount, (err4, remote) => {
                if (err4) return callback(err4);
                var src = populate ? remote : local;
                var dst = populate ? local : remote;
                IDBFS.reconcile(src, dst, callback);
              });
            });
          },
          quit: () => {
            Object.values(IDBFS.dbs).forEach((value) => value.close());
            IDBFS.dbs = {};
          },
          getDB: (name3, callback) => {
            var db2 = IDBFS.dbs[name3];
            if (db2) {
              return callback(null, db2);
            }
            var req;
            try {
              req = IDBFS.indexedDB().open(name3, IDBFS.DB_VERSION);
            } catch (e6) {
              return callback(e6);
            }
            if (!req) {
              return callback("Unable to connect to IndexedDB");
            }
            req.onupgradeneeded = (e6) => {
              var db3 = (
                /** @type {IDBDatabase} */
                e6.target.result
              );
              var transaction = e6.target.transaction;
              var fileStore;
              if (db3.objectStoreNames.contains(IDBFS.DB_STORE_NAME)) {
                fileStore = transaction.objectStore(IDBFS.DB_STORE_NAME);
              } else {
                fileStore = db3.createObjectStore(IDBFS.DB_STORE_NAME);
              }
              if (!fileStore.indexNames.contains("timestamp")) {
                fileStore.createIndex("timestamp", "timestamp", { unique: false });
              }
            };
            req.onsuccess = () => {
              db2 = /** @type {IDBDatabase} */
              req.result;
              IDBFS.dbs[name3] = db2;
              callback(null, db2);
            };
            req.onerror = (e6) => {
              callback(e6.target.error);
              e6.preventDefault();
            };
          },
          getLocalSet: (mount, callback) => {
            var entries = {};
            function isRealDir(p11) {
              return p11 !== "." && p11 !== "..";
            }
            ;
            function toAbsolute(root) {
              return (p11) => PATH.join2(root, p11);
            }
            ;
            var check2 = FS.readdir(mount.mountpoint).filter(isRealDir).map(toAbsolute(mount.mountpoint));
            while (check2.length) {
              var path3 = check2.pop();
              var stat2;
              try {
                stat2 = FS.stat(path3);
              } catch (e6) {
                return callback(e6);
              }
              if (FS.isDir(stat2.mode)) {
                check2.push(...FS.readdir(path3).filter(isRealDir).map(toAbsolute(path3)));
              }
              entries[path3] = { "timestamp": stat2.mtime };
            }
            return callback(null, { type: "local", entries });
          },
          getRemoteSet: (mount, callback) => {
            var entries = {};
            IDBFS.getDB(mount.mountpoint, (err3, db2) => {
              if (err3) return callback(err3);
              try {
                var transaction = db2.transaction([IDBFS.DB_STORE_NAME], "readonly");
                transaction.onerror = (e6) => {
                  callback(e6.target.error);
                  e6.preventDefault();
                };
                var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
                var index7 = store.index("timestamp");
                index7.openKeyCursor().onsuccess = (event) => {
                  var cursor = event.target.result;
                  if (!cursor) {
                    return callback(null, { type: "remote", db: db2, entries });
                  }
                  entries[cursor.primaryKey] = { "timestamp": cursor.key };
                  cursor.continue();
                };
              } catch (e6) {
                return callback(e6);
              }
            });
          },
          loadLocalEntry: (path3, callback) => {
            var stat2, node;
            try {
              var lookup = FS.lookupPath(path3);
              node = lookup.node;
              stat2 = FS.stat(path3);
            } catch (e6) {
              return callback(e6);
            }
            if (FS.isDir(stat2.mode)) {
              return callback(null, { "timestamp": stat2.mtime, "mode": stat2.mode });
            } else if (FS.isFile(stat2.mode)) {
              node.contents = MEMFS.getFileDataAsTypedArray(node);
              return callback(null, { "timestamp": stat2.mtime, "mode": stat2.mode, "contents": node.contents });
            } else {
              return callback(new Error("node type not supported"));
            }
          },
          storeLocalEntry: (path3, entry, callback) => {
            try {
              if (FS.isDir(entry["mode"])) {
                FS.mkdirTree(path3, entry["mode"]);
              } else if (FS.isFile(entry["mode"])) {
                FS.writeFile(path3, entry["contents"], { canOwn: true });
              } else {
                return callback(new Error("node type not supported"));
              }
              FS.chmod(path3, entry["mode"]);
              FS.utime(path3, entry["timestamp"], entry["timestamp"]);
            } catch (e6) {
              return callback(e6);
            }
            callback(null);
          },
          removeLocalEntry: (path3, callback) => {
            try {
              var stat2 = FS.stat(path3);
              if (FS.isDir(stat2.mode)) {
                FS.rmdir(path3);
              } else if (FS.isFile(stat2.mode)) {
                FS.unlink(path3);
              }
            } catch (e6) {
              return callback(e6);
            }
            callback(null);
          },
          loadRemoteEntry: (store, path3, callback) => {
            var req = store.get(path3);
            req.onsuccess = (event) => callback(null, event.target.result);
            req.onerror = (e6) => {
              callback(e6.target.error);
              e6.preventDefault();
            };
          },
          storeRemoteEntry: (store, path3, entry, callback) => {
            try {
              var req = store.put(entry, path3);
            } catch (e6) {
              callback(e6);
              return;
            }
            req.onsuccess = (event) => callback();
            req.onerror = (e6) => {
              callback(e6.target.error);
              e6.preventDefault();
            };
          },
          removeRemoteEntry: (store, path3, callback) => {
            var req = store.delete(path3);
            req.onsuccess = (event) => callback();
            req.onerror = (e6) => {
              callback(e6.target.error);
              e6.preventDefault();
            };
          },
          reconcile: (src, dst, callback) => {
            var total = 0;
            var create = [];
            Object.keys(src.entries).forEach((key) => {
              var e6 = src.entries[key];
              var e22 = dst.entries[key];
              if (!e22 || e6["timestamp"].getTime() != e22["timestamp"].getTime()) {
                create.push(key);
                total++;
              }
            });
            var remove = [];
            Object.keys(dst.entries).forEach((key) => {
              if (!src.entries[key]) {
                remove.push(key);
                total++;
              }
            });
            if (!total) {
              return callback(null);
            }
            var errored = false;
            var db2 = src.type === "remote" ? src.db : dst.db;
            var transaction = db2.transaction([IDBFS.DB_STORE_NAME], "readwrite");
            var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
            function done(err3) {
              if (err3 && !errored) {
                errored = true;
                return callback(err3);
              }
            }
            ;
            transaction.onerror = transaction.onabort = (e6) => {
              done(e6.target.error);
              e6.preventDefault();
            };
            transaction.oncomplete = (e6) => {
              if (!errored) {
                callback(null);
              }
            };
            create.sort().forEach((path3) => {
              if (dst.type === "local") {
                IDBFS.loadRemoteEntry(store, path3, (err3, entry) => {
                  if (err3) return done(err3);
                  IDBFS.storeLocalEntry(path3, entry, done);
                });
              } else {
                IDBFS.loadLocalEntry(path3, (err3, entry) => {
                  if (err3) return done(err3);
                  IDBFS.storeRemoteEntry(store, path3, entry, done);
                });
              }
            });
            remove.sort().reverse().forEach((path3) => {
              if (dst.type === "local") {
                IDBFS.removeLocalEntry(path3, done);
              } else {
                IDBFS.removeRemoteEntry(store, path3, done);
              }
            });
          }
        };
        var ERRNO_CODES = {
          "EPERM": 63,
          "ENOENT": 44,
          "ESRCH": 71,
          "EINTR": 27,
          "EIO": 29,
          "ENXIO": 60,
          "E2BIG": 1,
          "ENOEXEC": 45,
          "EBADF": 8,
          "ECHILD": 12,
          "EAGAIN": 6,
          "EWOULDBLOCK": 6,
          "ENOMEM": 48,
          "EACCES": 2,
          "EFAULT": 21,
          "ENOTBLK": 105,
          "EBUSY": 10,
          "EEXIST": 20,
          "EXDEV": 75,
          "ENODEV": 43,
          "ENOTDIR": 54,
          "EISDIR": 31,
          "EINVAL": 28,
          "ENFILE": 41,
          "EMFILE": 33,
          "ENOTTY": 59,
          "ETXTBSY": 74,
          "EFBIG": 22,
          "ENOSPC": 51,
          "ESPIPE": 70,
          "EROFS": 69,
          "EMLINK": 34,
          "EPIPE": 64,
          "EDOM": 18,
          "ERANGE": 68,
          "ENOMSG": 49,
          "EIDRM": 24,
          "ECHRNG": 106,
          "EL2NSYNC": 156,
          "EL3HLT": 107,
          "EL3RST": 108,
          "ELNRNG": 109,
          "EUNATCH": 110,
          "ENOCSI": 111,
          "EL2HLT": 112,
          "EDEADLK": 16,
          "ENOLCK": 46,
          "EBADE": 113,
          "EBADR": 114,
          "EXFULL": 115,
          "ENOANO": 104,
          "EBADRQC": 103,
          "EBADSLT": 102,
          "EDEADLOCK": 16,
          "EBFONT": 101,
          "ENOSTR": 100,
          "ENODATA": 116,
          "ETIME": 117,
          "ENOSR": 118,
          "ENONET": 119,
          "ENOPKG": 120,
          "EREMOTE": 121,
          "ENOLINK": 47,
          "EADV": 122,
          "ESRMNT": 123,
          "ECOMM": 124,
          "EPROTO": 65,
          "EMULTIHOP": 36,
          "EDOTDOT": 125,
          "EBADMSG": 9,
          "ENOTUNIQ": 126,
          "EBADFD": 127,
          "EREMCHG": 128,
          "ELIBACC": 129,
          "ELIBBAD": 130,
          "ELIBSCN": 131,
          "ELIBMAX": 132,
          "ELIBEXEC": 133,
          "ENOSYS": 52,
          "ENOTEMPTY": 55,
          "ENAMETOOLONG": 37,
          "ELOOP": 32,
          "EOPNOTSUPP": 138,
          "EPFNOSUPPORT": 139,
          "ECONNRESET": 15,
          "ENOBUFS": 42,
          "EAFNOSUPPORT": 5,
          "EPROTOTYPE": 67,
          "ENOTSOCK": 57,
          "ENOPROTOOPT": 50,
          "ESHUTDOWN": 140,
          "ECONNREFUSED": 14,
          "EADDRINUSE": 3,
          "ECONNABORTED": 13,
          "ENETUNREACH": 40,
          "ENETDOWN": 38,
          "ETIMEDOUT": 73,
          "EHOSTDOWN": 142,
          "EHOSTUNREACH": 23,
          "EINPROGRESS": 26,
          "EALREADY": 7,
          "EDESTADDRREQ": 17,
          "EMSGSIZE": 35,
          "EPROTONOSUPPORT": 66,
          "ESOCKTNOSUPPORT": 137,
          "EADDRNOTAVAIL": 4,
          "ENETRESET": 39,
          "EISCONN": 30,
          "ENOTCONN": 53,
          "ETOOMANYREFS": 141,
          "EUSERS": 136,
          "EDQUOT": 19,
          "ESTALE": 72,
          "ENOTSUP": 138,
          "ENOMEDIUM": 148,
          "EILSEQ": 25,
          "EOVERFLOW": 61,
          "ECANCELED": 11,
          "ENOTRECOVERABLE": 56,
          "EOWNERDEAD": 62,
          "ESTRPIPE": 135
        };
        var NODEFS = {
          isWindows: false,
          staticInit() {
            NODEFS.isWindows = !!process.platform.match(/^win/);
            var flags2 = process.binding("constants");
            if (flags2["fs"]) {
              flags2 = flags2["fs"];
            }
            NODEFS.flagsForNodeMap = {
              "1024": flags2["O_APPEND"],
              "64": flags2["O_CREAT"],
              "128": flags2["O_EXCL"],
              "256": flags2["O_NOCTTY"],
              "0": flags2["O_RDONLY"],
              "2": flags2["O_RDWR"],
              "4096": flags2["O_SYNC"],
              "512": flags2["O_TRUNC"],
              "1": flags2["O_WRONLY"],
              "131072": flags2["O_NOFOLLOW"]
            };
          },
          convertNodeCode(e6) {
            var code = e6.code;
            return ERRNO_CODES[code];
          },
          tryFSOperation(f9) {
            try {
              return f9();
            } catch (e6) {
              if (!e6.code) throw e6;
              if (e6.code === "UNKNOWN") throw new FS.ErrnoError(28);
              throw new FS.ErrnoError(NODEFS.convertNodeCode(e6));
            }
          },
          mount(mount) {
            return NODEFS.createNode(null, "/", NODEFS.getMode(mount.opts.root), 0);
          },
          createNode(parent, name3, mode, dev) {
            if (!FS.isDir(mode) && !FS.isFile(mode) && !FS.isLink(mode)) {
              throw new FS.ErrnoError(28);
            }
            var node = FS.createNode(parent, name3, mode);
            node.node_ops = NODEFS.node_ops;
            node.stream_ops = NODEFS.stream_ops;
            return node;
          },
          getMode(path3) {
            var stat2;
            return NODEFS.tryFSOperation(() => {
              stat2 = fs.lstatSync(path3);
              if (NODEFS.isWindows) {
                stat2.mode |= (stat2.mode & 292) >> 2;
              }
              return stat2.mode;
            });
          },
          realPath(node) {
            var parts2 = [];
            while (node.parent !== node) {
              parts2.push(node.name);
              node = node.parent;
            }
            parts2.push(node.mount.opts.root);
            parts2.reverse();
            return PATH.join(...parts2);
          },
          flagsForNode(flags2) {
            flags2 &= ~2097152;
            flags2 &= ~2048;
            flags2 &= ~32768;
            flags2 &= ~524288;
            flags2 &= ~65536;
            var newFlags = 0;
            for (var k9 in NODEFS.flagsForNodeMap) {
              if (flags2 & k9) {
                newFlags |= NODEFS.flagsForNodeMap[k9];
                flags2 ^= k9;
              }
            }
            if (flags2) {
              throw new FS.ErrnoError(28);
            }
            return newFlags;
          },
          node_ops: {
            getattr(node) {
              var path3 = NODEFS.realPath(node);
              var stat2;
              NODEFS.tryFSOperation(() => stat2 = fs.lstatSync(path3));
              if (NODEFS.isWindows) {
                if (!stat2.blksize) {
                  stat2.blksize = 4096;
                }
                if (!stat2.blocks) {
                  stat2.blocks = (stat2.size + stat2.blksize - 1) / stat2.blksize | 0;
                }
                stat2.mode |= (stat2.mode & 292) >> 2;
              }
              return {
                dev: stat2.dev,
                ino: stat2.ino,
                mode: stat2.mode,
                nlink: stat2.nlink,
                uid: stat2.uid,
                gid: stat2.gid,
                rdev: stat2.rdev,
                size: stat2.size,
                atime: stat2.atime,
                mtime: stat2.mtime,
                ctime: stat2.ctime,
                blksize: stat2.blksize,
                blocks: stat2.blocks
              };
            },
            setattr(node, attr) {
              var path3 = NODEFS.realPath(node);
              NODEFS.tryFSOperation(() => {
                if (attr.mode !== void 0) {
                  fs.chmodSync(path3, attr.mode);
                  node.mode = attr.mode;
                }
                if (attr.timestamp !== void 0) {
                  var date4 = new Date(attr.timestamp);
                  fs.utimesSync(path3, date4, date4);
                }
                if (attr.size !== void 0) {
                  fs.truncateSync(path3, attr.size);
                }
              });
            },
            lookup(parent, name3) {
              var path3 = PATH.join2(NODEFS.realPath(parent), name3);
              var mode = NODEFS.getMode(path3);
              return NODEFS.createNode(parent, name3, mode);
            },
            mknod(parent, name3, mode, dev) {
              var node = NODEFS.createNode(parent, name3, mode, dev);
              var path3 = NODEFS.realPath(node);
              NODEFS.tryFSOperation(() => {
                if (FS.isDir(node.mode)) {
                  fs.mkdirSync(path3, node.mode);
                } else {
                  fs.writeFileSync(path3, "", { mode: node.mode });
                }
              });
              return node;
            },
            rename(oldNode, newDir, newName) {
              var oldPath = NODEFS.realPath(oldNode);
              var newPath = PATH.join2(NODEFS.realPath(newDir), newName);
              NODEFS.tryFSOperation(() => fs.renameSync(oldPath, newPath));
              oldNode.name = newName;
            },
            unlink(parent, name3) {
              var path3 = PATH.join2(NODEFS.realPath(parent), name3);
              NODEFS.tryFSOperation(() => fs.unlinkSync(path3));
            },
            rmdir(parent, name3) {
              var path3 = PATH.join2(NODEFS.realPath(parent), name3);
              NODEFS.tryFSOperation(() => fs.rmdirSync(path3));
            },
            readdir(node) {
              var path3 = NODEFS.realPath(node);
              return NODEFS.tryFSOperation(() => fs.readdirSync(path3));
            },
            symlink(parent, newName, oldPath) {
              var newPath = PATH.join2(NODEFS.realPath(parent), newName);
              NODEFS.tryFSOperation(() => fs.symlinkSync(oldPath, newPath));
            },
            readlink(node) {
              var path3 = NODEFS.realPath(node);
              return NODEFS.tryFSOperation(() => fs.readlinkSync(path3));
            }
          },
          stream_ops: {
            open(stream) {
              var path3 = NODEFS.realPath(stream.node);
              NODEFS.tryFSOperation(() => {
                if (FS.isFile(stream.node.mode)) {
                  stream.shared.refcount = 1;
                  stream.nfd = fs.openSync(path3, NODEFS.flagsForNode(stream.flags));
                }
              });
            },
            close(stream) {
              NODEFS.tryFSOperation(() => {
                if (FS.isFile(stream.node.mode) && stream.nfd && --stream.shared.refcount === 0) {
                  fs.closeSync(stream.nfd);
                }
              });
            },
            dup(stream) {
              stream.shared.refcount++;
            },
            read(stream, buffer2, offset, length, position) {
              if (length === 0) return 0;
              return NODEFS.tryFSOperation(
                () => fs.readSync(stream.nfd, new Int8Array(buffer2.buffer, offset, length), 0, length, position)
              );
            },
            write(stream, buffer2, offset, length, position) {
              return NODEFS.tryFSOperation(
                () => fs.writeSync(stream.nfd, new Int8Array(buffer2.buffer, offset, length), 0, length, position)
              );
            },
            llseek(stream, offset, whence) {
              var position = offset;
              if (whence === 1) {
                position += stream.position;
              } else if (whence === 2) {
                if (FS.isFile(stream.node.mode)) {
                  NODEFS.tryFSOperation(() => {
                    var stat2 = fs.fstatSync(stream.nfd);
                    position += stat2.size;
                  });
                }
              }
              if (position < 0) {
                throw new FS.ErrnoError(28);
              }
              return position;
            },
            mmap(stream, length, position, prot, flags2) {
              if (!FS.isFile(stream.node.mode)) {
                throw new FS.ErrnoError(43);
              }
              var ptr = mmapAlloc(length);
              NODEFS.stream_ops.read(stream, HEAP8, ptr, length, position);
              return { ptr, allocated: true };
            },
            msync(stream, buffer2, offset, length, mmapFlags) {
              NODEFS.stream_ops.write(stream, buffer2, 0, length, offset, false);
              return 0;
            }
          }
        };
        var FS = {
          root: null,
          mounts: [],
          devices: {},
          streams: [],
          nextInode: 1,
          nameTable: null,
          currentPath: "/",
          initialized: false,
          ignorePermissions: true,
          ErrnoError: class {
            // We set the `name` property to be able to identify `FS.ErrnoError`
            // - the `name` is a standard ECMA-262 property of error objects. Kind of good to have it anyway.
            // - when using PROXYFS, an error can come from an underlying FS
            // as different FS objects have their own FS.ErrnoError each,
            // the test `err instanceof FS.ErrnoError` won't detect an error coming from another filesystem, causing bugs.
            // we'll use the reliable test `err.name == "ErrnoError"` instead
            constructor(errno) {
              this.name = "ErrnoError";
              this.errno = errno;
            }
          },
          genericErrors: {},
          filesystems: null,
          syncFSRequests: 0,
          readFiles: {},
          FSStream: class {
            constructor() {
              this.shared = {};
            }
            get object() {
              return this.node;
            }
            set object(val2) {
              this.node = val2;
            }
            get isRead() {
              return (this.flags & 2097155) !== 1;
            }
            get isWrite() {
              return (this.flags & 2097155) !== 0;
            }
            get isAppend() {
              return this.flags & 1024;
            }
            get flags() {
              return this.shared.flags;
            }
            set flags(val2) {
              this.shared.flags = val2;
            }
            get position() {
              return this.shared.position;
            }
            set position(val2) {
              this.shared.position = val2;
            }
          },
          FSNode: class {
            constructor(parent, name3, mode, rdev) {
              if (!parent) {
                parent = this;
              }
              this.parent = parent;
              this.mount = parent.mount;
              this.mounted = null;
              this.id = FS.nextInode++;
              this.name = name3;
              this.mode = mode;
              this.node_ops = {};
              this.stream_ops = {};
              this.rdev = rdev;
              this.readMode = 292 | 73;
              this.writeMode = 146;
            }
            get read() {
              return (this.mode & this.readMode) === this.readMode;
            }
            set read(val2) {
              val2 ? this.mode |= this.readMode : this.mode &= ~this.readMode;
            }
            get write() {
              return (this.mode & this.writeMode) === this.writeMode;
            }
            set write(val2) {
              val2 ? this.mode |= this.writeMode : this.mode &= ~this.writeMode;
            }
            get isFolder() {
              return FS.isDir(this.mode);
            }
            get isDevice() {
              return FS.isChrdev(this.mode);
            }
          },
          lookupPath(path3, opts = {}) {
            path3 = PATH_FS.resolve(path3);
            if (!path3) return { path: "", node: null };
            var defaults3 = {
              follow_mount: true,
              recurse_count: 0
            };
            opts = Object.assign(defaults3, opts);
            if (opts.recurse_count > 8) {
              throw new FS.ErrnoError(32);
            }
            var parts2 = path3.split("/").filter((p11) => !!p11);
            var current = FS.root;
            var current_path = "/";
            for (var i8 = 0; i8 < parts2.length; i8++) {
              var islast = i8 === parts2.length - 1;
              if (islast && opts.parent) {
                break;
              }
              current = FS.lookupNode(current, parts2[i8]);
              current_path = PATH.join2(current_path, parts2[i8]);
              if (FS.isMountpoint(current)) {
                if (!islast || islast && opts.follow_mount) {
                  current = current.mounted.root;
                }
              }
              if (!islast || opts.follow) {
                var count2 = 0;
                while (FS.isLink(current.mode)) {
                  var link = FS.readlink(current_path);
                  current_path = PATH_FS.resolve(PATH.dirname(current_path), link);
                  var lookup = FS.lookupPath(current_path, { recurse_count: opts.recurse_count + 1 });
                  current = lookup.node;
                  if (count2++ > 40) {
                    throw new FS.ErrnoError(32);
                  }
                }
              }
            }
            return { path: current_path, node: current };
          },
          getPath(node) {
            var path3;
            while (true) {
              if (FS.isRoot(node)) {
                var mount = node.mount.mountpoint;
                if (!path3) return mount;
                return mount[mount.length - 1] !== "/" ? `${mount}/${path3}` : mount + path3;
              }
              path3 = path3 ? `${node.name}/${path3}` : node.name;
              node = node.parent;
            }
          },
          hashName(parentid, name3) {
            var hash = 0;
            for (var i8 = 0; i8 < name3.length; i8++) {
              hash = (hash << 5) - hash + name3.charCodeAt(i8) | 0;
            }
            return (parentid + hash >>> 0) % FS.nameTable.length;
          },
          hashAddNode(node) {
            var hash = FS.hashName(node.parent.id, node.name);
            node.name_next = FS.nameTable[hash];
            FS.nameTable[hash] = node;
          },
          hashRemoveNode(node) {
            var hash = FS.hashName(node.parent.id, node.name);
            if (FS.nameTable[hash] === node) {
              FS.nameTable[hash] = node.name_next;
            } else {
              var current = FS.nameTable[hash];
              while (current) {
                if (current.name_next === node) {
                  current.name_next = node.name_next;
                  break;
                }
                current = current.name_next;
              }
            }
          },
          lookupNode(parent, name3) {
            var errCode = FS.mayLookup(parent);
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            var hash = FS.hashName(parent.id, name3);
            for (var node = FS.nameTable[hash]; node; node = node.name_next) {
              var nodeName = node.name;
              if (node.parent.id === parent.id && nodeName === name3) {
                return node;
              }
            }
            return FS.lookup(parent, name3);
          },
          createNode(parent, name3, mode, rdev) {
            var node = new FS.FSNode(parent, name3, mode, rdev);
            FS.hashAddNode(node);
            return node;
          },
          destroyNode(node) {
            FS.hashRemoveNode(node);
          },
          isRoot(node) {
            return node === node.parent;
          },
          isMountpoint(node) {
            return !!node.mounted;
          },
          isFile(mode) {
            return (mode & 61440) === 32768;
          },
          isDir(mode) {
            return (mode & 61440) === 16384;
          },
          isLink(mode) {
            return (mode & 61440) === 40960;
          },
          isChrdev(mode) {
            return (mode & 61440) === 8192;
          },
          isBlkdev(mode) {
            return (mode & 61440) === 24576;
          },
          isFIFO(mode) {
            return (mode & 61440) === 4096;
          },
          isSocket(mode) {
            return (mode & 49152) === 49152;
          },
          flagsToPermissionString(flag) {
            var perms = ["r", "w", "rw"][flag & 3];
            if (flag & 512) {
              perms += "w";
            }
            return perms;
          },
          nodePermissions(node, perms) {
            if (FS.ignorePermissions) {
              return 0;
            }
            if (perms.includes("r") && !(node.mode & 292)) {
              return 2;
            } else if (perms.includes("w") && !(node.mode & 146)) {
              return 2;
            } else if (perms.includes("x") && !(node.mode & 73)) {
              return 2;
            }
            return 0;
          },
          mayLookup(dir) {
            if (!FS.isDir(dir.mode)) return 54;
            var errCode = FS.nodePermissions(dir, "x");
            if (errCode) return errCode;
            if (!dir.node_ops.lookup) return 2;
            return 0;
          },
          mayCreate(dir, name3) {
            try {
              var node = FS.lookupNode(dir, name3);
              return 20;
            } catch (e6) {
            }
            return FS.nodePermissions(dir, "wx");
          },
          mayDelete(dir, name3, isdir) {
            var node;
            try {
              node = FS.lookupNode(dir, name3);
            } catch (e6) {
              return e6.errno;
            }
            var errCode = FS.nodePermissions(dir, "wx");
            if (errCode) {
              return errCode;
            }
            if (isdir) {
              if (!FS.isDir(node.mode)) {
                return 54;
              }
              if (FS.isRoot(node) || FS.getPath(node) === FS.cwd()) {
                return 10;
              }
            } else {
              if (FS.isDir(node.mode)) {
                return 31;
              }
            }
            return 0;
          },
          mayOpen(node, flags2) {
            if (!node) {
              return 44;
            }
            if (FS.isLink(node.mode)) {
              return 32;
            } else if (FS.isDir(node.mode)) {
              if (FS.flagsToPermissionString(flags2) !== "r" || // opening for write
              flags2 & 512) {
                return 31;
              }
            }
            return FS.nodePermissions(node, FS.flagsToPermissionString(flags2));
          },
          MAX_OPEN_FDS: 4096,
          nextfd() {
            for (var fd = 0; fd <= FS.MAX_OPEN_FDS; fd++) {
              if (!FS.streams[fd]) {
                return fd;
              }
            }
            throw new FS.ErrnoError(33);
          },
          getStreamChecked(fd) {
            var stream = FS.getStream(fd);
            if (!stream) {
              throw new FS.ErrnoError(8);
            }
            return stream;
          },
          getStream: (fd) => FS.streams[fd],
          createStream(stream, fd = -1) {
            stream = Object.assign(new FS.FSStream(), stream);
            if (fd == -1) {
              fd = FS.nextfd();
            }
            stream.fd = fd;
            FS.streams[fd] = stream;
            return stream;
          },
          closeStream(fd) {
            FS.streams[fd] = null;
          },
          dupStream(origStream, fd = -1) {
            var stream = FS.createStream(origStream, fd);
            stream.stream_ops?.dup?.(stream);
            return stream;
          },
          chrdev_stream_ops: {
            open(stream) {
              var device = FS.getDevice(stream.node.rdev);
              stream.stream_ops = device.stream_ops;
              stream.stream_ops.open?.(stream);
            },
            llseek() {
              throw new FS.ErrnoError(70);
            }
          },
          major: (dev) => dev >> 8,
          minor: (dev) => dev & 255,
          makedev: (ma, mi2) => ma << 8 | mi2,
          registerDevice(dev, ops) {
            FS.devices[dev] = { stream_ops: ops };
          },
          getDevice: (dev) => FS.devices[dev],
          getMounts(mount) {
            var mounts = [];
            var check2 = [mount];
            while (check2.length) {
              var m12 = check2.pop();
              mounts.push(m12);
              check2.push(...m12.mounts);
            }
            return mounts;
          },
          syncfs(populate, callback) {
            if (typeof populate == "function") {
              callback = populate;
              populate = false;
            }
            FS.syncFSRequests++;
            if (FS.syncFSRequests > 1) {
              err(`warning: ${FS.syncFSRequests} FS.syncfs operations in flight at once, probably just doing extra work`);
            }
            var mounts = FS.getMounts(FS.root.mount);
            var completed = 0;
            function doCallback(errCode) {
              FS.syncFSRequests--;
              return callback(errCode);
            }
            function done(errCode) {
              if (errCode) {
                if (!done.errored) {
                  done.errored = true;
                  return doCallback(errCode);
                }
                return;
              }
              if (++completed >= mounts.length) {
                doCallback(null);
              }
            }
            ;
            mounts.forEach((mount) => {
              if (!mount.type.syncfs) {
                return done(null);
              }
              mount.type.syncfs(mount, populate, done);
            });
          },
          mount(type, opts, mountpoint) {
            var root = mountpoint === "/";
            var pseudo = !mountpoint;
            var node;
            if (root && FS.root) {
              throw new FS.ErrnoError(10);
            } else if (!root && !pseudo) {
              var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
              mountpoint = lookup.path;
              node = lookup.node;
              if (FS.isMountpoint(node)) {
                throw new FS.ErrnoError(10);
              }
              if (!FS.isDir(node.mode)) {
                throw new FS.ErrnoError(54);
              }
            }
            var mount = {
              type,
              opts,
              mountpoint,
              mounts: []
            };
            var mountRoot = type.mount(mount);
            mountRoot.mount = mount;
            mount.root = mountRoot;
            if (root) {
              FS.root = mountRoot;
            } else if (node) {
              node.mounted = mount;
              if (node.mount) {
                node.mount.mounts.push(mount);
              }
            }
            return mountRoot;
          },
          unmount(mountpoint) {
            var lookup = FS.lookupPath(mountpoint, { follow_mount: false });
            if (!FS.isMountpoint(lookup.node)) {
              throw new FS.ErrnoError(28);
            }
            var node = lookup.node;
            var mount = node.mounted;
            var mounts = FS.getMounts(mount);
            Object.keys(FS.nameTable).forEach((hash) => {
              var current = FS.nameTable[hash];
              while (current) {
                var next = current.name_next;
                if (mounts.includes(current.mount)) {
                  FS.destroyNode(current);
                }
                current = next;
              }
            });
            node.mounted = null;
            var idx = node.mount.mounts.indexOf(mount);
            node.mount.mounts.splice(idx, 1);
          },
          lookup(parent, name3) {
            return parent.node_ops.lookup(parent, name3);
          },
          mknod(path3, mode, dev) {
            var lookup = FS.lookupPath(path3, { parent: true });
            var parent = lookup.node;
            var name3 = PATH.basename(path3);
            if (!name3 || name3 === "." || name3 === "..") {
              throw new FS.ErrnoError(28);
            }
            var errCode = FS.mayCreate(parent, name3);
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            if (!parent.node_ops.mknod) {
              throw new FS.ErrnoError(63);
            }
            return parent.node_ops.mknod(parent, name3, mode, dev);
          },
          create(path3, mode) {
            mode = mode !== void 0 ? mode : 438;
            mode &= 4095;
            mode |= 32768;
            return FS.mknod(path3, mode, 0);
          },
          mkdir(path3, mode) {
            mode = mode !== void 0 ? mode : 511;
            mode &= 511 | 512;
            mode |= 16384;
            return FS.mknod(path3, mode, 0);
          },
          mkdirTree(path3, mode) {
            var dirs = path3.split("/");
            var d7 = "";
            for (var i8 = 0; i8 < dirs.length; ++i8) {
              if (!dirs[i8]) continue;
              d7 += "/" + dirs[i8];
              try {
                FS.mkdir(d7, mode);
              } catch (e6) {
                if (e6.errno != 20) throw e6;
              }
            }
          },
          mkdev(path3, mode, dev) {
            if (typeof dev == "undefined") {
              dev = mode;
              mode = 438;
            }
            mode |= 8192;
            return FS.mknod(path3, mode, dev);
          },
          symlink(oldpath, newpath) {
            if (!PATH_FS.resolve(oldpath)) {
              throw new FS.ErrnoError(44);
            }
            var lookup = FS.lookupPath(newpath, { parent: true });
            var parent = lookup.node;
            if (!parent) {
              throw new FS.ErrnoError(44);
            }
            var newname = PATH.basename(newpath);
            var errCode = FS.mayCreate(parent, newname);
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            if (!parent.node_ops.symlink) {
              throw new FS.ErrnoError(63);
            }
            return parent.node_ops.symlink(parent, newname, oldpath);
          },
          rename(old_path, new_path) {
            var old_dirname = PATH.dirname(old_path);
            var new_dirname = PATH.dirname(new_path);
            var old_name = PATH.basename(old_path);
            var new_name = PATH.basename(new_path);
            var lookup, old_dir, new_dir;
            lookup = FS.lookupPath(old_path, { parent: true });
            old_dir = lookup.node;
            lookup = FS.lookupPath(new_path, { parent: true });
            new_dir = lookup.node;
            if (!old_dir || !new_dir) throw new FS.ErrnoError(44);
            if (old_dir.mount !== new_dir.mount) {
              throw new FS.ErrnoError(75);
            }
            var old_node = FS.lookupNode(old_dir, old_name);
            var relative = PATH_FS.relative(old_path, new_dirname);
            if (relative.charAt(0) !== ".") {
              throw new FS.ErrnoError(28);
            }
            relative = PATH_FS.relative(new_path, old_dirname);
            if (relative.charAt(0) !== ".") {
              throw new FS.ErrnoError(55);
            }
            var new_node;
            try {
              new_node = FS.lookupNode(new_dir, new_name);
            } catch (e6) {
            }
            if (old_node === new_node) {
              return;
            }
            var isdir = FS.isDir(old_node.mode);
            var errCode = FS.mayDelete(old_dir, old_name, isdir);
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            errCode = new_node ? FS.mayDelete(new_dir, new_name, isdir) : FS.mayCreate(new_dir, new_name);
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            if (!old_dir.node_ops.rename) {
              throw new FS.ErrnoError(63);
            }
            if (FS.isMountpoint(old_node) || new_node && FS.isMountpoint(new_node)) {
              throw new FS.ErrnoError(10);
            }
            if (new_dir !== old_dir) {
              errCode = FS.nodePermissions(old_dir, "w");
              if (errCode) {
                throw new FS.ErrnoError(errCode);
              }
            }
            FS.hashRemoveNode(old_node);
            try {
              old_dir.node_ops.rename(old_node, new_dir, new_name);
              old_node.parent = new_dir;
            } catch (e6) {
              throw e6;
            } finally {
              FS.hashAddNode(old_node);
            }
          },
          rmdir(path3) {
            var lookup = FS.lookupPath(path3, { parent: true });
            var parent = lookup.node;
            var name3 = PATH.basename(path3);
            var node = FS.lookupNode(parent, name3);
            var errCode = FS.mayDelete(parent, name3, true);
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            if (!parent.node_ops.rmdir) {
              throw new FS.ErrnoError(63);
            }
            if (FS.isMountpoint(node)) {
              throw new FS.ErrnoError(10);
            }
            parent.node_ops.rmdir(parent, name3);
            FS.destroyNode(node);
          },
          readdir(path3) {
            var lookup = FS.lookupPath(path3, { follow: true });
            var node = lookup.node;
            if (!node.node_ops.readdir) {
              throw new FS.ErrnoError(54);
            }
            return node.node_ops.readdir(node);
          },
          unlink(path3) {
            var lookup = FS.lookupPath(path3, { parent: true });
            var parent = lookup.node;
            if (!parent) {
              throw new FS.ErrnoError(44);
            }
            var name3 = PATH.basename(path3);
            var node = FS.lookupNode(parent, name3);
            var errCode = FS.mayDelete(parent, name3, false);
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            if (!parent.node_ops.unlink) {
              throw new FS.ErrnoError(63);
            }
            if (FS.isMountpoint(node)) {
              throw new FS.ErrnoError(10);
            }
            parent.node_ops.unlink(parent, name3);
            FS.destroyNode(node);
          },
          readlink(path3) {
            var lookup = FS.lookupPath(path3);
            var link = lookup.node;
            if (!link) {
              throw new FS.ErrnoError(44);
            }
            if (!link.node_ops.readlink) {
              throw new FS.ErrnoError(28);
            }
            return PATH_FS.resolve(FS.getPath(link.parent), link.node_ops.readlink(link));
          },
          stat(path3, dontFollow) {
            var lookup = FS.lookupPath(path3, { follow: !dontFollow });
            var node = lookup.node;
            if (!node) {
              throw new FS.ErrnoError(44);
            }
            if (!node.node_ops.getattr) {
              throw new FS.ErrnoError(63);
            }
            return node.node_ops.getattr(node);
          },
          lstat(path3) {
            return FS.stat(path3, true);
          },
          chmod(path3, mode, dontFollow) {
            var node;
            if (typeof path3 == "string") {
              var lookup = FS.lookupPath(path3, { follow: !dontFollow });
              node = lookup.node;
            } else {
              node = path3;
            }
            if (!node.node_ops.setattr) {
              throw new FS.ErrnoError(63);
            }
            node.node_ops.setattr(node, {
              mode: mode & 4095 | node.mode & ~4095,
              timestamp: Date.now()
            });
          },
          lchmod(path3, mode) {
            FS.chmod(path3, mode, true);
          },
          fchmod(fd, mode) {
            var stream = FS.getStreamChecked(fd);
            FS.chmod(stream.node, mode);
          },
          chown(path3, uid2, gid, dontFollow) {
            var node;
            if (typeof path3 == "string") {
              var lookup = FS.lookupPath(path3, { follow: !dontFollow });
              node = lookup.node;
            } else {
              node = path3;
            }
            if (!node.node_ops.setattr) {
              throw new FS.ErrnoError(63);
            }
            node.node_ops.setattr(node, {
              timestamp: Date.now()
              // we ignore the uid / gid for now
            });
          },
          lchown(path3, uid2, gid) {
            FS.chown(path3, uid2, gid, true);
          },
          fchown(fd, uid2, gid) {
            var stream = FS.getStreamChecked(fd);
            FS.chown(stream.node, uid2, gid);
          },
          truncate(path3, len) {
            if (len < 0) {
              throw new FS.ErrnoError(28);
            }
            var node;
            if (typeof path3 == "string") {
              var lookup = FS.lookupPath(path3, { follow: true });
              node = lookup.node;
            } else {
              node = path3;
            }
            if (!node.node_ops.setattr) {
              throw new FS.ErrnoError(63);
            }
            if (FS.isDir(node.mode)) {
              throw new FS.ErrnoError(31);
            }
            if (!FS.isFile(node.mode)) {
              throw new FS.ErrnoError(28);
            }
            var errCode = FS.nodePermissions(node, "w");
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            node.node_ops.setattr(node, {
              size: len,
              timestamp: Date.now()
            });
          },
          ftruncate(fd, len) {
            var stream = FS.getStreamChecked(fd);
            if ((stream.flags & 2097155) === 0) {
              throw new FS.ErrnoError(28);
            }
            FS.truncate(stream.node, len);
          },
          utime(path3, atime, mtime) {
            var lookup = FS.lookupPath(path3, { follow: true });
            var node = lookup.node;
            node.node_ops.setattr(node, {
              timestamp: Math.max(atime, mtime)
            });
          },
          open(path3, flags2, mode) {
            if (path3 === "") {
              throw new FS.ErrnoError(44);
            }
            flags2 = typeof flags2 == "string" ? FS_modeStringToFlags(flags2) : flags2;
            if (flags2 & 64) {
              mode = typeof mode == "undefined" ? 438 : mode;
              mode = mode & 4095 | 32768;
            } else {
              mode = 0;
            }
            var node;
            if (typeof path3 == "object") {
              node = path3;
            } else {
              path3 = PATH.normalize(path3);
              try {
                var lookup = FS.lookupPath(path3, {
                  follow: !(flags2 & 131072)
                });
                node = lookup.node;
              } catch (e6) {
              }
            }
            var created = false;
            if (flags2 & 64) {
              if (node) {
                if (flags2 & 128) {
                  throw new FS.ErrnoError(20);
                }
              } else {
                node = FS.mknod(path3, mode, 0);
                created = true;
              }
            }
            if (!node) {
              throw new FS.ErrnoError(44);
            }
            if (FS.isChrdev(node.mode)) {
              flags2 &= ~512;
            }
            if (flags2 & 65536 && !FS.isDir(node.mode)) {
              throw new FS.ErrnoError(54);
            }
            if (!created) {
              var errCode = FS.mayOpen(node, flags2);
              if (errCode) {
                throw new FS.ErrnoError(errCode);
              }
            }
            if (flags2 & 512 && !created) {
              FS.truncate(node, 0);
            }
            flags2 &= ~(128 | 512 | 131072);
            var stream = FS.createStream({
              node,
              path: FS.getPath(node),
              // we want the absolute path to the node
              flags: flags2,
              seekable: true,
              position: 0,
              stream_ops: node.stream_ops,
              // used by the file family libc calls (fopen, fwrite, ferror, etc.)
              ungotten: [],
              error: false
            });
            if (stream.stream_ops.open) {
              stream.stream_ops.open(stream);
            }
            if (Module["logReadFiles"] && !(flags2 & 1)) {
              if (!(path3 in FS.readFiles)) {
                FS.readFiles[path3] = 1;
              }
            }
            return stream;
          },
          close(stream) {
            if (FS.isClosed(stream)) {
              throw new FS.ErrnoError(8);
            }
            if (stream.getdents) stream.getdents = null;
            try {
              if (stream.stream_ops.close) {
                stream.stream_ops.close(stream);
              }
            } catch (e6) {
              throw e6;
            } finally {
              FS.closeStream(stream.fd);
            }
            stream.fd = null;
          },
          isClosed(stream) {
            return stream.fd === null;
          },
          llseek(stream, offset, whence) {
            if (FS.isClosed(stream)) {
              throw new FS.ErrnoError(8);
            }
            if (!stream.seekable || !stream.stream_ops.llseek) {
              throw new FS.ErrnoError(70);
            }
            if (whence != 0 && whence != 1 && whence != 2) {
              throw new FS.ErrnoError(28);
            }
            stream.position = stream.stream_ops.llseek(stream, offset, whence);
            stream.ungotten = [];
            return stream.position;
          },
          read(stream, buffer2, offset, length, position) {
            if (length < 0 || position < 0) {
              throw new FS.ErrnoError(28);
            }
            if (FS.isClosed(stream)) {
              throw new FS.ErrnoError(8);
            }
            if ((stream.flags & 2097155) === 1) {
              throw new FS.ErrnoError(8);
            }
            if (FS.isDir(stream.node.mode)) {
              throw new FS.ErrnoError(31);
            }
            if (!stream.stream_ops.read) {
              throw new FS.ErrnoError(28);
            }
            var seeking = typeof position != "undefined";
            if (!seeking) {
              position = stream.position;
            } else if (!stream.seekable) {
              throw new FS.ErrnoError(70);
            }
            var bytesRead = stream.stream_ops.read(stream, buffer2, offset, length, position);
            if (!seeking) stream.position += bytesRead;
            return bytesRead;
          },
          write(stream, buffer2, offset, length, position, canOwn) {
            if (length < 0 || position < 0) {
              throw new FS.ErrnoError(28);
            }
            if (FS.isClosed(stream)) {
              throw new FS.ErrnoError(8);
            }
            if ((stream.flags & 2097155) === 0) {
              throw new FS.ErrnoError(8);
            }
            if (FS.isDir(stream.node.mode)) {
              throw new FS.ErrnoError(31);
            }
            if (!stream.stream_ops.write) {
              throw new FS.ErrnoError(28);
            }
            if (stream.seekable && stream.flags & 1024) {
              FS.llseek(stream, 0, 2);
            }
            var seeking = typeof position != "undefined";
            if (!seeking) {
              position = stream.position;
            } else if (!stream.seekable) {
              throw new FS.ErrnoError(70);
            }
            var bytesWritten = stream.stream_ops.write(stream, buffer2, offset, length, position, canOwn);
            if (!seeking) stream.position += bytesWritten;
            return bytesWritten;
          },
          allocate(stream, offset, length) {
            if (FS.isClosed(stream)) {
              throw new FS.ErrnoError(8);
            }
            if (offset < 0 || length <= 0) {
              throw new FS.ErrnoError(28);
            }
            if ((stream.flags & 2097155) === 0) {
              throw new FS.ErrnoError(8);
            }
            if (!FS.isFile(stream.node.mode) && !FS.isDir(stream.node.mode)) {
              throw new FS.ErrnoError(43);
            }
            if (!stream.stream_ops.allocate) {
              throw new FS.ErrnoError(138);
            }
            stream.stream_ops.allocate(stream, offset, length);
          },
          mmap(stream, length, position, prot, flags2) {
            if ((prot & 2) !== 0 && (flags2 & 2) === 0 && (stream.flags & 2097155) !== 2) {
              throw new FS.ErrnoError(2);
            }
            if ((stream.flags & 2097155) === 1) {
              throw new FS.ErrnoError(2);
            }
            if (!stream.stream_ops.mmap) {
              throw new FS.ErrnoError(43);
            }
            if (!length) {
              throw new FS.ErrnoError(28);
            }
            return stream.stream_ops.mmap(stream, length, position, prot, flags2);
          },
          msync(stream, buffer2, offset, length, mmapFlags) {
            if (!stream.stream_ops.msync) {
              return 0;
            }
            return stream.stream_ops.msync(stream, buffer2, offset, length, mmapFlags);
          },
          ioctl(stream, cmd, arg) {
            if (!stream.stream_ops.ioctl) {
              throw new FS.ErrnoError(59);
            }
            return stream.stream_ops.ioctl(stream, cmd, arg);
          },
          readFile(path3, opts = {}) {
            opts.flags = opts.flags || 0;
            opts.encoding = opts.encoding || "binary";
            if (opts.encoding !== "utf8" && opts.encoding !== "binary") {
              throw new Error(`Invalid encoding type "${opts.encoding}"`);
            }
            var ret;
            var stream = FS.open(path3, opts.flags);
            var stat2 = FS.stat(path3);
            var length = stat2.size;
            var buf = new Uint8Array(length);
            FS.read(stream, buf, 0, length, 0);
            if (opts.encoding === "utf8") {
              ret = UTF8ArrayToString(buf, 0);
            } else if (opts.encoding === "binary") {
              ret = buf;
            }
            FS.close(stream);
            return ret;
          },
          writeFile(path3, data, opts = {}) {
            opts.flags = opts.flags || 577;
            var stream = FS.open(path3, opts.flags, opts.mode);
            if (typeof data == "string") {
              var buf = new Uint8Array(lengthBytesUTF8(data) + 1);
              var actualNumBytes = stringToUTF8Array(data, buf, 0, buf.length);
              FS.write(stream, buf, 0, actualNumBytes, void 0, opts.canOwn);
            } else if (ArrayBuffer.isView(data)) {
              FS.write(stream, data, 0, data.byteLength, void 0, opts.canOwn);
            } else {
              throw new Error("Unsupported data type");
            }
            FS.close(stream);
          },
          cwd: () => FS.currentPath,
          chdir(path3) {
            var lookup = FS.lookupPath(path3, { follow: true });
            if (lookup.node === null) {
              throw new FS.ErrnoError(44);
            }
            if (!FS.isDir(lookup.node.mode)) {
              throw new FS.ErrnoError(54);
            }
            var errCode = FS.nodePermissions(lookup.node, "x");
            if (errCode) {
              throw new FS.ErrnoError(errCode);
            }
            FS.currentPath = lookup.path;
          },
          createDefaultDirectories() {
            FS.mkdir("/tmp");
            FS.mkdir("/home");
            FS.mkdir("/home/web_user");
          },
          createDefaultDevices() {
            FS.mkdir("/dev");
            FS.registerDevice(FS.makedev(1, 3), {
              read: () => 0,
              write: (stream, buffer2, offset, length, pos) => length
            });
            FS.mkdev("/dev/null", FS.makedev(1, 3));
            TTY.register(FS.makedev(5, 0), TTY.default_tty_ops);
            TTY.register(FS.makedev(6, 0), TTY.default_tty1_ops);
            FS.mkdev("/dev/tty", FS.makedev(5, 0));
            FS.mkdev("/dev/tty1", FS.makedev(6, 0));
            var randomBuffer = new Uint8Array(1024), randomLeft = 0;
            var randomByte = () => {
              if (randomLeft === 0) {
                randomLeft = randomFill(randomBuffer).byteLength;
              }
              return randomBuffer[--randomLeft];
            };
            FS.createDevice("/dev", "random", randomByte);
            FS.createDevice("/dev", "urandom", randomByte);
            FS.mkdir("/dev/shm");
            FS.mkdir("/dev/shm/tmp");
          },
          createSpecialDirectories() {
            FS.mkdir("/proc");
            var proc_self = FS.mkdir("/proc/self");
            FS.mkdir("/proc/self/fd");
            FS.mount({
              mount() {
                var node = FS.createNode(proc_self, "fd", 16384 | 511, 73);
                node.node_ops = {
                  lookup(parent, name3) {
                    var fd = +name3;
                    var stream = FS.getStreamChecked(fd);
                    var ret = {
                      parent: null,
                      mount: { mountpoint: "fake" },
                      node_ops: { readlink: () => stream.path }
                    };
                    ret.parent = ret;
                    return ret;
                  }
                };
                return node;
              }
            }, {}, "/proc/self/fd");
          },
          createStandardStreams(input, output, error2) {
            if (input) {
              FS.createDevice("/dev", "stdin", input);
            } else {
              FS.symlink("/dev/tty", "/dev/stdin");
            }
            if (output) {
              FS.createDevice("/dev", "stdout", null, output);
            } else {
              FS.symlink("/dev/tty", "/dev/stdout");
            }
            if (error2) {
              FS.createDevice("/dev", "stderr", null, error2);
            } else {
              FS.symlink("/dev/tty1", "/dev/stderr");
            }
            var stdin = FS.open("/dev/stdin", 0);
            var stdout = FS.open("/dev/stdout", 1);
            var stderr = FS.open("/dev/stderr", 1);
          },
          staticInit() {
            [44].forEach((code) => {
              FS.genericErrors[code] = new FS.ErrnoError(code);
              FS.genericErrors[code].stack = "<generic error, no stack>";
            });
            FS.nameTable = new Array(4096);
            FS.mount(MEMFS, {}, "/");
            FS.createDefaultDirectories();
            FS.createDefaultDevices();
            FS.createSpecialDirectories();
            FS.filesystems = {
              "MEMFS": MEMFS,
              "IDBFS": IDBFS,
              "NODEFS": NODEFS
            };
          },
          init(input, output, error2) {
            FS.initialized = true;
            input ??= Module["stdin"];
            output ??= Module["stdout"];
            error2 ??= Module["stderr"];
            FS.createStandardStreams(input, output, error2);
          },
          quit() {
            FS.initialized = false;
            _fflush(0);
            for (var i8 = 0; i8 < FS.streams.length; i8++) {
              var stream = FS.streams[i8];
              if (!stream) {
                continue;
              }
              FS.close(stream);
            }
          },
          findObject(path3, dontResolveLastLink) {
            var ret = FS.analyzePath(path3, dontResolveLastLink);
            if (!ret.exists) {
              return null;
            }
            return ret.object;
          },
          analyzePath(path3, dontResolveLastLink) {
            try {
              var lookup = FS.lookupPath(path3, { follow: !dontResolveLastLink });
              path3 = lookup.path;
            } catch (e6) {
            }
            var ret = {
              isRoot: false,
              exists: false,
              error: 0,
              name: null,
              path: null,
              object: null,
              parentExists: false,
              parentPath: null,
              parentObject: null
            };
            try {
              var lookup = FS.lookupPath(path3, { parent: true });
              ret.parentExists = true;
              ret.parentPath = lookup.path;
              ret.parentObject = lookup.node;
              ret.name = PATH.basename(path3);
              lookup = FS.lookupPath(path3, { follow: !dontResolveLastLink });
              ret.exists = true;
              ret.path = lookup.path;
              ret.object = lookup.node;
              ret.name = lookup.node.name;
              ret.isRoot = lookup.path === "/";
            } catch (e6) {
              ret.error = e6.errno;
            }
            ;
            return ret;
          },
          createPath(parent, path3, canRead, canWrite) {
            parent = typeof parent == "string" ? parent : FS.getPath(parent);
            var parts2 = path3.split("/").reverse();
            while (parts2.length) {
              var part = parts2.pop();
              if (!part) continue;
              var current = PATH.join2(parent, part);
              try {
                FS.mkdir(current);
              } catch (e6) {
              }
              parent = current;
            }
            return current;
          },
          createFile(parent, name3, properties, canRead, canWrite) {
            var path3 = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name3);
            var mode = FS_getMode(canRead, canWrite);
            return FS.create(path3, mode);
          },
          createDataFile(parent, name3, data, canRead, canWrite, canOwn) {
            var path3 = name3;
            if (parent) {
              parent = typeof parent == "string" ? parent : FS.getPath(parent);
              path3 = name3 ? PATH.join2(parent, name3) : parent;
            }
            var mode = FS_getMode(canRead, canWrite);
            var node = FS.create(path3, mode);
            if (data) {
              if (typeof data == "string") {
                var arr = new Array(data.length);
                for (var i8 = 0, len = data.length; i8 < len; ++i8) arr[i8] = data.charCodeAt(i8);
                data = arr;
              }
              FS.chmod(node, mode | 146);
              var stream = FS.open(node, 577);
              FS.write(stream, data, 0, data.length, 0, canOwn);
              FS.close(stream);
              FS.chmod(node, mode);
            }
          },
          createDevice(parent, name3, input, output) {
            var path3 = PATH.join2(typeof parent == "string" ? parent : FS.getPath(parent), name3);
            var mode = FS_getMode(!!input, !!output);
            FS.createDevice.major ??= 64;
            var dev = FS.makedev(FS.createDevice.major++, 0);
            FS.registerDevice(dev, {
              open(stream) {
                stream.seekable = false;
              },
              close(stream) {
                if (output?.buffer?.length) {
                  output(10);
                }
              },
              read(stream, buffer2, offset, length, pos) {
                var bytesRead = 0;
                for (var i8 = 0; i8 < length; i8++) {
                  var result;
                  try {
                    result = input();
                  } catch (e6) {
                    throw new FS.ErrnoError(29);
                  }
                  if (result === void 0 && bytesRead === 0) {
                    throw new FS.ErrnoError(6);
                  }
                  if (result === null || result === void 0) break;
                  bytesRead++;
                  buffer2[offset + i8] = result;
                }
                if (bytesRead) {
                  stream.node.timestamp = Date.now();
                }
                return bytesRead;
              },
              write(stream, buffer2, offset, length, pos) {
                for (var i8 = 0; i8 < length; i8++) {
                  try {
                    output(buffer2[offset + i8]);
                  } catch (e6) {
                    throw new FS.ErrnoError(29);
                  }
                }
                if (length) {
                  stream.node.timestamp = Date.now();
                }
                return i8;
              }
            });
            return FS.mkdev(path3, mode, dev);
          },
          forceLoadFile(obj) {
            if (obj.isDevice || obj.isFolder || obj.link || obj.contents) return true;
            if (typeof XMLHttpRequest != "undefined") {
              throw new Error("Lazy loading should have been performed (contents set) in createLazyFile, but it was not. Lazy loading only works in web workers. Use --embed-file or --preload-file in emcc on the main thread.");
            } else {
              try {
                obj.contents = readBinary(obj.url);
                obj.usedBytes = obj.contents.length;
              } catch (e6) {
                throw new FS.ErrnoError(29);
              }
            }
          },
          createLazyFile(parent, name3, url, canRead, canWrite) {
            class LazyUint8Array {
              constructor() {
                this.lengthKnown = false;
                this.chunks = [];
              }
              get(idx) {
                if (idx > this.length - 1 || idx < 0) {
                  return void 0;
                }
                var chunkOffset = idx % this.chunkSize;
                var chunkNum = idx / this.chunkSize | 0;
                return this.getter(chunkNum)[chunkOffset];
              }
              setDataGetter(getter) {
                this.getter = getter;
              }
              cacheLength() {
                var xhr = new XMLHttpRequest();
                xhr.open("HEAD", url, false);
                xhr.send(null);
                if (!(xhr.status >= 200 && xhr.status < 300 || xhr.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr.status);
                var datalength = Number(xhr.getResponseHeader("Content-length"));
                var header;
                var hasByteServing = (header = xhr.getResponseHeader("Accept-Ranges")) && header === "bytes";
                var usesGzip = (header = xhr.getResponseHeader("Content-Encoding")) && header === "gzip";
                var chunkSize = 1024 * 1024;
                if (!hasByteServing) chunkSize = datalength;
                var doXHR = (from, to3) => {
                  if (from > to3) throw new Error("invalid range (" + from + ", " + to3 + ") or no bytes requested!");
                  if (to3 > datalength - 1) throw new Error("only " + datalength + " bytes available! programmer error!");
                  var xhr2 = new XMLHttpRequest();
                  xhr2.open("GET", url, false);
                  if (datalength !== chunkSize) xhr2.setRequestHeader("Range", "bytes=" + from + "-" + to3);
                  xhr2.responseType = "arraybuffer";
                  if (xhr2.overrideMimeType) {
                    xhr2.overrideMimeType("text/plain; charset=x-user-defined");
                  }
                  xhr2.send(null);
                  if (!(xhr2.status >= 200 && xhr2.status < 300 || xhr2.status === 304)) throw new Error("Couldn't load " + url + ". Status: " + xhr2.status);
                  if (xhr2.response !== void 0) {
                    return new Uint8Array(
                      /** @type{Array<number>} */
                      xhr2.response || []
                    );
                  }
                  return intArrayFromString(xhr2.responseText || "", true);
                };
                var lazyArray2 = this;
                lazyArray2.setDataGetter((chunkNum) => {
                  var start2 = chunkNum * chunkSize;
                  var end = (chunkNum + 1) * chunkSize - 1;
                  end = Math.min(end, datalength - 1);
                  if (typeof lazyArray2.chunks[chunkNum] == "undefined") {
                    lazyArray2.chunks[chunkNum] = doXHR(start2, end);
                  }
                  if (typeof lazyArray2.chunks[chunkNum] == "undefined") throw new Error("doXHR failed!");
                  return lazyArray2.chunks[chunkNum];
                });
                if (usesGzip || !datalength) {
                  chunkSize = datalength = 1;
                  datalength = this.getter(0).length;
                  chunkSize = datalength;
                  out("LazyFiles on gzip forces download of the whole file when length is accessed");
                }
                this._length = datalength;
                this._chunkSize = chunkSize;
                this.lengthKnown = true;
              }
              get length() {
                if (!this.lengthKnown) {
                  this.cacheLength();
                }
                return this._length;
              }
              get chunkSize() {
                if (!this.lengthKnown) {
                  this.cacheLength();
                }
                return this._chunkSize;
              }
            }
            if (typeof XMLHttpRequest != "undefined") {
              if (!ENVIRONMENT_IS_WORKER) throw "Cannot do synchronous binary XHRs outside webworkers in modern browsers. Use --embed-file or --preload-file in emcc";
              var lazyArray = new LazyUint8Array();
              var properties = { isDevice: false, contents: lazyArray };
            } else {
              var properties = { isDevice: false, url };
            }
            var node = FS.createFile(parent, name3, properties, canRead, canWrite);
            if (properties.contents) {
              node.contents = properties.contents;
            } else if (properties.url) {
              node.contents = null;
              node.url = properties.url;
            }
            Object.defineProperties(node, {
              usedBytes: {
                get: function() {
                  return this.contents.length;
                }
              }
            });
            var stream_ops = {};
            var keys = Object.keys(node.stream_ops);
            keys.forEach((key) => {
              var fn3 = node.stream_ops[key];
              stream_ops[key] = (...args2) => {
                FS.forceLoadFile(node);
                return fn3(...args2);
              };
            });
            function writeChunks(stream, buffer2, offset, length, position) {
              var contents = stream.node.contents;
              if (position >= contents.length)
                return 0;
              var size2 = Math.min(contents.length - position, length);
              if (contents.slice) {
                for (var i8 = 0; i8 < size2; i8++) {
                  buffer2[offset + i8] = contents[position + i8];
                }
              } else {
                for (var i8 = 0; i8 < size2; i8++) {
                  buffer2[offset + i8] = contents.get(position + i8);
                }
              }
              return size2;
            }
            stream_ops.read = (stream, buffer2, offset, length, position) => {
              FS.forceLoadFile(node);
              return writeChunks(stream, buffer2, offset, length, position);
            };
            stream_ops.mmap = (stream, length, position, prot, flags2) => {
              FS.forceLoadFile(node);
              var ptr = mmapAlloc(length);
              if (!ptr) {
                throw new FS.ErrnoError(48);
              }
              writeChunks(stream, HEAP8, ptr, length, position);
              return { ptr, allocated: true };
            };
            node.stream_ops = stream_ops;
            return node;
          }
        };
        var SYSCALLS = {
          DEFAULT_POLLMASK: 5,
          calculateAt(dirfd, path3, allowEmpty) {
            if (PATH.isAbs(path3)) {
              return path3;
            }
            var dir;
            if (dirfd === -100) {
              dir = FS.cwd();
            } else {
              var dirstream = SYSCALLS.getStreamFromFD(dirfd);
              dir = dirstream.path;
            }
            if (path3.length == 0) {
              if (!allowEmpty) {
                throw new FS.ErrnoError(44);
                ;
              }
              return dir;
            }
            return PATH.join2(dir, path3);
          },
          doStat(func2, path3, buf) {
            var stat2 = func2(path3);
            HEAP32[buf >> 2] = stat2.dev;
            HEAP32[buf + 4 >> 2] = stat2.mode;
            HEAPU32[buf + 8 >> 2] = stat2.nlink;
            HEAP32[buf + 12 >> 2] = stat2.uid;
            HEAP32[buf + 16 >> 2] = stat2.gid;
            HEAP32[buf + 20 >> 2] = stat2.rdev;
            HEAP64[buf + 24 >> 3] = BigInt(stat2.size);
            HEAP32[buf + 32 >> 2] = 4096;
            HEAP32[buf + 36 >> 2] = stat2.blocks;
            var atime = stat2.atime.getTime();
            var mtime = stat2.mtime.getTime();
            var ctime = stat2.ctime.getTime();
            HEAP64[buf + 40 >> 3] = BigInt(Math.floor(atime / 1e3));
            HEAPU32[buf + 48 >> 2] = atime % 1e3 * 1e3 * 1e3;
            HEAP64[buf + 56 >> 3] = BigInt(Math.floor(mtime / 1e3));
            HEAPU32[buf + 64 >> 2] = mtime % 1e3 * 1e3 * 1e3;
            HEAP64[buf + 72 >> 3] = BigInt(Math.floor(ctime / 1e3));
            HEAPU32[buf + 80 >> 2] = ctime % 1e3 * 1e3 * 1e3;
            HEAP64[buf + 88 >> 3] = BigInt(stat2.ino);
            return 0;
          },
          doMsync(addr2, stream, len, flags2, offset) {
            if (!FS.isFile(stream.node.mode)) {
              throw new FS.ErrnoError(43);
            }
            if (flags2 & 2) {
              return 0;
            }
            var buffer2 = HEAPU8.slice(addr2, addr2 + len);
            FS.msync(stream, buffer2, offset, len, flags2);
          },
          getStreamFromFD(fd) {
            var stream = FS.getStreamChecked(fd);
            return stream;
          },
          varargs: void 0,
          getStr(ptr) {
            var ret = UTF8ToString(ptr);
            return ret;
          }
        };
        function ___syscall__newselect(nfds, readfds, writefds, exceptfds, timeout) {
          try {
            var total = 0;
            var srcReadLow = readfds ? HEAP32[readfds >> 2] : 0, srcReadHigh = readfds ? HEAP32[readfds + 4 >> 2] : 0;
            var srcWriteLow = writefds ? HEAP32[writefds >> 2] : 0, srcWriteHigh = writefds ? HEAP32[writefds + 4 >> 2] : 0;
            var srcExceptLow = exceptfds ? HEAP32[exceptfds >> 2] : 0, srcExceptHigh = exceptfds ? HEAP32[exceptfds + 4 >> 2] : 0;
            var dstReadLow = 0, dstReadHigh = 0;
            var dstWriteLow = 0, dstWriteHigh = 0;
            var dstExceptLow = 0, dstExceptHigh = 0;
            var allLow = (readfds ? HEAP32[readfds >> 2] : 0) | (writefds ? HEAP32[writefds >> 2] : 0) | (exceptfds ? HEAP32[exceptfds >> 2] : 0);
            var allHigh = (readfds ? HEAP32[readfds + 4 >> 2] : 0) | (writefds ? HEAP32[writefds + 4 >> 2] : 0) | (exceptfds ? HEAP32[exceptfds + 4 >> 2] : 0);
            var check2 = function(fd2, low, high, val2) {
              return fd2 < 32 ? low & val2 : high & val2;
            };
            for (var fd = 0; fd < nfds; fd++) {
              var mask = 1 << fd % 32;
              if (!check2(fd, allLow, allHigh, mask)) {
                continue;
              }
              var stream = SYSCALLS.getStreamFromFD(fd);
              var flags2 = SYSCALLS.DEFAULT_POLLMASK;
              if (stream.stream_ops.poll) {
                var timeoutInMillis = -1;
                if (timeout) {
                  var tv_sec = readfds ? HEAP32[timeout >> 2] : 0, tv_usec = readfds ? HEAP32[timeout + 4 >> 2] : 0;
                  timeoutInMillis = (tv_sec + tv_usec / 1e6) * 1e3;
                }
                flags2 = stream.stream_ops.poll(stream, timeoutInMillis);
              }
              if (flags2 & 1 && check2(fd, srcReadLow, srcReadHigh, mask)) {
                fd < 32 ? dstReadLow = dstReadLow | mask : dstReadHigh = dstReadHigh | mask;
                total++;
              }
              if (flags2 & 4 && check2(fd, srcWriteLow, srcWriteHigh, mask)) {
                fd < 32 ? dstWriteLow = dstWriteLow | mask : dstWriteHigh = dstWriteHigh | mask;
                total++;
              }
              if (flags2 & 2 && check2(fd, srcExceptLow, srcExceptHigh, mask)) {
                fd < 32 ? dstExceptLow = dstExceptLow | mask : dstExceptHigh = dstExceptHigh | mask;
                total++;
              }
            }
            if (readfds) {
              HEAP32[readfds >> 2] = dstReadLow;
              HEAP32[readfds + 4 >> 2] = dstReadHigh;
            }
            if (writefds) {
              HEAP32[writefds >> 2] = dstWriteLow;
              HEAP32[writefds + 4 >> 2] = dstWriteHigh;
            }
            if (exceptfds) {
              HEAP32[exceptfds >> 2] = dstExceptLow;
              HEAP32[exceptfds + 4 >> 2] = dstExceptHigh;
            }
            return total;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall__newselect.sig = "iipppp";
        var SOCKFS = {
          mount(mount) {
            Module["websocket"] = Module["websocket"] && "object" === typeof Module["websocket"] ? Module["websocket"] : {};
            Module["websocket"]._callbacks = {};
            Module["websocket"]["on"] = /** @this{Object} */
            function(event, callback) {
              if ("function" === typeof callback) {
                this._callbacks[event] = callback;
              }
              return this;
            };
            Module["websocket"].emit = /** @this{Object} */
            function(event, param2) {
              if ("function" === typeof this._callbacks[event]) {
                this._callbacks[event].call(this, param2);
              }
            };
            return FS.createNode(null, "/", 16384 | 511, 0);
          },
          createSocket(family, type, protocol2) {
            type &= ~526336;
            var streaming = type == 1;
            if (streaming && protocol2 && protocol2 != 6) {
              throw new FS.ErrnoError(66);
            }
            var sock = {
              family,
              type,
              protocol: protocol2,
              server: null,
              error: null,
              // Used in getsockopt for SOL_SOCKET/SO_ERROR test
              peers: {},
              pending: [],
              recv_queue: [],
              sock_ops: SOCKFS.websocket_sock_ops
            };
            var name3 = SOCKFS.nextname();
            var node = FS.createNode(SOCKFS.root, name3, 49152, 0);
            node.sock = sock;
            var stream = FS.createStream({
              path: name3,
              node,
              flags: 2,
              seekable: false,
              stream_ops: SOCKFS.stream_ops
            });
            sock.stream = stream;
            return sock;
          },
          getSocket(fd) {
            var stream = FS.getStream(fd);
            if (!stream || !FS.isSocket(stream.node.mode)) {
              return null;
            }
            return stream.node.sock;
          },
          stream_ops: {
            poll(stream) {
              var sock = stream.node.sock;
              return sock.sock_ops.poll(sock);
            },
            ioctl(stream, request2, varargs) {
              var sock = stream.node.sock;
              return sock.sock_ops.ioctl(sock, request2, varargs);
            },
            read(stream, buffer2, offset, length, position) {
              var sock = stream.node.sock;
              var msg = sock.sock_ops.recvmsg(sock, length);
              if (!msg) {
                return 0;
              }
              buffer2.set(msg.buffer, offset);
              return msg.buffer.length;
            },
            write(stream, buffer2, offset, length, position) {
              var sock = stream.node.sock;
              return sock.sock_ops.sendmsg(sock, buffer2, offset, length);
            },
            close(stream) {
              var sock = stream.node.sock;
              sock.sock_ops.close(sock);
            }
          },
          nextname() {
            if (!SOCKFS.nextname.current) {
              SOCKFS.nextname.current = 0;
            }
            return "socket[" + SOCKFS.nextname.current++ + "]";
          },
          websocket_sock_ops: {
            createPeer(sock, addr2, port) {
              var ws4;
              if (typeof addr2 == "object") {
                ws4 = addr2;
                addr2 = null;
                port = null;
              }
              if (ws4) {
                if (ws4._socket) {
                  addr2 = ws4._socket.remoteAddress;
                  port = ws4._socket.remotePort;
                } else {
                  var result = /ws[s]?:\/\/([^:]+):(\d+)/.exec(ws4.url);
                  if (!result) {
                    throw new Error("WebSocket URL must be in the format ws(s)://address:port");
                  }
                  addr2 = result[1];
                  port = parseInt(result[2], 10);
                }
              } else {
                try {
                  var runtimeConfig = Module["websocket"] && "object" === typeof Module["websocket"];
                  var url = "ws:#".replace("#", "//");
                  if (runtimeConfig) {
                    if ("string" === typeof Module["websocket"]["url"]) {
                      url = Module["websocket"]["url"];
                    }
                  }
                  if (url === "ws://" || url === "wss://") {
                    var parts2 = addr2.split("/");
                    url = url + parts2[0] + ":" + port + "/" + parts2.slice(1).join("/");
                  }
                  var subProtocols = "binary";
                  if (runtimeConfig) {
                    if ("string" === typeof Module["websocket"]["subprotocol"]) {
                      subProtocols = Module["websocket"]["subprotocol"];
                    }
                  }
                  var opts = void 0;
                  if (subProtocols !== "null") {
                    subProtocols = subProtocols.replace(/^ +| +$/g, "").split(/ *, */);
                    opts = subProtocols;
                  }
                  if (runtimeConfig && null === Module["websocket"]["subprotocol"]) {
                    subProtocols = "null";
                    opts = void 0;
                  }
                  var WebSocketConstructor;
                  if (ENVIRONMENT_IS_NODE) {
                    WebSocketConstructor = /** @type{(typeof WebSocket)} */
                    require("ws");
                  } else {
                    WebSocketConstructor = WebSocket;
                  }
                  ws4 = new WebSocketConstructor(url, opts);
                  ws4.binaryType = "arraybuffer";
                } catch (e6) {
                  throw new FS.ErrnoError(23);
                }
              }
              var peer = {
                addr: addr2,
                port,
                socket: ws4,
                dgram_send_queue: []
              };
              SOCKFS.websocket_sock_ops.addPeer(sock, peer);
              SOCKFS.websocket_sock_ops.handlePeerEvents(sock, peer);
              if (sock.type === 2 && typeof sock.sport != "undefined") {
                peer.dgram_send_queue.push(new Uint8Array([
                  255,
                  255,
                  255,
                  255,
                  "p".charCodeAt(0),
                  "o".charCodeAt(0),
                  "r".charCodeAt(0),
                  "t".charCodeAt(0),
                  (sock.sport & 65280) >> 8,
                  sock.sport & 255
                ]));
              }
              return peer;
            },
            getPeer(sock, addr2, port) {
              return sock.peers[addr2 + ":" + port];
            },
            addPeer(sock, peer) {
              sock.peers[peer.addr + ":" + peer.port] = peer;
            },
            removePeer(sock, peer) {
              delete sock.peers[peer.addr + ":" + peer.port];
            },
            handlePeerEvents(sock, peer) {
              var first = true;
              var handleOpen = function() {
                Module["websocket"].emit("open", sock.stream.fd);
                try {
                  var queued = peer.dgram_send_queue.shift();
                  while (queued) {
                    peer.socket.send(queued);
                    queued = peer.dgram_send_queue.shift();
                  }
                } catch (e6) {
                  peer.socket.close();
                }
              };
              function handleMessage(data) {
                if (typeof data == "string") {
                  var encoder = new TextEncoder();
                  data = encoder.encode(data);
                } else {
                  assert(data.byteLength !== void 0);
                  if (data.byteLength == 0) {
                    return;
                  }
                  data = new Uint8Array(data);
                }
                var wasfirst = first;
                first = false;
                if (wasfirst && data.length === 10 && data[0] === 255 && data[1] === 255 && data[2] === 255 && data[3] === 255 && data[4] === "p".charCodeAt(0) && data[5] === "o".charCodeAt(0) && data[6] === "r".charCodeAt(0) && data[7] === "t".charCodeAt(0)) {
                  var newport = data[8] << 8 | data[9];
                  SOCKFS.websocket_sock_ops.removePeer(sock, peer);
                  peer.port = newport;
                  SOCKFS.websocket_sock_ops.addPeer(sock, peer);
                  return;
                }
                sock.recv_queue.push({ addr: peer.addr, port: peer.port, data });
                Module["websocket"].emit("message", sock.stream.fd);
              }
              ;
              if (ENVIRONMENT_IS_NODE) {
                peer.socket.on("open", handleOpen);
                peer.socket.on("message", function(data, isBinary2) {
                  if (!isBinary2) {
                    return;
                  }
                  handleMessage(new Uint8Array(data).buffer);
                });
                peer.socket.on("close", function() {
                  Module["websocket"].emit("close", sock.stream.fd);
                });
                peer.socket.on("error", function(error2) {
                  sock.error = 14;
                  Module["websocket"].emit("error", [sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused"]);
                });
              } else {
                peer.socket.onopen = handleOpen;
                peer.socket.onclose = function() {
                  Module["websocket"].emit("close", sock.stream.fd);
                };
                peer.socket.onmessage = function peer_socket_onmessage(event) {
                  handleMessage(event.data);
                };
                peer.socket.onerror = function(error2) {
                  sock.error = 14;
                  Module["websocket"].emit("error", [sock.stream.fd, sock.error, "ECONNREFUSED: Connection refused"]);
                };
              }
            },
            poll(sock) {
              if (sock.type === 1 && sock.server) {
                return sock.pending.length ? 64 | 1 : 0;
              }
              var mask = 0;
              var dest = sock.type === 1 ? (
                // we only care about the socket state for connection-based sockets
                SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport)
              ) : null;
              if (sock.recv_queue.length || !dest || // connection-less sockets are always ready to read
              dest && dest.socket.readyState === dest.socket.CLOSING || dest && dest.socket.readyState === dest.socket.CLOSED) {
                mask |= 64 | 1;
              }
              if (!dest || // connection-less sockets are always ready to write
              dest && dest.socket.readyState === dest.socket.OPEN) {
                mask |= 4;
              }
              if (dest && dest.socket.readyState === dest.socket.CLOSING || dest && dest.socket.readyState === dest.socket.CLOSED) {
                mask |= 16;
              }
              return mask;
            },
            ioctl(sock, request2, arg) {
              switch (request2) {
                case 21531:
                  var bytes2 = 0;
                  if (sock.recv_queue.length) {
                    bytes2 = sock.recv_queue[0].data.length;
                  }
                  HEAP32[arg >> 2] = bytes2;
                  return 0;
                default:
                  return 28;
              }
            },
            close(sock) {
              if (sock.server) {
                try {
                  sock.server.close();
                } catch (e6) {
                }
                sock.server = null;
              }
              var peers = Object.keys(sock.peers);
              for (var i8 = 0; i8 < peers.length; i8++) {
                var peer = sock.peers[peers[i8]];
                try {
                  peer.socket.close();
                } catch (e6) {
                }
                SOCKFS.websocket_sock_ops.removePeer(sock, peer);
              }
              return 0;
            },
            bind(sock, addr2, port) {
              if (typeof sock.saddr != "undefined" || typeof sock.sport != "undefined") {
                throw new FS.ErrnoError(28);
              }
              sock.saddr = addr2;
              sock.sport = port;
              if (sock.type === 2) {
                if (sock.server) {
                  sock.server.close();
                  sock.server = null;
                }
                try {
                  sock.sock_ops.listen(sock, 0);
                } catch (e6) {
                  if (!(e6.name === "ErrnoError")) throw e6;
                  if (e6.errno !== 138) throw e6;
                }
              }
            },
            connect(sock, addr2, port) {
              if (sock.server) {
                throw new FS.ErrnoError(138);
              }
              if (typeof sock.daddr != "undefined" && typeof sock.dport != "undefined") {
                var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
                if (dest) {
                  if (dest.socket.readyState === dest.socket.CONNECTING) {
                    throw new FS.ErrnoError(7);
                  } else {
                    throw new FS.ErrnoError(30);
                  }
                }
              }
              var peer = SOCKFS.websocket_sock_ops.createPeer(sock, addr2, port);
              sock.daddr = peer.addr;
              sock.dport = peer.port;
              throw new FS.ErrnoError(26);
            },
            listen(sock, backlog) {
              if (!ENVIRONMENT_IS_NODE) {
                throw new FS.ErrnoError(138);
              }
              if (sock.server) {
                throw new FS.ErrnoError(28);
              }
              var WebSocketServer3 = require("ws").Server;
              var host = sock.saddr;
              sock.server = new WebSocketServer3({
                host,
                port: sock.sport
                // TODO support backlog
              });
              Module["websocket"].emit("listen", sock.stream.fd);
              sock.server.on("connection", function(ws4) {
                if (sock.type === 1) {
                  var newsock = SOCKFS.createSocket(sock.family, sock.type, sock.protocol);
                  var peer = SOCKFS.websocket_sock_ops.createPeer(newsock, ws4);
                  newsock.daddr = peer.addr;
                  newsock.dport = peer.port;
                  sock.pending.push(newsock);
                  Module["websocket"].emit("connection", newsock.stream.fd);
                } else {
                  SOCKFS.websocket_sock_ops.createPeer(sock, ws4);
                  Module["websocket"].emit("connection", sock.stream.fd);
                }
              });
              sock.server.on("close", function() {
                Module["websocket"].emit("close", sock.stream.fd);
                sock.server = null;
              });
              sock.server.on("error", function(error2) {
                sock.error = 23;
                Module["websocket"].emit("error", [sock.stream.fd, sock.error, "EHOSTUNREACH: Host is unreachable"]);
              });
            },
            accept(listensock) {
              if (!listensock.server || !listensock.pending.length) {
                throw new FS.ErrnoError(28);
              }
              var newsock = listensock.pending.shift();
              newsock.stream.flags = listensock.stream.flags;
              return newsock;
            },
            getname(sock, peer) {
              var addr2, port;
              if (peer) {
                if (sock.daddr === void 0 || sock.dport === void 0) {
                  throw new FS.ErrnoError(53);
                }
                addr2 = sock.daddr;
                port = sock.dport;
              } else {
                addr2 = sock.saddr || 0;
                port = sock.sport || 0;
              }
              return { addr: addr2, port };
            },
            sendmsg(sock, buffer2, offset, length, addr2, port) {
              if (sock.type === 2) {
                if (addr2 === void 0 || port === void 0) {
                  addr2 = sock.daddr;
                  port = sock.dport;
                }
                if (addr2 === void 0 || port === void 0) {
                  throw new FS.ErrnoError(17);
                }
              } else {
                addr2 = sock.daddr;
                port = sock.dport;
              }
              var dest = SOCKFS.websocket_sock_ops.getPeer(sock, addr2, port);
              if (sock.type === 1) {
                if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
                  throw new FS.ErrnoError(53);
                } else if (dest.socket.readyState === dest.socket.CONNECTING) {
                  throw new FS.ErrnoError(6);
                }
              }
              if (ArrayBuffer.isView(buffer2)) {
                offset += buffer2.byteOffset;
                buffer2 = buffer2.buffer;
              }
              var data;
              data = buffer2.slice(offset, offset + length);
              if (sock.type === 2) {
                if (!dest || dest.socket.readyState !== dest.socket.OPEN) {
                  if (!dest || dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
                    dest = SOCKFS.websocket_sock_ops.createPeer(sock, addr2, port);
                  }
                  dest.dgram_send_queue.push(data);
                  return length;
                }
              }
              try {
                dest.socket.send(data);
                return length;
              } catch (e6) {
                throw new FS.ErrnoError(28);
              }
            },
            recvmsg(sock, length) {
              if (sock.type === 1 && sock.server) {
                throw new FS.ErrnoError(53);
              }
              var queued = sock.recv_queue.shift();
              if (!queued) {
                if (sock.type === 1) {
                  var dest = SOCKFS.websocket_sock_ops.getPeer(sock, sock.daddr, sock.dport);
                  if (!dest) {
                    throw new FS.ErrnoError(53);
                  }
                  if (dest.socket.readyState === dest.socket.CLOSING || dest.socket.readyState === dest.socket.CLOSED) {
                    return null;
                  }
                  throw new FS.ErrnoError(6);
                }
                throw new FS.ErrnoError(6);
              }
              var queuedLength = queued.data.byteLength || queued.data.length;
              var queuedOffset = queued.data.byteOffset || 0;
              var queuedBuffer = queued.data.buffer || queued.data;
              var bytesRead = Math.min(length, queuedLength);
              var res = {
                buffer: new Uint8Array(queuedBuffer, queuedOffset, bytesRead),
                addr: queued.addr,
                port: queued.port
              };
              if (sock.type === 1 && bytesRead < queuedLength) {
                var bytesRemaining = queuedLength - bytesRead;
                queued.data = new Uint8Array(queuedBuffer, queuedOffset + bytesRead, bytesRemaining);
                sock.recv_queue.unshift(queued);
              }
              return res;
            }
          }
        };
        var getSocketFromFD = (fd) => {
          var socket = SOCKFS.getSocket(fd);
          if (!socket) throw new FS.ErrnoError(8);
          return socket;
        };
        var Sockets = {
          BUFFER_SIZE: 10240,
          MAX_BUFFER_SIZE: 10485760,
          nextFd: 1,
          fds: {},
          nextport: 1,
          maxport: 65535,
          peer: null,
          connections: {},
          portmap: {},
          localAddr: 4261412874,
          addrPool: [33554442, 50331658, 67108874, 83886090, 100663306, 117440522, 134217738, 150994954, 167772170, 184549386, 201326602, 218103818, 234881034]
        };
        var inetNtop4 = (addr2) => {
          return (addr2 & 255) + "." + (addr2 >> 8 & 255) + "." + (addr2 >> 16 & 255) + "." + (addr2 >> 24 & 255);
        };
        var inetNtop6 = (ints) => {
          var str = "";
          var word = 0;
          var longest = 0;
          var lastzero = 0;
          var zstart = 0;
          var len = 0;
          var i8 = 0;
          var parts2 = [
            ints[0] & 65535,
            ints[0] >> 16,
            ints[1] & 65535,
            ints[1] >> 16,
            ints[2] & 65535,
            ints[2] >> 16,
            ints[3] & 65535,
            ints[3] >> 16
          ];
          var hasipv4 = true;
          var v4part = "";
          for (i8 = 0; i8 < 5; i8++) {
            if (parts2[i8] !== 0) {
              hasipv4 = false;
              break;
            }
          }
          if (hasipv4) {
            v4part = inetNtop4(parts2[6] | parts2[7] << 16);
            if (parts2[5] === -1) {
              str = "::ffff:";
              str += v4part;
              return str;
            }
            if (parts2[5] === 0) {
              str = "::";
              if (v4part === "0.0.0.0") v4part = "";
              if (v4part === "0.0.0.1") v4part = "1";
              str += v4part;
              return str;
            }
          }
          for (word = 0; word < 8; word++) {
            if (parts2[word] === 0) {
              if (word - lastzero > 1) {
                len = 0;
              }
              lastzero = word;
              len++;
            }
            if (len > longest) {
              longest = len;
              zstart = word - longest + 1;
            }
          }
          for (word = 0; word < 8; word++) {
            if (longest > 1) {
              if (parts2[word] === 0 && word >= zstart && word < zstart + longest) {
                if (word === zstart) {
                  str += ":";
                  if (zstart === 0) str += ":";
                }
                continue;
              }
            }
            str += Number(_ntohs(parts2[word] & 65535)).toString(16);
            str += word < 7 ? ":" : "";
          }
          return str;
        };
        var readSockaddr = (sa, salen) => {
          var family = HEAP16[sa >> 1];
          var port = _ntohs(HEAPU16[sa + 2 >> 1]);
          var addr2;
          switch (family) {
            case 2:
              if (salen !== 16) {
                return { errno: 28 };
              }
              addr2 = HEAP32[sa + 4 >> 2];
              addr2 = inetNtop4(addr2);
              break;
            case 10:
              if (salen !== 28) {
                return { errno: 28 };
              }
              addr2 = [
                HEAP32[sa + 8 >> 2],
                HEAP32[sa + 12 >> 2],
                HEAP32[sa + 16 >> 2],
                HEAP32[sa + 20 >> 2]
              ];
              addr2 = inetNtop6(addr2);
              break;
            default:
              return { errno: 5 };
          }
          return { family, addr: addr2, port };
        };
        var inetPton4 = (str) => {
          var b9 = str.split(".");
          for (var i8 = 0; i8 < 4; i8++) {
            var tmp = Number(b9[i8]);
            if (isNaN(tmp)) return null;
            b9[i8] = tmp;
          }
          return (b9[0] | b9[1] << 8 | b9[2] << 16 | b9[3] << 24) >>> 0;
        };
        var jstoi_q = (str) => parseInt(str);
        var inetPton6 = (str) => {
          var words;
          var w10, offset, z6, i8;
          var valid6regx = /^((?=.*::)(?!.*::.+::)(::)?([\dA-F]{1,4}:(:|\b)|){5}|([\dA-F]{1,4}:){6})((([\dA-F]{1,4}((?!\3)::|:\b|$))|(?!\2\3)){2}|(((2[0-4]|1\d|[1-9])?\d|25[0-5])\.?\b){4})$/i;
          var parts2 = [];
          if (!valid6regx.test(str)) {
            return null;
          }
          if (str === "::") {
            return [0, 0, 0, 0, 0, 0, 0, 0];
          }
          if (str.startsWith("::")) {
            str = str.replace("::", "Z:");
          } else {
            str = str.replace("::", ":Z:");
          }
          if (str.indexOf(".") > 0) {
            str = str.replace(new RegExp("[.]", "g"), ":");
            words = str.split(":");
            words[words.length - 4] = jstoi_q(words[words.length - 4]) + jstoi_q(words[words.length - 3]) * 256;
            words[words.length - 3] = jstoi_q(words[words.length - 2]) + jstoi_q(words[words.length - 1]) * 256;
            words = words.slice(0, words.length - 2);
          } else {
            words = str.split(":");
          }
          offset = 0;
          z6 = 0;
          for (w10 = 0; w10 < words.length; w10++) {
            if (typeof words[w10] == "string") {
              if (words[w10] === "Z") {
                for (z6 = 0; z6 < 8 - words.length + 1; z6++) {
                  parts2[w10 + z6] = 0;
                }
                offset = z6 - 1;
              } else {
                parts2[w10 + offset] = _htons(parseInt(words[w10], 16));
              }
            } else {
              parts2[w10 + offset] = words[w10];
            }
          }
          return [
            parts2[1] << 16 | parts2[0],
            parts2[3] << 16 | parts2[2],
            parts2[5] << 16 | parts2[4],
            parts2[7] << 16 | parts2[6]
          ];
        };
        var DNS = {
          address_map: {
            id: 1,
            addrs: {},
            names: {}
          },
          lookup_name(name3) {
            var res = inetPton4(name3);
            if (res !== null) {
              return name3;
            }
            res = inetPton6(name3);
            if (res !== null) {
              return name3;
            }
            var addr2;
            if (DNS.address_map.addrs[name3]) {
              addr2 = DNS.address_map.addrs[name3];
            } else {
              var id = DNS.address_map.id++;
              assert(id < 65535, "exceeded max address mappings of 65535");
              addr2 = "172.29." + (id & 255) + "." + (id & 65280);
              DNS.address_map.names[addr2] = name3;
              DNS.address_map.addrs[name3] = addr2;
            }
            return addr2;
          },
          lookup_addr(addr2) {
            if (DNS.address_map.names[addr2]) {
              return DNS.address_map.names[addr2];
            }
            return null;
          }
        };
        var getSocketAddress = (addrp, addrlen) => {
          var info3 = readSockaddr(addrp, addrlen);
          if (info3.errno) throw new FS.ErrnoError(info3.errno);
          info3.addr = DNS.lookup_addr(info3.addr) || info3.addr;
          return info3;
        };
        function ___syscall_bind(fd, addr2, addrlen, d1, d22, d32) {
          try {
            var sock = getSocketFromFD(fd);
            var info3 = getSocketAddress(addr2, addrlen);
            sock.sock_ops.bind(sock, info3.addr, info3.port);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_bind.sig = "iippiii";
        function ___syscall_chdir(path3) {
          try {
            path3 = SYSCALLS.getStr(path3);
            FS.chdir(path3);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_chdir.sig = "ip";
        function ___syscall_chmod(path3, mode) {
          try {
            path3 = SYSCALLS.getStr(path3);
            FS.chmod(path3, mode);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_chmod.sig = "ipi";
        function ___syscall_connect(fd, addr2, addrlen, d1, d22, d32) {
          try {
            var sock = getSocketFromFD(fd);
            var info3 = getSocketAddress(addr2, addrlen);
            sock.sock_ops.connect(sock, info3.addr, info3.port);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_connect.sig = "iippiii";
        function ___syscall_dup(fd) {
          try {
            var old = SYSCALLS.getStreamFromFD(fd);
            return FS.dupStream(old).fd;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_dup.sig = "ii";
        function ___syscall_dup3(fd, newfd, flags2) {
          try {
            var old = SYSCALLS.getStreamFromFD(fd);
            if (old.fd === newfd) return -28;
            if (newfd < 0 || newfd >= FS.MAX_OPEN_FDS) return -8;
            var existing = FS.getStream(newfd);
            if (existing) FS.close(existing);
            return FS.dupStream(old, newfd).fd;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_dup3.sig = "iiii";
        function ___syscall_faccessat(dirfd, path3, amode, flags2) {
          try {
            path3 = SYSCALLS.getStr(path3);
            path3 = SYSCALLS.calculateAt(dirfd, path3);
            if (amode & ~7) {
              return -28;
            }
            var lookup = FS.lookupPath(path3, { follow: true });
            var node = lookup.node;
            if (!node) {
              return -44;
            }
            var perms = "";
            if (amode & 4) perms += "r";
            if (amode & 2) perms += "w";
            if (amode & 1) perms += "x";
            if (perms && FS.nodePermissions(node, perms)) {
              return -2;
            }
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_faccessat.sig = "iipii";
        var ___syscall_fadvise64 = (fd, offset, len, advice) => {
          return 0;
        };
        ___syscall_fadvise64.sig = "iijji";
        var INT53_MAX = 9007199254740992;
        var INT53_MIN = -9007199254740992;
        var bigintToI53Checked = (num) => num < INT53_MIN || num > INT53_MAX ? NaN : Number(num);
        function ___syscall_fallocate(fd, mode, offset, len) {
          offset = bigintToI53Checked(offset);
          len = bigintToI53Checked(len);
          try {
            if (isNaN(offset)) return 61;
            var stream = SYSCALLS.getStreamFromFD(fd);
            FS.allocate(stream, offset, len);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
          ;
        }
        ___syscall_fallocate.sig = "iiijj";
        function syscallGetVarargI() {
          var ret = HEAP32[+SYSCALLS.varargs >> 2];
          SYSCALLS.varargs += 4;
          return ret;
        }
        var syscallGetVarargP = syscallGetVarargI;
        function ___syscall_fcntl64(fd, cmd, varargs) {
          SYSCALLS.varargs = varargs;
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            switch (cmd) {
              case 0: {
                var arg = syscallGetVarargI();
                if (arg < 0) {
                  return -28;
                }
                while (FS.streams[arg]) {
                  arg++;
                }
                var newStream;
                newStream = FS.dupStream(stream, arg);
                return newStream.fd;
              }
              case 1:
              case 2:
                return 0;
              // FD_CLOEXEC makes no sense for a single process.
              case 3:
                return stream.flags;
              case 4: {
                var arg = syscallGetVarargI();
                stream.flags |= arg;
                return 0;
              }
              case 12: {
                var arg = syscallGetVarargP();
                var offset = 0;
                HEAP16[arg + offset >> 1] = 2;
                return 0;
              }
              case 13:
              case 14:
                return 0;
            }
            return -28;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_fcntl64.sig = "iiip";
        function ___syscall_fdatasync(fd) {
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_fdatasync.sig = "ii";
        function ___syscall_fstat64(fd, buf) {
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            return SYSCALLS.doStat(FS.stat, stream.path, buf);
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_fstat64.sig = "iip";
        function ___syscall_ftruncate64(fd, length) {
          length = bigintToI53Checked(length);
          try {
            if (isNaN(length)) return 61;
            FS.ftruncate(fd, length);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
          ;
        }
        ___syscall_ftruncate64.sig = "iij";
        var stringToUTF8 = (str, outPtr, maxBytesToWrite) => {
          return stringToUTF8Array(str, HEAPU8, outPtr, maxBytesToWrite);
        };
        function ___syscall_getcwd(buf, size2) {
          try {
            if (size2 === 0) return -28;
            var cwd = FS.cwd();
            var cwdLengthInBytes = lengthBytesUTF8(cwd) + 1;
            if (size2 < cwdLengthInBytes) return -68;
            stringToUTF8(cwd, buf, size2);
            return cwdLengthInBytes;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_getcwd.sig = "ipp";
        function ___syscall_getdents64(fd, dirp, count2) {
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            stream.getdents ||= FS.readdir(stream.path);
            var struct_size = 280;
            var pos = 0;
            var off = FS.llseek(stream, 0, 1);
            var idx = Math.floor(off / struct_size);
            while (idx < stream.getdents.length && pos + struct_size <= count2) {
              var id;
              var type;
              var name3 = stream.getdents[idx];
              if (name3 === ".") {
                id = stream.node.id;
                type = 4;
              } else if (name3 === "..") {
                var lookup = FS.lookupPath(stream.path, { parent: true });
                id = lookup.node.id;
                type = 4;
              } else {
                var child = FS.lookupNode(stream.node, name3);
                id = child.id;
                type = FS.isChrdev(child.mode) ? 2 : (
                  // DT_CHR, character device.
                  FS.isDir(child.mode) ? 4 : (
                    // DT_DIR, directory.
                    FS.isLink(child.mode) ? 10 : (
                      // DT_LNK, symbolic link.
                      8
                    )
                  )
                );
              }
              HEAP64[dirp + pos >> 3] = BigInt(id);
              HEAP64[dirp + pos + 8 >> 3] = BigInt((idx + 1) * struct_size);
              HEAP16[dirp + pos + 16 >> 1] = 280;
              HEAP8[dirp + pos + 18] = type;
              stringToUTF8(name3, dirp + pos + 19, 256);
              pos += struct_size;
              idx += 1;
            }
            FS.llseek(stream, idx * struct_size, 0);
            return pos;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_getdents64.sig = "iipp";
        var writeSockaddr = (sa, family, addr2, port, addrlen) => {
          switch (family) {
            case 2:
              addr2 = inetPton4(addr2);
              zeroMemory(sa, 16);
              if (addrlen) {
                HEAP32[addrlen >> 2] = 16;
              }
              HEAP16[sa >> 1] = family;
              HEAP32[sa + 4 >> 2] = addr2;
              HEAP16[sa + 2 >> 1] = _htons(port);
              break;
            case 10:
              addr2 = inetPton6(addr2);
              zeroMemory(sa, 28);
              if (addrlen) {
                HEAP32[addrlen >> 2] = 28;
              }
              HEAP32[sa >> 2] = family;
              HEAP32[sa + 8 >> 2] = addr2[0];
              HEAP32[sa + 12 >> 2] = addr2[1];
              HEAP32[sa + 16 >> 2] = addr2[2];
              HEAP32[sa + 20 >> 2] = addr2[3];
              HEAP16[sa + 2 >> 1] = _htons(port);
              break;
            default:
              return 5;
          }
          return 0;
        };
        function ___syscall_getsockname(fd, addr2, addrlen, d1, d22, d32) {
          try {
            var sock = getSocketFromFD(fd);
            var errno = writeSockaddr(addr2, sock.family, DNS.lookup_name(sock.saddr || "0.0.0.0"), sock.sport, addrlen);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_getsockname.sig = "iippiii";
        function ___syscall_getsockopt(fd, level, optname, optval, optlen, d1) {
          try {
            var sock = getSocketFromFD(fd);
            if (level === 1) {
              if (optname === 4) {
                HEAP32[optval >> 2] = sock.error;
                HEAP32[optlen >> 2] = 4;
                sock.error = null;
                return 0;
              }
            }
            return -50;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_getsockopt.sig = "iiiippi";
        function ___syscall_ioctl(fd, op, varargs) {
          SYSCALLS.varargs = varargs;
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            switch (op) {
              case 21509: {
                if (!stream.tty) return -59;
                return 0;
              }
              case 21505: {
                if (!stream.tty) return -59;
                if (stream.tty.ops.ioctl_tcgets) {
                  var termios = stream.tty.ops.ioctl_tcgets(stream);
                  var argp = syscallGetVarargP();
                  HEAP32[argp >> 2] = termios.c_iflag || 0;
                  HEAP32[argp + 4 >> 2] = termios.c_oflag || 0;
                  HEAP32[argp + 8 >> 2] = termios.c_cflag || 0;
                  HEAP32[argp + 12 >> 2] = termios.c_lflag || 0;
                  for (var i8 = 0; i8 < 32; i8++) {
                    HEAP8[argp + i8 + 17] = termios.c_cc[i8] || 0;
                  }
                  return 0;
                }
                return 0;
              }
              case 21510:
              case 21511:
              case 21512: {
                if (!stream.tty) return -59;
                return 0;
              }
              case 21506:
              case 21507:
              case 21508: {
                if (!stream.tty) return -59;
                if (stream.tty.ops.ioctl_tcsets) {
                  var argp = syscallGetVarargP();
                  var c_iflag = HEAP32[argp >> 2];
                  var c_oflag = HEAP32[argp + 4 >> 2];
                  var c_cflag = HEAP32[argp + 8 >> 2];
                  var c_lflag = HEAP32[argp + 12 >> 2];
                  var c_cc = [];
                  for (var i8 = 0; i8 < 32; i8++) {
                    c_cc.push(HEAP8[argp + i8 + 17]);
                  }
                  return stream.tty.ops.ioctl_tcsets(stream.tty, op, { c_iflag, c_oflag, c_cflag, c_lflag, c_cc });
                }
                return 0;
              }
              case 21519: {
                if (!stream.tty) return -59;
                var argp = syscallGetVarargP();
                HEAP32[argp >> 2] = 0;
                return 0;
              }
              case 21520: {
                if (!stream.tty) return -59;
                return -28;
              }
              case 21531: {
                var argp = syscallGetVarargP();
                return FS.ioctl(stream, op, argp);
              }
              case 21523: {
                if (!stream.tty) return -59;
                if (stream.tty.ops && stream.tty.ops.ioctl_tiocgwinsz) {
                  var winsize = stream.tty.ops.ioctl_tiocgwinsz(stream.tty);
                  var argp = syscallGetVarargP();
                  HEAP16[argp >> 1] = winsize[0];
                  HEAP16[argp + 2 >> 1] = winsize[1];
                }
                return 0;
              }
              case 21524: {
                if (!stream.tty) return -59;
                return 0;
              }
              case 21515: {
                if (!stream.tty) return -59;
                return 0;
              }
              default:
                return -28;
            }
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_ioctl.sig = "iiip";
        function ___syscall_lstat64(path3, buf) {
          try {
            path3 = SYSCALLS.getStr(path3);
            return SYSCALLS.doStat(FS.lstat, path3, buf);
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_lstat64.sig = "ipp";
        function ___syscall_mkdirat(dirfd, path3, mode) {
          try {
            path3 = SYSCALLS.getStr(path3);
            path3 = SYSCALLS.calculateAt(dirfd, path3);
            path3 = PATH.normalize(path3);
            if (path3[path3.length - 1] === "/") path3 = path3.substr(0, path3.length - 1);
            FS.mkdir(path3, mode, 0);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_mkdirat.sig = "iipi";
        function ___syscall_newfstatat(dirfd, path3, buf, flags2) {
          try {
            path3 = SYSCALLS.getStr(path3);
            var nofollow = flags2 & 256;
            var allowEmpty = flags2 & 4096;
            flags2 = flags2 & ~6400;
            path3 = SYSCALLS.calculateAt(dirfd, path3, allowEmpty);
            return SYSCALLS.doStat(nofollow ? FS.lstat : FS.stat, path3, buf);
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_newfstatat.sig = "iippi";
        function ___syscall_openat(dirfd, path3, flags2, varargs) {
          SYSCALLS.varargs = varargs;
          try {
            path3 = SYSCALLS.getStr(path3);
            path3 = SYSCALLS.calculateAt(dirfd, path3);
            var mode = varargs ? syscallGetVarargI() : 0;
            return FS.open(path3, flags2, mode).fd;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_openat.sig = "iipip";
        var PIPEFS = {
          BUCKET_BUFFER_SIZE: 8192,
          mount(mount) {
            return FS.createNode(null, "/", 16384 | 511, 0);
          },
          createPipe() {
            var pipe = {
              buckets: [],
              // refcnt 2 because pipe has a read end and a write end. We need to be
              // able to read from the read end after write end is closed.
              refcnt: 2
            };
            pipe.buckets.push({
              buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
              offset: 0,
              roffset: 0
            });
            var rName = PIPEFS.nextname();
            var wName = PIPEFS.nextname();
            var rNode = FS.createNode(PIPEFS.root, rName, 4096, 0);
            var wNode = FS.createNode(PIPEFS.root, wName, 4096, 0);
            rNode.pipe = pipe;
            wNode.pipe = pipe;
            var readableStream = FS.createStream({
              path: rName,
              node: rNode,
              flags: 0,
              seekable: false,
              stream_ops: PIPEFS.stream_ops
            });
            rNode.stream = readableStream;
            var writableStream = FS.createStream({
              path: wName,
              node: wNode,
              flags: 1,
              seekable: false,
              stream_ops: PIPEFS.stream_ops
            });
            wNode.stream = writableStream;
            return {
              readable_fd: readableStream.fd,
              writable_fd: writableStream.fd
            };
          },
          stream_ops: {
            poll(stream) {
              var pipe = stream.node.pipe;
              if ((stream.flags & 2097155) === 1) {
                return 256 | 4;
              }
              if (pipe.buckets.length > 0) {
                for (var i8 = 0; i8 < pipe.buckets.length; i8++) {
                  var bucket = pipe.buckets[i8];
                  if (bucket.offset - bucket.roffset > 0) {
                    return 64 | 1;
                  }
                }
              }
              return 0;
            },
            ioctl(stream, request2, varargs) {
              return 28;
            },
            fsync(stream) {
              return 28;
            },
            read(stream, buffer2, offset, length, position) {
              var pipe = stream.node.pipe;
              var currentLength = 0;
              for (var i8 = 0; i8 < pipe.buckets.length; i8++) {
                var bucket = pipe.buckets[i8];
                currentLength += bucket.offset - bucket.roffset;
              }
              var data = buffer2.subarray(offset, offset + length);
              if (length <= 0) {
                return 0;
              }
              if (currentLength == 0) {
                throw new FS.ErrnoError(6);
              }
              var toRead = Math.min(currentLength, length);
              var totalRead = toRead;
              var toRemove = 0;
              for (var i8 = 0; i8 < pipe.buckets.length; i8++) {
                var currBucket = pipe.buckets[i8];
                var bucketSize = currBucket.offset - currBucket.roffset;
                if (toRead <= bucketSize) {
                  var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset);
                  if (toRead < bucketSize) {
                    tmpSlice = tmpSlice.subarray(0, toRead);
                    currBucket.roffset += toRead;
                  } else {
                    toRemove++;
                  }
                  data.set(tmpSlice);
                  break;
                } else {
                  var tmpSlice = currBucket.buffer.subarray(currBucket.roffset, currBucket.offset);
                  data.set(tmpSlice);
                  data = data.subarray(tmpSlice.byteLength);
                  toRead -= tmpSlice.byteLength;
                  toRemove++;
                }
              }
              if (toRemove && toRemove == pipe.buckets.length) {
                toRemove--;
                pipe.buckets[toRemove].offset = 0;
                pipe.buckets[toRemove].roffset = 0;
              }
              pipe.buckets.splice(0, toRemove);
              return totalRead;
            },
            write(stream, buffer2, offset, length, position) {
              var pipe = stream.node.pipe;
              var data = buffer2.subarray(offset, offset + length);
              var dataLen = data.byteLength;
              if (dataLen <= 0) {
                return 0;
              }
              var currBucket = null;
              if (pipe.buckets.length == 0) {
                currBucket = {
                  buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
                  offset: 0,
                  roffset: 0
                };
                pipe.buckets.push(currBucket);
              } else {
                currBucket = pipe.buckets[pipe.buckets.length - 1];
              }
              assert(currBucket.offset <= PIPEFS.BUCKET_BUFFER_SIZE);
              var freeBytesInCurrBuffer = PIPEFS.BUCKET_BUFFER_SIZE - currBucket.offset;
              if (freeBytesInCurrBuffer >= dataLen) {
                currBucket.buffer.set(data, currBucket.offset);
                currBucket.offset += dataLen;
                return dataLen;
              } else if (freeBytesInCurrBuffer > 0) {
                currBucket.buffer.set(data.subarray(0, freeBytesInCurrBuffer), currBucket.offset);
                currBucket.offset += freeBytesInCurrBuffer;
                data = data.subarray(freeBytesInCurrBuffer, data.byteLength);
              }
              var numBuckets = data.byteLength / PIPEFS.BUCKET_BUFFER_SIZE | 0;
              var remElements = data.byteLength % PIPEFS.BUCKET_BUFFER_SIZE;
              for (var i8 = 0; i8 < numBuckets; i8++) {
                var newBucket = {
                  buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
                  offset: PIPEFS.BUCKET_BUFFER_SIZE,
                  roffset: 0
                };
                pipe.buckets.push(newBucket);
                newBucket.buffer.set(data.subarray(0, PIPEFS.BUCKET_BUFFER_SIZE));
                data = data.subarray(PIPEFS.BUCKET_BUFFER_SIZE, data.byteLength);
              }
              if (remElements > 0) {
                var newBucket = {
                  buffer: new Uint8Array(PIPEFS.BUCKET_BUFFER_SIZE),
                  offset: data.byteLength,
                  roffset: 0
                };
                pipe.buckets.push(newBucket);
                newBucket.buffer.set(data);
              }
              return dataLen;
            },
            close(stream) {
              var pipe = stream.node.pipe;
              pipe.refcnt--;
              if (pipe.refcnt === 0) {
                pipe.buckets = null;
              }
            }
          },
          nextname() {
            if (!PIPEFS.nextname.current) {
              PIPEFS.nextname.current = 0;
            }
            return "pipe[" + PIPEFS.nextname.current++ + "]";
          }
        };
        function ___syscall_pipe(fdPtr) {
          try {
            if (fdPtr == 0) {
              throw new FS.ErrnoError(21);
            }
            var res = PIPEFS.createPipe();
            HEAP32[fdPtr >> 2] = res.readable_fd;
            HEAP32[fdPtr + 4 >> 2] = res.writable_fd;
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_pipe.sig = "ip";
        function ___syscall_poll(fds, nfds, timeout) {
          try {
            var nonzero = 0;
            for (var i8 = 0; i8 < nfds; i8++) {
              var pollfd = fds + 8 * i8;
              var fd = HEAP32[pollfd >> 2];
              var events = HEAP16[pollfd + 4 >> 1];
              var mask = 32;
              var stream = FS.getStream(fd);
              if (stream) {
                mask = SYSCALLS.DEFAULT_POLLMASK;
                if (stream.stream_ops.poll) {
                  mask = stream.stream_ops.poll(stream, -1);
                }
              }
              mask &= events | 8 | 16;
              if (mask) nonzero++;
              HEAP16[pollfd + 6 >> 1] = mask;
            }
            return nonzero;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_poll.sig = "ipii";
        function ___syscall_readlinkat(dirfd, path3, buf, bufsize) {
          try {
            path3 = SYSCALLS.getStr(path3);
            path3 = SYSCALLS.calculateAt(dirfd, path3);
            if (bufsize <= 0) return -28;
            var ret = FS.readlink(path3);
            var len = Math.min(bufsize, lengthBytesUTF8(ret));
            var endChar = HEAP8[buf + len];
            stringToUTF8(ret, buf, bufsize + 1);
            HEAP8[buf + len] = endChar;
            return len;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_readlinkat.sig = "iippp";
        function ___syscall_recvfrom(fd, buf, len, flags2, addr2, addrlen) {
          try {
            var sock = getSocketFromFD(fd);
            var msg = sock.sock_ops.recvmsg(sock, len);
            if (!msg) return 0;
            if (addr2) {
              var errno = writeSockaddr(addr2, sock.family, DNS.lookup_name(msg.addr), msg.port, addrlen);
            }
            HEAPU8.set(msg.buffer, buf);
            return msg.buffer.byteLength;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_recvfrom.sig = "iippipp";
        function ___syscall_renameat(olddirfd, oldpath, newdirfd, newpath) {
          try {
            oldpath = SYSCALLS.getStr(oldpath);
            newpath = SYSCALLS.getStr(newpath);
            oldpath = SYSCALLS.calculateAt(olddirfd, oldpath);
            newpath = SYSCALLS.calculateAt(newdirfd, newpath);
            FS.rename(oldpath, newpath);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_renameat.sig = "iipip";
        function ___syscall_rmdir(path3) {
          try {
            path3 = SYSCALLS.getStr(path3);
            FS.rmdir(path3);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_rmdir.sig = "ip";
        function ___syscall_sendto(fd, message, length, flags2, addr2, addr_len) {
          try {
            var sock = getSocketFromFD(fd);
            if (!addr2) {
              return FS.write(sock.stream, HEAP8, message, length);
            }
            var dest = getSocketAddress(addr2, addr_len);
            return sock.sock_ops.sendmsg(sock, HEAP8, message, length, dest.addr, dest.port);
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_sendto.sig = "iippipp";
        function ___syscall_socket(domain, type, protocol2) {
          try {
            var sock = SOCKFS.createSocket(domain, type, protocol2);
            return sock.stream.fd;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_socket.sig = "iiiiiii";
        function ___syscall_stat64(path3, buf) {
          try {
            path3 = SYSCALLS.getStr(path3);
            return SYSCALLS.doStat(FS.stat, path3, buf);
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_stat64.sig = "ipp";
        function ___syscall_symlink(target, linkpath) {
          try {
            target = SYSCALLS.getStr(target);
            linkpath = SYSCALLS.getStr(linkpath);
            FS.symlink(target, linkpath);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_symlink.sig = "ipp";
        function ___syscall_truncate64(path3, length) {
          length = bigintToI53Checked(length);
          try {
            if (isNaN(length)) return 61;
            path3 = SYSCALLS.getStr(path3);
            FS.truncate(path3, length);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
          ;
        }
        ___syscall_truncate64.sig = "ipj";
        function ___syscall_unlinkat(dirfd, path3, flags2) {
          try {
            path3 = SYSCALLS.getStr(path3);
            path3 = SYSCALLS.calculateAt(dirfd, path3);
            if (flags2 === 0) {
              FS.unlink(path3);
            } else if (flags2 === 512) {
              FS.rmdir(path3);
            } else {
              abort("Invalid flags passed to unlinkat");
            }
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
        }
        ___syscall_unlinkat.sig = "iipi";
        var ___table_base = new WebAssembly.Global({ "value": "i32", "mutable": false }, 1);
        var __abort_js = () => {
          abort("");
        };
        __abort_js.sig = "v";
        var ENV = {};
        var stackAlloc = (sz) => __emscripten_stack_alloc(sz);
        var stringToUTF8OnStack = (str) => {
          var size2 = lengthBytesUTF8(str) + 1;
          var ret = stackAlloc(size2);
          stringToUTF8(str, ret, size2);
          return ret;
        };
        var dlSetError = (msg) => {
          var sp = stackSave();
          var cmsg = stringToUTF8OnStack(msg);
          ___dl_seterr(cmsg, 0);
          stackRestore(sp);
        };
        var dlopenInternal = (handle2, jsflags) => {
          var filename = UTF8ToString(handle2 + 36);
          var flags2 = HEAP32[handle2 + 4 >> 2];
          filename = PATH.normalize(filename);
          var searchpaths = [];
          var global2 = Boolean(flags2 & 256);
          var localScope2 = global2 ? null : {};
          var combinedFlags = {
            global: global2,
            nodelete: Boolean(flags2 & 4096),
            loadAsync: jsflags.loadAsync
          };
          if (jsflags.loadAsync) {
            return loadDynamicLibrary(filename, combinedFlags, localScope2, handle2);
          }
          try {
            return loadDynamicLibrary(filename, combinedFlags, localScope2, handle2);
          } catch (e6) {
            dlSetError(`Could not load dynamic lib: ${filename}
${e6}`);
            return 0;
          }
        };
        var __dlopen_js = (handle2) => {
          return dlopenInternal(handle2, { loadAsync: false });
        };
        __dlopen_js.sig = "pp";
        var __dlsym_js = (handle2, symbol, symbolIndex) => {
          symbol = UTF8ToString(symbol);
          var result;
          var newSymIndex;
          var lib = LDSO.loadedLibsByHandle[handle2];
          if (!lib.exports.hasOwnProperty(symbol) || lib.exports[symbol].stub) {
            dlSetError(`Tried to lookup unknown symbol "${symbol}" in dynamic lib: ${lib.name}`);
            return 0;
          }
          newSymIndex = Object.keys(lib.exports).indexOf(symbol);
          result = lib.exports[symbol];
          if (typeof result == "function") {
            var addr2 = getFunctionAddress(result);
            if (addr2) {
              result = addr2;
            } else {
              result = addFunction(result, result.sig);
              HEAPU32[symbolIndex >> 2] = newSymIndex;
            }
          }
          return result;
        };
        __dlsym_js.sig = "pppp";
        var nowIsMonotonic = 1;
        var __emscripten_get_now_is_monotonic = () => nowIsMonotonic;
        __emscripten_get_now_is_monotonic.sig = "i";
        var __emscripten_runtime_keepalive_clear = () => {
          noExitRuntime = false;
          runtimeKeepaliveCounter = 0;
        };
        __emscripten_runtime_keepalive_clear.sig = "v";
        var __emscripten_system = (command) => {
          if (ENVIRONMENT_IS_NODE) {
            if (!command) return 1;
            var cmdstr = UTF8ToString(command);
            if (!cmdstr.length) return 0;
            var cp = require("child_process");
            var ret = cp.spawnSync(cmdstr, [], { shell: true, stdio: "inherit" });
            var _W_EXITCODE = (ret2, sig) => ret2 << 8 | sig;
            if (ret.status === null) {
              var signalToNumber = (sig) => {
                switch (sig) {
                  case "SIGHUP":
                    return 1;
                  case "SIGQUIT":
                    return 3;
                  case "SIGFPE":
                    return 8;
                  case "SIGKILL":
                    return 9;
                  case "SIGALRM":
                    return 14;
                  case "SIGTERM":
                    return 15;
                  default:
                    return 2;
                }
              };
              return _W_EXITCODE(0, signalToNumber(ret.signal));
            }
            return _W_EXITCODE(ret.status, 0);
          }
          if (!command) return 0;
          return -52;
        };
        __emscripten_system.sig = "ip";
        var __emscripten_throw_longjmp = () => {
          throw Infinity;
        };
        __emscripten_throw_longjmp.sig = "v";
        function __gmtime_js(time4, tmPtr) {
          time4 = bigintToI53Checked(time4);
          var date4 = new Date(time4 * 1e3);
          HEAP32[tmPtr >> 2] = date4.getUTCSeconds();
          HEAP32[tmPtr + 4 >> 2] = date4.getUTCMinutes();
          HEAP32[tmPtr + 8 >> 2] = date4.getUTCHours();
          HEAP32[tmPtr + 12 >> 2] = date4.getUTCDate();
          HEAP32[tmPtr + 16 >> 2] = date4.getUTCMonth();
          HEAP32[tmPtr + 20 >> 2] = date4.getUTCFullYear() - 1900;
          HEAP32[tmPtr + 24 >> 2] = date4.getUTCDay();
          var start2 = Date.UTC(date4.getUTCFullYear(), 0, 1, 0, 0, 0, 0);
          var yday = (date4.getTime() - start2) / (1e3 * 60 * 60 * 24) | 0;
          HEAP32[tmPtr + 28 >> 2] = yday;
          ;
        }
        __gmtime_js.sig = "vjp";
        var isLeapYear = (year3) => year3 % 4 === 0 && (year3 % 100 !== 0 || year3 % 400 === 0);
        var MONTH_DAYS_LEAP_CUMULATIVE = [0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335];
        var MONTH_DAYS_REGULAR_CUMULATIVE = [0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334];
        var ydayFromDate = (date4) => {
          var leap = isLeapYear(date4.getFullYear());
          var monthDaysCumulative = leap ? MONTH_DAYS_LEAP_CUMULATIVE : MONTH_DAYS_REGULAR_CUMULATIVE;
          var yday = monthDaysCumulative[date4.getMonth()] + date4.getDate() - 1;
          return yday;
        };
        function __localtime_js(time4, tmPtr) {
          time4 = bigintToI53Checked(time4);
          var date4 = new Date(time4 * 1e3);
          HEAP32[tmPtr >> 2] = date4.getSeconds();
          HEAP32[tmPtr + 4 >> 2] = date4.getMinutes();
          HEAP32[tmPtr + 8 >> 2] = date4.getHours();
          HEAP32[tmPtr + 12 >> 2] = date4.getDate();
          HEAP32[tmPtr + 16 >> 2] = date4.getMonth();
          HEAP32[tmPtr + 20 >> 2] = date4.getFullYear() - 1900;
          HEAP32[tmPtr + 24 >> 2] = date4.getDay();
          var yday = ydayFromDate(date4) | 0;
          HEAP32[tmPtr + 28 >> 2] = yday;
          HEAP32[tmPtr + 36 >> 2] = -(date4.getTimezoneOffset() * 60);
          var start2 = new Date(date4.getFullYear(), 0, 1);
          var summerOffset = new Date(date4.getFullYear(), 6, 1).getTimezoneOffset();
          var winterOffset = start2.getTimezoneOffset();
          var dst = (summerOffset != winterOffset && date4.getTimezoneOffset() == Math.min(winterOffset, summerOffset)) | 0;
          HEAP32[tmPtr + 32 >> 2] = dst;
          ;
        }
        __localtime_js.sig = "vjp";
        function __mmap_js(len, prot, flags2, fd, offset, allocated, addr2) {
          offset = bigintToI53Checked(offset);
          try {
            if (isNaN(offset)) return 61;
            var stream = SYSCALLS.getStreamFromFD(fd);
            var res = FS.mmap(stream, len, offset, prot, flags2);
            var ptr = res.ptr;
            HEAP32[allocated >> 2] = res.allocated;
            HEAPU32[addr2 >> 2] = ptr;
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
          ;
        }
        __mmap_js.sig = "ipiiijpp";
        function __munmap_js(addr2, len, prot, flags2, fd, offset) {
          offset = bigintToI53Checked(offset);
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            if (prot & 2) {
              SYSCALLS.doMsync(addr2, stream, len, flags2, offset);
            }
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return -e6.errno;
          }
          ;
        }
        __munmap_js.sig = "ippiiij";
        var timers = {};
        var handleException = (e6) => {
          if (e6 instanceof ExitStatus || e6 == "unwind") {
            return EXITSTATUS;
          }
          quit_(1, e6);
        };
        var runtimeKeepaliveCounter = 0;
        var keepRuntimeAlive = () => noExitRuntime || runtimeKeepaliveCounter > 0;
        var _proc_exit = (code) => {
          EXITSTATUS = code;
          if (!keepRuntimeAlive()) {
            Module["onExit"]?.(code);
            ABORT = true;
          }
          quit_(code, new ExitStatus(code));
        };
        _proc_exit.sig = "vi";
        var exitJS = (status, implicit) => {
          EXITSTATUS = status;
          _proc_exit(status);
        };
        var _exit = exitJS;
        _exit.sig = "vi";
        var maybeExit = () => {
          if (!keepRuntimeAlive()) {
            try {
              _exit(EXITSTATUS);
            } catch (e6) {
              handleException(e6);
            }
          }
        };
        var callUserCallback = (func2) => {
          if (ABORT) {
            return;
          }
          try {
            func2();
            maybeExit();
          } catch (e6) {
            handleException(e6);
          }
        };
        var _emscripten_get_now = () => performance.now();
        _emscripten_get_now.sig = "d";
        var __setitimer_js = (which, timeout_ms) => {
          if (timers[which]) {
            clearTimeout(timers[which].id);
            delete timers[which];
          }
          if (!timeout_ms) return 0;
          var id = setTimeout(() => {
            delete timers[which];
            callUserCallback(() => __emscripten_timeout(which, _emscripten_get_now()));
          }, timeout_ms);
          timers[which] = { id, timeout_ms };
          return 0;
        };
        __setitimer_js.sig = "iid";
        var __tzset_js = (timezone, daylight, std_name, dst_name) => {
          var currentYear = (/* @__PURE__ */ new Date()).getFullYear();
          var winter = new Date(currentYear, 0, 1);
          var summer = new Date(currentYear, 6, 1);
          var winterOffset = winter.getTimezoneOffset();
          var summerOffset = summer.getTimezoneOffset();
          var stdTimezoneOffset = Math.max(winterOffset, summerOffset);
          HEAPU32[timezone >> 2] = stdTimezoneOffset * 60;
          HEAP32[daylight >> 2] = Number(winterOffset != summerOffset);
          var extractZone = (timezoneOffset) => {
            var sign = timezoneOffset >= 0 ? "-" : "+";
            var absOffset = Math.abs(timezoneOffset);
            var hours = String(Math.floor(absOffset / 60)).padStart(2, "0");
            var minutes = String(absOffset % 60).padStart(2, "0");
            return `UTC${sign}${hours}${minutes}`;
          };
          var winterName = extractZone(winterOffset);
          var summerName = extractZone(summerOffset);
          if (summerOffset < winterOffset) {
            stringToUTF8(winterName, std_name, 17);
            stringToUTF8(summerName, dst_name, 17);
          } else {
            stringToUTF8(winterName, dst_name, 17);
            stringToUTF8(summerName, std_name, 17);
          }
        };
        __tzset_js.sig = "vpppp";
        var readEmAsmArgsArray = [];
        var readEmAsmArgs = (sigPtr, buf) => {
          readEmAsmArgsArray.length = 0;
          var ch;
          while (ch = HEAPU8[sigPtr++]) {
            var wide = ch != 105;
            wide &= ch != 112;
            buf += wide && buf % 8 ? 4 : 0;
            readEmAsmArgsArray.push(
              // Special case for pointers under wasm64 or CAN_ADDRESS_2GB mode.
              ch == 112 ? HEAPU32[buf >> 2] : ch == 106 ? HEAP64[buf >> 3] : ch == 105 ? HEAP32[buf >> 2] : HEAPF64[buf >> 3]
            );
            buf += wide ? 8 : 4;
          }
          return readEmAsmArgsArray;
        };
        var runEmAsmFunction = (code, sigPtr, argbuf) => {
          var args2 = readEmAsmArgs(sigPtr, argbuf);
          return ASM_CONSTS[code](...args2);
        };
        var _emscripten_asm_const_int = (code, sigPtr, argbuf) => {
          return runEmAsmFunction(code, sigPtr, argbuf);
        };
        _emscripten_asm_const_int.sig = "ippp";
        var _emscripten_date_now = () => Date.now();
        _emscripten_date_now.sig = "d";
        var _emscripten_force_exit = (status) => {
          __emscripten_runtime_keepalive_clear();
          _exit(status);
        };
        _emscripten_force_exit.sig = "vi";
        var getHeapMax = () => (
          // Stay one Wasm page short of 4GB: while e.g. Chrome is able to allocate
          // full 4GB Wasm memories, the size will wrap back to 0 bytes in Wasm side
          // for any code that deals with heap sizes, which would require special
          // casing all heap size related code to treat 0 specially.
          2147483648
        );
        var growMemory = (size2) => {
          var b9 = wasmMemory.buffer;
          var pages = (size2 - b9.byteLength + 65535) / 65536;
          try {
            wasmMemory.grow(pages);
            updateMemoryViews();
            return 1;
          } catch (e6) {
          }
        };
        var _emscripten_resize_heap = (requestedSize) => {
          var oldSize = HEAPU8.length;
          requestedSize >>>= 0;
          var maxHeapSize = getHeapMax();
          if (requestedSize > maxHeapSize) {
            return false;
          }
          for (var cutDown = 1; cutDown <= 4; cutDown *= 2) {
            var overGrownHeapSize = oldSize * (1 + 0.2 / cutDown);
            overGrownHeapSize = Math.min(overGrownHeapSize, requestedSize + 100663296);
            var newSize = Math.min(maxHeapSize, alignMemory(Math.max(requestedSize, overGrownHeapSize), 65536));
            var replacement2 = growMemory(newSize);
            if (replacement2) {
              return true;
            }
          }
          return false;
        };
        _emscripten_resize_heap.sig = "ip";
        var _emscripten_set_main_loop_timing = (mode, value) => {
          MainLoop.timingMode = mode;
          MainLoop.timingValue = value;
          if (!MainLoop.func) {
            return 1;
          }
          if (!MainLoop.running) {
            MainLoop.running = true;
          }
          if (mode == 0) {
            MainLoop.scheduler = function MainLoop_scheduler_setTimeout() {
              var timeUntilNextTick = Math.max(0, MainLoop.tickStartTime + value - _emscripten_get_now()) | 0;
              setTimeout(MainLoop.runner, timeUntilNextTick);
            };
            MainLoop.method = "timeout";
          } else if (mode == 1) {
            MainLoop.scheduler = function MainLoop_scheduler_rAF() {
              MainLoop.requestAnimationFrame(MainLoop.runner);
            };
            MainLoop.method = "rAF";
          } else if (mode == 2) {
            if (typeof MainLoop.setImmediate == "undefined") {
              if (typeof setImmediate == "undefined") {
                var setImmediates = [];
                var emscriptenMainLoopMessageId = "setimmediate";
                var MainLoop_setImmediate_messageHandler = (event) => {
                  if (event.data === emscriptenMainLoopMessageId || event.data.target === emscriptenMainLoopMessageId) {
                    event.stopPropagation();
                    setImmediates.shift()();
                  }
                };
                addEventListener("message", MainLoop_setImmediate_messageHandler, true);
                MainLoop.setImmediate = /** @type{function(function(): ?, ...?): number} */
                (func2) => {
                  setImmediates.push(func2);
                  if (ENVIRONMENT_IS_WORKER) {
                    Module["setImmediates"] ??= [];
                    Module["setImmediates"].push(func2);
                    postMessage({ target: emscriptenMainLoopMessageId });
                  } else postMessage(emscriptenMainLoopMessageId, "*");
                };
              } else {
                MainLoop.setImmediate = setImmediate;
              }
            }
            MainLoop.scheduler = function MainLoop_scheduler_setImmediate() {
              MainLoop.setImmediate(MainLoop.runner);
            };
            MainLoop.method = "immediate";
          }
          return 0;
        };
        _emscripten_set_main_loop_timing.sig = "iii";
        var MainLoop = {
          running: false,
          scheduler: null,
          method: "",
          currentlyRunningMainloop: 0,
          func: null,
          arg: 0,
          timingMode: 0,
          timingValue: 0,
          currentFrameNumber: 0,
          queue: [],
          preMainLoop: [],
          postMainLoop: [],
          pause() {
            MainLoop.scheduler = null;
            MainLoop.currentlyRunningMainloop++;
          },
          resume() {
            MainLoop.currentlyRunningMainloop++;
            var timingMode = MainLoop.timingMode;
            var timingValue = MainLoop.timingValue;
            var func2 = MainLoop.func;
            MainLoop.func = null;
            setMainLoop(func2, 0, false, MainLoop.arg, true);
            _emscripten_set_main_loop_timing(timingMode, timingValue);
            MainLoop.scheduler();
          },
          updateStatus() {
            if (Module["setStatus"]) {
              var message = Module["statusMessage"] || "Please wait...";
              var remaining = MainLoop.remainingBlockers ?? 0;
              var expected = MainLoop.expectedBlockers ?? 0;
              if (remaining) {
                if (remaining < expected) {
                  Module["setStatus"](`{message} ({expected - remaining}/{expected})`);
                } else {
                  Module["setStatus"](message);
                }
              } else {
                Module["setStatus"]("");
              }
            }
          },
          init() {
            Module["preMainLoop"] && MainLoop.preMainLoop.push(Module["preMainLoop"]);
            Module["postMainLoop"] && MainLoop.postMainLoop.push(Module["postMainLoop"]);
          },
          runIter(func2) {
            if (ABORT) return;
            for (var pre of MainLoop.preMainLoop) {
              if (pre() === false) {
                return;
              }
            }
            callUserCallback(func2);
            for (var post of MainLoop.postMainLoop) {
              post();
            }
          },
          nextRAF: 0,
          fakeRequestAnimationFrame(func2) {
            var now = Date.now();
            if (MainLoop.nextRAF === 0) {
              MainLoop.nextRAF = now + 1e3 / 60;
            } else {
              while (now + 2 >= MainLoop.nextRAF) {
                MainLoop.nextRAF += 1e3 / 60;
              }
            }
            var delay = Math.max(MainLoop.nextRAF - now, 0);
            setTimeout(func2, delay);
          },
          requestAnimationFrame(func2) {
            if (typeof requestAnimationFrame == "function") {
              requestAnimationFrame(func2);
              return;
            }
            var RAF = MainLoop.fakeRequestAnimationFrame;
            RAF(func2);
          }
        };
        var setMainLoop = (iterFunc, fps, simulateInfiniteLoop, arg, noSetTiming) => {
          MainLoop.func = iterFunc;
          MainLoop.arg = arg;
          var thisMainLoopId = MainLoop.currentlyRunningMainloop;
          function checkIsRunning() {
            if (thisMainLoopId < MainLoop.currentlyRunningMainloop) {
              maybeExit();
              return false;
            }
            return true;
          }
          MainLoop.running = false;
          MainLoop.runner = function MainLoop_runner() {
            if (ABORT) return;
            if (MainLoop.queue.length > 0) {
              var start2 = Date.now();
              var blocker = MainLoop.queue.shift();
              blocker.func(blocker.arg);
              if (MainLoop.remainingBlockers) {
                var remaining = MainLoop.remainingBlockers;
                var next = remaining % 1 == 0 ? remaining - 1 : Math.floor(remaining);
                if (blocker.counted) {
                  MainLoop.remainingBlockers = next;
                } else {
                  next = next + 0.5;
                  MainLoop.remainingBlockers = (8 * remaining + next) / 9;
                }
              }
              MainLoop.updateStatus();
              if (!checkIsRunning()) return;
              setTimeout(MainLoop.runner, 0);
              return;
            }
            if (!checkIsRunning()) return;
            MainLoop.currentFrameNumber = MainLoop.currentFrameNumber + 1 | 0;
            if (MainLoop.timingMode == 1 && MainLoop.timingValue > 1 && MainLoop.currentFrameNumber % MainLoop.timingValue != 0) {
              MainLoop.scheduler();
              return;
            } else if (MainLoop.timingMode == 0) {
              MainLoop.tickStartTime = _emscripten_get_now();
            }
            MainLoop.runIter(iterFunc);
            if (!checkIsRunning()) return;
            MainLoop.scheduler();
          };
          if (!noSetTiming) {
            if (fps && fps > 0) {
              _emscripten_set_main_loop_timing(0, 1e3 / fps);
            } else {
              _emscripten_set_main_loop_timing(1, 1);
            }
            MainLoop.scheduler();
          }
          if (simulateInfiniteLoop) {
            throw "unwind";
          }
        };
        var _emscripten_set_main_loop = (func2, fps, simulateInfiniteLoop) => {
          var iterFunc = getWasmTableEntry(func2);
          setMainLoop(iterFunc, fps, simulateInfiniteLoop);
        };
        _emscripten_set_main_loop.sig = "vpii";
        var getExecutableName = () => {
          return thisProgram || "./this.program";
        };
        var getEnvStrings = () => {
          if (!getEnvStrings.strings) {
            var lang = (typeof navigator == "object" && navigator.languages && navigator.languages[0] || "C").replace("-", "_") + ".UTF-8";
            var env4 = {
              "USER": "web_user",
              "LOGNAME": "web_user",
              "PATH": "/",
              "PWD": "/",
              "HOME": "/home/web_user",
              "LANG": lang,
              "_": getExecutableName()
            };
            for (var x11 in ENV) {
              if (ENV[x11] === void 0) delete env4[x11];
              else env4[x11] = ENV[x11];
            }
            var strings = [];
            for (var x11 in env4) {
              strings.push(`${x11}=${env4[x11]}`);
            }
            getEnvStrings.strings = strings;
          }
          return getEnvStrings.strings;
        };
        var stringToAscii = (str, buffer2) => {
          for (var i8 = 0; i8 < str.length; ++i8) {
            HEAP8[buffer2++] = str.charCodeAt(i8);
          }
          HEAP8[buffer2] = 0;
        };
        var _environ_get = (__environ, environ_buf) => {
          var bufSize = 0;
          getEnvStrings().forEach((string2, i8) => {
            var ptr = environ_buf + bufSize;
            HEAPU32[__environ + i8 * 4 >> 2] = ptr;
            stringToAscii(string2, ptr);
            bufSize += string2.length + 1;
          });
          return 0;
        };
        _environ_get.sig = "ipp";
        var _environ_sizes_get = (penviron_count, penviron_buf_size) => {
          var strings = getEnvStrings();
          HEAPU32[penviron_count >> 2] = strings.length;
          var bufSize = 0;
          strings.forEach((string2) => bufSize += string2.length + 1);
          HEAPU32[penviron_buf_size >> 2] = bufSize;
          return 0;
        };
        _environ_sizes_get.sig = "ipp";
        function _fd_close(fd) {
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            FS.close(stream);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
        }
        _fd_close.sig = "ii";
        function _fd_fdstat_get(fd, pbuf) {
          try {
            var rightsBase = 0;
            var rightsInheriting = 0;
            var flags2 = 0;
            {
              var stream = SYSCALLS.getStreamFromFD(fd);
              var type = stream.tty ? 2 : FS.isDir(stream.mode) ? 3 : FS.isLink(stream.mode) ? 7 : 4;
            }
            HEAP8[pbuf] = type;
            HEAP16[pbuf + 2 >> 1] = flags2;
            HEAP64[pbuf + 8 >> 3] = BigInt(rightsBase);
            HEAP64[pbuf + 16 >> 3] = BigInt(rightsInheriting);
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
        }
        _fd_fdstat_get.sig = "iip";
        var doReadv = (stream, iov, iovcnt, offset) => {
          var ret = 0;
          for (var i8 = 0; i8 < iovcnt; i8++) {
            var ptr = HEAPU32[iov >> 2];
            var len = HEAPU32[iov + 4 >> 2];
            iov += 8;
            var curr = FS.read(stream, HEAP8, ptr, len, offset);
            if (curr < 0) return -1;
            ret += curr;
            if (curr < len) break;
            if (typeof offset != "undefined") {
              offset += curr;
            }
          }
          return ret;
        };
        function _fd_pread(fd, iov, iovcnt, offset, pnum) {
          offset = bigintToI53Checked(offset);
          try {
            if (isNaN(offset)) return 61;
            var stream = SYSCALLS.getStreamFromFD(fd);
            var num = doReadv(stream, iov, iovcnt, offset);
            HEAPU32[pnum >> 2] = num;
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
          ;
        }
        _fd_pread.sig = "iippjp";
        var doWritev = (stream, iov, iovcnt, offset) => {
          var ret = 0;
          for (var i8 = 0; i8 < iovcnt; i8++) {
            var ptr = HEAPU32[iov >> 2];
            var len = HEAPU32[iov + 4 >> 2];
            iov += 8;
            var curr = FS.write(stream, HEAP8, ptr, len, offset);
            if (curr < 0) return -1;
            ret += curr;
            if (curr < len) {
              break;
            }
            if (typeof offset != "undefined") {
              offset += curr;
            }
          }
          return ret;
        };
        function _fd_pwrite(fd, iov, iovcnt, offset, pnum) {
          offset = bigintToI53Checked(offset);
          try {
            if (isNaN(offset)) return 61;
            var stream = SYSCALLS.getStreamFromFD(fd);
            var num = doWritev(stream, iov, iovcnt, offset);
            HEAPU32[pnum >> 2] = num;
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
          ;
        }
        _fd_pwrite.sig = "iippjp";
        function _fd_read(fd, iov, iovcnt, pnum) {
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            var num = doReadv(stream, iov, iovcnt);
            HEAPU32[pnum >> 2] = num;
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
        }
        _fd_read.sig = "iippp";
        function _fd_seek(fd, offset, whence, newOffset) {
          offset = bigintToI53Checked(offset);
          try {
            if (isNaN(offset)) return 61;
            var stream = SYSCALLS.getStreamFromFD(fd);
            FS.llseek(stream, offset, whence);
            HEAP64[newOffset >> 3] = BigInt(stream.position);
            if (stream.getdents && offset === 0 && whence === 0) stream.getdents = null;
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
          ;
        }
        _fd_seek.sig = "iijip";
        function _fd_sync(fd) {
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            if (stream.stream_ops?.fsync) {
              return stream.stream_ops.fsync(stream);
            }
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
        }
        _fd_sync.sig = "ii";
        function _fd_write(fd, iov, iovcnt, pnum) {
          try {
            var stream = SYSCALLS.getStreamFromFD(fd);
            var num = doWritev(stream, iov, iovcnt);
            HEAPU32[pnum >> 2] = num;
            return 0;
          } catch (e6) {
            if (typeof FS == "undefined" || !(e6.name === "ErrnoError")) throw e6;
            return e6.errno;
          }
        }
        _fd_write.sig = "iippp";
        var _getaddrinfo = (node, service, hint, out2) => {
          var addrs = [];
          var canon = null;
          var addr2 = 0;
          var port = 0;
          var flags2 = 0;
          var family = 0;
          var type = 0;
          var proto2 = 0;
          var ai, last;
          function allocaddrinfo(family2, type2, proto3, canon2, addr3, port2) {
            var sa, salen, ai2;
            var errno;
            salen = family2 === 10 ? 28 : 16;
            addr3 = family2 === 10 ? inetNtop6(addr3) : inetNtop4(addr3);
            sa = _malloc(salen);
            errno = writeSockaddr(sa, family2, addr3, port2);
            assert(!errno);
            ai2 = _malloc(32);
            HEAP32[ai2 + 4 >> 2] = family2;
            HEAP32[ai2 + 8 >> 2] = type2;
            HEAP32[ai2 + 12 >> 2] = proto3;
            HEAPU32[ai2 + 24 >> 2] = canon2;
            HEAPU32[ai2 + 20 >> 2] = sa;
            if (family2 === 10) {
              HEAP32[ai2 + 16 >> 2] = 28;
            } else {
              HEAP32[ai2 + 16 >> 2] = 16;
            }
            HEAP32[ai2 + 28 >> 2] = 0;
            return ai2;
          }
          if (hint) {
            flags2 = HEAP32[hint >> 2];
            family = HEAP32[hint + 4 >> 2];
            type = HEAP32[hint + 8 >> 2];
            proto2 = HEAP32[hint + 12 >> 2];
          }
          if (type && !proto2) {
            proto2 = type === 2 ? 17 : 6;
          }
          if (!type && proto2) {
            type = proto2 === 17 ? 2 : 1;
          }
          if (proto2 === 0) {
            proto2 = 6;
          }
          if (type === 0) {
            type = 1;
          }
          if (!node && !service) {
            return -2;
          }
          if (flags2 & ~(1 | 2 | 4 | 1024 | 8 | 16 | 32)) {
            return -1;
          }
          if (hint !== 0 && HEAP32[hint >> 2] & 2 && !node) {
            return -1;
          }
          if (flags2 & 32) {
            return -2;
          }
          if (type !== 0 && type !== 1 && type !== 2) {
            return -7;
          }
          if (family !== 0 && family !== 2 && family !== 10) {
            return -6;
          }
          if (service) {
            service = UTF8ToString(service);
            port = parseInt(service, 10);
            if (isNaN(port)) {
              if (flags2 & 1024) {
                return -2;
              }
              return -8;
            }
          }
          if (!node) {
            if (family === 0) {
              family = 2;
            }
            if ((flags2 & 1) === 0) {
              if (family === 2) {
                addr2 = _htonl(2130706433);
              } else {
                addr2 = [0, 0, 0, 1];
              }
            }
            ai = allocaddrinfo(family, type, proto2, null, addr2, port);
            HEAPU32[out2 >> 2] = ai;
            return 0;
          }
          node = UTF8ToString(node);
          addr2 = inetPton4(node);
          if (addr2 !== null) {
            if (family === 0 || family === 2) {
              family = 2;
            } else if (family === 10 && flags2 & 8) {
              addr2 = [0, 0, _htonl(65535), addr2];
              family = 10;
            } else {
              return -2;
            }
          } else {
            addr2 = inetPton6(node);
            if (addr2 !== null) {
              if (family === 0 || family === 10) {
                family = 10;
              } else {
                return -2;
              }
            }
          }
          if (addr2 != null) {
            ai = allocaddrinfo(family, type, proto2, node, addr2, port);
            HEAPU32[out2 >> 2] = ai;
            return 0;
          }
          if (flags2 & 4) {
            return -2;
          }
          node = DNS.lookup_name(node);
          addr2 = inetPton4(node);
          if (family === 0) {
            family = 2;
          } else if (family === 10) {
            addr2 = [0, 0, _htonl(65535), addr2];
          }
          ai = allocaddrinfo(family, type, proto2, null, addr2, port);
          HEAPU32[out2 >> 2] = ai;
          return 0;
        };
        _getaddrinfo.sig = "ipppp";
        var _getnameinfo = (sa, salen, node, nodelen, serv, servlen, flags2) => {
          var info3 = readSockaddr(sa, salen);
          if (info3.errno) {
            return -6;
          }
          var port = info3.port;
          var addr2 = info3.addr;
          var overflowed = false;
          if (node && nodelen) {
            var lookup;
            if (flags2 & 1 || !(lookup = DNS.lookup_addr(addr2))) {
              if (flags2 & 8) {
                return -2;
              }
            } else {
              addr2 = lookup;
            }
            var numBytesWrittenExclNull = stringToUTF8(addr2, node, nodelen);
            if (numBytesWrittenExclNull + 1 >= nodelen) {
              overflowed = true;
            }
          }
          if (serv && servlen) {
            port = "" + port;
            var numBytesWrittenExclNull = stringToUTF8(port, serv, servlen);
            if (numBytesWrittenExclNull + 1 >= servlen) {
              overflowed = true;
            }
          }
          if (overflowed) {
            return -12;
          }
          return 0;
        };
        _getnameinfo.sig = "ipipipii";
        var stringToNewUTF8 = (str) => {
          var size2 = lengthBytesUTF8(str) + 1;
          var ret = _malloc(size2);
          if (ret) stringToUTF8(str, ret, size2);
          return ret;
        };
        var getCFunc = (ident) => {
          var func2 = Module["_" + ident];
          return func2;
        };
        var writeArrayToMemory = (array3, buffer2) => {
          HEAP8.set(array3, buffer2);
        };
        var ccall = (ident, returnType, argTypes, args2, opts) => {
          var toC = {
            "string": (str) => {
              var ret2 = 0;
              if (str !== null && str !== void 0 && str !== 0) {
                ret2 = stringToUTF8OnStack(str);
              }
              return ret2;
            },
            "array": (arr) => {
              var ret2 = stackAlloc(arr.length);
              writeArrayToMemory(arr, ret2);
              return ret2;
            }
          };
          function convertReturnValue(ret2) {
            if (returnType === "string") {
              return UTF8ToString(ret2);
            }
            if (returnType === "boolean") return Boolean(ret2);
            return ret2;
          }
          var func2 = getCFunc(ident);
          var cArgs = [];
          var stack = 0;
          if (args2) {
            for (var i8 = 0; i8 < args2.length; i8++) {
              var converter = toC[argTypes[i8]];
              if (converter) {
                if (stack === 0) stack = stackSave();
                cArgs[i8] = converter(args2[i8]);
              } else {
                cArgs[i8] = args2[i8];
              }
            }
          }
          var ret = func2(...cArgs);
          function onDone(ret2) {
            if (stack !== 0) stackRestore(stack);
            return convertReturnValue(ret2);
          }
          ret = onDone(ret);
          return ret;
        };
        var cwrap = (ident, returnType, argTypes, opts) => {
          var numericArgs = !argTypes || argTypes.every((type) => type === "number" || type === "boolean");
          var numericRet = returnType !== "string";
          if (numericRet && numericArgs && !opts) {
            return getCFunc(ident);
          }
          return (...args2) => ccall(ident, returnType, argTypes, args2, opts);
        };
        var FS_createPath = FS.createPath;
        var FS_unlink = (path3) => FS.unlink(path3);
        var FS_createLazyFile = FS.createLazyFile;
        var FS_createDevice = FS.createDevice;
        var setTempRet0 = (val2) => __emscripten_tempret_set(val2);
        var _setTempRet0 = setTempRet0;
        Module["_setTempRet0"] = _setTempRet0;
        var getTempRet0 = (val2) => __emscripten_tempret_get();
        var _getTempRet0 = getTempRet0;
        Module["_getTempRet0"] = _getTempRet0;
        registerWasmPlugin();
        ;
        FS.createPreloadedFile = FS_createPreloadedFile;
        FS.staticInit();
        Module["FS_createPath"] = FS.createPath;
        Module["FS_createDataFile"] = FS.createDataFile;
        Module["FS_createPreloadedFile"] = FS.createPreloadedFile;
        Module["FS_unlink"] = FS.unlink;
        Module["FS_createLazyFile"] = FS.createLazyFile;
        Module["FS_createDevice"] = FS.createDevice;
        ;
        if (ENVIRONMENT_IS_NODE) {
          NODEFS.staticInit();
        }
        ;
        Module["requestAnimationFrame"] = MainLoop.requestAnimationFrame;
        Module["pauseMainLoop"] = MainLoop.pause;
        Module["resumeMainLoop"] = MainLoop.resume;
        MainLoop.init();
        ;
        var wasmImports = {
          /** @export */
          __assert_fail: ___assert_fail,
          /** @export */
          __call_sighandler: ___call_sighandler,
          /** @export */
          __heap_base: ___heap_base,
          /** @export */
          __indirect_function_table: wasmTable,
          /** @export */
          __memory_base: ___memory_base,
          /** @export */
          __stack_pointer: ___stack_pointer,
          /** @export */
          __syscall__newselect: ___syscall__newselect,
          /** @export */
          __syscall_bind: ___syscall_bind,
          /** @export */
          __syscall_chdir: ___syscall_chdir,
          /** @export */
          __syscall_chmod: ___syscall_chmod,
          /** @export */
          __syscall_connect: ___syscall_connect,
          /** @export */
          __syscall_dup: ___syscall_dup,
          /** @export */
          __syscall_dup3: ___syscall_dup3,
          /** @export */
          __syscall_faccessat: ___syscall_faccessat,
          /** @export */
          __syscall_fadvise64: ___syscall_fadvise64,
          /** @export */
          __syscall_fallocate: ___syscall_fallocate,
          /** @export */
          __syscall_fcntl64: ___syscall_fcntl64,
          /** @export */
          __syscall_fdatasync: ___syscall_fdatasync,
          /** @export */
          __syscall_fstat64: ___syscall_fstat64,
          /** @export */
          __syscall_ftruncate64: ___syscall_ftruncate64,
          /** @export */
          __syscall_getcwd: ___syscall_getcwd,
          /** @export */
          __syscall_getdents64: ___syscall_getdents64,
          /** @export */
          __syscall_getsockname: ___syscall_getsockname,
          /** @export */
          __syscall_getsockopt: ___syscall_getsockopt,
          /** @export */
          __syscall_ioctl: ___syscall_ioctl,
          /** @export */
          __syscall_lstat64: ___syscall_lstat64,
          /** @export */
          __syscall_mkdirat: ___syscall_mkdirat,
          /** @export */
          __syscall_newfstatat: ___syscall_newfstatat,
          /** @export */
          __syscall_openat: ___syscall_openat,
          /** @export */
          __syscall_pipe: ___syscall_pipe,
          /** @export */
          __syscall_poll: ___syscall_poll,
          /** @export */
          __syscall_readlinkat: ___syscall_readlinkat,
          /** @export */
          __syscall_recvfrom: ___syscall_recvfrom,
          /** @export */
          __syscall_renameat: ___syscall_renameat,
          /** @export */
          __syscall_rmdir: ___syscall_rmdir,
          /** @export */
          __syscall_sendto: ___syscall_sendto,
          /** @export */
          __syscall_socket: ___syscall_socket,
          /** @export */
          __syscall_stat64: ___syscall_stat64,
          /** @export */
          __syscall_symlink: ___syscall_symlink,
          /** @export */
          __syscall_truncate64: ___syscall_truncate64,
          /** @export */
          __syscall_unlinkat: ___syscall_unlinkat,
          /** @export */
          __table_base: ___table_base,
          /** @export */
          _abort_js: __abort_js,
          /** @export */
          _dlopen_js: __dlopen_js,
          /** @export */
          _dlsym_js: __dlsym_js,
          /** @export */
          _emscripten_get_now_is_monotonic: __emscripten_get_now_is_monotonic,
          /** @export */
          _emscripten_runtime_keepalive_clear: __emscripten_runtime_keepalive_clear,
          /** @export */
          _emscripten_system: __emscripten_system,
          /** @export */
          _emscripten_throw_longjmp: __emscripten_throw_longjmp,
          /** @export */
          _gmtime_js: __gmtime_js,
          /** @export */
          _localtime_js: __localtime_js,
          /** @export */
          _mmap_js: __mmap_js,
          /** @export */
          _munmap_js: __munmap_js,
          /** @export */
          _setitimer_js: __setitimer_js,
          /** @export */
          _tzset_js: __tzset_js,
          /** @export */
          emscripten_asm_const_int: _emscripten_asm_const_int,
          /** @export */
          emscripten_date_now: _emscripten_date_now,
          /** @export */
          emscripten_force_exit: _emscripten_force_exit,
          /** @export */
          emscripten_get_now: _emscripten_get_now,
          /** @export */
          emscripten_resize_heap: _emscripten_resize_heap,
          /** @export */
          emscripten_set_main_loop: _emscripten_set_main_loop,
          /** @export */
          environ_get: _environ_get,
          /** @export */
          environ_sizes_get: _environ_sizes_get,
          /** @export */
          exit: _exit,
          /** @export */
          fd_close: _fd_close,
          /** @export */
          fd_fdstat_get: _fd_fdstat_get,
          /** @export */
          fd_pread: _fd_pread,
          /** @export */
          fd_pwrite: _fd_pwrite,
          /** @export */
          fd_read: _fd_read,
          /** @export */
          fd_seek: _fd_seek,
          /** @export */
          fd_sync: _fd_sync,
          /** @export */
          fd_write: _fd_write,
          /** @export */
          getTempRet0: _getTempRet0,
          /** @export */
          getaddrinfo: _getaddrinfo,
          /** @export */
          getnameinfo: _getnameinfo,
          /** @export */
          invoke_di,
          /** @export */
          invoke_i,
          /** @export */
          invoke_id,
          /** @export */
          invoke_ii,
          /** @export */
          invoke_iii,
          /** @export */
          invoke_iiii,
          /** @export */
          invoke_iiiii,
          /** @export */
          invoke_iiiiii,
          /** @export */
          invoke_iiiiiii,
          /** @export */
          invoke_iiiiiiii,
          /** @export */
          invoke_iiiiiiiii,
          /** @export */
          invoke_iiiiiiiiii,
          /** @export */
          invoke_iiiiiiiiiiiiiiiii,
          /** @export */
          invoke_iiiiiji,
          /** @export */
          invoke_iiiij,
          /** @export */
          invoke_iiiijii,
          /** @export */
          invoke_iiij,
          /** @export */
          invoke_iiji,
          /** @export */
          invoke_ij,
          /** @export */
          invoke_ijiiiii,
          /** @export */
          invoke_ijiiiiii,
          /** @export */
          invoke_ji,
          /** @export */
          invoke_jii,
          /** @export */
          invoke_jiiii,
          /** @export */
          invoke_jiiiii,
          /** @export */
          invoke_jiiiiiiii,
          /** @export */
          invoke_v,
          /** @export */
          invoke_vi,
          /** @export */
          invoke_vid,
          /** @export */
          invoke_vii,
          /** @export */
          invoke_viii,
          /** @export */
          invoke_viiii,
          /** @export */
          invoke_viiiii,
          /** @export */
          invoke_viiiiii,
          /** @export */
          invoke_viiiiiii,
          /** @export */
          invoke_viiiiiiii,
          /** @export */
          invoke_viiiiiiiii,
          /** @export */
          invoke_viiiiiiiiiiii,
          /** @export */
          invoke_viiij,
          /** @export */
          invoke_viij,
          /** @export */
          invoke_viiji,
          /** @export */
          invoke_viijii,
          /** @export */
          invoke_viijiiii,
          /** @export */
          invoke_vij,
          /** @export */
          invoke_viji,
          /** @export */
          invoke_vijiji,
          /** @export */
          invoke_vj,
          /** @export */
          invoke_vji,
          /** @export */
          is_web_env,
          /** @export */
          memory: wasmMemory,
          /** @export */
          proc_exit: _proc_exit,
          /** @export */
          setTempRet0: _setTempRet0
        };
        var wasmExports = createWasm();
        var ___wasm_call_ctors = () => (___wasm_call_ctors = wasmExports["__wasm_call_ctors"])();
        var ___wasm_apply_data_relocs = () => (___wasm_apply_data_relocs = wasmExports["__wasm_apply_data_relocs"])();
        var _ScanKeywordLookup = Module["_ScanKeywordLookup"] = (a0, a1) => (_ScanKeywordLookup = Module["_ScanKeywordLookup"] = wasmExports["ScanKeywordLookup"])(a0, a1);
        var _pg_snprintf = Module["_pg_snprintf"] = (a0, a1, a22, a32) => (_pg_snprintf = Module["_pg_snprintf"] = wasmExports["pg_snprintf"])(a0, a1, a22, a32);
        var _strlen = Module["_strlen"] = (a0) => (_strlen = Module["_strlen"] = wasmExports["strlen"])(a0);
        var _memset = Module["_memset"] = (a0, a1, a22) => (_memset = Module["_memset"] = wasmExports["memset"])(a0, a1, a22);
        var _strchr = Module["_strchr"] = (a0, a1) => (_strchr = Module["_strchr"] = wasmExports["strchr"])(a0, a1);
        var _PQserverVersion = Module["_PQserverVersion"] = (a0) => (_PQserverVersion = Module["_PQserverVersion"] = wasmExports["PQserverVersion"])(a0);
        var _strstr = Module["_strstr"] = (a0, a1) => (_strstr = Module["_strstr"] = wasmExports["strstr"])(a0, a1);
        var _pg_fprintf = Module["_pg_fprintf"] = (a0, a1, a22) => (_pg_fprintf = Module["_pg_fprintf"] = wasmExports["pg_fprintf"])(a0, a1, a22);
        var _strspn = Module["_strspn"] = (a0, a1) => (_strspn = Module["_strspn"] = wasmExports["strspn"])(a0, a1);
        var _malloc = Module["_malloc"] = (a0) => (_malloc = Module["_malloc"] = wasmExports["malloc"])(a0);
        var _pg_strcasecmp = Module["_pg_strcasecmp"] = (a0, a1) => (_pg_strcasecmp = Module["_pg_strcasecmp"] = wasmExports["pg_strcasecmp"])(a0, a1);
        var _strcmp = Module["_strcmp"] = (a0, a1) => (_strcmp = Module["_strcmp"] = wasmExports["strcmp"])(a0, a1);
        var _free = Module["_free"] = (a0) => (_free = Module["_free"] = wasmExports["free"])(a0);
        var _pg_tolower = Module["_pg_tolower"] = (a0) => (_pg_tolower = Module["_pg_tolower"] = wasmExports["pg_tolower"])(a0);
        var _memchr = Module["_memchr"] = (a0, a1, a22) => (_memchr = Module["_memchr"] = wasmExports["memchr"])(a0, a1, a22);
        var _getenv = Module["_getenv"] = (a0) => (_getenv = Module["_getenv"] = wasmExports["getenv"])(a0);
        var _fileno = Module["_fileno"] = (a0) => (_fileno = Module["_fileno"] = wasmExports["fileno"])(a0);
        var _isatty = Module["_isatty"] = (a0) => (_isatty = Module["_isatty"] = wasmExports["isatty"])(a0);
        var _strdup = Module["_strdup"] = (a0) => (_strdup = Module["_strdup"] = wasmExports["strdup"])(a0);
        var ___errno_location = Module["___errno_location"] = () => (___errno_location = Module["___errno_location"] = wasmExports["__errno_location"])();
        var _fflush = Module["_fflush"] = (a0) => (_fflush = Module["_fflush"] = wasmExports["fflush"])(a0);
        var _pg_vsnprintf = Module["_pg_vsnprintf"] = (a0, a1, a22, a32) => (_pg_vsnprintf = Module["_pg_vsnprintf"] = wasmExports["pg_vsnprintf"])(a0, a1, a22, a32);
        var _pg_malloc_extended = Module["_pg_malloc_extended"] = (a0, a1) => (_pg_malloc_extended = Module["_pg_malloc_extended"] = wasmExports["pg_malloc_extended"])(a0, a1);
        var _errstart_cold = Module["_errstart_cold"] = (a0, a1) => (_errstart_cold = Module["_errstart_cold"] = wasmExports["errstart_cold"])(a0, a1);
        var _errmsg_internal = Module["_errmsg_internal"] = (a0, a1) => (_errmsg_internal = Module["_errmsg_internal"] = wasmExports["errmsg_internal"])(a0, a1);
        var _errfinish = Module["_errfinish"] = (a0, a1, a22) => (_errfinish = Module["_errfinish"] = wasmExports["errfinish"])(a0, a1, a22);
        var _puts = Module["_puts"] = (a0) => (_puts = Module["_puts"] = wasmExports["puts"])(a0);
        var _psprintf = Module["_psprintf"] = (a0, a1) => (_psprintf = Module["_psprintf"] = wasmExports["psprintf"])(a0, a1);
        var _pfree = Module["_pfree"] = (a0) => (_pfree = Module["_pfree"] = wasmExports["pfree"])(a0);
        var _initStringInfo = Module["_initStringInfo"] = (a0) => (_initStringInfo = Module["_initStringInfo"] = wasmExports["initStringInfo"])(a0);
        var _appendStringInfoChar = Module["_appendStringInfoChar"] = (a0, a1) => (_appendStringInfoChar = Module["_appendStringInfoChar"] = wasmExports["appendStringInfoChar"])(a0, a1);
        var _appendStringInfoString = Module["_appendStringInfoString"] = (a0, a1) => (_appendStringInfoString = Module["_appendStringInfoString"] = wasmExports["appendStringInfoString"])(a0, a1);
        var _escape_json = Module["_escape_json"] = (a0, a1) => (_escape_json = Module["_escape_json"] = wasmExports["escape_json"])(a0, a1);
        var _enlargeStringInfo = Module["_enlargeStringInfo"] = (a0, a1) => (_enlargeStringInfo = Module["_enlargeStringInfo"] = wasmExports["enlargeStringInfo"])(a0, a1);
        var _appendStringInfo = Module["_appendStringInfo"] = (a0, a1, a22) => (_appendStringInfo = Module["_appendStringInfo"] = wasmExports["appendStringInfo"])(a0, a1, a22);
        var _errmsg = Module["_errmsg"] = (a0, a1) => (_errmsg = Module["_errmsg"] = wasmExports["errmsg"])(a0, a1);
        var _errcode_for_file_access = Module["_errcode_for_file_access"] = () => (_errcode_for_file_access = Module["_errcode_for_file_access"] = wasmExports["errcode_for_file_access"])();
        var _palloc0 = Module["_palloc0"] = (a0) => (_palloc0 = Module["_palloc0"] = wasmExports["palloc0"])(a0);
        var _palloc = Module["_palloc"] = (a0) => (_palloc = Module["_palloc"] = wasmExports["palloc"])(a0);
        var _errcode = Module["_errcode"] = (a0) => (_errcode = Module["_errcode"] = wasmExports["errcode"])(a0);
        var _bbsink_forward_end_archive = Module["_bbsink_forward_end_archive"] = (a0) => (_bbsink_forward_end_archive = Module["_bbsink_forward_end_archive"] = wasmExports["bbsink_forward_end_archive"])(a0);
        var _memcpy = Module["_memcpy"] = (a0, a1, a22) => (_memcpy = Module["_memcpy"] = wasmExports["memcpy"])(a0, a1, a22);
        var _bbsink_forward_begin_manifest = Module["_bbsink_forward_begin_manifest"] = (a0) => (_bbsink_forward_begin_manifest = Module["_bbsink_forward_begin_manifest"] = wasmExports["bbsink_forward_begin_manifest"])(a0);
        var _bbsink_forward_end_manifest = Module["_bbsink_forward_end_manifest"] = (a0) => (_bbsink_forward_end_manifest = Module["_bbsink_forward_end_manifest"] = wasmExports["bbsink_forward_end_manifest"])(a0);
        var _bbsink_forward_end_backup = Module["_bbsink_forward_end_backup"] = (a0, a1, a22) => (_bbsink_forward_end_backup = Module["_bbsink_forward_end_backup"] = wasmExports["bbsink_forward_end_backup"])(a0, a1, a22);
        var _bbsink_forward_cleanup = Module["_bbsink_forward_cleanup"] = (a0) => (_bbsink_forward_cleanup = Module["_bbsink_forward_cleanup"] = wasmExports["bbsink_forward_cleanup"])(a0);
        var _StartTransactionCommand = Module["_StartTransactionCommand"] = () => (_StartTransactionCommand = Module["_StartTransactionCommand"] = wasmExports["StartTransactionCommand"])();
        var _GetUserId = Module["_GetUserId"] = () => (_GetUserId = Module["_GetUserId"] = wasmExports["GetUserId"])();
        var _has_privs_of_role = Module["_has_privs_of_role"] = (a0, a1) => (_has_privs_of_role = Module["_has_privs_of_role"] = wasmExports["has_privs_of_role"])(a0, a1);
        var _errdetail = Module["_errdetail"] = (a0, a1) => (_errdetail = Module["_errdetail"] = wasmExports["errdetail"])(a0, a1);
        var _CommitTransactionCommand = Module["_CommitTransactionCommand"] = () => (_CommitTransactionCommand = Module["_CommitTransactionCommand"] = wasmExports["CommitTransactionCommand"])();
        var _bbsink_forward_begin_archive = Module["_bbsink_forward_begin_archive"] = (a0, a1) => (_bbsink_forward_begin_archive = Module["_bbsink_forward_begin_archive"] = wasmExports["bbsink_forward_begin_archive"])(a0, a1);
        var _errhint = Module["_errhint"] = (a0, a1) => (_errhint = Module["_errhint"] = wasmExports["errhint"])(a0, a1);
        var _bbsink_forward_archive_contents = Module["_bbsink_forward_archive_contents"] = (a0, a1) => (_bbsink_forward_archive_contents = Module["_bbsink_forward_archive_contents"] = wasmExports["bbsink_forward_archive_contents"])(a0, a1);
        var _bbsink_forward_manifest_contents = Module["_bbsink_forward_manifest_contents"] = (a0, a1) => (_bbsink_forward_manifest_contents = Module["_bbsink_forward_manifest_contents"] = wasmExports["bbsink_forward_manifest_contents"])(a0, a1);
        var _fd_durable_rename = Module["_fd_durable_rename"] = (a0, a1, a22) => (_fd_durable_rename = Module["_fd_durable_rename"] = wasmExports["fd_durable_rename"])(a0, a1, a22);
        var _bbsink_forward_begin_backup = Module["_bbsink_forward_begin_backup"] = (a0) => (_bbsink_forward_begin_backup = Module["_bbsink_forward_begin_backup"] = wasmExports["bbsink_forward_begin_backup"])(a0);
        var _BaseBackupAddTarget = Module["_BaseBackupAddTarget"] = (a0, a1, a22) => (_BaseBackupAddTarget = Module["_BaseBackupAddTarget"] = wasmExports["BaseBackupAddTarget"])(a0, a1, a22);
        var _lappend = Module["_lappend"] = (a0, a1) => (_lappend = Module["_lappend"] = wasmExports["lappend"])(a0, a1);
        var _pstrdup = Module["_pstrdup"] = (a0) => (_pstrdup = Module["_pstrdup"] = wasmExports["pstrdup"])(a0);
        var _GetCurrentTimestamp = Module["_GetCurrentTimestamp"] = () => (_GetCurrentTimestamp = Module["_GetCurrentTimestamp"] = wasmExports["GetCurrentTimestamp"])();
        var _CreateDestReceiver = Module["_CreateDestReceiver"] = (a0) => (_CreateDestReceiver = Module["_CreateDestReceiver"] = wasmExports["CreateDestReceiver"])(a0);
        var _CreateTemplateTupleDesc = Module["_CreateTemplateTupleDesc"] = (a0) => (_CreateTemplateTupleDesc = Module["_CreateTemplateTupleDesc"] = wasmExports["CreateTemplateTupleDesc"])(a0);
        var _strtoul = Module["_strtoul"] = (a0, a1, a22) => (_strtoul = Module["_strtoul"] = wasmExports["strtoul"])(a0, a1, a22);
        var _cstring_to_text = Module["_cstring_to_text"] = (a0) => (_cstring_to_text = Module["_cstring_to_text"] = wasmExports["cstring_to_text"])(a0);
        var _Int64GetDatum = Module["_Int64GetDatum"] = (a0) => (_Int64GetDatum = Module["_Int64GetDatum"] = wasmExports["Int64GetDatum"])(a0);
        var _TimestampDifferenceMilliseconds = Module["_TimestampDifferenceMilliseconds"] = (a0, a1) => (_TimestampDifferenceMilliseconds = Module["_TimestampDifferenceMilliseconds"] = wasmExports["TimestampDifferenceMilliseconds"])(a0, a1);
        var ___wasm_setjmp_test = Module["___wasm_setjmp_test"] = (a0, a1) => (___wasm_setjmp_test = Module["___wasm_setjmp_test"] = wasmExports["__wasm_setjmp_test"])(a0, a1);
        var _defGetString = Module["_defGetString"] = (a0) => (_defGetString = Module["_defGetString"] = wasmExports["defGetString"])(a0);
        var _defGetBoolean = Module["_defGetBoolean"] = (a0) => (_defGetBoolean = Module["_defGetBoolean"] = wasmExports["defGetBoolean"])(a0);
        var _parse_bool = Module["_parse_bool"] = (a0, a1) => (_parse_bool = Module["_parse_bool"] = wasmExports["parse_bool"])(a0, a1);
        var ___wasm_setjmp = Module["___wasm_setjmp"] = (a0, a1, a22) => (___wasm_setjmp = Module["___wasm_setjmp"] = wasmExports["__wasm_setjmp"])(a0, a1, a22);
        var _pg_re_throw = Module["_pg_re_throw"] = () => (_pg_re_throw = Module["_pg_re_throw"] = wasmExports["pg_re_throw"])();
        var _emscripten_longjmp = Module["_emscripten_longjmp"] = (a0, a1) => (_emscripten_longjmp = Module["_emscripten_longjmp"] = wasmExports["emscripten_longjmp"])(a0, a1);
        var _ResourceOwnerCreate = Module["_ResourceOwnerCreate"] = (a0, a1) => (_ResourceOwnerCreate = Module["_ResourceOwnerCreate"] = wasmExports["ResourceOwnerCreate"])(a0, a1);
        var _RecoveryInProgress = Module["_RecoveryInProgress"] = () => (_RecoveryInProgress = Module["_RecoveryInProgress"] = wasmExports["RecoveryInProgress"])();
        var _makeStringInfo = Module["_makeStringInfo"] = () => (_makeStringInfo = Module["_makeStringInfo"] = wasmExports["makeStringInfo"])();
        var _before_shmem_exit = Module["_before_shmem_exit"] = (a0, a1) => (_before_shmem_exit = Module["_before_shmem_exit"] = wasmExports["before_shmem_exit"])(a0, a1);
        var _cancel_before_shmem_exit = Module["_cancel_before_shmem_exit"] = (a0, a1) => (_cancel_before_shmem_exit = Module["_cancel_before_shmem_exit"] = wasmExports["cancel_before_shmem_exit"])(a0, a1);
        var _AllocateDir = Module["_AllocateDir"] = (a0) => (_AllocateDir = Module["_AllocateDir"] = wasmExports["AllocateDir"])(a0);
        var _ReadDir = Module["_ReadDir"] = (a0, a1) => (_ReadDir = Module["_ReadDir"] = wasmExports["ReadDir"])(a0, a1);
        var _FreeDir = Module["_FreeDir"] = (a0) => (_FreeDir = Module["_FreeDir"] = wasmExports["FreeDir"])(a0);
        var _list_sort = Module["_list_sort"] = (a0, a1) => (_list_sort = Module["_list_sort"] = wasmExports["list_sort"])(a0, a1);
        var _sscanf = Module["_sscanf"] = (a0, a1, a22) => (_sscanf = Module["_sscanf"] = wasmExports["sscanf"])(a0, a1, a22);
        var _OpenTransientFile = Module["_OpenTransientFile"] = (a0, a1) => (_OpenTransientFile = Module["_OpenTransientFile"] = wasmExports["OpenTransientFile"])(a0, a1);
        var _fstat = Module["_fstat"] = (a0, a1) => (_fstat = Module["_fstat"] = wasmExports["fstat"])(a0, a1);
        var _CloseTransientFile = Module["_CloseTransientFile"] = (a0) => (_CloseTransientFile = Module["_CloseTransientFile"] = wasmExports["CloseTransientFile"])(a0);
        var _errstart = Module["_errstart"] = (a0, a1) => (_errstart = Module["_errstart"] = wasmExports["errstart"])(a0, a1);
        var _errmsg_plural = Module["_errmsg_plural"] = (a0, a1, a22, a32) => (_errmsg_plural = Module["_errmsg_plural"] = wasmExports["errmsg_plural"])(a0, a1, a22, a32);
        var _strncmp = Module["_strncmp"] = (a0, a1, a22) => (_strncmp = Module["_strncmp"] = wasmExports["strncmp"])(a0, a1, a22);
        var _ProcessInterrupts = Module["_ProcessInterrupts"] = () => (_ProcessInterrupts = Module["_ProcessInterrupts"] = wasmExports["ProcessInterrupts"])();
        var _memcmp = Module["_memcmp"] = (a0, a1, a22) => (_memcmp = Module["_memcmp"] = wasmExports["memcmp"])(a0, a1, a22);
        var _geteuid = Module["_geteuid"] = () => (_geteuid = Module["_geteuid"] = wasmExports["geteuid"])();
        var _time = Module["_time"] = (a0) => (_time = Module["_time"] = wasmExports["time"])(a0);
        var _atoi = Module["_atoi"] = (a0) => (_atoi = Module["_atoi"] = wasmExports["atoi"])(a0);
        var _pg_checksum_page = Module["_pg_checksum_page"] = (a0, a1) => (_pg_checksum_page = Module["_pg_checksum_page"] = wasmExports["pg_checksum_page"])(a0, a1);
        var _pgstat_progress_update_param = Module["_pgstat_progress_update_param"] = (a0, a1) => (_pgstat_progress_update_param = Module["_pgstat_progress_update_param"] = wasmExports["pgstat_progress_update_param"])(a0, a1);
        var _ResetLatch = Module["_ResetLatch"] = (a0) => (_ResetLatch = Module["_ResetLatch"] = wasmExports["ResetLatch"])(a0);
        var _WaitLatch = Module["_WaitLatch"] = (a0, a1, a22, a32) => (_WaitLatch = Module["_WaitLatch"] = wasmExports["WaitLatch"])(a0, a1, a22, a32);
        var _gettimeofday = Module["_gettimeofday"] = (a0, a1) => (_gettimeofday = Module["_gettimeofday"] = wasmExports["gettimeofday"])(a0, a1);
        var _raw_parser = Module["_raw_parser"] = (a0, a1) => (_raw_parser = Module["_raw_parser"] = wasmExports["raw_parser"])(a0, a1);
        var _errdetail_internal = Module["_errdetail_internal"] = (a0, a1) => (_errdetail_internal = Module["_errdetail_internal"] = wasmExports["errdetail_internal"])(a0, a1);
        var _list_make1_impl = Module["_list_make1_impl"] = (a0, a1) => (_list_make1_impl = Module["_list_make1_impl"] = wasmExports["list_make1_impl"])(a0, a1);
        var _MemoryContextAllocZeroAligned = Module["_MemoryContextAllocZeroAligned"] = (a0, a1) => (_MemoryContextAllocZeroAligned = Module["_MemoryContextAllocZeroAligned"] = wasmExports["MemoryContextAllocZeroAligned"])(a0, a1);
        var _pg_prng_double = Module["_pg_prng_double"] = (a0) => (_pg_prng_double = Module["_pg_prng_double"] = wasmExports["pg_prng_double"])(a0);
        var _sigaddset = Module["_sigaddset"] = (a0, a1) => (_sigaddset = Module["_sigaddset"] = wasmExports["sigaddset"])(a0, a1);
        var _die = Module["_die"] = (a0) => (_die = Module["_die"] = wasmExports["die"])(a0);
        var _check_stack_depth = Module["_check_stack_depth"] = () => (_check_stack_depth = Module["_check_stack_depth"] = wasmExports["check_stack_depth"])();
        var _pre_format_elog_string = Module["_pre_format_elog_string"] = (a0, a1) => (_pre_format_elog_string = Module["_pre_format_elog_string"] = wasmExports["pre_format_elog_string"])(a0, a1);
        var _format_elog_string = Module["_format_elog_string"] = (a0, a1) => (_format_elog_string = Module["_format_elog_string"] = wasmExports["format_elog_string"])(a0, a1);
        var _SplitIdentifierString = Module["_SplitIdentifierString"] = (a0, a1, a22) => (_SplitIdentifierString = Module["_SplitIdentifierString"] = wasmExports["SplitIdentifierString"])(a0, a1, a22);
        var _list_free = Module["_list_free"] = (a0) => (_list_free = Module["_list_free"] = wasmExports["list_free"])(a0);
        var _guc_malloc = Module["_guc_malloc"] = (a0, a1) => (_guc_malloc = Module["_guc_malloc"] = wasmExports["guc_malloc"])(a0, a1);
        var _SetConfigOption = Module["_SetConfigOption"] = (a0, a1, a22, a32) => (_SetConfigOption = Module["_SetConfigOption"] = wasmExports["SetConfigOption"])(a0, a1, a22, a32);
        var _pg_sprintf = Module["_pg_sprintf"] = (a0, a1, a22) => (_pg_sprintf = Module["_pg_sprintf"] = wasmExports["pg_sprintf"])(a0, a1, a22);
        var _strlcpy = Module["_strlcpy"] = (a0, a1, a22) => (_strlcpy = Module["_strlcpy"] = wasmExports["strlcpy"])(a0, a1, a22);
        var _fsync_pgdata = Module["_fsync_pgdata"] = (a0, a1) => (_fsync_pgdata = Module["_fsync_pgdata"] = wasmExports["fsync_pgdata"])(a0, a1);
        var _get_restricted_token = Module["_get_restricted_token"] = () => (_get_restricted_token = Module["_get_restricted_token"] = wasmExports["get_restricted_token"])();
        var _pg_malloc = Module["_pg_malloc"] = (a0) => (_pg_malloc = Module["_pg_malloc"] = wasmExports["pg_malloc"])(a0);
        var _pg_realloc = Module["_pg_realloc"] = (a0, a1) => (_pg_realloc = Module["_pg_realloc"] = wasmExports["pg_realloc"])(a0, a1);
        var _realloc = Module["_realloc"] = (a0, a1) => (_realloc = Module["_realloc"] = wasmExports["realloc"])(a0, a1);
        var _pg_strdup = Module["_pg_strdup"] = (a0) => (_pg_strdup = Module["_pg_strdup"] = wasmExports["pg_strdup"])(a0);
        var _simple_prompt = Module["_simple_prompt"] = (a0, a1) => (_simple_prompt = Module["_simple_prompt"] = wasmExports["simple_prompt"])(a0, a1);
        var _MemoryContextDelete = Module["_MemoryContextDelete"] = (a0) => (_MemoryContextDelete = Module["_MemoryContextDelete"] = wasmExports["MemoryContextDelete"])(a0);
        var _pg_printf = Module["_pg_printf"] = (a0, a1) => (_pg_printf = Module["_pg_printf"] = wasmExports["pg_printf"])(a0, a1);
        var _AllocSetContextCreateInternal = Module["_AllocSetContextCreateInternal"] = (a0, a1, a22, a32, a42) => (_AllocSetContextCreateInternal = Module["_AllocSetContextCreateInternal"] = wasmExports["AllocSetContextCreateInternal"])(a0, a1, a22, a32, a42);
        var _fopen = Module["_fopen"] = (a0, a1) => (_fopen = Module["_fopen"] = wasmExports["fopen"])(a0, a1);
        var _interactive_file = Module["_interactive_file"] = () => (_interactive_file = Module["_interactive_file"] = wasmExports["interactive_file"])();
        var _fclose = Module["_fclose"] = (a0) => (_fclose = Module["_fclose"] = wasmExports["fclose"])(a0);
        var _interactive_one = Module["_interactive_one"] = () => (_interactive_one = Module["_interactive_one"] = wasmExports["interactive_one"])();
        var _MemoryContextReset = Module["_MemoryContextReset"] = (a0) => (_MemoryContextReset = Module["_MemoryContextReset"] = wasmExports["MemoryContextReset"])(a0);
        var _resetStringInfo = Module["_resetStringInfo"] = (a0) => (_resetStringInfo = Module["_resetStringInfo"] = wasmExports["resetStringInfo"])(a0);
        var _getc = Module["_getc"] = (a0) => (_getc = Module["_getc"] = wasmExports["getc"])(a0);
        var _pq_getmsgint = Module["_pq_getmsgint"] = (a0, a1) => (_pq_getmsgint = Module["_pq_getmsgint"] = wasmExports["pq_getmsgint"])(a0, a1);
        var _pgstat_report_activity = Module["_pgstat_report_activity"] = (a0, a1) => (_pgstat_report_activity = Module["_pgstat_report_activity"] = wasmExports["pgstat_report_activity"])(a0, a1);
        var _access = Module["_access"] = (a0, a1) => (_access = Module["_access"] = wasmExports["access"])(a0, a1);
        var _pq_recvbuf_fill = Module["_pq_recvbuf_fill"] = (a0, a1) => (_pq_recvbuf_fill = Module["_pq_recvbuf_fill"] = wasmExports["pq_recvbuf_fill"])(a0, a1);
        var _unlink = Module["_unlink"] = (a0) => (_unlink = Module["_unlink"] = wasmExports["unlink"])(a0);
        var _calloc = Module["_calloc"] = (a0, a1) => (_calloc = Module["_calloc"] = wasmExports["calloc"])(a0, a1);
        var _EmitErrorReport = Module["_EmitErrorReport"] = () => (_EmitErrorReport = Module["_EmitErrorReport"] = wasmExports["EmitErrorReport"])();
        var _FlushErrorState = Module["_FlushErrorState"] = () => (_FlushErrorState = Module["_FlushErrorState"] = wasmExports["FlushErrorState"])();
        var _pg_repl_raf = Module["_pg_repl_raf"] = () => (_pg_repl_raf = Module["_pg_repl_raf"] = wasmExports["pg_repl_raf"])();
        var _pg_shutdown = Module["_pg_shutdown"] = () => (_pg_shutdown = Module["_pg_shutdown"] = wasmExports["pg_shutdown"])();
        var _errhidestmt = Module["_errhidestmt"] = (a0) => (_errhidestmt = Module["_errhidestmt"] = wasmExports["errhidestmt"])(a0);
        var _GetTransactionSnapshot = Module["_GetTransactionSnapshot"] = () => (_GetTransactionSnapshot = Module["_GetTransactionSnapshot"] = wasmExports["GetTransactionSnapshot"])();
        var _PushActiveSnapshot = Module["_PushActiveSnapshot"] = (a0) => (_PushActiveSnapshot = Module["_PushActiveSnapshot"] = wasmExports["PushActiveSnapshot"])(a0);
        var _PopActiveSnapshot = Module["_PopActiveSnapshot"] = () => (_PopActiveSnapshot = Module["_PopActiveSnapshot"] = wasmExports["PopActiveSnapshot"])();
        var _CommandCounterIncrement = Module["_CommandCounterIncrement"] = () => (_CommandCounterIncrement = Module["_CommandCounterIncrement"] = wasmExports["CommandCounterIncrement"])();
        var _MemoryContextSetParent = Module["_MemoryContextSetParent"] = (a0, a1) => (_MemoryContextSetParent = Module["_MemoryContextSetParent"] = wasmExports["MemoryContextSetParent"])(a0, a1);
        var _makeParamList = Module["_makeParamList"] = (a0) => (_makeParamList = Module["_makeParamList"] = wasmExports["makeParamList"])(a0);
        var _getTypeInputInfo = Module["_getTypeInputInfo"] = (a0, a1, a22) => (_getTypeInputInfo = Module["_getTypeInputInfo"] = wasmExports["getTypeInputInfo"])(a0, a1, a22);
        var _pnstrdup = Module["_pnstrdup"] = (a0, a1) => (_pnstrdup = Module["_pnstrdup"] = wasmExports["pnstrdup"])(a0, a1);
        var _interactive_write = Module["_interactive_write"] = (a0) => (_interactive_write = Module["_interactive_write"] = wasmExports["interactive_write"])(a0);
        var _interactive_read = Module["_interactive_read"] = () => (_interactive_read = Module["_interactive_read"] = wasmExports["interactive_read"])();
        var _appendStringInfoStringQuoted = Module["_appendStringInfoStringQuoted"] = (a0, a1, a22) => (_appendStringInfoStringQuoted = Module["_appendStringInfoStringQuoted"] = wasmExports["appendStringInfoStringQuoted"])(a0, a1, a22);
        var _set_errcontext_domain = Module["_set_errcontext_domain"] = (a0) => (_set_errcontext_domain = Module["_set_errcontext_domain"] = wasmExports["set_errcontext_domain"])(a0);
        var _errcontext_msg = Module["_errcontext_msg"] = (a0, a1) => (_errcontext_msg = Module["_errcontext_msg"] = wasmExports["errcontext_msg"])(a0, a1);
        var _SearchSysCache1 = Module["_SearchSysCache1"] = (a0, a1) => (_SearchSysCache1 = Module["_SearchSysCache1"] = wasmExports["SearchSysCache1"])(a0, a1);
        var _ReleaseSysCache = Module["_ReleaseSysCache"] = (a0) => (_ReleaseSysCache = Module["_ReleaseSysCache"] = wasmExports["ReleaseSysCache"])(a0);
        var _fmgr_info = Module["_fmgr_info"] = (a0, a1) => (_fmgr_info = Module["_fmgr_info"] = wasmExports["fmgr_info"])(a0, a1);
        var _object_aclcheck = Module["_object_aclcheck"] = (a0, a1, a22, a32) => (_object_aclcheck = Module["_object_aclcheck"] = wasmExports["object_aclcheck"])(a0, a1, a22, a32);
        var _get_namespace_name = Module["_get_namespace_name"] = (a0) => (_get_namespace_name = Module["_get_namespace_name"] = wasmExports["get_namespace_name"])(a0);
        var _aclcheck_error = Module["_aclcheck_error"] = (a0, a1, a22) => (_aclcheck_error = Module["_aclcheck_error"] = wasmExports["aclcheck_error"])(a0, a1, a22);
        var _appendBinaryStringInfo = Module["_appendBinaryStringInfo"] = (a0, a1, a22) => (_appendBinaryStringInfo = Module["_appendBinaryStringInfo"] = wasmExports["appendBinaryStringInfo"])(a0, a1, a22);
        var _getTypeOutputInfo = Module["_getTypeOutputInfo"] = (a0, a1, a22) => (_getTypeOutputInfo = Module["_getTypeOutputInfo"] = wasmExports["getTypeOutputInfo"])(a0, a1, a22);
        var _OidOutputFunctionCall = Module["_OidOutputFunctionCall"] = (a0, a1) => (_OidOutputFunctionCall = Module["_OidOutputFunctionCall"] = wasmExports["OidOutputFunctionCall"])(a0, a1);
        var _RegisterSnapshot = Module["_RegisterSnapshot"] = (a0) => (_RegisterSnapshot = Module["_RegisterSnapshot"] = wasmExports["RegisterSnapshot"])(a0);
        var _UnregisterSnapshot = Module["_UnregisterSnapshot"] = (a0) => (_UnregisterSnapshot = Module["_UnregisterSnapshot"] = wasmExports["UnregisterSnapshot"])(a0);
        var _GetActiveSnapshot = Module["_GetActiveSnapshot"] = () => (_GetActiveSnapshot = Module["_GetActiveSnapshot"] = wasmExports["GetActiveSnapshot"])();
        var _MemoryContextAlloc = Module["_MemoryContextAlloc"] = (a0, a1) => (_MemoryContextAlloc = Module["_MemoryContextAlloc"] = wasmExports["MemoryContextAlloc"])(a0, a1);
        var _SetTuplestoreDestReceiverParams = Module["_SetTuplestoreDestReceiverParams"] = (a0, a1, a22, a32, a42, a52) => (_SetTuplestoreDestReceiverParams = Module["_SetTuplestoreDestReceiverParams"] = wasmExports["SetTuplestoreDestReceiverParams"])(a0, a1, a22, a32, a42, a52);
        var _MemoryContextDeleteChildren = Module["_MemoryContextDeleteChildren"] = (a0) => (_MemoryContextDeleteChildren = Module["_MemoryContextDeleteChildren"] = wasmExports["MemoryContextDeleteChildren"])(a0);
        var _EnsurePortalSnapshotExists = Module["_EnsurePortalSnapshotExists"] = () => (_EnsurePortalSnapshotExists = Module["_EnsurePortalSnapshotExists"] = wasmExports["EnsurePortalSnapshotExists"])();
        var _MakeSingleTupleTableSlot = Module["_MakeSingleTupleTableSlot"] = (a0, a1) => (_MakeSingleTupleTableSlot = Module["_MakeSingleTupleTableSlot"] = wasmExports["MakeSingleTupleTableSlot"])(a0, a1);
        var _ExecDropSingleTupleTableSlot = Module["_ExecDropSingleTupleTableSlot"] = (a0) => (_ExecDropSingleTupleTableSlot = Module["_ExecDropSingleTupleTableSlot"] = wasmExports["ExecDropSingleTupleTableSlot"])(a0);
        var _GetCommandTagName = Module["_GetCommandTagName"] = (a0) => (_GetCommandTagName = Module["_GetCommandTagName"] = wasmExports["GetCommandTagName"])(a0);
        var _standard_ProcessUtility = Module["_standard_ProcessUtility"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_standard_ProcessUtility = Module["_standard_ProcessUtility"] = wasmExports["standard_ProcessUtility"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _copyObjectImpl = Module["_copyObjectImpl"] = (a0) => (_copyObjectImpl = Module["_copyObjectImpl"] = wasmExports["copyObjectImpl"])(a0);
        var _Async_Notify = Module["_Async_Notify"] = (a0, a1) => (_Async_Notify = Module["_Async_Notify"] = wasmExports["Async_Notify"])(a0, a1);
        var _superuser = Module["_superuser"] = () => (_superuser = Module["_superuser"] = wasmExports["superuser"])();
        var _list_concat = Module["_list_concat"] = (a0, a1) => (_list_concat = Module["_list_concat"] = wasmExports["list_concat"])(a0, a1);
        var _RangeVarGetRelidExtended = Module["_RangeVarGetRelidExtended"] = (a0, a1, a22, a32, a42) => (_RangeVarGetRelidExtended = Module["_RangeVarGetRelidExtended"] = wasmExports["RangeVarGetRelidExtended"])(a0, a1, a22, a32, a42);
        var _get_rel_relkind = Module["_get_rel_relkind"] = (a0) => (_get_rel_relkind = Module["_get_rel_relkind"] = wasmExports["get_rel_relkind"])(a0);
        var _CreateTupleDescCopy = Module["_CreateTupleDescCopy"] = (a0) => (_CreateTupleDescCopy = Module["_CreateTupleDescCopy"] = wasmExports["CreateTupleDescCopy"])(a0);
        var _bms_next_member = Module["_bms_next_member"] = (a0, a1) => (_bms_next_member = Module["_bms_next_member"] = wasmExports["bms_next_member"])(a0, a1);
        var _bms_add_member = Module["_bms_add_member"] = (a0, a1) => (_bms_add_member = Module["_bms_add_member"] = wasmExports["bms_add_member"])(a0, a1);
        var _bms_is_member = Module["_bms_is_member"] = (a0, a1) => (_bms_is_member = Module["_bms_is_member"] = wasmExports["bms_is_member"])(a0, a1);
        var _bms_del_member = Module["_bms_del_member"] = (a0, a1) => (_bms_del_member = Module["_bms_del_member"] = wasmExports["bms_del_member"])(a0, a1);
        var _bms_union = Module["_bms_union"] = (a0, a1) => (_bms_union = Module["_bms_union"] = wasmExports["bms_union"])(a0, a1);
        var _bms_overlap = Module["_bms_overlap"] = (a0, a1) => (_bms_overlap = Module["_bms_overlap"] = wasmExports["bms_overlap"])(a0, a1);
        var _table_open = Module["_table_open"] = (a0, a1) => (_table_open = Module["_table_open"] = wasmExports["table_open"])(a0, a1);
        var _ScanKeyInit = Module["_ScanKeyInit"] = (a0, a1, a22, a32, a42) => (_ScanKeyInit = Module["_ScanKeyInit"] = wasmExports["ScanKeyInit"])(a0, a1, a22, a32, a42);
        var _systable_beginscan = Module["_systable_beginscan"] = (a0, a1, a22, a32, a42, a52) => (_systable_beginscan = Module["_systable_beginscan"] = wasmExports["systable_beginscan"])(a0, a1, a22, a32, a42, a52);
        var _systable_getnext = Module["_systable_getnext"] = (a0) => (_systable_getnext = Module["_systable_getnext"] = wasmExports["systable_getnext"])(a0);
        var _systable_endscan = Module["_systable_endscan"] = (a0) => (_systable_endscan = Module["_systable_endscan"] = wasmExports["systable_endscan"])(a0);
        var _table_close = Module["_table_close"] = (a0, a1) => (_table_close = Module["_table_close"] = wasmExports["table_close"])(a0, a1);
        var _errdetail_relkind_not_supported = Module["_errdetail_relkind_not_supported"] = (a0) => (_errdetail_relkind_not_supported = Module["_errdetail_relkind_not_supported"] = wasmExports["errdetail_relkind_not_supported"])(a0);
        var _object_ownercheck = Module["_object_ownercheck"] = (a0, a1, a22) => (_object_ownercheck = Module["_object_ownercheck"] = wasmExports["object_ownercheck"])(a0, a1, a22);
        var _get_relkind_objtype = Module["_get_relkind_objtype"] = (a0) => (_get_relkind_objtype = Module["_get_relkind_objtype"] = wasmExports["get_relkind_objtype"])(a0);
        var _SearchSysCache2 = Module["_SearchSysCache2"] = (a0, a1, a22) => (_SearchSysCache2 = Module["_SearchSysCache2"] = wasmExports["SearchSysCache2"])(a0, a1, a22);
        var _get_rel_name = Module["_get_rel_name"] = (a0) => (_get_rel_name = Module["_get_rel_name"] = wasmExports["get_rel_name"])(a0);
        var _heap_form_tuple = Module["_heap_form_tuple"] = (a0, a1, a22) => (_heap_form_tuple = Module["_heap_form_tuple"] = wasmExports["heap_form_tuple"])(a0, a1, a22);
        var _heap_freetuple = Module["_heap_freetuple"] = (a0) => (_heap_freetuple = Module["_heap_freetuple"] = wasmExports["heap_freetuple"])(a0);
        var _exprType = Module["_exprType"] = (a0) => (_exprType = Module["_exprType"] = wasmExports["exprType"])(a0);
        var _format_type_be = Module["_format_type_be"] = (a0) => (_format_type_be = Module["_format_type_be"] = wasmExports["format_type_be"])(a0);
        var _exprTypmod = Module["_exprTypmod"] = (a0) => (_exprTypmod = Module["_exprTypmod"] = wasmExports["exprTypmod"])(a0);
        var _format_type_with_typemod = Module["_format_type_with_typemod"] = (a0, a1) => (_format_type_with_typemod = Module["_format_type_with_typemod"] = wasmExports["format_type_with_typemod"])(a0, a1);
        var _relation_open = Module["_relation_open"] = (a0, a1) => (_relation_open = Module["_relation_open"] = wasmExports["relation_open"])(a0, a1);
        var _relation_close = Module["_relation_close"] = (a0, a1) => (_relation_close = Module["_relation_close"] = wasmExports["relation_close"])(a0, a1);
        var _makeString = Module["_makeString"] = (a0) => (_makeString = Module["_makeString"] = wasmExports["makeString"])(a0);
        var _makeTargetEntry = Module["_makeTargetEntry"] = (a0, a1, a22, a32) => (_makeTargetEntry = Module["_makeTargetEntry"] = wasmExports["makeTargetEntry"])(a0, a1, a22, a32);
        var _makeVar = Module["_makeVar"] = (a0, a1, a22, a32, a42, a52) => (_makeVar = Module["_makeVar"] = wasmExports["makeVar"])(a0, a1, a22, a32, a42, a52);
        var _list_make2_impl = Module["_list_make2_impl"] = (a0, a1, a22) => (_list_make2_impl = Module["_list_make2_impl"] = wasmExports["list_make2_impl"])(a0, a1, a22);
        var _lappend_oid = Module["_lappend_oid"] = (a0, a1) => (_lappend_oid = Module["_lappend_oid"] = wasmExports["lappend_oid"])(a0, a1);
        var _lappend_int = Module["_lappend_int"] = (a0, a1) => (_lappend_int = Module["_lappend_int"] = wasmExports["lappend_int"])(a0, a1);
        var _SearchSysCacheExists = Module["_SearchSysCacheExists"] = (a0, a1, a22, a32, a42) => (_SearchSysCacheExists = Module["_SearchSysCacheExists"] = wasmExports["SearchSysCacheExists"])(a0, a1, a22, a32, a42);
        var _strip_implicit_coercions = Module["_strip_implicit_coercions"] = (a0) => (_strip_implicit_coercions = Module["_strip_implicit_coercions"] = wasmExports["strip_implicit_coercions"])(a0);
        var _stringToNode = Module["_stringToNode"] = (a0) => (_stringToNode = Module["_stringToNode"] = wasmExports["stringToNode"])(a0);
        var _coerce_to_target_type = Module["_coerce_to_target_type"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_coerce_to_target_type = Module["_coerce_to_target_type"] = wasmExports["coerce_to_target_type"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _try_relation_open = Module["_try_relation_open"] = (a0, a1) => (_try_relation_open = Module["_try_relation_open"] = wasmExports["try_relation_open"])(a0, a1);
        var _list_member_oid = Module["_list_member_oid"] = (a0, a1) => (_list_member_oid = Module["_list_member_oid"] = wasmExports["list_member_oid"])(a0, a1);
        var _list_delete_last = Module["_list_delete_last"] = (a0) => (_list_delete_last = Module["_list_delete_last"] = wasmExports["list_delete_last"])(a0);
        var _list_delete_cell = Module["_list_delete_cell"] = (a0, a1) => (_list_delete_cell = Module["_list_delete_cell"] = wasmExports["list_delete_cell"])(a0, a1);
        var _addRTEPermissionInfo = Module["_addRTEPermissionInfo"] = (a0, a1) => (_addRTEPermissionInfo = Module["_addRTEPermissionInfo"] = wasmExports["addRTEPermissionInfo"])(a0, a1);
        var _equal = Module["_equal"] = (a0, a1) => (_equal = Module["_equal"] = wasmExports["equal"])(a0, a1);
        var _repalloc = Module["_repalloc"] = (a0, a1) => (_repalloc = Module["_repalloc"] = wasmExports["repalloc"])(a0, a1);
        var _memmove = Module["_memmove"] = (a0, a1, a22) => (_memmove = Module["_memmove"] = wasmExports["memmove"])(a0, a1, a22);
        var _palloc_extended = Module["_palloc_extended"] = (a0, a1) => (_palloc_extended = Module["_palloc_extended"] = wasmExports["palloc_extended"])(a0, a1);
        var _pg_reg_getinitialstate = Module["_pg_reg_getinitialstate"] = (a0) => (_pg_reg_getinitialstate = Module["_pg_reg_getinitialstate"] = wasmExports["pg_reg_getinitialstate"])(a0);
        var _pg_reg_getfinalstate = Module["_pg_reg_getfinalstate"] = (a0) => (_pg_reg_getfinalstate = Module["_pg_reg_getfinalstate"] = wasmExports["pg_reg_getfinalstate"])(a0);
        var _pg_reg_getnumoutarcs = Module["_pg_reg_getnumoutarcs"] = (a0, a1) => (_pg_reg_getnumoutarcs = Module["_pg_reg_getnumoutarcs"] = wasmExports["pg_reg_getnumoutarcs"])(a0, a1);
        var _pg_reg_getoutarcs = Module["_pg_reg_getoutarcs"] = (a0, a1, a22, a32) => (_pg_reg_getoutarcs = Module["_pg_reg_getoutarcs"] = wasmExports["pg_reg_getoutarcs"])(a0, a1, a22, a32);
        var _pg_reg_getnumcolors = Module["_pg_reg_getnumcolors"] = (a0) => (_pg_reg_getnumcolors = Module["_pg_reg_getnumcolors"] = wasmExports["pg_reg_getnumcolors"])(a0);
        var _pg_reg_colorisbegin = Module["_pg_reg_colorisbegin"] = (a0, a1) => (_pg_reg_colorisbegin = Module["_pg_reg_colorisbegin"] = wasmExports["pg_reg_colorisbegin"])(a0, a1);
        var _pg_reg_colorisend = Module["_pg_reg_colorisend"] = (a0, a1) => (_pg_reg_colorisend = Module["_pg_reg_colorisend"] = wasmExports["pg_reg_colorisend"])(a0, a1);
        var _pg_reg_getnumcharacters = Module["_pg_reg_getnumcharacters"] = (a0, a1) => (_pg_reg_getnumcharacters = Module["_pg_reg_getnumcharacters"] = wasmExports["pg_reg_getnumcharacters"])(a0, a1);
        var _pg_reg_getcharacters = Module["_pg_reg_getcharacters"] = (a0, a1, a22, a32) => (_pg_reg_getcharacters = Module["_pg_reg_getcharacters"] = wasmExports["pg_reg_getcharacters"])(a0, a1, a22, a32);
        var _pg_regerror = Module["_pg_regerror"] = (a0, a1, a22, a32) => (_pg_regerror = Module["_pg_regerror"] = wasmExports["pg_regerror"])(a0, a1, a22, a32);
        var _strcpy = Module["_strcpy"] = (a0, a1) => (_strcpy = Module["_strcpy"] = wasmExports["strcpy"])(a0, a1);
        var _pg_regcomp = Module["_pg_regcomp"] = (a0, a1, a22, a32, a42) => (_pg_regcomp = Module["_pg_regcomp"] = wasmExports["pg_regcomp"])(a0, a1, a22, a32, a42);
        var _GetDatabaseEncoding = Module["_GetDatabaseEncoding"] = () => (_GetDatabaseEncoding = Module["_GetDatabaseEncoding"] = wasmExports["GetDatabaseEncoding"])();
        var _pg_qsort = Module["_pg_qsort"] = (a0, a1, a22, a32) => (_pg_qsort = Module["_pg_qsort"] = wasmExports["pg_qsort"])(a0, a1, a22, a32);
        var _isalnum = Module["_isalnum"] = (a0) => (_isalnum = Module["_isalnum"] = wasmExports["isalnum"])(a0);
        var _tolower = Module["_tolower"] = (a0) => (_tolower = Module["_tolower"] = wasmExports["tolower"])(a0);
        var _toupper = Module["_toupper"] = (a0) => (_toupper = Module["_toupper"] = wasmExports["toupper"])(a0);
        var _makeRangeVar = Module["_makeRangeVar"] = (a0, a1, a22) => (_makeRangeVar = Module["_makeRangeVar"] = wasmExports["makeRangeVar"])(a0, a1, a22);
        var _ferror = Module["_ferror"] = (a0) => (_ferror = Module["_ferror"] = wasmExports["ferror"])(a0);
        var _fread = Module["_fread"] = (a0, a1, a22, a32) => (_fread = Module["_fread"] = wasmExports["fread"])(a0, a1, a22, a32);
        var _clearerr = Module["_clearerr"] = (a0) => (_clearerr = Module["_clearerr"] = wasmExports["clearerr"])(a0);
        var _pqsignal = Module["_pqsignal"] = (a0, a1) => (_pqsignal = Module["_pqsignal"] = wasmExports["pqsignal"])(a0, a1);
        var _table_openrv = Module["_table_openrv"] = (a0, a1) => (_table_openrv = Module["_table_openrv"] = wasmExports["table_openrv"])(a0, a1);
        var _MemoryContextAllocZero = Module["_MemoryContextAllocZero"] = (a0, a1) => (_MemoryContextAllocZero = Module["_MemoryContextAllocZero"] = wasmExports["MemoryContextAllocZero"])(a0, a1);
        var _heap_getnext = Module["_heap_getnext"] = (a0, a1) => (_heap_getnext = Module["_heap_getnext"] = wasmExports["heap_getnext"])(a0, a1);
        var _list_free_deep = Module["_list_free_deep"] = (a0) => (_list_free_deep = Module["_list_free_deep"] = wasmExports["list_free_deep"])(a0);
        var _index_open = Module["_index_open"] = (a0, a1) => (_index_open = Module["_index_open"] = wasmExports["index_open"])(a0, a1);
        var _index_close = Module["_index_close"] = (a0, a1) => (_index_close = Module["_index_close"] = wasmExports["index_close"])(a0, a1);
        var _ExecReScan = Module["_ExecReScan"] = (a0) => (_ExecReScan = Module["_ExecReScan"] = wasmExports["ExecReScan"])(a0);
        var _InstrEndLoop = Module["_InstrEndLoop"] = (a0) => (_InstrEndLoop = Module["_InstrEndLoop"] = wasmExports["InstrEndLoop"])(a0);
        var _bms_free = Module["_bms_free"] = (a0) => (_bms_free = Module["_bms_free"] = wasmExports["bms_free"])(a0);
        var _text_to_cstring = Module["_text_to_cstring"] = (a0) => (_text_to_cstring = Module["_text_to_cstring"] = wasmExports["text_to_cstring"])(a0);
        var _slot_getsomeattrs_int = Module["_slot_getsomeattrs_int"] = (a0, a1) => (_slot_getsomeattrs_int = Module["_slot_getsomeattrs_int"] = wasmExports["slot_getsomeattrs_int"])(a0, a1);
        var _CreateExecutorState = Module["_CreateExecutorState"] = () => (_CreateExecutorState = Module["_CreateExecutorState"] = wasmExports["CreateExecutorState"])();
        var _FreeExecutorState = Module["_FreeExecutorState"] = (a0) => (_FreeExecutorState = Module["_FreeExecutorState"] = wasmExports["FreeExecutorState"])(a0);
        var _FreeExprContext = Module["_FreeExprContext"] = (a0, a1) => (_FreeExprContext = Module["_FreeExprContext"] = wasmExports["FreeExprContext"])(a0, a1);
        var _CreateExprContext = Module["_CreateExprContext"] = (a0) => (_CreateExprContext = Module["_CreateExprContext"] = wasmExports["CreateExprContext"])(a0);
        var _MakePerTupleExprContext = Module["_MakePerTupleExprContext"] = (a0) => (_MakePerTupleExprContext = Module["_MakePerTupleExprContext"] = wasmExports["MakePerTupleExprContext"])(a0);
        var _list_member_int = Module["_list_member_int"] = (a0, a1) => (_list_member_int = Module["_list_member_int"] = wasmExports["list_member_int"])(a0, a1);
        var _ExecOpenScanRelation = Module["_ExecOpenScanRelation"] = (a0, a1, a22) => (_ExecOpenScanRelation = Module["_ExecOpenScanRelation"] = wasmExports["ExecOpenScanRelation"])(a0, a1, a22);
        var _ExecInitRangeTable = Module["_ExecInitRangeTable"] = (a0, a1, a22) => (_ExecInitRangeTable = Module["_ExecInitRangeTable"] = wasmExports["ExecInitRangeTable"])(a0, a1, a22);
        var _pg_mbstrlen_with_len = Module["_pg_mbstrlen_with_len"] = (a0, a1) => (_pg_mbstrlen_with_len = Module["_pg_mbstrlen_with_len"] = wasmExports["pg_mbstrlen_with_len"])(a0, a1);
        var _errposition = Module["_errposition"] = (a0) => (_errposition = Module["_errposition"] = wasmExports["errposition"])(a0);
        var _lookup_rowtype_tupdesc = Module["_lookup_rowtype_tupdesc"] = (a0, a1) => (_lookup_rowtype_tupdesc = Module["_lookup_rowtype_tupdesc"] = wasmExports["lookup_rowtype_tupdesc"])(a0, a1);
        var _DecrTupleDescRefCount = Module["_DecrTupleDescRefCount"] = (a0) => (_DecrTupleDescRefCount = Module["_DecrTupleDescRefCount"] = wasmExports["DecrTupleDescRefCount"])(a0);
        var _getmissingattr = Module["_getmissingattr"] = (a0, a1, a22) => (_getmissingattr = Module["_getmissingattr"] = wasmExports["getmissingattr"])(a0, a1, a22);
        var _nocachegetattr = Module["_nocachegetattr"] = (a0, a1, a22) => (_nocachegetattr = Module["_nocachegetattr"] = wasmExports["nocachegetattr"])(a0, a1, a22);
        var _ExecGetReturningSlot = Module["_ExecGetReturningSlot"] = (a0, a1) => (_ExecGetReturningSlot = Module["_ExecGetReturningSlot"] = wasmExports["ExecGetReturningSlot"])(a0, a1);
        var _build_attrmap_by_name_if_req = Module["_build_attrmap_by_name_if_req"] = (a0, a1, a22) => (_build_attrmap_by_name_if_req = Module["_build_attrmap_by_name_if_req"] = wasmExports["build_attrmap_by_name_if_req"])(a0, a1, a22);
        var _ExecGetResultRelCheckAsUser = Module["_ExecGetResultRelCheckAsUser"] = (a0, a1) => (_ExecGetResultRelCheckAsUser = Module["_ExecGetResultRelCheckAsUser"] = wasmExports["ExecGetResultRelCheckAsUser"])(a0, a1);
        var _add_size = Module["_add_size"] = (a0, a1) => (_add_size = Module["_add_size"] = wasmExports["add_size"])(a0, a1);
        var _shm_toc_allocate = Module["_shm_toc_allocate"] = (a0, a1) => (_shm_toc_allocate = Module["_shm_toc_allocate"] = wasmExports["shm_toc_allocate"])(a0, a1);
        var _shm_toc_insert = Module["_shm_toc_insert"] = (a0, a1, a22) => (_shm_toc_insert = Module["_shm_toc_insert"] = wasmExports["shm_toc_insert"])(a0, a1, a22);
        var _shm_toc_lookup = Module["_shm_toc_lookup"] = (a0, a1, a22) => (_shm_toc_lookup = Module["_shm_toc_lookup"] = wasmExports["shm_toc_lookup"])(a0, a1, a22);
        var _ExecInitExpr = Module["_ExecInitExpr"] = (a0, a1) => (_ExecInitExpr = Module["_ExecInitExpr"] = wasmExports["ExecInitExpr"])(a0, a1);
        var _ItemPointerCompare = Module["_ItemPointerCompare"] = (a0, a1) => (_ItemPointerCompare = Module["_ItemPointerCompare"] = wasmExports["ItemPointerCompare"])(a0, a1);
        var _bms_add_members = Module["_bms_add_members"] = (a0, a1) => (_bms_add_members = Module["_bms_add_members"] = wasmExports["bms_add_members"])(a0, a1);
        var _bms_num_members = Module["_bms_num_members"] = (a0) => (_bms_num_members = Module["_bms_num_members"] = wasmExports["bms_num_members"])(a0);
        var _tuplesort_end = Module["_tuplesort_end"] = (a0) => (_tuplesort_end = Module["_tuplesort_end"] = wasmExports["tuplesort_end"])(a0);
        var _ExecInitExprList = Module["_ExecInitExprList"] = (a0, a1) => (_ExecInitExprList = Module["_ExecInitExprList"] = wasmExports["ExecInitExprList"])(a0, a1);
        var _get_typlenbyval = Module["_get_typlenbyval"] = (a0, a1, a22) => (_get_typlenbyval = Module["_get_typlenbyval"] = wasmExports["get_typlenbyval"])(a0, a1, a22);
        var _SysCacheGetAttr = Module["_SysCacheGetAttr"] = (a0, a1, a22, a32) => (_SysCacheGetAttr = Module["_SysCacheGetAttr"] = wasmExports["SysCacheGetAttr"])(a0, a1, a22, a32);
        var _ExecForceStoreHeapTuple = Module["_ExecForceStoreHeapTuple"] = (a0, a1, a22) => (_ExecForceStoreHeapTuple = Module["_ExecForceStoreHeapTuple"] = wasmExports["ExecForceStoreHeapTuple"])(a0, a1, a22);
        var _tuplesort_performsort = Module["_tuplesort_performsort"] = (a0) => (_tuplesort_performsort = Module["_tuplesort_performsort"] = wasmExports["tuplesort_performsort"])(a0);
        var _tuplesort_begin_heap = Module["_tuplesort_begin_heap"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82) => (_tuplesort_begin_heap = Module["_tuplesort_begin_heap"] = wasmExports["tuplesort_begin_heap"])(a0, a1, a22, a32, a42, a52, a62, a72, a82);
        var _ExecStoreVirtualTuple = Module["_ExecStoreVirtualTuple"] = (a0) => (_ExecStoreVirtualTuple = Module["_ExecStoreVirtualTuple"] = wasmExports["ExecStoreVirtualTuple"])(a0);
        var _MemoryContextMemAllocated = Module["_MemoryContextMemAllocated"] = (a0, a1) => (_MemoryContextMemAllocated = Module["_MemoryContextMemAllocated"] = wasmExports["MemoryContextMemAllocated"])(a0, a1);
        var _tuplesort_gettupleslot = Module["_tuplesort_gettupleslot"] = (a0, a1, a22, a32, a42) => (_tuplesort_gettupleslot = Module["_tuplesort_gettupleslot"] = wasmExports["tuplesort_gettupleslot"])(a0, a1, a22, a32, a42);
        var _tuplesort_puttupleslot = Module["_tuplesort_puttupleslot"] = (a0, a1) => (_tuplesort_puttupleslot = Module["_tuplesort_puttupleslot"] = wasmExports["tuplesort_puttupleslot"])(a0, a1);
        var _datumCopy = Module["_datumCopy"] = (a0, a1, a22) => (_datumCopy = Module["_datumCopy"] = wasmExports["datumCopy"])(a0, a1, a22);
        var _ExecStoreAllNullTuple = Module["_ExecStoreAllNullTuple"] = (a0) => (_ExecStoreAllNullTuple = Module["_ExecStoreAllNullTuple"] = wasmExports["ExecStoreAllNullTuple"])(a0);
        var _FunctionCall2Coll = Module["_FunctionCall2Coll"] = (a0, a1, a22, a32) => (_FunctionCall2Coll = Module["_FunctionCall2Coll"] = wasmExports["FunctionCall2Coll"])(a0, a1, a22, a32);
        var _MakeExpandedObjectReadOnlyInternal = Module["_MakeExpandedObjectReadOnlyInternal"] = (a0) => (_MakeExpandedObjectReadOnlyInternal = Module["_MakeExpandedObjectReadOnlyInternal"] = wasmExports["MakeExpandedObjectReadOnlyInternal"])(a0);
        var _ReleaseBuffer = Module["_ReleaseBuffer"] = (a0) => (_ReleaseBuffer = Module["_ReleaseBuffer"] = wasmExports["ReleaseBuffer"])(a0);
        var _s_init_lock_sema = Module["_s_init_lock_sema"] = (a0, a1) => (_s_init_lock_sema = Module["_s_init_lock_sema"] = wasmExports["s_init_lock_sema"])(a0, a1);
        var _ConditionVariableInit = Module["_ConditionVariableInit"] = (a0) => (_ConditionVariableInit = Module["_ConditionVariableInit"] = wasmExports["ConditionVariableInit"])(a0);
        var _tas_sema = Module["_tas_sema"] = (a0) => (_tas_sema = Module["_tas_sema"] = wasmExports["tas_sema"])(a0);
        var _s_lock = Module["_s_lock"] = (a0, a1, a22, a32) => (_s_lock = Module["_s_lock"] = wasmExports["s_lock"])(a0, a1, a22, a32);
        var _s_unlock_sema = Module["_s_unlock_sema"] = (a0) => (_s_unlock_sema = Module["_s_unlock_sema"] = wasmExports["s_unlock_sema"])(a0);
        var _ConditionVariableSleep = Module["_ConditionVariableSleep"] = (a0, a1) => (_ConditionVariableSleep = Module["_ConditionVariableSleep"] = wasmExports["ConditionVariableSleep"])(a0, a1);
        var _ConditionVariableCancelSleep = Module["_ConditionVariableCancelSleep"] = () => (_ConditionVariableCancelSleep = Module["_ConditionVariableCancelSleep"] = wasmExports["ConditionVariableCancelSleep"])();
        var _visibilitymap_get_status = Module["_visibilitymap_get_status"] = (a0, a1, a22) => (_visibilitymap_get_status = Module["_visibilitymap_get_status"] = wasmExports["visibilitymap_get_status"])(a0, a1, a22);
        var _PrefetchBuffer = Module["_PrefetchBuffer"] = (a0, a1, a22, a32) => (_PrefetchBuffer = Module["_PrefetchBuffer"] = wasmExports["PrefetchBuffer"])(a0, a1, a22, a32);
        var _ExecFindJunkAttributeInTlist = Module["_ExecFindJunkAttributeInTlist"] = (a0, a1) => (_ExecFindJunkAttributeInTlist = Module["_ExecFindJunkAttributeInTlist"] = wasmExports["ExecFindJunkAttributeInTlist"])(a0, a1);
        var _get_call_expr_argtype = Module["_get_call_expr_argtype"] = (a0, a1) => (_get_call_expr_argtype = Module["_get_call_expr_argtype"] = wasmExports["get_call_expr_argtype"])(a0, a1);
        var _get_typcollation = Module["_get_typcollation"] = (a0) => (_get_typcollation = Module["_get_typcollation"] = wasmExports["get_typcollation"])(a0);
        var _MemoryContextSetIdentifier = Module["_MemoryContextSetIdentifier"] = (a0, a1) => (_MemoryContextSetIdentifier = Module["_MemoryContextSetIdentifier"] = wasmExports["MemoryContextSetIdentifier"])(a0, a1);
        var _get_call_result_type = Module["_get_call_result_type"] = (a0, a1, a22) => (_get_call_result_type = Module["_get_call_result_type"] = wasmExports["get_call_result_type"])(a0, a1, a22);
        var _SysCacheGetAttrNotNull = Module["_SysCacheGetAttrNotNull"] = (a0, a1, a22) => (_SysCacheGetAttrNotNull = Module["_SysCacheGetAttrNotNull"] = wasmExports["SysCacheGetAttrNotNull"])(a0, a1, a22);
        var _BlessTupleDesc = Module["_BlessTupleDesc"] = (a0) => (_BlessTupleDesc = Module["_BlessTupleDesc"] = wasmExports["BlessTupleDesc"])(a0);
        var _type_is_rowtype = Module["_type_is_rowtype"] = (a0) => (_type_is_rowtype = Module["_type_is_rowtype"] = wasmExports["type_is_rowtype"])(a0);
        var _GetCurrentSubTransactionId = Module["_GetCurrentSubTransactionId"] = () => (_GetCurrentSubTransactionId = Module["_GetCurrentSubTransactionId"] = wasmExports["GetCurrentSubTransactionId"])();
        var _tuplestore_begin_heap = Module["_tuplestore_begin_heap"] = (a0, a1, a22) => (_tuplestore_begin_heap = Module["_tuplestore_begin_heap"] = wasmExports["tuplestore_begin_heap"])(a0, a1, a22);
        var _geterrposition = Module["_geterrposition"] = () => (_geterrposition = Module["_geterrposition"] = wasmExports["geterrposition"])();
        var _internalerrposition = Module["_internalerrposition"] = (a0) => (_internalerrposition = Module["_internalerrposition"] = wasmExports["internalerrposition"])(a0);
        var _internalerrquery = Module["_internalerrquery"] = (a0) => (_internalerrquery = Module["_internalerrquery"] = wasmExports["internalerrquery"])(a0);
        var _tuplestore_end = Module["_tuplestore_end"] = (a0) => (_tuplestore_end = Module["_tuplestore_end"] = wasmExports["tuplestore_end"])(a0);
        var _get_typtype = Module["_get_typtype"] = (a0) => (_get_typtype = Module["_get_typtype"] = wasmExports["get_typtype"])(a0);
        var _InstrAlloc = Module["_InstrAlloc"] = (a0, a1, a22) => (_InstrAlloc = Module["_InstrAlloc"] = wasmExports["InstrAlloc"])(a0, a1, a22);
        var _table_parallelscan_estimate = Module["_table_parallelscan_estimate"] = (a0, a1) => (_table_parallelscan_estimate = Module["_table_parallelscan_estimate"] = wasmExports["table_parallelscan_estimate"])(a0, a1);
        var _table_parallelscan_initialize = Module["_table_parallelscan_initialize"] = (a0, a1, a22) => (_table_parallelscan_initialize = Module["_table_parallelscan_initialize"] = wasmExports["table_parallelscan_initialize"])(a0, a1, a22);
        var _table_beginscan_parallel = Module["_table_beginscan_parallel"] = (a0, a1) => (_table_beginscan_parallel = Module["_table_beginscan_parallel"] = wasmExports["table_beginscan_parallel"])(a0, a1);
        var _tuplestore_putvalues = Module["_tuplestore_putvalues"] = (a0, a1, a22, a32) => (_tuplestore_putvalues = Module["_tuplestore_putvalues"] = wasmExports["tuplestore_putvalues"])(a0, a1, a22, a32);
        var _pull_varattnos = Module["_pull_varattnos"] = (a0, a1, a22) => (_pull_varattnos = Module["_pull_varattnos"] = wasmExports["pull_varattnos"])(a0, a1, a22);
        var _ExecPrepareExpr = Module["_ExecPrepareExpr"] = (a0, a1) => (_ExecPrepareExpr = Module["_ExecPrepareExpr"] = wasmExports["ExecPrepareExpr"])(a0, a1);
        var _hash_search = Module["_hash_search"] = (a0, a1, a22, a32) => (_hash_search = Module["_hash_search"] = wasmExports["hash_search"])(a0, a1, a22, a32);
        var _hash_create = Module["_hash_create"] = (a0, a1, a22, a32) => (_hash_create = Module["_hash_create"] = wasmExports["hash_create"])(a0, a1, a22, a32);
        var _pg_detoast_datum = Module["_pg_detoast_datum"] = (a0) => (_pg_detoast_datum = Module["_pg_detoast_datum"] = wasmExports["pg_detoast_datum"])(a0);
        var _TransactionIdIsCurrentTransactionId = Module["_TransactionIdIsCurrentTransactionId"] = (a0) => (_TransactionIdIsCurrentTransactionId = Module["_TransactionIdIsCurrentTransactionId"] = wasmExports["TransactionIdIsCurrentTransactionId"])(a0);
        var _execute_attr_map_slot = Module["_execute_attr_map_slot"] = (a0, a1, a22) => (_execute_attr_map_slot = Module["_execute_attr_map_slot"] = wasmExports["execute_attr_map_slot"])(a0, a1, a22);
        var _MemoryContextAllocExtended = Module["_MemoryContextAllocExtended"] = (a0, a1, a22) => (_MemoryContextAllocExtended = Module["_MemoryContextAllocExtended"] = wasmExports["MemoryContextAllocExtended"])(a0, a1, a22);
        var _bms_nonempty_difference = Module["_bms_nonempty_difference"] = (a0, a1) => (_bms_nonempty_difference = Module["_bms_nonempty_difference"] = wasmExports["bms_nonempty_difference"])(a0, a1);
        var _FunctionCall1Coll = Module["_FunctionCall1Coll"] = (a0, a1, a22) => (_FunctionCall1Coll = Module["_FunctionCall1Coll"] = wasmExports["FunctionCall1Coll"])(a0, a1, a22);
        var _fmgr_info_cxt = Module["_fmgr_info_cxt"] = (a0, a1, a22) => (_fmgr_info_cxt = Module["_fmgr_info_cxt"] = wasmExports["fmgr_info_cxt"])(a0, a1, a22);
        var _tuplesort_reset = Module["_tuplesort_reset"] = (a0) => (_tuplesort_reset = Module["_tuplesort_reset"] = wasmExports["tuplesort_reset"])(a0);
        var _deconstruct_array_builtin = Module["_deconstruct_array_builtin"] = (a0, a1, a22, a32, a42) => (_deconstruct_array_builtin = Module["_deconstruct_array_builtin"] = wasmExports["deconstruct_array_builtin"])(a0, a1, a22, a32, a42);
        var _pairingheap_remove_first = Module["_pairingheap_remove_first"] = (a0) => (_pairingheap_remove_first = Module["_pairingheap_remove_first"] = wasmExports["pairingheap_remove_first"])(a0);
        var _get_typlenbyvalalign = Module["_get_typlenbyvalalign"] = (a0, a1, a22, a32) => (_get_typlenbyvalalign = Module["_get_typlenbyvalalign"] = wasmExports["get_typlenbyvalalign"])(a0, a1, a22, a32);
        var _deconstruct_array = Module["_deconstruct_array"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_deconstruct_array = Module["_deconstruct_array"] = wasmExports["deconstruct_array"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _pairingheap_allocate = Module["_pairingheap_allocate"] = (a0, a1) => (_pairingheap_allocate = Module["_pairingheap_allocate"] = wasmExports["pairingheap_allocate"])(a0, a1);
        var _pairingheap_first = Module["_pairingheap_first"] = (a0) => (_pairingheap_first = Module["_pairingheap_first"] = wasmExports["pairingheap_first"])(a0);
        var _pairingheap_add = Module["_pairingheap_add"] = (a0, a1) => (_pairingheap_add = Module["_pairingheap_add"] = wasmExports["pairingheap_add"])(a0, a1);
        var _convert_tuples_by_position = Module["_convert_tuples_by_position"] = (a0, a1, a22) => (_convert_tuples_by_position = Module["_convert_tuples_by_position"] = wasmExports["convert_tuples_by_position"])(a0, a1, a22);
        var _detoast_external_attr = Module["_detoast_external_attr"] = (a0) => (_detoast_external_attr = Module["_detoast_external_attr"] = wasmExports["detoast_external_attr"])(a0);
        var _LaunchParallelWorkers = Module["_LaunchParallelWorkers"] = (a0) => (_LaunchParallelWorkers = Module["_LaunchParallelWorkers"] = wasmExports["LaunchParallelWorkers"])(a0);
        var _TupleDescInitEntry = Module["_TupleDescInitEntry"] = (a0, a1, a22, a32, a42, a52) => (_TupleDescInitEntry = Module["_TupleDescInitEntry"] = wasmExports["TupleDescInitEntry"])(a0, a1, a22, a32, a42, a52);
        var _TupleDescInitEntryCollation = Module["_TupleDescInitEntryCollation"] = (a0, a1, a22) => (_TupleDescInitEntryCollation = Module["_TupleDescInitEntryCollation"] = wasmExports["TupleDescInitEntryCollation"])(a0, a1, a22);
        var _pg_prng_uint32 = Module["_pg_prng_uint32"] = (a0) => (_pg_prng_uint32 = Module["_pg_prng_uint32"] = wasmExports["pg_prng_uint32"])(a0);
        var _DirectFunctionCall1Coll = Module["_DirectFunctionCall1Coll"] = (a0, a1, a22) => (_DirectFunctionCall1Coll = Module["_DirectFunctionCall1Coll"] = wasmExports["DirectFunctionCall1Coll"])(a0, a1, a22);
        var _get_attstatsslot = Module["_get_attstatsslot"] = (a0, a1, a22, a32, a42) => (_get_attstatsslot = Module["_get_attstatsslot"] = wasmExports["get_attstatsslot"])(a0, a1, a22, a32, a42);
        var _free_attstatsslot = Module["_free_attstatsslot"] = (a0) => (_free_attstatsslot = Module["_free_attstatsslot"] = wasmExports["free_attstatsslot"])(a0);
        var _LWLockAcquire = Module["_LWLockAcquire"] = (a0, a1) => (_LWLockAcquire = Module["_LWLockAcquire"] = wasmExports["LWLockAcquire"])(a0, a1);
        var _LWLockRelease = Module["_LWLockRelease"] = (a0) => (_LWLockRelease = Module["_LWLockRelease"] = wasmExports["LWLockRelease"])(a0);
        var _LWLockInitialize = Module["_LWLockInitialize"] = (a0, a1) => (_LWLockInitialize = Module["_LWLockInitialize"] = wasmExports["LWLockInitialize"])(a0, a1);
        var _SPI_connect = Module["_SPI_connect"] = () => (_SPI_connect = Module["_SPI_connect"] = wasmExports["SPI_connect"])();
        var _SPI_connect_ext = Module["_SPI_connect_ext"] = (a0) => (_SPI_connect_ext = Module["_SPI_connect_ext"] = wasmExports["SPI_connect_ext"])(a0);
        var _SPI_finish = Module["_SPI_finish"] = () => (_SPI_finish = Module["_SPI_finish"] = wasmExports["SPI_finish"])();
        var _SPI_commit = Module["_SPI_commit"] = () => (_SPI_commit = Module["_SPI_commit"] = wasmExports["SPI_commit"])();
        var _CopyErrorData = Module["_CopyErrorData"] = () => (_CopyErrorData = Module["_CopyErrorData"] = wasmExports["CopyErrorData"])();
        var _ReThrowError = Module["_ReThrowError"] = (a0) => (_ReThrowError = Module["_ReThrowError"] = wasmExports["ReThrowError"])(a0);
        var _SPI_commit_and_chain = Module["_SPI_commit_and_chain"] = () => (_SPI_commit_and_chain = Module["_SPI_commit_and_chain"] = wasmExports["SPI_commit_and_chain"])();
        var _SPI_rollback = Module["_SPI_rollback"] = () => (_SPI_rollback = Module["_SPI_rollback"] = wasmExports["SPI_rollback"])();
        var _SPI_rollback_and_chain = Module["_SPI_rollback_and_chain"] = () => (_SPI_rollback_and_chain = Module["_SPI_rollback_and_chain"] = wasmExports["SPI_rollback_and_chain"])();
        var _SPI_execute = Module["_SPI_execute"] = (a0, a1, a22) => (_SPI_execute = Module["_SPI_execute"] = wasmExports["SPI_execute"])(a0, a1, a22);
        var _SPI_freetuptable = Module["_SPI_freetuptable"] = (a0) => (_SPI_freetuptable = Module["_SPI_freetuptable"] = wasmExports["SPI_freetuptable"])(a0);
        var _ReleaseCachedPlan = Module["_ReleaseCachedPlan"] = (a0, a1) => (_ReleaseCachedPlan = Module["_ReleaseCachedPlan"] = wasmExports["ReleaseCachedPlan"])(a0, a1);
        var _SPI_exec = Module["_SPI_exec"] = (a0, a1) => (_SPI_exec = Module["_SPI_exec"] = wasmExports["SPI_exec"])(a0, a1);
        var _SPI_execute_extended = Module["_SPI_execute_extended"] = (a0, a1) => (_SPI_execute_extended = Module["_SPI_execute_extended"] = wasmExports["SPI_execute_extended"])(a0, a1);
        var _SPI_execp = Module["_SPI_execp"] = (a0, a1, a22, a32) => (_SPI_execp = Module["_SPI_execp"] = wasmExports["SPI_execp"])(a0, a1, a22, a32);
        var _SPI_execute_plan_extended = Module["_SPI_execute_plan_extended"] = (a0, a1) => (_SPI_execute_plan_extended = Module["_SPI_execute_plan_extended"] = wasmExports["SPI_execute_plan_extended"])(a0, a1);
        var _SPI_execute_plan_with_paramlist = Module["_SPI_execute_plan_with_paramlist"] = (a0, a1, a22, a32) => (_SPI_execute_plan_with_paramlist = Module["_SPI_execute_plan_with_paramlist"] = wasmExports["SPI_execute_plan_with_paramlist"])(a0, a1, a22, a32);
        var _SPI_prepare = Module["_SPI_prepare"] = (a0, a1, a22) => (_SPI_prepare = Module["_SPI_prepare"] = wasmExports["SPI_prepare"])(a0, a1, a22);
        var _SPI_prepare_extended = Module["_SPI_prepare_extended"] = (a0, a1) => (_SPI_prepare_extended = Module["_SPI_prepare_extended"] = wasmExports["SPI_prepare_extended"])(a0, a1);
        var _SPI_keepplan = Module["_SPI_keepplan"] = (a0) => (_SPI_keepplan = Module["_SPI_keepplan"] = wasmExports["SPI_keepplan"])(a0);
        var _SPI_freeplan = Module["_SPI_freeplan"] = (a0) => (_SPI_freeplan = Module["_SPI_freeplan"] = wasmExports["SPI_freeplan"])(a0);
        var _SPI_copytuple = Module["_SPI_copytuple"] = (a0) => (_SPI_copytuple = Module["_SPI_copytuple"] = wasmExports["SPI_copytuple"])(a0);
        var _SPI_returntuple = Module["_SPI_returntuple"] = (a0, a1) => (_SPI_returntuple = Module["_SPI_returntuple"] = wasmExports["SPI_returntuple"])(a0, a1);
        var _heap_deform_tuple = Module["_heap_deform_tuple"] = (a0, a1, a22, a32) => (_heap_deform_tuple = Module["_heap_deform_tuple"] = wasmExports["heap_deform_tuple"])(a0, a1, a22, a32);
        var _SPI_fnumber = Module["_SPI_fnumber"] = (a0, a1) => (_SPI_fnumber = Module["_SPI_fnumber"] = wasmExports["SPI_fnumber"])(a0, a1);
        var _SPI_fname = Module["_SPI_fname"] = (a0, a1) => (_SPI_fname = Module["_SPI_fname"] = wasmExports["SPI_fname"])(a0, a1);
        var _SPI_getvalue = Module["_SPI_getvalue"] = (a0, a1, a22) => (_SPI_getvalue = Module["_SPI_getvalue"] = wasmExports["SPI_getvalue"])(a0, a1, a22);
        var _SPI_getbinval = Module["_SPI_getbinval"] = (a0, a1, a22, a32) => (_SPI_getbinval = Module["_SPI_getbinval"] = wasmExports["SPI_getbinval"])(a0, a1, a22, a32);
        var _SPI_gettype = Module["_SPI_gettype"] = (a0, a1) => (_SPI_gettype = Module["_SPI_gettype"] = wasmExports["SPI_gettype"])(a0, a1);
        var _SPI_gettypeid = Module["_SPI_gettypeid"] = (a0, a1) => (_SPI_gettypeid = Module["_SPI_gettypeid"] = wasmExports["SPI_gettypeid"])(a0, a1);
        var _SPI_getrelname = Module["_SPI_getrelname"] = (a0) => (_SPI_getrelname = Module["_SPI_getrelname"] = wasmExports["SPI_getrelname"])(a0);
        var _SPI_palloc = Module["_SPI_palloc"] = (a0) => (_SPI_palloc = Module["_SPI_palloc"] = wasmExports["SPI_palloc"])(a0);
        var _SPI_datumTransfer = Module["_SPI_datumTransfer"] = (a0, a1, a22) => (_SPI_datumTransfer = Module["_SPI_datumTransfer"] = wasmExports["SPI_datumTransfer"])(a0, a1, a22);
        var _datumTransfer = Module["_datumTransfer"] = (a0, a1, a22) => (_datumTransfer = Module["_datumTransfer"] = wasmExports["datumTransfer"])(a0, a1, a22);
        var _MemoryContextStrdup = Module["_MemoryContextStrdup"] = (a0, a1) => (_MemoryContextStrdup = Module["_MemoryContextStrdup"] = wasmExports["MemoryContextStrdup"])(a0, a1);
        var _SPI_cursor_open_with_paramlist = Module["_SPI_cursor_open_with_paramlist"] = (a0, a1, a22, a32) => (_SPI_cursor_open_with_paramlist = Module["_SPI_cursor_open_with_paramlist"] = wasmExports["SPI_cursor_open_with_paramlist"])(a0, a1, a22, a32);
        var _SPI_cursor_parse_open = Module["_SPI_cursor_parse_open"] = (a0, a1, a22) => (_SPI_cursor_parse_open = Module["_SPI_cursor_parse_open"] = wasmExports["SPI_cursor_parse_open"])(a0, a1, a22);
        var _SPI_cursor_find = Module["_SPI_cursor_find"] = (a0) => (_SPI_cursor_find = Module["_SPI_cursor_find"] = wasmExports["SPI_cursor_find"])(a0);
        var _SPI_cursor_fetch = Module["_SPI_cursor_fetch"] = (a0, a1, a22) => (_SPI_cursor_fetch = Module["_SPI_cursor_fetch"] = wasmExports["SPI_cursor_fetch"])(a0, a1, a22);
        var _SPI_scroll_cursor_fetch = Module["_SPI_scroll_cursor_fetch"] = (a0, a1, a22) => (_SPI_scroll_cursor_fetch = Module["_SPI_scroll_cursor_fetch"] = wasmExports["SPI_scroll_cursor_fetch"])(a0, a1, a22);
        var _SPI_scroll_cursor_move = Module["_SPI_scroll_cursor_move"] = (a0, a1, a22) => (_SPI_scroll_cursor_move = Module["_SPI_scroll_cursor_move"] = wasmExports["SPI_scroll_cursor_move"])(a0, a1, a22);
        var _SPI_cursor_close = Module["_SPI_cursor_close"] = (a0) => (_SPI_cursor_close = Module["_SPI_cursor_close"] = wasmExports["SPI_cursor_close"])(a0);
        var _SPI_result_code_string = Module["_SPI_result_code_string"] = (a0) => (_SPI_result_code_string = Module["_SPI_result_code_string"] = wasmExports["SPI_result_code_string"])(a0);
        var _SPI_plan_get_plan_sources = Module["_SPI_plan_get_plan_sources"] = (a0) => (_SPI_plan_get_plan_sources = Module["_SPI_plan_get_plan_sources"] = wasmExports["SPI_plan_get_plan_sources"])(a0);
        var _SPI_plan_get_cached_plan = Module["_SPI_plan_get_cached_plan"] = (a0) => (_SPI_plan_get_cached_plan = Module["_SPI_plan_get_cached_plan"] = wasmExports["SPI_plan_get_cached_plan"])(a0);
        var _SPI_register_trigger_data = Module["_SPI_register_trigger_data"] = (a0) => (_SPI_register_trigger_data = Module["_SPI_register_trigger_data"] = wasmExports["SPI_register_trigger_data"])(a0);
        var _tuplestore_tuple_count = Module["_tuplestore_tuple_count"] = (a0) => (_tuplestore_tuple_count = Module["_tuplestore_tuple_count"] = wasmExports["tuplestore_tuple_count"])(a0);
        var _exprLocation = Module["_exprLocation"] = (a0) => (_exprLocation = Module["_exprLocation"] = wasmExports["exprLocation"])(a0);
        var _tuplestore_puttuple = Module["_tuplestore_puttuple"] = (a0, a1) => (_tuplestore_puttuple = Module["_tuplestore_puttuple"] = wasmExports["tuplestore_puttuple"])(a0, a1);
        var _pg_class_aclcheck = Module["_pg_class_aclcheck"] = (a0, a1, a22) => (_pg_class_aclcheck = Module["_pg_class_aclcheck"] = wasmExports["pg_class_aclcheck"])(a0, a1, a22);
        var _RelationGetIndexList = Module["_RelationGetIndexList"] = (a0) => (_RelationGetIndexList = Module["_RelationGetIndexList"] = wasmExports["RelationGetIndexList"])(a0);
        var _get_partition_ancestors = Module["_get_partition_ancestors"] = (a0) => (_get_partition_ancestors = Module["_get_partition_ancestors"] = wasmExports["get_partition_ancestors"])(a0);
        var _ExecInitExprWithParams = Module["_ExecInitExprWithParams"] = (a0, a1) => (_ExecInitExprWithParams = Module["_ExecInitExprWithParams"] = wasmExports["ExecInitExprWithParams"])(a0, a1);
        var _AddWaitEventToSet = Module["_AddWaitEventToSet"] = (a0, a1, a22, a32, a42) => (_AddWaitEventToSet = Module["_AddWaitEventToSet"] = wasmExports["AddWaitEventToSet"])(a0, a1, a22, a32, a42);
        var _GetNumRegisteredWaitEvents = Module["_GetNumRegisteredWaitEvents"] = (a0) => (_GetNumRegisteredWaitEvents = Module["_GetNumRegisteredWaitEvents"] = wasmExports["GetNumRegisteredWaitEvents"])(a0);
        var _BuildIndexInfo = Module["_BuildIndexInfo"] = (a0) => (_BuildIndexInfo = Module["_BuildIndexInfo"] = wasmExports["BuildIndexInfo"])(a0);
        var _ItemPointerEquals = Module["_ItemPointerEquals"] = (a0, a1) => (_ItemPointerEquals = Module["_ItemPointerEquals"] = wasmExports["ItemPointerEquals"])(a0, a1);
        var _TransactionIdPrecedes = Module["_TransactionIdPrecedes"] = (a0, a1) => (_TransactionIdPrecedes = Module["_TransactionIdPrecedes"] = wasmExports["TransactionIdPrecedes"])(a0, a1);
        var _bsearch = Module["_bsearch"] = (a0, a1, a22, a32, a42) => (_bsearch = Module["_bsearch"] = wasmExports["bsearch"])(a0, a1, a22, a32, a42);
        var _pg_detoast_datum_copy = Module["_pg_detoast_datum_copy"] = (a0) => (_pg_detoast_datum_copy = Module["_pg_detoast_datum_copy"] = wasmExports["pg_detoast_datum_copy"])(a0);
        var _HeapTupleHeaderGetDatum = Module["_HeapTupleHeaderGetDatum"] = (a0) => (_HeapTupleHeaderGetDatum = Module["_HeapTupleHeaderGetDatum"] = wasmExports["HeapTupleHeaderGetDatum"])(a0);
        var _construct_md_array = Module["_construct_md_array"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82) => (_construct_md_array = Module["_construct_md_array"] = wasmExports["construct_md_array"])(a0, a1, a22, a32, a42, a52, a62, a72, a82);
        var _ArrayGetNItems = Module["_ArrayGetNItems"] = (a0, a1) => (_ArrayGetNItems = Module["_ArrayGetNItems"] = wasmExports["ArrayGetNItems"])(a0, a1);
        var _construct_empty_array = Module["_construct_empty_array"] = (a0) => (_construct_empty_array = Module["_construct_empty_array"] = wasmExports["construct_empty_array"])(a0);
        var _DatumGetEOHP = Module["_DatumGetEOHP"] = (a0) => (_DatumGetEOHP = Module["_DatumGetEOHP"] = wasmExports["DatumGetEOHP"])(a0);
        var _expanded_record_fetch_tupdesc = Module["_expanded_record_fetch_tupdesc"] = (a0) => (_expanded_record_fetch_tupdesc = Module["_expanded_record_fetch_tupdesc"] = wasmExports["expanded_record_fetch_tupdesc"])(a0);
        var _expanded_record_fetch_field = Module["_expanded_record_fetch_field"] = (a0, a1, a22) => (_expanded_record_fetch_field = Module["_expanded_record_fetch_field"] = wasmExports["expanded_record_fetch_field"])(a0, a1, a22);
        var _lookup_type_cache = Module["_lookup_type_cache"] = (a0, a1) => (_lookup_type_cache = Module["_lookup_type_cache"] = wasmExports["lookup_type_cache"])(a0, a1);
        var _execute_attr_map_tuple = Module["_execute_attr_map_tuple"] = (a0, a1) => (_execute_attr_map_tuple = Module["_execute_attr_map_tuple"] = wasmExports["execute_attr_map_tuple"])(a0, a1);
        var _cstring_to_text_with_len = Module["_cstring_to_text_with_len"] = (a0, a1) => (_cstring_to_text_with_len = Module["_cstring_to_text_with_len"] = wasmExports["cstring_to_text_with_len"])(a0, a1);
        var _pg_detoast_datum_packed = Module["_pg_detoast_datum_packed"] = (a0) => (_pg_detoast_datum_packed = Module["_pg_detoast_datum_packed"] = wasmExports["pg_detoast_datum_packed"])(a0);
        var _lookup_rowtype_tupdesc_domain = Module["_lookup_rowtype_tupdesc_domain"] = (a0, a1, a22) => (_lookup_rowtype_tupdesc_domain = Module["_lookup_rowtype_tupdesc_domain"] = wasmExports["lookup_rowtype_tupdesc_domain"])(a0, a1, a22);
        var _MemoryContextGetParent = Module["_MemoryContextGetParent"] = (a0) => (_MemoryContextGetParent = Module["_MemoryContextGetParent"] = wasmExports["MemoryContextGetParent"])(a0);
        var _DeleteExpandedObject = Module["_DeleteExpandedObject"] = (a0) => (_DeleteExpandedObject = Module["_DeleteExpandedObject"] = wasmExports["DeleteExpandedObject"])(a0);
        var _get_opfamily_member = Module["_get_opfamily_member"] = (a0, a1, a22, a32) => (_get_opfamily_member = Module["_get_opfamily_member"] = wasmExports["get_opfamily_member"])(a0, a1, a22, a32);
        var _GetCurrentCommandId = Module["_GetCurrentCommandId"] = (a0) => (_GetCurrentCommandId = Module["_GetCurrentCommandId"] = wasmExports["GetCurrentCommandId"])(a0);
        var _clock_gettime = Module["_clock_gettime"] = (a0, a1) => (_clock_gettime = Module["_clock_gettime"] = wasmExports["clock_gettime"])(a0, a1);
        var _BufferUsageAccumDiff = Module["_BufferUsageAccumDiff"] = (a0, a1, a22) => (_BufferUsageAccumDiff = Module["_BufferUsageAccumDiff"] = wasmExports["BufferUsageAccumDiff"])(a0, a1, a22);
        var _WalUsageAccumDiff = Module["_WalUsageAccumDiff"] = (a0, a1, a22) => (_WalUsageAccumDiff = Module["_WalUsageAccumDiff"] = wasmExports["WalUsageAccumDiff"])(a0, a1, a22);
        var _InstrUpdateTupleCount = Module["_InstrUpdateTupleCount"] = (a0, a1) => (_InstrUpdateTupleCount = Module["_InstrUpdateTupleCount"] = wasmExports["InstrUpdateTupleCount"])(a0, a1);
        var _ExprEvalPushStep = Module["_ExprEvalPushStep"] = (a0, a1) => (_ExprEvalPushStep = Module["_ExprEvalPushStep"] = wasmExports["ExprEvalPushStep"])(a0, a1);
        var _get_element_type = Module["_get_element_type"] = (a0) => (_get_element_type = Module["_get_element_type"] = wasmExports["get_element_type"])(a0);
        var _EOH_get_flat_size = Module["_EOH_get_flat_size"] = (a0) => (_EOH_get_flat_size = Module["_EOH_get_flat_size"] = wasmExports["EOH_get_flat_size"])(a0);
        var _EOH_flatten_into = Module["_EOH_flatten_into"] = (a0, a1, a22) => (_EOH_flatten_into = Module["_EOH_flatten_into"] = wasmExports["EOH_flatten_into"])(a0, a1, a22);
        var _ExecStoreHeapTuple = Module["_ExecStoreHeapTuple"] = (a0, a1, a22) => (_ExecStoreHeapTuple = Module["_ExecStoreHeapTuple"] = wasmExports["ExecStoreHeapTuple"])(a0, a1, a22);
        var _MakeTupleTableSlot = Module["_MakeTupleTableSlot"] = (a0, a1) => (_MakeTupleTableSlot = Module["_MakeTupleTableSlot"] = wasmExports["MakeTupleTableSlot"])(a0, a1);
        var _ExecFetchSlotHeapTuple = Module["_ExecFetchSlotHeapTuple"] = (a0, a1, a22) => (_ExecFetchSlotHeapTuple = Module["_ExecFetchSlotHeapTuple"] = wasmExports["ExecFetchSlotHeapTuple"])(a0, a1, a22);
        var _TupleDescGetAttInMetadata = Module["_TupleDescGetAttInMetadata"] = (a0) => (_TupleDescGetAttInMetadata = Module["_TupleDescGetAttInMetadata"] = wasmExports["TupleDescGetAttInMetadata"])(a0);
        var _BuildTupleFromCStrings = Module["_BuildTupleFromCStrings"] = (a0, a1) => (_BuildTupleFromCStrings = Module["_BuildTupleFromCStrings"] = wasmExports["BuildTupleFromCStrings"])(a0, a1);
        var _InputFunctionCall = Module["_InputFunctionCall"] = (a0, a1, a22, a32) => (_InputFunctionCall = Module["_InputFunctionCall"] = wasmExports["InputFunctionCall"])(a0, a1, a22, a32);
        var _standard_ExecutorStart = Module["_standard_ExecutorStart"] = (a0, a1) => (_standard_ExecutorStart = Module["_standard_ExecutorStart"] = wasmExports["standard_ExecutorStart"])(a0, a1);
        var _get_rel_namespace = Module["_get_rel_namespace"] = (a0) => (_get_rel_namespace = Module["_get_rel_namespace"] = wasmExports["get_rel_namespace"])(a0);
        var _standard_ExecutorRun = Module["_standard_ExecutorRun"] = (a0, a1, a22, a32) => (_standard_ExecutorRun = Module["_standard_ExecutorRun"] = wasmExports["standard_ExecutorRun"])(a0, a1, a22, a32);
        var _EnterParallelMode = Module["_EnterParallelMode"] = () => (_EnterParallelMode = Module["_EnterParallelMode"] = wasmExports["EnterParallelMode"])();
        var _ExitParallelMode = Module["_ExitParallelMode"] = () => (_ExitParallelMode = Module["_ExitParallelMode"] = wasmExports["ExitParallelMode"])();
        var _standard_ExecutorFinish = Module["_standard_ExecutorFinish"] = (a0) => (_standard_ExecutorFinish = Module["_standard_ExecutorFinish"] = wasmExports["standard_ExecutorFinish"])(a0);
        var _standard_ExecutorEnd = Module["_standard_ExecutorEnd"] = (a0) => (_standard_ExecutorEnd = Module["_standard_ExecutorEnd"] = wasmExports["standard_ExecutorEnd"])(a0);
        var _CreateParallelContext = Module["_CreateParallelContext"] = (a0, a1, a22) => (_CreateParallelContext = Module["_CreateParallelContext"] = wasmExports["CreateParallelContext"])(a0, a1, a22);
        var _InitializeParallelDSM = Module["_InitializeParallelDSM"] = (a0) => (_InitializeParallelDSM = Module["_InitializeParallelDSM"] = wasmExports["InitializeParallelDSM"])(a0);
        var _WaitForParallelWorkersToFinish = Module["_WaitForParallelWorkersToFinish"] = (a0) => (_WaitForParallelWorkersToFinish = Module["_WaitForParallelWorkersToFinish"] = wasmExports["WaitForParallelWorkersToFinish"])(a0);
        var _DestroyParallelContext = Module["_DestroyParallelContext"] = (a0) => (_DestroyParallelContext = Module["_DestroyParallelContext"] = wasmExports["DestroyParallelContext"])(a0);
        var _index_deform_tuple = Module["_index_deform_tuple"] = (a0, a1, a22, a32) => (_index_deform_tuple = Module["_index_deform_tuple"] = wasmExports["index_deform_tuple"])(a0, a1, a22, a32);
        var _ExecAsyncResponse = Module["_ExecAsyncResponse"] = (a0) => (_ExecAsyncResponse = Module["_ExecAsyncResponse"] = wasmExports["ExecAsyncResponse"])(a0);
        var _ExecAsyncRequestDone = Module["_ExecAsyncRequestDone"] = (a0, a1) => (_ExecAsyncRequestDone = Module["_ExecAsyncRequestDone"] = wasmExports["ExecAsyncRequestDone"])(a0, a1);
        var _ExecAsyncRequestPending = Module["_ExecAsyncRequestPending"] = (a0) => (_ExecAsyncRequestPending = Module["_ExecAsyncRequestPending"] = wasmExports["ExecAsyncRequestPending"])(a0);
        var _format_procedure = Module["_format_procedure"] = (a0) => (_format_procedure = Module["_format_procedure"] = wasmExports["format_procedure"])(a0);
        var _stat = Module["_stat"] = (a0, a1) => (_stat = Module["_stat"] = wasmExports["stat"])(a0, a1);
        var _bloom_create = Module["_bloom_create"] = (a0, a1, a22) => (_bloom_create = Module["_bloom_create"] = wasmExports["bloom_create"])(a0, a1, a22);
        var _bloom_free = Module["_bloom_free"] = (a0) => (_bloom_free = Module["_bloom_free"] = wasmExports["bloom_free"])(a0);
        var _bloom_add_element = Module["_bloom_add_element"] = (a0, a1, a22) => (_bloom_add_element = Module["_bloom_add_element"] = wasmExports["bloom_add_element"])(a0, a1, a22);
        var _hash_bytes_extended = Module["_hash_bytes_extended"] = (a0, a1, a22) => (_hash_bytes_extended = Module["_hash_bytes_extended"] = wasmExports["hash_bytes_extended"])(a0, a1, a22);
        var _bloom_lacks_element = Module["_bloom_lacks_element"] = (a0, a1, a22) => (_bloom_lacks_element = Module["_bloom_lacks_element"] = wasmExports["bloom_lacks_element"])(a0, a1, a22);
        var _bloom_prop_bits_set = Module["_bloom_prop_bits_set"] = (a0) => (_bloom_prop_bits_set = Module["_bloom_prop_bits_set"] = wasmExports["bloom_prop_bits_set"])(a0);
        var _pg_popcount = Module["_pg_popcount"] = (a0, a1) => (_pg_popcount = Module["_pg_popcount"] = wasmExports["pg_popcount"])(a0, a1);
        var _log = Module["_log"] = (a0) => (_log = Module["_log"] = wasmExports["log"])(a0);
        var _bms_make_singleton = Module["_bms_make_singleton"] = (a0) => (_bms_make_singleton = Module["_bms_make_singleton"] = wasmExports["bms_make_singleton"])(a0);
        var _pairingheap_free = Module["_pairingheap_free"] = (a0) => (_pairingheap_free = Module["_pairingheap_free"] = wasmExports["pairingheap_free"])(a0);
        var _estimate_expression_value = Module["_estimate_expression_value"] = (a0, a1) => (_estimate_expression_value = Module["_estimate_expression_value"] = wasmExports["estimate_expression_value"])(a0, a1);
        var _clamp_row_est = Module["_clamp_row_est"] = (a0) => (_clamp_row_est = Module["_clamp_row_est"] = wasmExports["clamp_row_est"])(a0);
        var _hash_bytes = Module["_hash_bytes"] = (a0, a1) => (_hash_bytes = Module["_hash_bytes"] = wasmExports["hash_bytes"])(a0, a1);
        var _MarkBufferDirty = Module["_MarkBufferDirty"] = (a0) => (_MarkBufferDirty = Module["_MarkBufferDirty"] = wasmExports["MarkBufferDirty"])(a0);
        var _UnlockReleaseBuffer = Module["_UnlockReleaseBuffer"] = (a0) => (_UnlockReleaseBuffer = Module["_UnlockReleaseBuffer"] = wasmExports["UnlockReleaseBuffer"])(a0);
        var _PageAddItemExtended = Module["_PageAddItemExtended"] = (a0, a1, a22, a32, a42) => (_PageAddItemExtended = Module["_PageAddItemExtended"] = wasmExports["PageAddItemExtended"])(a0, a1, a22, a32, a42);
        var _BufferGetBlockNumber = Module["_BufferGetBlockNumber"] = (a0) => (_BufferGetBlockNumber = Module["_BufferGetBlockNumber"] = wasmExports["BufferGetBlockNumber"])(a0);
        var _PageIndexMultiDelete = Module["_PageIndexMultiDelete"] = (a0, a1, a22) => (_PageIndexMultiDelete = Module["_PageIndexMultiDelete"] = wasmExports["PageIndexMultiDelete"])(a0, a1, a22);
        var __hash_ovflblkno_to_bitno = Module["__hash_ovflblkno_to_bitno"] = (a0, a1) => (__hash_ovflblkno_to_bitno = Module["__hash_ovflblkno_to_bitno"] = wasmExports["_hash_ovflblkno_to_bitno"])(a0, a1);
        var _LockBuffer = Module["_LockBuffer"] = (a0, a1) => (_LockBuffer = Module["_LockBuffer"] = wasmExports["LockBuffer"])(a0, a1);
        var __hash_relbuf = Module["__hash_relbuf"] = (a0, a1) => (__hash_relbuf = Module["__hash_relbuf"] = wasmExports["_hash_relbuf"])(a0, a1);
        var __hash_getbuf = Module["__hash_getbuf"] = (a0, a1, a22, a32) => (__hash_getbuf = Module["__hash_getbuf"] = wasmExports["_hash_getbuf"])(a0, a1, a22, a32);
        var _XLogBeginInsert = Module["_XLogBeginInsert"] = () => (_XLogBeginInsert = Module["_XLogBeginInsert"] = wasmExports["XLogBeginInsert"])();
        var _XLogRegisterData = Module["_XLogRegisterData"] = (a0, a1) => (_XLogRegisterData = Module["_XLogRegisterData"] = wasmExports["XLogRegisterData"])(a0, a1);
        var _XLogInsert = Module["_XLogInsert"] = (a0, a1) => (_XLogInsert = Module["_XLogInsert"] = wasmExports["XLogInsert"])(a0, a1);
        var __hash_getbuf_with_strategy = Module["__hash_getbuf_with_strategy"] = (a0, a1, a22, a32, a42) => (__hash_getbuf_with_strategy = Module["__hash_getbuf_with_strategy"] = wasmExports["_hash_getbuf_with_strategy"])(a0, a1, a22, a32, a42);
        var _SearchSysCacheList = Module["_SearchSysCacheList"] = (a0, a1, a22, a32, a42) => (_SearchSysCacheList = Module["_SearchSysCacheList"] = wasmExports["SearchSysCacheList"])(a0, a1, a22, a32, a42);
        var _check_amoptsproc_signature = Module["_check_amoptsproc_signature"] = (a0) => (_check_amoptsproc_signature = Module["_check_amoptsproc_signature"] = wasmExports["check_amoptsproc_signature"])(a0);
        var _format_operator = Module["_format_operator"] = (a0) => (_format_operator = Module["_format_operator"] = wasmExports["format_operator"])(a0);
        var _check_amop_signature = Module["_check_amop_signature"] = (a0, a1, a22, a32) => (_check_amop_signature = Module["_check_amop_signature"] = wasmExports["check_amop_signature"])(a0, a1, a22, a32);
        var _identify_opfamily_groups = Module["_identify_opfamily_groups"] = (a0, a1) => (_identify_opfamily_groups = Module["_identify_opfamily_groups"] = wasmExports["identify_opfamily_groups"])(a0, a1);
        var _ReleaseCatCacheList = Module["_ReleaseCatCacheList"] = (a0) => (_ReleaseCatCacheList = Module["_ReleaseCatCacheList"] = wasmExports["ReleaseCatCacheList"])(a0);
        var __hash_get_indextuple_hashkey = Module["__hash_get_indextuple_hashkey"] = (a0) => (__hash_get_indextuple_hashkey = Module["__hash_get_indextuple_hashkey"] = wasmExports["_hash_get_indextuple_hashkey"])(a0);
        var _PageGetFreeSpace = Module["_PageGetFreeSpace"] = (a0) => (_PageGetFreeSpace = Module["_PageGetFreeSpace"] = wasmExports["PageGetFreeSpace"])(a0);
        var _ReadBuffer = Module["_ReadBuffer"] = (a0, a1) => (_ReadBuffer = Module["_ReadBuffer"] = wasmExports["ReadBuffer"])(a0, a1);
        var _ReadBufferExtended = Module["_ReadBufferExtended"] = (a0, a1, a22, a32, a42) => (_ReadBufferExtended = Module["_ReadBufferExtended"] = wasmExports["ReadBufferExtended"])(a0, a1, a22, a32, a42);
        var _PageInit = Module["_PageInit"] = (a0, a1, a22) => (_PageInit = Module["_PageInit"] = wasmExports["PageInit"])(a0, a1, a22);
        var _RelationGetNumberOfBlocksInFork = Module["_RelationGetNumberOfBlocksInFork"] = (a0, a1) => (_RelationGetNumberOfBlocksInFork = Module["_RelationGetNumberOfBlocksInFork"] = wasmExports["RelationGetNumberOfBlocksInFork"])(a0, a1);
        var _ExtendBufferedRel = Module["_ExtendBufferedRel"] = (a0, a1, a22, a32) => (_ExtendBufferedRel = Module["_ExtendBufferedRel"] = wasmExports["ExtendBufferedRel"])(a0, a1, a22, a32);
        var _index_getprocid = Module["_index_getprocid"] = (a0, a1, a22) => (_index_getprocid = Module["_index_getprocid"] = wasmExports["index_getprocid"])(a0, a1, a22);
        var _smgropen = Module["_smgropen"] = (a0, a1) => (_smgropen = Module["_smgropen"] = wasmExports["smgropen"])(a0, a1);
        var _smgrsetowner = Module["_smgrsetowner"] = (a0, a1) => (_smgrsetowner = Module["_smgrsetowner"] = wasmExports["smgrsetowner"])(a0, a1);
        var _hash_destroy = Module["_hash_destroy"] = (a0) => (_hash_destroy = Module["_hash_destroy"] = wasmExports["hash_destroy"])(a0);
        var _index_form_tuple = Module["_index_form_tuple"] = (a0, a1, a22) => (_index_form_tuple = Module["_index_form_tuple"] = wasmExports["index_form_tuple"])(a0, a1, a22);
        var _LockBufferForCleanup = Module["_LockBufferForCleanup"] = (a0) => (_LockBufferForCleanup = Module["_LockBufferForCleanup"] = wasmExports["LockBufferForCleanup"])(a0);
        var _RelationGetIndexScan = Module["_RelationGetIndexScan"] = (a0, a1, a22) => (_RelationGetIndexScan = Module["_RelationGetIndexScan"] = wasmExports["RelationGetIndexScan"])(a0, a1, a22);
        var _tbm_add_tuples = Module["_tbm_add_tuples"] = (a0, a1, a22, a32) => (_tbm_add_tuples = Module["_tbm_add_tuples"] = wasmExports["tbm_add_tuples"])(a0, a1, a22, a32);
        var _vacuum_delay_point = Module["_vacuum_delay_point"] = () => (_vacuum_delay_point = Module["_vacuum_delay_point"] = wasmExports["vacuum_delay_point"])();
        var _index_getprocinfo = Module["_index_getprocinfo"] = (a0, a1, a22) => (_index_getprocinfo = Module["_index_getprocinfo"] = wasmExports["index_getprocinfo"])(a0, a1, a22);
        var _build_reloptions = Module["_build_reloptions"] = (a0, a1, a22, a32, a42, a52) => (_build_reloptions = Module["_build_reloptions"] = wasmExports["build_reloptions"])(a0, a1, a22, a32, a42, a52);
        var _TestForOldSnapshot_impl = Module["_TestForOldSnapshot_impl"] = (a0, a1) => (_TestForOldSnapshot_impl = Module["_TestForOldSnapshot_impl"] = wasmExports["TestForOldSnapshot_impl"])(a0, a1);
        var _pgstat_assoc_relation = Module["_pgstat_assoc_relation"] = (a0) => (_pgstat_assoc_relation = Module["_pgstat_assoc_relation"] = wasmExports["pgstat_assoc_relation"])(a0);
        var _visibilitymap_clear = Module["_visibilitymap_clear"] = (a0, a1, a22, a32) => (_visibilitymap_clear = Module["_visibilitymap_clear"] = wasmExports["visibilitymap_clear"])(a0, a1, a22, a32);
        var _visibilitymap_pin = Module["_visibilitymap_pin"] = (a0, a1, a22) => (_visibilitymap_pin = Module["_visibilitymap_pin"] = wasmExports["visibilitymap_pin"])(a0, a1, a22);
        var _smgrexists = Module["_smgrexists"] = (a0, a1) => (_smgrexists = Module["_smgrexists"] = wasmExports["smgrexists"])(a0, a1);
        var _visibilitymap_prepare_truncate = Module["_visibilitymap_prepare_truncate"] = (a0, a1) => (_visibilitymap_prepare_truncate = Module["_visibilitymap_prepare_truncate"] = wasmExports["visibilitymap_prepare_truncate"])(a0, a1);
        var _log_newpage_buffer = Module["_log_newpage_buffer"] = (a0, a1) => (_log_newpage_buffer = Module["_log_newpage_buffer"] = wasmExports["log_newpage_buffer"])(a0, a1);
        var _HeapTupleSatisfiesVisibility = Module["_HeapTupleSatisfiesVisibility"] = (a0, a1, a22) => (_HeapTupleSatisfiesVisibility = Module["_HeapTupleSatisfiesVisibility"] = wasmExports["HeapTupleSatisfiesVisibility"])(a0, a1, a22);
        var _HeapTupleGetUpdateXid = Module["_HeapTupleGetUpdateXid"] = (a0) => (_HeapTupleGetUpdateXid = Module["_HeapTupleGetUpdateXid"] = wasmExports["HeapTupleGetUpdateXid"])(a0);
        var _HeapTupleSatisfiesVacuum = Module["_HeapTupleSatisfiesVacuum"] = (a0, a1, a22) => (_HeapTupleSatisfiesVacuum = Module["_HeapTupleSatisfiesVacuum"] = wasmExports["HeapTupleSatisfiesVacuum"])(a0, a1, a22);
        var _GetOldestNonRemovableTransactionId = Module["_GetOldestNonRemovableTransactionId"] = (a0) => (_GetOldestNonRemovableTransactionId = Module["_GetOldestNonRemovableTransactionId"] = wasmExports["GetOldestNonRemovableTransactionId"])(a0);
        var _PageGetHeapFreeSpace = Module["_PageGetHeapFreeSpace"] = (a0) => (_PageGetHeapFreeSpace = Module["_PageGetHeapFreeSpace"] = wasmExports["PageGetHeapFreeSpace"])(a0);
        var _vac_estimate_reltuples = Module["_vac_estimate_reltuples"] = (a0, a1, a22, a32) => (_vac_estimate_reltuples = Module["_vac_estimate_reltuples"] = wasmExports["vac_estimate_reltuples"])(a0, a1, a22, a32);
        var _GetRecordedFreeSpace = Module["_GetRecordedFreeSpace"] = (a0, a1) => (_GetRecordedFreeSpace = Module["_GetRecordedFreeSpace"] = wasmExports["GetRecordedFreeSpace"])(a0, a1);
        var _heap_tuple_needs_eventual_freeze = Module["_heap_tuple_needs_eventual_freeze"] = (a0) => (_heap_tuple_needs_eventual_freeze = Module["_heap_tuple_needs_eventual_freeze"] = wasmExports["heap_tuple_needs_eventual_freeze"])(a0);
        var _hash_seq_init = Module["_hash_seq_init"] = (a0, a1) => (_hash_seq_init = Module["_hash_seq_init"] = wasmExports["hash_seq_init"])(a0, a1);
        var _hash_seq_search = Module["_hash_seq_search"] = (a0) => (_hash_seq_search = Module["_hash_seq_search"] = wasmExports["hash_seq_search"])(a0);
        var _ftruncate = Module["_ftruncate"] = (a0, a1) => (_ftruncate = Module["_ftruncate"] = wasmExports["ftruncate"])(a0, a1);
        var _pwrite = Module["_pwrite"] = (a0, a1, a22, a32) => (_pwrite = Module["_pwrite"] = wasmExports["pwrite"])(a0, a1, a22, a32);
        var _fd_fsync_fname = Module["_fd_fsync_fname"] = (a0, a1) => (_fd_fsync_fname = Module["_fd_fsync_fname"] = wasmExports["fd_fsync_fname"])(a0, a1);
        var _GetMultiXactIdMembers = Module["_GetMultiXactIdMembers"] = (a0, a1, a22, a32) => (_GetMultiXactIdMembers = Module["_GetMultiXactIdMembers"] = wasmExports["GetMultiXactIdMembers"])(a0, a1, a22, a32);
        var _GetAccessStrategy = Module["_GetAccessStrategy"] = (a0) => (_GetAccessStrategy = Module["_GetAccessStrategy"] = wasmExports["GetAccessStrategy"])(a0);
        var _FreeAccessStrategy = Module["_FreeAccessStrategy"] = (a0) => (_FreeAccessStrategy = Module["_FreeAccessStrategy"] = wasmExports["FreeAccessStrategy"])(a0);
        var _HeapTupleSatisfiesUpdate = Module["_HeapTupleSatisfiesUpdate"] = (a0, a1, a22) => (_HeapTupleSatisfiesUpdate = Module["_HeapTupleSatisfiesUpdate"] = wasmExports["HeapTupleSatisfiesUpdate"])(a0, a1, a22);
        var _TransactionIdDidCommit = Module["_TransactionIdDidCommit"] = (a0) => (_TransactionIdDidCommit = Module["_TransactionIdDidCommit"] = wasmExports["TransactionIdDidCommit"])(a0);
        var _TransactionIdIsInProgress = Module["_TransactionIdIsInProgress"] = (a0) => (_TransactionIdIsInProgress = Module["_TransactionIdIsInProgress"] = wasmExports["TransactionIdIsInProgress"])(a0);
        var _datumIsEqual = Module["_datumIsEqual"] = (a0, a1, a22, a32) => (_datumIsEqual = Module["_datumIsEqual"] = wasmExports["datumIsEqual"])(a0, a1, a22, a32);
        var _MultiXactIdPrecedes = Module["_MultiXactIdPrecedes"] = (a0, a1) => (_MultiXactIdPrecedes = Module["_MultiXactIdPrecedes"] = wasmExports["MultiXactIdPrecedes"])(a0, a1);
        var _XLogRecGetBlockTagExtended = Module["_XLogRecGetBlockTagExtended"] = (a0, a1, a22, a32, a42, a52) => (_XLogRecGetBlockTagExtended = Module["_XLogRecGetBlockTagExtended"] = wasmExports["XLogRecGetBlockTagExtended"])(a0, a1, a22, a32, a42, a52);
        var _ConditionalLockBuffer = Module["_ConditionalLockBuffer"] = (a0) => (_ConditionalLockBuffer = Module["_ConditionalLockBuffer"] = wasmExports["ConditionalLockBuffer"])(a0);
        var _toast_open_indexes = Module["_toast_open_indexes"] = (a0, a1, a22, a32) => (_toast_open_indexes = Module["_toast_open_indexes"] = wasmExports["toast_open_indexes"])(a0, a1, a22, a32);
        var _init_toast_snapshot = Module["_init_toast_snapshot"] = (a0) => (_init_toast_snapshot = Module["_init_toast_snapshot"] = wasmExports["init_toast_snapshot"])(a0);
        var _systable_beginscan_ordered = Module["_systable_beginscan_ordered"] = (a0, a1, a22, a32, a42) => (_systable_beginscan_ordered = Module["_systable_beginscan_ordered"] = wasmExports["systable_beginscan_ordered"])(a0, a1, a22, a32, a42);
        var _systable_getnext_ordered = Module["_systable_getnext_ordered"] = (a0, a1) => (_systable_getnext_ordered = Module["_systable_getnext_ordered"] = wasmExports["systable_getnext_ordered"])(a0, a1);
        var _systable_endscan_ordered = Module["_systable_endscan_ordered"] = (a0) => (_systable_endscan_ordered = Module["_systable_endscan_ordered"] = wasmExports["systable_endscan_ordered"])(a0);
        var _toast_close_indexes = Module["_toast_close_indexes"] = (a0, a1, a22) => (_toast_close_indexes = Module["_toast_close_indexes"] = wasmExports["toast_close_indexes"])(a0, a1, a22);
        var _GenerationContextCreate = Module["_GenerationContextCreate"] = (a0, a1, a22, a32, a42) => (_GenerationContextCreate = Module["_GenerationContextCreate"] = wasmExports["GenerationContextCreate"])(a0, a1, a22, a32, a42);
        var _LockRelationForExtension = Module["_LockRelationForExtension"] = (a0, a1) => (_LockRelationForExtension = Module["_LockRelationForExtension"] = wasmExports["LockRelationForExtension"])(a0, a1);
        var _UnlockRelationForExtension = Module["_UnlockRelationForExtension"] = (a0, a1) => (_UnlockRelationForExtension = Module["_UnlockRelationForExtension"] = wasmExports["UnlockRelationForExtension"])(a0, a1);
        var _RecordFreeIndexPage = Module["_RecordFreeIndexPage"] = (a0, a1) => (_RecordFreeIndexPage = Module["_RecordFreeIndexPage"] = wasmExports["RecordFreeIndexPage"])(a0, a1);
        var _IndexFreeSpaceMapVacuum = Module["_IndexFreeSpaceMapVacuum"] = (a0) => (_IndexFreeSpaceMapVacuum = Module["_IndexFreeSpaceMapVacuum"] = wasmExports["IndexFreeSpaceMapVacuum"])(a0);
        var _gistcheckpage = Module["_gistcheckpage"] = (a0, a1) => (_gistcheckpage = Module["_gistcheckpage"] = wasmExports["gistcheckpage"])(a0, a1);
        var _nocache_index_getattr = Module["_nocache_index_getattr"] = (a0, a1, a22) => (_nocache_index_getattr = Module["_nocache_index_getattr"] = wasmExports["nocache_index_getattr"])(a0, a1, a22);
        var _GetFreeIndexPage = Module["_GetFreeIndexPage"] = (a0) => (_GetFreeIndexPage = Module["_GetFreeIndexPage"] = wasmExports["GetFreeIndexPage"])(a0);
        var _check_amproc_signature = Module["_check_amproc_signature"] = (a0, a1, a22, a32, a42, a52) => (_check_amproc_signature = Module["_check_amproc_signature"] = wasmExports["check_amproc_signature"])(a0, a1, a22, a32, a42, a52);
        var _DirectFunctionCall2Coll = Module["_DirectFunctionCall2Coll"] = (a0, a1, a22, a32) => (_DirectFunctionCall2Coll = Module["_DirectFunctionCall2Coll"] = wasmExports["DirectFunctionCall2Coll"])(a0, a1, a22, a32);
        var _float_overflow_error = Module["_float_overflow_error"] = () => (_float_overflow_error = Module["_float_overflow_error"] = wasmExports["float_overflow_error"])();
        var _float_underflow_error = Module["_float_underflow_error"] = () => (_float_underflow_error = Module["_float_underflow_error"] = wasmExports["float_underflow_error"])();
        var _DirectFunctionCall5Coll = Module["_DirectFunctionCall5Coll"] = (a0, a1, a22, a32, a42, a52, a62) => (_DirectFunctionCall5Coll = Module["_DirectFunctionCall5Coll"] = wasmExports["DirectFunctionCall5Coll"])(a0, a1, a22, a32, a42, a52, a62);
        var _Float8GetDatum = Module["_Float8GetDatum"] = (a0) => (_Float8GetDatum = Module["_Float8GetDatum"] = wasmExports["Float8GetDatum"])(a0);
        var _fmgr_info_copy = Module["_fmgr_info_copy"] = (a0, a1, a22) => (_fmgr_info_copy = Module["_fmgr_info_copy"] = wasmExports["fmgr_info_copy"])(a0, a1, a22);
        var _PageIndexTupleOverwrite = Module["_PageIndexTupleOverwrite"] = (a0, a1, a22, a32) => (_PageIndexTupleOverwrite = Module["_PageIndexTupleOverwrite"] = wasmExports["PageIndexTupleOverwrite"])(a0, a1, a22, a32);
        var _log_newpage_range = Module["_log_newpage_range"] = (a0, a1, a22, a32, a42) => (_log_newpage_range = Module["_log_newpage_range"] = wasmExports["log_newpage_range"])(a0, a1, a22, a32, a42);
        var _pow = Module["_pow"] = (a0, a1) => (_pow = Module["_pow"] = wasmExports["pow"])(a0, a1);
        var _CreateTupleDescCopyConstr = Module["_CreateTupleDescCopyConstr"] = (a0) => (_CreateTupleDescCopyConstr = Module["_CreateTupleDescCopyConstr"] = wasmExports["CreateTupleDescCopyConstr"])(a0);
        var _PageGetExactFreeSpace = Module["_PageGetExactFreeSpace"] = (a0) => (_PageGetExactFreeSpace = Module["_PageGetExactFreeSpace"] = wasmExports["PageGetExactFreeSpace"])(a0);
        var _brin_build_desc = Module["_brin_build_desc"] = (a0) => (_brin_build_desc = Module["_brin_build_desc"] = wasmExports["brin_build_desc"])(a0);
        var _brin_deform_tuple = Module["_brin_deform_tuple"] = (a0, a1, a22) => (_brin_deform_tuple = Module["_brin_deform_tuple"] = wasmExports["brin_deform_tuple"])(a0, a1, a22);
        var _IndexGetRelation = Module["_IndexGetRelation"] = (a0, a1) => (_IndexGetRelation = Module["_IndexGetRelation"] = wasmExports["IndexGetRelation"])(a0, a1);
        var _FunctionCall4Coll = Module["_FunctionCall4Coll"] = (a0, a1, a22, a32, a42, a52) => (_FunctionCall4Coll = Module["_FunctionCall4Coll"] = wasmExports["FunctionCall4Coll"])(a0, a1, a22, a32, a42, a52);
        var _brin_free_desc = Module["_brin_free_desc"] = (a0) => (_brin_free_desc = Module["_brin_free_desc"] = wasmExports["brin_free_desc"])(a0);
        var _GetUserIdAndSecContext = Module["_GetUserIdAndSecContext"] = (a0, a1) => (_GetUserIdAndSecContext = Module["_GetUserIdAndSecContext"] = wasmExports["GetUserIdAndSecContext"])(a0, a1);
        var _SetUserIdAndSecContext = Module["_SetUserIdAndSecContext"] = (a0, a1) => (_SetUserIdAndSecContext = Module["_SetUserIdAndSecContext"] = wasmExports["SetUserIdAndSecContext"])(a0, a1);
        var _NewGUCNestLevel = Module["_NewGUCNestLevel"] = () => (_NewGUCNestLevel = Module["_NewGUCNestLevel"] = wasmExports["NewGUCNestLevel"])();
        var _AtEOXact_GUC = Module["_AtEOXact_GUC"] = (a0, a1) => (_AtEOXact_GUC = Module["_AtEOXact_GUC"] = wasmExports["AtEOXact_GUC"])(a0, a1);
        var _get_fn_opclass_options = Module["_get_fn_opclass_options"] = (a0) => (_get_fn_opclass_options = Module["_get_fn_opclass_options"] = wasmExports["get_fn_opclass_options"])(a0);
        var _init_local_reloptions = Module["_init_local_reloptions"] = (a0, a1) => (_init_local_reloptions = Module["_init_local_reloptions"] = wasmExports["init_local_reloptions"])(a0, a1);
        var _numeric_sub = Module["_numeric_sub"] = (a0) => (_numeric_sub = Module["_numeric_sub"] = wasmExports["numeric_sub"])(a0);
        var _qsort_arg = Module["_qsort_arg"] = (a0, a1, a22, a32, a42) => (_qsort_arg = Module["_qsort_arg"] = wasmExports["qsort_arg"])(a0, a1, a22, a32, a42);
        var _add_local_int_reloption = Module["_add_local_int_reloption"] = (a0, a1, a22, a32, a42, a52, a62) => (_add_local_int_reloption = Module["_add_local_int_reloption"] = wasmExports["add_local_int_reloption"])(a0, a1, a22, a32, a42, a52, a62);
        var _OutputFunctionCall = Module["_OutputFunctionCall"] = (a0, a1) => (_OutputFunctionCall = Module["_OutputFunctionCall"] = wasmExports["OutputFunctionCall"])(a0, a1);
        var _accumArrayResult = Module["_accumArrayResult"] = (a0, a1, a22, a32, a42) => (_accumArrayResult = Module["_accumArrayResult"] = wasmExports["accumArrayResult"])(a0, a1, a22, a32, a42);
        var _makeArrayResult = Module["_makeArrayResult"] = (a0, a1) => (_makeArrayResult = Module["_makeArrayResult"] = wasmExports["makeArrayResult"])(a0, a1);
        var _hash_get_num_entries = Module["_hash_get_num_entries"] = (a0) => (_hash_get_num_entries = Module["_hash_get_num_entries"] = wasmExports["hash_get_num_entries"])(a0);
        var _RestoreBlockImage = Module["_RestoreBlockImage"] = (a0, a1, a22) => (_RestoreBlockImage = Module["_RestoreBlockImage"] = wasmExports["RestoreBlockImage"])(a0, a1, a22);
        var _wal_segment_open = Module["_wal_segment_open"] = (a0, a1, a22) => (_wal_segment_open = Module["_wal_segment_open"] = wasmExports["wal_segment_open"])(a0, a1, a22);
        var _wal_segment_close = Module["_wal_segment_close"] = (a0) => (_wal_segment_close = Module["_wal_segment_close"] = wasmExports["wal_segment_close"])(a0);
        var _close = Module["_close"] = (a0) => (_close = Module["_close"] = wasmExports["close"])(a0);
        var _GetFlushRecPtr = Module["_GetFlushRecPtr"] = (a0) => (_GetFlushRecPtr = Module["_GetFlushRecPtr"] = wasmExports["GetFlushRecPtr"])(a0);
        var _GetXLogReplayRecPtr = Module["_GetXLogReplayRecPtr"] = (a0) => (_GetXLogReplayRecPtr = Module["_GetXLogReplayRecPtr"] = wasmExports["GetXLogReplayRecPtr"])(a0);
        var _pg_usleep = Module["_pg_usleep"] = (a0) => (_pg_usleep = Module["_pg_usleep"] = wasmExports["pg_usleep"])(a0);
        var _read_local_xlog_page_no_wait = Module["_read_local_xlog_page_no_wait"] = (a0, a1, a22, a32, a42) => (_read_local_xlog_page_no_wait = Module["_read_local_xlog_page_no_wait"] = wasmExports["read_local_xlog_page_no_wait"])(a0, a1, a22, a32, a42);
        var _dsm_create = Module["_dsm_create"] = (a0, a1) => (_dsm_create = Module["_dsm_create"] = wasmExports["dsm_create"])(a0, a1);
        var _dsm_segment_address = Module["_dsm_segment_address"] = (a0) => (_dsm_segment_address = Module["_dsm_segment_address"] = wasmExports["dsm_segment_address"])(a0);
        var _WaitForBackgroundWorkerShutdown = Module["_WaitForBackgroundWorkerShutdown"] = (a0) => (_WaitForBackgroundWorkerShutdown = Module["_WaitForBackgroundWorkerShutdown"] = wasmExports["WaitForBackgroundWorkerShutdown"])(a0);
        var _dsm_segment_handle = Module["_dsm_segment_handle"] = (a0) => (_dsm_segment_handle = Module["_dsm_segment_handle"] = wasmExports["dsm_segment_handle"])(a0);
        var _RegisterDynamicBackgroundWorker = Module["_RegisterDynamicBackgroundWorker"] = (a0, a1) => (_RegisterDynamicBackgroundWorker = Module["_RegisterDynamicBackgroundWorker"] = wasmExports["RegisterDynamicBackgroundWorker"])(a0, a1);
        var _WaitForParallelWorkersToAttach = Module["_WaitForParallelWorkersToAttach"] = (a0) => (_WaitForParallelWorkersToAttach = Module["_WaitForParallelWorkersToAttach"] = wasmExports["WaitForParallelWorkersToAttach"])(a0);
        var _dsm_detach = Module["_dsm_detach"] = (a0) => (_dsm_detach = Module["_dsm_detach"] = wasmExports["dsm_detach"])(a0);
        var _BackgroundWorkerUnblockSignals = Module["_BackgroundWorkerUnblockSignals"] = () => (_BackgroundWorkerUnblockSignals = Module["_BackgroundWorkerUnblockSignals"] = wasmExports["BackgroundWorkerUnblockSignals"])();
        var _dsm_attach = Module["_dsm_attach"] = (a0) => (_dsm_attach = Module["_dsm_attach"] = wasmExports["dsm_attach"])(a0);
        var _BackgroundWorkerInitializeConnectionByOid = Module["_BackgroundWorkerInitializeConnectionByOid"] = (a0, a1, a22) => (_BackgroundWorkerInitializeConnectionByOid = Module["_BackgroundWorkerInitializeConnectionByOid"] = wasmExports["BackgroundWorkerInitializeConnectionByOid"])(a0, a1, a22);
        var _GenericXLogStart = Module["_GenericXLogStart"] = (a0) => (_GenericXLogStart = Module["_GenericXLogStart"] = wasmExports["GenericXLogStart"])(a0);
        var _GenericXLogRegisterBuffer = Module["_GenericXLogRegisterBuffer"] = (a0, a1, a22) => (_GenericXLogRegisterBuffer = Module["_GenericXLogRegisterBuffer"] = wasmExports["GenericXLogRegisterBuffer"])(a0, a1, a22);
        var _GenericXLogFinish = Module["_GenericXLogFinish"] = (a0) => (_GenericXLogFinish = Module["_GenericXLogFinish"] = wasmExports["GenericXLogFinish"])(a0);
        var _GenericXLogAbort = Module["_GenericXLogAbort"] = (a0) => (_GenericXLogAbort = Module["_GenericXLogAbort"] = wasmExports["GenericXLogAbort"])(a0);
        var _ShmemInitStruct = Module["_ShmemInitStruct"] = (a0, a1, a22) => (_ShmemInitStruct = Module["_ShmemInitStruct"] = wasmExports["ShmemInitStruct"])(a0, a1, a22);
        var _init_MultiFuncCall = Module["_init_MultiFuncCall"] = (a0) => (_init_MultiFuncCall = Module["_init_MultiFuncCall"] = wasmExports["init_MultiFuncCall"])(a0);
        var _per_MultiFuncCall = Module["_per_MultiFuncCall"] = (a0) => (_per_MultiFuncCall = Module["_per_MultiFuncCall"] = wasmExports["per_MultiFuncCall"])(a0);
        var _end_MultiFuncCall = Module["_end_MultiFuncCall"] = (a0, a1) => (_end_MultiFuncCall = Module["_end_MultiFuncCall"] = wasmExports["end_MultiFuncCall"])(a0, a1);
        var _read = Module["_read"] = (a0, a1, a22) => (_read = Module["_read"] = wasmExports["read"])(a0, a1, a22);
        var _superuser_arg = Module["_superuser_arg"] = (a0) => (_superuser_arg = Module["_superuser_arg"] = wasmExports["superuser_arg"])(a0);
        var _XLogReaderAllocate = Module["_XLogReaderAllocate"] = (a0, a1, a22, a32) => (_XLogReaderAllocate = Module["_XLogReaderAllocate"] = wasmExports["XLogReaderAllocate"])(a0, a1, a22, a32);
        var _XLogReadRecord = Module["_XLogReadRecord"] = (a0, a1) => (_XLogReadRecord = Module["_XLogReadRecord"] = wasmExports["XLogReadRecord"])(a0, a1);
        var _XLogReaderFree = Module["_XLogReaderFree"] = (a0) => (_XLogReaderFree = Module["_XLogReaderFree"] = wasmExports["XLogReaderFree"])(a0);
        var _write = Module["_write"] = (a0, a1, a22) => (_write = Module["_write"] = wasmExports["write"])(a0, a1, a22);
        var _ReadMultiXactIdRange = Module["_ReadMultiXactIdRange"] = (a0, a1) => (_ReadMultiXactIdRange = Module["_ReadMultiXactIdRange"] = wasmExports["ReadMultiXactIdRange"])(a0, a1);
        var _MultiXactIdPrecedesOrEquals = Module["_MultiXactIdPrecedesOrEquals"] = (a0, a1) => (_MultiXactIdPrecedesOrEquals = Module["_MultiXactIdPrecedesOrEquals"] = wasmExports["MultiXactIdPrecedesOrEquals"])(a0, a1);
        var _numeric_in = Module["_numeric_in"] = (a0) => (_numeric_in = Module["_numeric_in"] = wasmExports["numeric_in"])(a0);
        var _DirectFunctionCall3Coll = Module["_DirectFunctionCall3Coll"] = (a0, a1, a22, a32, a42) => (_DirectFunctionCall3Coll = Module["_DirectFunctionCall3Coll"] = wasmExports["DirectFunctionCall3Coll"])(a0, a1, a22, a32, a42);
        var _AllocateFile = Module["_AllocateFile"] = (a0, a1) => (_AllocateFile = Module["_AllocateFile"] = wasmExports["AllocateFile"])(a0, a1);
        var _FreeFile = Module["_FreeFile"] = (a0) => (_FreeFile = Module["_FreeFile"] = wasmExports["FreeFile"])(a0);
        var _InitMaterializedSRF = Module["_InitMaterializedSRF"] = (a0, a1) => (_InitMaterializedSRF = Module["_InitMaterializedSRF"] = wasmExports["InitMaterializedSRF"])(a0, a1);
        var _XLogRecStoreStats = Module["_XLogRecStoreStats"] = (a0, a1) => (_XLogRecStoreStats = Module["_XLogRecStoreStats"] = wasmExports["XLogRecStoreStats"])(a0, a1);
        var _XLogFindNextRecord = Module["_XLogFindNextRecord"] = (a0, a1) => (_XLogFindNextRecord = Module["_XLogFindNextRecord"] = wasmExports["XLogFindNextRecord"])(a0, a1);
        var _fgets = Module["_fgets"] = (a0, a1, a22) => (_fgets = Module["_fgets"] = wasmExports["fgets"])(a0, a1, a22);
        var _getpid = Module["_getpid"] = () => (_getpid = Module["_getpid"] = wasmExports["getpid"])();
        var _lseek = Module["_lseek"] = (a0, a1, a22) => (_lseek = Module["_lseek"] = wasmExports["lseek"])(a0, a1, a22);
        var _strtol = Module["_strtol"] = (a0, a1, a22) => (_strtol = Module["_strtol"] = wasmExports["strtol"])(a0, a1, a22);
        var _wait_result_to_str = Module["_wait_result_to_str"] = (a0) => (_wait_result_to_str = Module["_wait_result_to_str"] = wasmExports["wait_result_to_str"])(a0);
        var _replace_percent_placeholders = Module["_replace_percent_placeholders"] = (a0, a1, a22, a32) => (_replace_percent_placeholders = Module["_replace_percent_placeholders"] = wasmExports["replace_percent_placeholders"])(a0, a1, a22, a32);
        var _RmgrNotFound = Module["_RmgrNotFound"] = (a0) => (_RmgrNotFound = Module["_RmgrNotFound"] = wasmExports["RmgrNotFound"])(a0);
        var _GetCurrentTransactionNestLevel = Module["_GetCurrentTransactionNestLevel"] = () => (_GetCurrentTransactionNestLevel = Module["_GetCurrentTransactionNestLevel"] = wasmExports["GetCurrentTransactionNestLevel"])();
        var _ResourceOwnerDelete = Module["_ResourceOwnerDelete"] = (a0) => (_ResourceOwnerDelete = Module["_ResourceOwnerDelete"] = wasmExports["ResourceOwnerDelete"])(a0);
        var _AtEOSubXact_Files = Module["_AtEOSubXact_Files"] = (a0, a1, a22) => (_AtEOSubXact_Files = Module["_AtEOSubXact_Files"] = wasmExports["AtEOSubXact_Files"])(a0, a1, a22);
        var _RegisterXactCallback = Module["_RegisterXactCallback"] = (a0, a1) => (_RegisterXactCallback = Module["_RegisterXactCallback"] = wasmExports["RegisterXactCallback"])(a0, a1);
        var _RegisterSubXactCallback = Module["_RegisterSubXactCallback"] = (a0, a1) => (_RegisterSubXactCallback = Module["_RegisterSubXactCallback"] = wasmExports["RegisterSubXactCallback"])(a0, a1);
        var _BeginInternalSubTransaction = Module["_BeginInternalSubTransaction"] = (a0) => (_BeginInternalSubTransaction = Module["_BeginInternalSubTransaction"] = wasmExports["BeginInternalSubTransaction"])(a0);
        var _ReleaseCurrentSubTransaction = Module["_ReleaseCurrentSubTransaction"] = () => (_ReleaseCurrentSubTransaction = Module["_ReleaseCurrentSubTransaction"] = wasmExports["ReleaseCurrentSubTransaction"])();
        var _RollbackAndReleaseCurrentSubTransaction = Module["_RollbackAndReleaseCurrentSubTransaction"] = () => (_RollbackAndReleaseCurrentSubTransaction = Module["_RollbackAndReleaseCurrentSubTransaction"] = wasmExports["RollbackAndReleaseCurrentSubTransaction"])();
        var _timestamptz_in = Module["_timestamptz_in"] = (a0) => (_timestamptz_in = Module["_timestamptz_in"] = wasmExports["timestamptz_in"])(a0);
        var _timestamptz_to_str = Module["_timestamptz_to_str"] = (a0) => (_timestamptz_to_str = Module["_timestamptz_to_str"] = wasmExports["timestamptz_to_str"])(a0);
        var _fscanf = Module["_fscanf"] = (a0, a1, a22) => (_fscanf = Module["_fscanf"] = wasmExports["fscanf"])(a0, a1, a22);
        var _ParseDateTime = Module["_ParseDateTime"] = (a0, a1, a22, a32, a42, a52, a62) => (_ParseDateTime = Module["_ParseDateTime"] = wasmExports["ParseDateTime"])(a0, a1, a22, a32, a42, a52, a62);
        var _DecodeDateTime = Module["_DecodeDateTime"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_DecodeDateTime = Module["_DecodeDateTime"] = wasmExports["DecodeDateTime"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _ReleaseExternalFD = Module["_ReleaseExternalFD"] = () => (_ReleaseExternalFD = Module["_ReleaseExternalFD"] = wasmExports["ReleaseExternalFD"])();
        var _pg_strong_random = Module["_pg_strong_random"] = (a0, a1) => (_pg_strong_random = Module["_pg_strong_random"] = wasmExports["pg_strong_random"])(a0, a1);
        var _XLogRecGetBlockRefInfo = Module["_XLogRecGetBlockRefInfo"] = (a0, a1, a22, a32, a42) => (_XLogRecGetBlockRefInfo = Module["_XLogRecGetBlockRefInfo"] = wasmExports["XLogRecGetBlockRefInfo"])(a0, a1, a22, a32, a42);
        var _strncpy = Module["_strncpy"] = (a0, a1, a22) => (_strncpy = Module["_strncpy"] = wasmExports["strncpy"])(a0, a1, a22);
        var _heap_modify_tuple_by_cols = Module["_heap_modify_tuple_by_cols"] = (a0, a1, a22, a32, a42, a52) => (_heap_modify_tuple_by_cols = Module["_heap_modify_tuple_by_cols"] = wasmExports["heap_modify_tuple_by_cols"])(a0, a1, a22, a32, a42, a52);
        var _free_attrmap = Module["_free_attrmap"] = (a0) => (_free_attrmap = Module["_free_attrmap"] = wasmExports["free_attrmap"])(a0);
        var _add_reloption_kind = Module["_add_reloption_kind"] = () => (_add_reloption_kind = Module["_add_reloption_kind"] = wasmExports["add_reloption_kind"])();
        var _register_reloptions_validator = Module["_register_reloptions_validator"] = (a0, a1) => (_register_reloptions_validator = Module["_register_reloptions_validator"] = wasmExports["register_reloptions_validator"])(a0, a1);
        var _add_int_reloption = Module["_add_int_reloption"] = (a0, a1, a22, a32, a42, a52, a62) => (_add_int_reloption = Module["_add_int_reloption"] = wasmExports["add_int_reloption"])(a0, a1, a22, a32, a42, a52, a62);
        var _untransformRelOptions = Module["_untransformRelOptions"] = (a0) => (_untransformRelOptions = Module["_untransformRelOptions"] = wasmExports["untransformRelOptions"])(a0);
        var _makeDefElem = Module["_makeDefElem"] = (a0, a1, a22) => (_makeDefElem = Module["_makeDefElem"] = wasmExports["makeDefElem"])(a0, a1, a22);
        var _parse_int = Module["_parse_int"] = (a0, a1, a22, a32) => (_parse_int = Module["_parse_int"] = wasmExports["parse_int"])(a0, a1, a22, a32);
        var _parse_real = Module["_parse_real"] = (a0, a1, a22, a32) => (_parse_real = Module["_parse_real"] = wasmExports["parse_real"])(a0, a1, a22, a32);
        var _typenameTypeIdAndMod = Module["_typenameTypeIdAndMod"] = (a0, a1, a22, a32) => (_typenameTypeIdAndMod = Module["_typenameTypeIdAndMod"] = wasmExports["typenameTypeIdAndMod"])(a0, a1, a22, a32);
        var _pg_ltoa = Module["_pg_ltoa"] = (a0, a1) => (_pg_ltoa = Module["_pg_ltoa"] = wasmExports["pg_ltoa"])(a0, a1);
        var _RelationIdGetRelation = Module["_RelationIdGetRelation"] = (a0) => (_RelationIdGetRelation = Module["_RelationIdGetRelation"] = wasmExports["RelationIdGetRelation"])(a0);
        var _relation_openrv = Module["_relation_openrv"] = (a0, a1) => (_relation_openrv = Module["_relation_openrv"] = wasmExports["relation_openrv"])(a0, a1);
        var _RelationClose = Module["_RelationClose"] = (a0) => (_RelationClose = Module["_RelationClose"] = wasmExports["RelationClose"])(a0);
        var _varstr_cmp = Module["_varstr_cmp"] = (a0, a1, a22, a32, a42) => (_varstr_cmp = Module["_varstr_cmp"] = wasmExports["varstr_cmp"])(a0, a1, a22, a32, a42);
        var _pg_prng_uint64_range = Module["_pg_prng_uint64_range"] = (a0, a1, a22) => (_pg_prng_uint64_range = Module["_pg_prng_uint64_range"] = wasmExports["pg_prng_uint64_range"])(a0, a1, a22);
        var _ginPostingListDecode = Module["_ginPostingListDecode"] = (a0, a1) => (_ginPostingListDecode = Module["_ginPostingListDecode"] = wasmExports["ginPostingListDecode"])(a0, a1);
        var _LockPage = Module["_LockPage"] = (a0, a1, a22) => (_LockPage = Module["_LockPage"] = wasmExports["LockPage"])(a0, a1, a22);
        var _UnlockPage = Module["_UnlockPage"] = (a0, a1, a22) => (_UnlockPage = Module["_UnlockPage"] = wasmExports["UnlockPage"])(a0, a1, a22);
        var __bt_search = Module["__bt_search"] = (a0, a1, a22, a32, a42, a52) => (__bt_search = Module["__bt_search"] = wasmExports["_bt_search"])(a0, a1, a22, a32, a42, a52);
        var __bt_compare = Module["__bt_compare"] = (a0, a1, a22, a32) => (__bt_compare = Module["__bt_compare"] = wasmExports["_bt_compare"])(a0, a1, a22, a32);
        var __bt_relbuf = Module["__bt_relbuf"] = (a0, a1) => (__bt_relbuf = Module["__bt_relbuf"] = wasmExports["_bt_relbuf"])(a0, a1);
        var __bt_binsrch_insert = Module["__bt_binsrch_insert"] = (a0, a1) => (__bt_binsrch_insert = Module["__bt_binsrch_insert"] = wasmExports["_bt_binsrch_insert"])(a0, a1);
        var __bt_metaversion = Module["__bt_metaversion"] = (a0, a1, a22) => (__bt_metaversion = Module["__bt_metaversion"] = wasmExports["_bt_metaversion"])(a0, a1, a22);
        var __bt_freestack = Module["__bt_freestack"] = (a0) => (__bt_freestack = Module["__bt_freestack"] = wasmExports["_bt_freestack"])(a0);
        var _btboolcmp = Module["_btboolcmp"] = (a0) => (_btboolcmp = Module["_btboolcmp"] = wasmExports["btboolcmp"])(a0);
        var _btint2cmp = Module["_btint2cmp"] = (a0) => (_btint2cmp = Module["_btint2cmp"] = wasmExports["btint2cmp"])(a0);
        var _btint4cmp = Module["_btint4cmp"] = (a0) => (_btint4cmp = Module["_btint4cmp"] = wasmExports["btint4cmp"])(a0);
        var _btint8cmp = Module["_btint8cmp"] = (a0) => (_btint8cmp = Module["_btint8cmp"] = wasmExports["btint8cmp"])(a0);
        var _btoidcmp = Module["_btoidcmp"] = (a0) => (_btoidcmp = Module["_btoidcmp"] = wasmExports["btoidcmp"])(a0);
        var _btcharcmp = Module["_btcharcmp"] = (a0) => (_btcharcmp = Module["_btcharcmp"] = wasmExports["btcharcmp"])(a0);
        var __bt_checkpage = Module["__bt_checkpage"] = (a0, a1) => (__bt_checkpage = Module["__bt_checkpage"] = wasmExports["_bt_checkpage"])(a0, a1);
        var __bt_mkscankey = Module["__bt_mkscankey"] = (a0, a1) => (__bt_mkscankey = Module["__bt_mkscankey"] = wasmExports["_bt_mkscankey"])(a0, a1);
        var __bt_form_posting = Module["__bt_form_posting"] = (a0, a1, a22) => (__bt_form_posting = Module["__bt_form_posting"] = wasmExports["_bt_form_posting"])(a0, a1, a22);
        var __bt_allequalimage = Module["__bt_allequalimage"] = (a0, a1) => (__bt_allequalimage = Module["__bt_allequalimage"] = wasmExports["_bt_allequalimage"])(a0, a1);
        var _ConditionVariableSignal = Module["_ConditionVariableSignal"] = (a0) => (_ConditionVariableSignal = Module["_ConditionVariableSignal"] = wasmExports["ConditionVariableSignal"])(a0);
        var _tuplesort_estimate_shared = Module["_tuplesort_estimate_shared"] = (a0) => (_tuplesort_estimate_shared = Module["_tuplesort_estimate_shared"] = wasmExports["tuplesort_estimate_shared"])(a0);
        var _tuplesort_initialize_shared = Module["_tuplesort_initialize_shared"] = (a0, a1, a22) => (_tuplesort_initialize_shared = Module["_tuplesort_initialize_shared"] = wasmExports["tuplesort_initialize_shared"])(a0, a1, a22);
        var _tuplesort_attach_shared = Module["_tuplesort_attach_shared"] = (a0, a1) => (_tuplesort_attach_shared = Module["_tuplesort_attach_shared"] = wasmExports["tuplesort_attach_shared"])(a0, a1);
        var __bt_check_natts = Module["__bt_check_natts"] = (a0, a1, a22, a32) => (__bt_check_natts = Module["__bt_check_natts"] = wasmExports["_bt_check_natts"])(a0, a1, a22, a32);
        var _smgrread = Module["_smgrread"] = (a0, a1, a22, a32) => (_smgrread = Module["_smgrread"] = wasmExports["smgrread"])(a0, a1, a22, a32);
        var _smgrtruncate = Module["_smgrtruncate"] = (a0, a1, a22, a32) => (_smgrtruncate = Module["_smgrtruncate"] = wasmExports["smgrtruncate"])(a0, a1, a22, a32);
        var _ShmemInitHash = Module["_ShmemInitHash"] = (a0, a1, a22, a32, a42) => (_ShmemInitHash = Module["_ShmemInitHash"] = wasmExports["ShmemInitHash"])(a0, a1, a22, a32, a42);
        var _hash_estimate_size = Module["_hash_estimate_size"] = (a0, a1) => (_hash_estimate_size = Module["_hash_estimate_size"] = wasmExports["hash_estimate_size"])(a0, a1);
        var _on_shmem_exit = Module["_on_shmem_exit"] = (a0, a1) => (_on_shmem_exit = Module["_on_shmem_exit"] = wasmExports["on_shmem_exit"])(a0, a1);
        var _LWLockRegisterTranche = Module["_LWLockRegisterTranche"] = (a0, a1) => (_LWLockRegisterTranche = Module["_LWLockRegisterTranche"] = wasmExports["LWLockRegisterTranche"])(a0, a1);
        var _GetNamedLWLockTranche = Module["_GetNamedLWLockTranche"] = (a0) => (_GetNamedLWLockTranche = Module["_GetNamedLWLockTranche"] = wasmExports["GetNamedLWLockTranche"])(a0);
        var _LWLockNewTrancheId = Module["_LWLockNewTrancheId"] = () => (_LWLockNewTrancheId = Module["_LWLockNewTrancheId"] = wasmExports["LWLockNewTrancheId"])();
        var _RequestNamedLWLockTranche = Module["_RequestNamedLWLockTranche"] = (a0, a1) => (_RequestNamedLWLockTranche = Module["_RequestNamedLWLockTranche"] = wasmExports["RequestNamedLWLockTranche"])(a0, a1);
        var _RequestAddinShmemSpace = Module["_RequestAddinShmemSpace"] = (a0) => (_RequestAddinShmemSpace = Module["_RequestAddinShmemSpace"] = wasmExports["RequestAddinShmemSpace"])(a0);
        var _BackendXidGetPid = Module["_BackendXidGetPid"] = (a0) => (_BackendXidGetPid = Module["_BackendXidGetPid"] = wasmExports["BackendXidGetPid"])(a0);
        var _fcntl = Module["_fcntl"] = (a0, a1, a22) => (_fcntl = Module["_fcntl"] = wasmExports["fcntl"])(a0, a1, a22);
        var _poll = Module["_poll"] = (a0, a1, a22) => (_poll = Module["_poll"] = wasmExports["poll"])(a0, a1, a22);
        var _WaitLatchOrSocket = Module["_WaitLatchOrSocket"] = (a0, a1, a22, a32, a42) => (_WaitLatchOrSocket = Module["_WaitLatchOrSocket"] = wasmExports["WaitLatchOrSocket"])(a0, a1, a22, a32, a42);
        var _procsignal_sigusr1_handler = Module["_procsignal_sigusr1_handler"] = (a0) => (_procsignal_sigusr1_handler = Module["_procsignal_sigusr1_handler"] = wasmExports["procsignal_sigusr1_handler"])(a0);
        var _have_free_buffer = Module["_have_free_buffer"] = () => (_have_free_buffer = Module["_have_free_buffer"] = wasmExports["have_free_buffer"])();
        var _LockBufHdr = Module["_LockBufHdr"] = (a0) => (_LockBufHdr = Module["_LockBufHdr"] = wasmExports["LockBufHdr"])(a0);
        var _copy_file = Module["_copy_file"] = (a0, a1) => (_copy_file = Module["_copy_file"] = wasmExports["copy_file"])(a0, a1);
        var _wasm_OpenPipeStream = Module["_wasm_OpenPipeStream"] = (a0, a1) => (_wasm_OpenPipeStream = Module["_wasm_OpenPipeStream"] = wasmExports["wasm_OpenPipeStream"])(a0, a1);
        var _fiprintf = Module["_fiprintf"] = (a0, a1, a22) => (_fiprintf = Module["_fiprintf"] = wasmExports["fiprintf"])(a0, a1, a22);
        var _fsync_fname_ext = Module["_fsync_fname_ext"] = (a0, a1, a22, a32) => (_fsync_fname_ext = Module["_fsync_fname_ext"] = wasmExports["fsync_fname_ext"])(a0, a1, a22, a32);
        var _rename = Module["_rename"] = (a0, a1) => (_rename = Module["_rename"] = wasmExports["rename"])(a0, a1);
        var _dup = Module["_dup"] = (a0) => (_dup = Module["_dup"] = wasmExports["dup"])(a0);
        var _open = Module["_open"] = (a0, a1, a22) => (_open = Module["_open"] = wasmExports["open"])(a0, a1, a22);
        var _AcquireExternalFD = Module["_AcquireExternalFD"] = () => (_AcquireExternalFD = Module["_AcquireExternalFD"] = wasmExports["AcquireExternalFD"])();
        var _pclose = Module["_pclose"] = (a0) => (_pclose = Module["_pclose"] = wasmExports["pclose"])(a0);
        var _ClosePipeStream = Module["_ClosePipeStream"] = (a0) => (_ClosePipeStream = Module["_ClosePipeStream"] = wasmExports["ClosePipeStream"])(a0);
        var _get_tsearch_config_filename = Module["_get_tsearch_config_filename"] = (a0, a1) => (_get_tsearch_config_filename = Module["_get_tsearch_config_filename"] = wasmExports["get_tsearch_config_filename"])(a0, a1);
        var _lowerstr = Module["_lowerstr"] = (a0) => (_lowerstr = Module["_lowerstr"] = wasmExports["lowerstr"])(a0);
        var _readstoplist = Module["_readstoplist"] = (a0, a1, a22) => (_readstoplist = Module["_readstoplist"] = wasmExports["readstoplist"])(a0, a1, a22);
        var _lowerstr_with_len = Module["_lowerstr_with_len"] = (a0, a1) => (_lowerstr_with_len = Module["_lowerstr_with_len"] = wasmExports["lowerstr_with_len"])(a0, a1);
        var _searchstoplist = Module["_searchstoplist"] = (a0, a1) => (_searchstoplist = Module["_searchstoplist"] = wasmExports["searchstoplist"])(a0, a1);
        var _tsearch_readline_begin = Module["_tsearch_readline_begin"] = (a0, a1) => (_tsearch_readline_begin = Module["_tsearch_readline_begin"] = wasmExports["tsearch_readline_begin"])(a0, a1);
        var _tsearch_readline = Module["_tsearch_readline"] = (a0) => (_tsearch_readline = Module["_tsearch_readline"] = wasmExports["tsearch_readline"])(a0);
        var _pg_mblen = Module["_pg_mblen"] = (a0) => (_pg_mblen = Module["_pg_mblen"] = wasmExports["pg_mblen"])(a0);
        var _t_isspace = Module["_t_isspace"] = (a0) => (_t_isspace = Module["_t_isspace"] = wasmExports["t_isspace"])(a0);
        var _tsearch_readline_end = Module["_tsearch_readline_end"] = (a0) => (_tsearch_readline_end = Module["_tsearch_readline_end"] = wasmExports["tsearch_readline_end"])(a0);
        var _pg_mb2wchar_with_len = Module["_pg_mb2wchar_with_len"] = (a0, a1, a22) => (_pg_mb2wchar_with_len = Module["_pg_mb2wchar_with_len"] = wasmExports["pg_mb2wchar_with_len"])(a0, a1, a22);
        var _t_isdigit = Module["_t_isdigit"] = (a0) => (_t_isdigit = Module["_t_isdigit"] = wasmExports["t_isdigit"])(a0);
        var _strcat = Module["_strcat"] = (a0, a1) => (_strcat = Module["_strcat"] = wasmExports["strcat"])(a0, a1);
        var _lookup_ts_dictionary_cache = Module["_lookup_ts_dictionary_cache"] = (a0) => (_lookup_ts_dictionary_cache = Module["_lookup_ts_dictionary_cache"] = wasmExports["lookup_ts_dictionary_cache"])(a0);
        var _construct_array_builtin = Module["_construct_array_builtin"] = (a0, a1, a22) => (_construct_array_builtin = Module["_construct_array_builtin"] = wasmExports["construct_array_builtin"])(a0, a1, a22);
        var _t_isalnum = Module["_t_isalnum"] = (a0) => (_t_isalnum = Module["_t_isalnum"] = wasmExports["t_isalnum"])(a0);
        var _pg_any_to_server = Module["_pg_any_to_server"] = (a0, a1, a22) => (_pg_any_to_server = Module["_pg_any_to_server"] = wasmExports["pg_any_to_server"])(a0, a1, a22);
        var _pg_database_encoding_max_length = Module["_pg_database_encoding_max_length"] = () => (_pg_database_encoding_max_length = Module["_pg_database_encoding_max_length"] = wasmExports["pg_database_encoding_max_length"])();
        var _isxdigit = Module["_isxdigit"] = (a0) => (_isxdigit = Module["_isxdigit"] = wasmExports["isxdigit"])(a0);
        var _pg_strtoint32 = Module["_pg_strtoint32"] = (a0) => (_pg_strtoint32 = Module["_pg_strtoint32"] = wasmExports["pg_strtoint32"])(a0);
        var _textToQualifiedNameList = Module["_textToQualifiedNameList"] = (a0) => (_textToQualifiedNameList = Module["_textToQualifiedNameList"] = wasmExports["textToQualifiedNameList"])(a0);
        var _DirectFunctionCall4Coll = Module["_DirectFunctionCall4Coll"] = (a0, a1, a22, a32, a42, a52) => (_DirectFunctionCall4Coll = Module["_DirectFunctionCall4Coll"] = wasmExports["DirectFunctionCall4Coll"])(a0, a1, a22, a32, a42, a52);
        var _get_restriction_variable = Module["_get_restriction_variable"] = (a0, a1, a22, a32, a42, a52) => (_get_restriction_variable = Module["_get_restriction_variable"] = wasmExports["get_restriction_variable"])(a0, a1, a22, a32, a42, a52);
        var _GetForeignDataWrapper = Module["_GetForeignDataWrapper"] = (a0) => (_GetForeignDataWrapper = Module["_GetForeignDataWrapper"] = wasmExports["GetForeignDataWrapper"])(a0);
        var _GetSysCacheOid = Module["_GetSysCacheOid"] = (a0, a1, a22, a32, a42, a52) => (_GetSysCacheOid = Module["_GetSysCacheOid"] = wasmExports["GetSysCacheOid"])(a0, a1, a22, a32, a42, a52);
        var _GetForeignServer = Module["_GetForeignServer"] = (a0) => (_GetForeignServer = Module["_GetForeignServer"] = wasmExports["GetForeignServer"])(a0);
        var _GetForeignServerExtended = Module["_GetForeignServerExtended"] = (a0, a1) => (_GetForeignServerExtended = Module["_GetForeignServerExtended"] = wasmExports["GetForeignServerExtended"])(a0, a1);
        var _GetForeignServerByName = Module["_GetForeignServerByName"] = (a0, a1) => (_GetForeignServerByName = Module["_GetForeignServerByName"] = wasmExports["GetForeignServerByName"])(a0, a1);
        var _GetUserMapping = Module["_GetUserMapping"] = (a0, a1) => (_GetUserMapping = Module["_GetUserMapping"] = wasmExports["GetUserMapping"])(a0, a1);
        var _GetUserNameFromId = Module["_GetUserNameFromId"] = (a0, a1) => (_GetUserNameFromId = Module["_GetUserNameFromId"] = wasmExports["GetUserNameFromId"])(a0, a1);
        var _GetForeignTable = Module["_GetForeignTable"] = (a0) => (_GetForeignTable = Module["_GetForeignTable"] = wasmExports["GetForeignTable"])(a0);
        var _GetForeignColumnOptions = Module["_GetForeignColumnOptions"] = (a0, a1) => (_GetForeignColumnOptions = Module["_GetForeignColumnOptions"] = wasmExports["GetForeignColumnOptions"])(a0, a1);
        var _initClosestMatch = Module["_initClosestMatch"] = (a0, a1, a22) => (_initClosestMatch = Module["_initClosestMatch"] = wasmExports["initClosestMatch"])(a0, a1, a22);
        var _updateClosestMatch = Module["_updateClosestMatch"] = (a0, a1) => (_updateClosestMatch = Module["_updateClosestMatch"] = wasmExports["updateClosestMatch"])(a0, a1);
        var _getClosestMatch = Module["_getClosestMatch"] = (a0) => (_getClosestMatch = Module["_getClosestMatch"] = wasmExports["getClosestMatch"])(a0);
        var _GetExistingLocalJoinPath = Module["_GetExistingLocalJoinPath"] = (a0) => (_GetExistingLocalJoinPath = Module["_GetExistingLocalJoinPath"] = wasmExports["GetExistingLocalJoinPath"])(a0);
        var _find_base_rel = Module["_find_base_rel"] = (a0, a1) => (_find_base_rel = Module["_find_base_rel"] = wasmExports["find_base_rel"])(a0, a1);
        var _bms_equal = Module["_bms_equal"] = (a0, a1) => (_bms_equal = Module["_bms_equal"] = wasmExports["bms_equal"])(a0, a1);
        var _list_copy = Module["_list_copy"] = (a0) => (_list_copy = Module["_list_copy"] = wasmExports["list_copy"])(a0);
        var _list_make3_impl = Module["_list_make3_impl"] = (a0, a1, a22, a32) => (_list_make3_impl = Module["_list_make3_impl"] = wasmExports["list_make3_impl"])(a0, a1, a22, a32);
        var _parser_errposition = Module["_parser_errposition"] = (a0, a1) => (_parser_errposition = Module["_parser_errposition"] = wasmExports["parser_errposition"])(a0, a1);
        var _get_fn_expr_argtype = Module["_get_fn_expr_argtype"] = (a0, a1) => (_get_fn_expr_argtype = Module["_get_fn_expr_argtype"] = wasmExports["get_fn_expr_argtype"])(a0, a1);
        var _fwrite = Module["_fwrite"] = (a0, a1, a22, a32) => (_fwrite = Module["_fwrite"] = wasmExports["fwrite"])(a0, a1, a22, a32);
        var _fputc = Module["_fputc"] = (a0, a1) => (_fputc = Module["_fputc"] = wasmExports["fputc"])(a0, a1);
        var _MemoryContextAllocHuge = Module["_MemoryContextAllocHuge"] = (a0, a1) => (_MemoryContextAllocHuge = Module["_MemoryContextAllocHuge"] = wasmExports["MemoryContextAllocHuge"])(a0, a1);
        var _hash_seq_term = Module["_hash_seq_term"] = (a0) => (_hash_seq_term = Module["_hash_seq_term"] = wasmExports["hash_seq_term"])(a0);
        var _PinPortal = Module["_PinPortal"] = (a0) => (_PinPortal = Module["_PinPortal"] = wasmExports["PinPortal"])(a0);
        var _UnpinPortal = Module["_UnpinPortal"] = (a0) => (_UnpinPortal = Module["_UnpinPortal"] = wasmExports["UnpinPortal"])(a0);
        var _strnlen = Module["_strnlen"] = (a0, a1) => (_strnlen = Module["_strnlen"] = wasmExports["strnlen"])(a0, a1);
        var _pchomp = Module["_pchomp"] = (a0) => (_pchomp = Module["_pchomp"] = wasmExports["pchomp"])(a0);
        var _dlsym = Module["_dlsym"] = (a0, a1) => (_dlsym = Module["_dlsym"] = wasmExports["dlsym"])(a0, a1);
        var _dlopen = Module["_dlopen"] = (a0, a1) => (_dlopen = Module["_dlopen"] = wasmExports["dlopen"])(a0, a1);
        var _dlerror = Module["_dlerror"] = () => (_dlerror = Module["_dlerror"] = wasmExports["dlerror"])();
        var _dlclose = Module["_dlclose"] = (a0) => (_dlclose = Module["_dlclose"] = wasmExports["dlclose"])(a0);
        var _find_rendezvous_variable = Module["_find_rendezvous_variable"] = (a0) => (_find_rendezvous_variable = Module["_find_rendezvous_variable"] = wasmExports["find_rendezvous_variable"])(a0);
        var _canonicalize_path = Module["_canonicalize_path"] = (a0) => (_canonicalize_path = Module["_canonicalize_path"] = wasmExports["canonicalize_path"])(a0);
        var _CallerFInfoFunctionCall2 = Module["_CallerFInfoFunctionCall2"] = (a0, a1, a22, a32, a42) => (_CallerFInfoFunctionCall2 = Module["_CallerFInfoFunctionCall2"] = wasmExports["CallerFInfoFunctionCall2"])(a0, a1, a22, a32, a42);
        var _FunctionCall0Coll = Module["_FunctionCall0Coll"] = (a0, a1) => (_FunctionCall0Coll = Module["_FunctionCall0Coll"] = wasmExports["FunctionCall0Coll"])(a0, a1);
        var _get_fn_expr_rettype = Module["_get_fn_expr_rettype"] = (a0) => (_get_fn_expr_rettype = Module["_get_fn_expr_rettype"] = wasmExports["get_fn_expr_rettype"])(a0);
        var _get_base_element_type = Module["_get_base_element_type"] = (a0) => (_get_base_element_type = Module["_get_base_element_type"] = wasmExports["get_base_element_type"])(a0);
        var _has_fn_opclass_options = Module["_has_fn_opclass_options"] = (a0) => (_has_fn_opclass_options = Module["_has_fn_opclass_options"] = wasmExports["has_fn_opclass_options"])(a0);
        var _CheckFunctionValidatorAccess = Module["_CheckFunctionValidatorAccess"] = (a0, a1) => (_CheckFunctionValidatorAccess = Module["_CheckFunctionValidatorAccess"] = wasmExports["CheckFunctionValidatorAccess"])(a0, a1);
        var _resolve_polymorphic_argtypes = Module["_resolve_polymorphic_argtypes"] = (a0, a1, a22, a32) => (_resolve_polymorphic_argtypes = Module["_resolve_polymorphic_argtypes"] = wasmExports["resolve_polymorphic_argtypes"])(a0, a1, a22, a32);
        var _get_func_arg_info = Module["_get_func_arg_info"] = (a0, a1, a22, a32) => (_get_func_arg_info = Module["_get_func_arg_info"] = wasmExports["get_func_arg_info"])(a0, a1, a22, a32);
        var _makeRangeVarFromNameList = Module["_makeRangeVarFromNameList"] = (a0) => (_makeRangeVarFromNameList = Module["_makeRangeVarFromNameList"] = wasmExports["makeRangeVarFromNameList"])(a0);
        var _pg_hmac_free = Module["_pg_hmac_free"] = (a0) => (_pg_hmac_free = Module["_pg_hmac_free"] = wasmExports["pg_hmac_free"])(a0);
        var _ResourceOwnerReleaseAllPlanCacheRefs = Module["_ResourceOwnerReleaseAllPlanCacheRefs"] = (a0) => (_ResourceOwnerReleaseAllPlanCacheRefs = Module["_ResourceOwnerReleaseAllPlanCacheRefs"] = wasmExports["ResourceOwnerReleaseAllPlanCacheRefs"])(a0);
        var _RegisterResourceReleaseCallback = Module["_RegisterResourceReleaseCallback"] = (a0, a1) => (_RegisterResourceReleaseCallback = Module["_RegisterResourceReleaseCallback"] = wasmExports["RegisterResourceReleaseCallback"])(a0, a1);
        var _namein = Module["_namein"] = (a0) => (_namein = Module["_namein"] = wasmExports["namein"])(a0);
        var _tidin = Module["_tidin"] = (a0) => (_tidin = Module["_tidin"] = wasmExports["tidin"])(a0);
        var _tidout = Module["_tidout"] = (a0) => (_tidout = Module["_tidout"] = wasmExports["tidout"])(a0);
        var _texteq = Module["_texteq"] = (a0) => (_texteq = Module["_texteq"] = wasmExports["texteq"])(a0);
        var _btfloat4cmp = Module["_btfloat4cmp"] = (a0) => (_btfloat4cmp = Module["_btfloat4cmp"] = wasmExports["btfloat4cmp"])(a0);
        var _btfloat8cmp = Module["_btfloat8cmp"] = (a0) => (_btfloat8cmp = Module["_btfloat8cmp"] = wasmExports["btfloat8cmp"])(a0);
        var _btnamecmp = Module["_btnamecmp"] = (a0) => (_btnamecmp = Module["_btnamecmp"] = wasmExports["btnamecmp"])(a0);
        var _bttextcmp = Module["_bttextcmp"] = (a0) => (_bttextcmp = Module["_bttextcmp"] = wasmExports["bttextcmp"])(a0);
        var _cash_cmp = Module["_cash_cmp"] = (a0) => (_cash_cmp = Module["_cash_cmp"] = wasmExports["cash_cmp"])(a0);
        var _text_lt = Module["_text_lt"] = (a0) => (_text_lt = Module["_text_lt"] = wasmExports["text_lt"])(a0);
        var _text_le = Module["_text_le"] = (a0) => (_text_le = Module["_text_le"] = wasmExports["text_le"])(a0);
        var _text_gt = Module["_text_gt"] = (a0) => (_text_gt = Module["_text_gt"] = wasmExports["text_gt"])(a0);
        var _text_ge = Module["_text_ge"] = (a0) => (_text_ge = Module["_text_ge"] = wasmExports["text_ge"])(a0);
        var _current_query = Module["_current_query"] = (a0) => (_current_query = Module["_current_query"] = wasmExports["current_query"])(a0);
        var _macaddr_eq = Module["_macaddr_eq"] = (a0) => (_macaddr_eq = Module["_macaddr_eq"] = wasmExports["macaddr_eq"])(a0);
        var _macaddr_lt = Module["_macaddr_lt"] = (a0) => (_macaddr_lt = Module["_macaddr_lt"] = wasmExports["macaddr_lt"])(a0);
        var _macaddr_le = Module["_macaddr_le"] = (a0) => (_macaddr_le = Module["_macaddr_le"] = wasmExports["macaddr_le"])(a0);
        var _macaddr_gt = Module["_macaddr_gt"] = (a0) => (_macaddr_gt = Module["_macaddr_gt"] = wasmExports["macaddr_gt"])(a0);
        var _macaddr_ge = Module["_macaddr_ge"] = (a0) => (_macaddr_ge = Module["_macaddr_ge"] = wasmExports["macaddr_ge"])(a0);
        var _macaddr_cmp = Module["_macaddr_cmp"] = (a0) => (_macaddr_cmp = Module["_macaddr_cmp"] = wasmExports["macaddr_cmp"])(a0);
        var _inet_in = Module["_inet_in"] = (a0) => (_inet_in = Module["_inet_in"] = wasmExports["inet_in"])(a0);
        var _network_cmp = Module["_network_cmp"] = (a0) => (_network_cmp = Module["_network_cmp"] = wasmExports["network_cmp"])(a0);
        var _be_lo_unlink = Module["_be_lo_unlink"] = (a0) => (_be_lo_unlink = Module["_be_lo_unlink"] = wasmExports["be_lo_unlink"])(a0);
        var _bpchareq = Module["_bpchareq"] = (a0) => (_bpchareq = Module["_bpchareq"] = wasmExports["bpchareq"])(a0);
        var _bpcharlt = Module["_bpcharlt"] = (a0) => (_bpcharlt = Module["_bpcharlt"] = wasmExports["bpcharlt"])(a0);
        var _bpcharle = Module["_bpcharle"] = (a0) => (_bpcharle = Module["_bpcharle"] = wasmExports["bpcharle"])(a0);
        var _bpchargt = Module["_bpchargt"] = (a0) => (_bpchargt = Module["_bpchargt"] = wasmExports["bpchargt"])(a0);
        var _bpcharge = Module["_bpcharge"] = (a0) => (_bpcharge = Module["_bpcharge"] = wasmExports["bpcharge"])(a0);
        var _bpcharcmp = Module["_bpcharcmp"] = (a0) => (_bpcharcmp = Module["_bpcharcmp"] = wasmExports["bpcharcmp"])(a0);
        var _date_eq = Module["_date_eq"] = (a0) => (_date_eq = Module["_date_eq"] = wasmExports["date_eq"])(a0);
        var _date_lt = Module["_date_lt"] = (a0) => (_date_lt = Module["_date_lt"] = wasmExports["date_lt"])(a0);
        var _date_le = Module["_date_le"] = (a0) => (_date_le = Module["_date_le"] = wasmExports["date_le"])(a0);
        var _date_gt = Module["_date_gt"] = (a0) => (_date_gt = Module["_date_gt"] = wasmExports["date_gt"])(a0);
        var _date_ge = Module["_date_ge"] = (a0) => (_date_ge = Module["_date_ge"] = wasmExports["date_ge"])(a0);
        var _date_cmp = Module["_date_cmp"] = (a0) => (_date_cmp = Module["_date_cmp"] = wasmExports["date_cmp"])(a0);
        var _time_lt = Module["_time_lt"] = (a0) => (_time_lt = Module["_time_lt"] = wasmExports["time_lt"])(a0);
        var _time_le = Module["_time_le"] = (a0) => (_time_le = Module["_time_le"] = wasmExports["time_le"])(a0);
        var _time_gt = Module["_time_gt"] = (a0) => (_time_gt = Module["_time_gt"] = wasmExports["time_gt"])(a0);
        var _time_ge = Module["_time_ge"] = (a0) => (_time_ge = Module["_time_ge"] = wasmExports["time_ge"])(a0);
        var _time_cmp = Module["_time_cmp"] = (a0) => (_time_cmp = Module["_time_cmp"] = wasmExports["time_cmp"])(a0);
        var _date_mi = Module["_date_mi"] = (a0) => (_date_mi = Module["_date_mi"] = wasmExports["date_mi"])(a0);
        var _time_eq = Module["_time_eq"] = (a0) => (_time_eq = Module["_time_eq"] = wasmExports["time_eq"])(a0);
        var _timestamp_eq = Module["_timestamp_eq"] = (a0) => (_timestamp_eq = Module["_timestamp_eq"] = wasmExports["timestamp_eq"])(a0);
        var _timestamp_lt = Module["_timestamp_lt"] = (a0) => (_timestamp_lt = Module["_timestamp_lt"] = wasmExports["timestamp_lt"])(a0);
        var _timestamp_le = Module["_timestamp_le"] = (a0) => (_timestamp_le = Module["_timestamp_le"] = wasmExports["timestamp_le"])(a0);
        var _timestamp_ge = Module["_timestamp_ge"] = (a0) => (_timestamp_ge = Module["_timestamp_ge"] = wasmExports["timestamp_ge"])(a0);
        var _timestamp_gt = Module["_timestamp_gt"] = (a0) => (_timestamp_gt = Module["_timestamp_gt"] = wasmExports["timestamp_gt"])(a0);
        var _interval_eq = Module["_interval_eq"] = (a0) => (_interval_eq = Module["_interval_eq"] = wasmExports["interval_eq"])(a0);
        var _interval_lt = Module["_interval_lt"] = (a0) => (_interval_lt = Module["_interval_lt"] = wasmExports["interval_lt"])(a0);
        var _interval_le = Module["_interval_le"] = (a0) => (_interval_le = Module["_interval_le"] = wasmExports["interval_le"])(a0);
        var _interval_ge = Module["_interval_ge"] = (a0) => (_interval_ge = Module["_interval_ge"] = wasmExports["interval_ge"])(a0);
        var _interval_gt = Module["_interval_gt"] = (a0) => (_interval_gt = Module["_interval_gt"] = wasmExports["interval_gt"])(a0);
        var _interval_um = Module["_interval_um"] = (a0) => (_interval_um = Module["_interval_um"] = wasmExports["interval_um"])(a0);
        var _interval_mi = Module["_interval_mi"] = (a0) => (_interval_mi = Module["_interval_mi"] = wasmExports["interval_mi"])(a0);
        var _timestamp_mi = Module["_timestamp_mi"] = (a0) => (_timestamp_mi = Module["_timestamp_mi"] = wasmExports["timestamp_mi"])(a0);
        var _quote_ident = Module["_quote_ident"] = (a0) => (_quote_ident = Module["_quote_ident"] = wasmExports["quote_ident"])(a0);
        var _timestamp_in = Module["_timestamp_in"] = (a0) => (_timestamp_in = Module["_timestamp_in"] = wasmExports["timestamp_in"])(a0);
        var _timestamp_cmp = Module["_timestamp_cmp"] = (a0) => (_timestamp_cmp = Module["_timestamp_cmp"] = wasmExports["timestamp_cmp"])(a0);
        var _interval_cmp = Module["_interval_cmp"] = (a0) => (_interval_cmp = Module["_interval_cmp"] = wasmExports["interval_cmp"])(a0);
        var _timetz_cmp = Module["_timetz_cmp"] = (a0) => (_timetz_cmp = Module["_timetz_cmp"] = wasmExports["timetz_cmp"])(a0);
        var _bit_in = Module["_bit_in"] = (a0) => (_bit_in = Module["_bit_in"] = wasmExports["bit_in"])(a0);
        var _varbit_in = Module["_varbit_in"] = (a0) => (_varbit_in = Module["_varbit_in"] = wasmExports["varbit_in"])(a0);
        var _biteq = Module["_biteq"] = (a0) => (_biteq = Module["_biteq"] = wasmExports["biteq"])(a0);
        var _bitge = Module["_bitge"] = (a0) => (_bitge = Module["_bitge"] = wasmExports["bitge"])(a0);
        var _bitgt = Module["_bitgt"] = (a0) => (_bitgt = Module["_bitgt"] = wasmExports["bitgt"])(a0);
        var _bitle = Module["_bitle"] = (a0) => (_bitle = Module["_bitle"] = wasmExports["bitle"])(a0);
        var _bitlt = Module["_bitlt"] = (a0) => (_bitlt = Module["_bitlt"] = wasmExports["bitlt"])(a0);
        var _bitcmp = Module["_bitcmp"] = (a0) => (_bitcmp = Module["_bitcmp"] = wasmExports["bitcmp"])(a0);
        var _time_mi_time = Module["_time_mi_time"] = (a0) => (_time_mi_time = Module["_time_mi_time"] = wasmExports["time_mi_time"])(a0);
        var _numeric_eq = Module["_numeric_eq"] = (a0) => (_numeric_eq = Module["_numeric_eq"] = wasmExports["numeric_eq"])(a0);
        var _numeric_gt = Module["_numeric_gt"] = (a0) => (_numeric_gt = Module["_numeric_gt"] = wasmExports["numeric_gt"])(a0);
        var _numeric_ge = Module["_numeric_ge"] = (a0) => (_numeric_ge = Module["_numeric_ge"] = wasmExports["numeric_ge"])(a0);
        var _numeric_lt = Module["_numeric_lt"] = (a0) => (_numeric_lt = Module["_numeric_lt"] = wasmExports["numeric_lt"])(a0);
        var _numeric_le = Module["_numeric_le"] = (a0) => (_numeric_le = Module["_numeric_le"] = wasmExports["numeric_le"])(a0);
        var _numeric_div = Module["_numeric_div"] = (a0) => (_numeric_div = Module["_numeric_div"] = wasmExports["numeric_div"])(a0);
        var _numeric_float4 = Module["_numeric_float4"] = (a0) => (_numeric_float4 = Module["_numeric_float4"] = wasmExports["numeric_float4"])(a0);
        var _numeric_cmp = Module["_numeric_cmp"] = (a0) => (_numeric_cmp = Module["_numeric_cmp"] = wasmExports["numeric_cmp"])(a0);
        var _byteaeq = Module["_byteaeq"] = (a0) => (_byteaeq = Module["_byteaeq"] = wasmExports["byteaeq"])(a0);
        var _bytealt = Module["_bytealt"] = (a0) => (_bytealt = Module["_bytealt"] = wasmExports["bytealt"])(a0);
        var _byteale = Module["_byteale"] = (a0) => (_byteale = Module["_byteale"] = wasmExports["byteale"])(a0);
        var _byteagt = Module["_byteagt"] = (a0) => (_byteagt = Module["_byteagt"] = wasmExports["byteagt"])(a0);
        var _byteage = Module["_byteage"] = (a0) => (_byteage = Module["_byteage"] = wasmExports["byteage"])(a0);
        var _byteacmp = Module["_byteacmp"] = (a0) => (_byteacmp = Module["_byteacmp"] = wasmExports["byteacmp"])(a0);
        var _to_hex32 = Module["_to_hex32"] = (a0) => (_to_hex32 = Module["_to_hex32"] = wasmExports["to_hex32"])(a0);
        var _uuid_in = Module["_uuid_in"] = (a0) => (_uuid_in = Module["_uuid_in"] = wasmExports["uuid_in"])(a0);
        var _uuid_out = Module["_uuid_out"] = (a0) => (_uuid_out = Module["_uuid_out"] = wasmExports["uuid_out"])(a0);
        var _uuid_cmp = Module["_uuid_cmp"] = (a0) => (_uuid_cmp = Module["_uuid_cmp"] = wasmExports["uuid_cmp"])(a0);
        var _pg_lsn_in = Module["_pg_lsn_in"] = (a0) => (_pg_lsn_in = Module["_pg_lsn_in"] = wasmExports["pg_lsn_in"])(a0);
        var _gen_random_uuid = Module["_gen_random_uuid"] = (a0) => (_gen_random_uuid = Module["_gen_random_uuid"] = wasmExports["gen_random_uuid"])(a0);
        var _enum_lt = Module["_enum_lt"] = (a0) => (_enum_lt = Module["_enum_lt"] = wasmExports["enum_lt"])(a0);
        var _enum_gt = Module["_enum_gt"] = (a0) => (_enum_gt = Module["_enum_gt"] = wasmExports["enum_gt"])(a0);
        var _enum_le = Module["_enum_le"] = (a0) => (_enum_le = Module["_enum_le"] = wasmExports["enum_le"])(a0);
        var _enum_ge = Module["_enum_ge"] = (a0) => (_enum_ge = Module["_enum_ge"] = wasmExports["enum_ge"])(a0);
        var _enum_cmp = Module["_enum_cmp"] = (a0) => (_enum_cmp = Module["_enum_cmp"] = wasmExports["enum_cmp"])(a0);
        var _arraycontsel = Module["_arraycontsel"] = (a0) => (_arraycontsel = Module["_arraycontsel"] = wasmExports["arraycontsel"])(a0);
        var _arraycontjoinsel = Module["_arraycontjoinsel"] = (a0) => (_arraycontjoinsel = Module["_arraycontjoinsel"] = wasmExports["arraycontjoinsel"])(a0);
        var _macaddr8_eq = Module["_macaddr8_eq"] = (a0) => (_macaddr8_eq = Module["_macaddr8_eq"] = wasmExports["macaddr8_eq"])(a0);
        var _macaddr8_lt = Module["_macaddr8_lt"] = (a0) => (_macaddr8_lt = Module["_macaddr8_lt"] = wasmExports["macaddr8_lt"])(a0);
        var _macaddr8_le = Module["_macaddr8_le"] = (a0) => (_macaddr8_le = Module["_macaddr8_le"] = wasmExports["macaddr8_le"])(a0);
        var _macaddr8_gt = Module["_macaddr8_gt"] = (a0) => (_macaddr8_gt = Module["_macaddr8_gt"] = wasmExports["macaddr8_gt"])(a0);
        var _macaddr8_ge = Module["_macaddr8_ge"] = (a0) => (_macaddr8_ge = Module["_macaddr8_ge"] = wasmExports["macaddr8_ge"])(a0);
        var _macaddr8_cmp = Module["_macaddr8_cmp"] = (a0) => (_macaddr8_cmp = Module["_macaddr8_cmp"] = wasmExports["macaddr8_cmp"])(a0);
        var _local2local = Module["_local2local"] = (a0, a1, a22, a32, a42, a52, a62) => (_local2local = Module["_local2local"] = wasmExports["local2local"])(a0, a1, a22, a32, a42, a52, a62);
        var _report_invalid_encoding = Module["_report_invalid_encoding"] = (a0, a1, a22) => (_report_invalid_encoding = Module["_report_invalid_encoding"] = wasmExports["report_invalid_encoding"])(a0, a1, a22);
        var _report_untranslatable_char = Module["_report_untranslatable_char"] = (a0, a1, a22, a32) => (_report_untranslatable_char = Module["_report_untranslatable_char"] = wasmExports["report_untranslatable_char"])(a0, a1, a22, a32);
        var _latin2mic = Module["_latin2mic"] = (a0, a1, a22, a32, a42, a52) => (_latin2mic = Module["_latin2mic"] = wasmExports["latin2mic"])(a0, a1, a22, a32, a42, a52);
        var _mic2latin = Module["_mic2latin"] = (a0, a1, a22, a32, a42, a52) => (_mic2latin = Module["_mic2latin"] = wasmExports["mic2latin"])(a0, a1, a22, a32, a42, a52);
        var _latin2mic_with_table = Module["_latin2mic_with_table"] = (a0, a1, a22, a32, a42, a52, a62) => (_latin2mic_with_table = Module["_latin2mic_with_table"] = wasmExports["latin2mic_with_table"])(a0, a1, a22, a32, a42, a52, a62);
        var _mic2latin_with_table = Module["_mic2latin_with_table"] = (a0, a1, a22, a32, a42, a52, a62) => (_mic2latin_with_table = Module["_mic2latin_with_table"] = wasmExports["mic2latin_with_table"])(a0, a1, a22, a32, a42, a52, a62);
        var _pg_utf_mblen = Module["_pg_utf_mblen"] = (a0) => (_pg_utf_mblen = Module["_pg_utf_mblen"] = wasmExports["pg_utf_mblen"])(a0);
        var _pg_encoding_verifymbchar = Module["_pg_encoding_verifymbchar"] = (a0, a1, a22) => (_pg_encoding_verifymbchar = Module["_pg_encoding_verifymbchar"] = wasmExports["pg_encoding_verifymbchar"])(a0, a1, a22);
        var _GetDatabaseEncodingName = Module["_GetDatabaseEncodingName"] = () => (_GetDatabaseEncodingName = Module["_GetDatabaseEncodingName"] = wasmExports["GetDatabaseEncodingName"])();
        var _pg_do_encoding_conversion = Module["_pg_do_encoding_conversion"] = (a0, a1, a22, a32) => (_pg_do_encoding_conversion = Module["_pg_do_encoding_conversion"] = wasmExports["pg_do_encoding_conversion"])(a0, a1, a22, a32);
        var _pg_encoding_to_char_private = Module["_pg_encoding_to_char_private"] = (a0) => (_pg_encoding_to_char_private = Module["_pg_encoding_to_char_private"] = wasmExports["pg_encoding_to_char_private"])(a0);
        var _pg_char_to_encoding_private = Module["_pg_char_to_encoding_private"] = (a0) => (_pg_char_to_encoding_private = Module["_pg_char_to_encoding_private"] = wasmExports["pg_char_to_encoding_private"])(a0);
        var _pg_encoding_max_length = Module["_pg_encoding_max_length"] = (a0) => (_pg_encoding_max_length = Module["_pg_encoding_max_length"] = wasmExports["pg_encoding_max_length"])(a0);
        var _pg_server_to_any = Module["_pg_server_to_any"] = (a0, a1, a22) => (_pg_server_to_any = Module["_pg_server_to_any"] = wasmExports["pg_server_to_any"])(a0, a1, a22);
        var _pg_wchar2mb_with_len = Module["_pg_wchar2mb_with_len"] = (a0, a1, a22) => (_pg_wchar2mb_with_len = Module["_pg_wchar2mb_with_len"] = wasmExports["pg_wchar2mb_with_len"])(a0, a1, a22);
        var _pg_encoding_mblen = Module["_pg_encoding_mblen"] = (a0, a1) => (_pg_encoding_mblen = Module["_pg_encoding_mblen"] = wasmExports["pg_encoding_mblen"])(a0, a1);
        var _check_encoding_conversion_args = Module["_check_encoding_conversion_args"] = (a0, a1, a22, a32, a42) => (_check_encoding_conversion_args = Module["_check_encoding_conversion_args"] = wasmExports["check_encoding_conversion_args"])(a0, a1, a22, a32, a42);
        var _set_config_option = Module["_set_config_option"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_set_config_option = Module["_set_config_option"] = wasmExports["set_config_option"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _quote_identifier = Module["_quote_identifier"] = (a0) => (_quote_identifier = Module["_quote_identifier"] = wasmExports["quote_identifier"])(a0);
        var _list_delete = Module["_list_delete"] = (a0, a1) => (_list_delete = Module["_list_delete"] = wasmExports["list_delete"])(a0, a1);
        var _feof = Module["_feof"] = (a0) => (_feof = Module["_feof"] = wasmExports["feof"])(a0);
        var _BlockSampler_Init = Module["_BlockSampler_Init"] = (a0, a1, a22, a32) => (_BlockSampler_Init = Module["_BlockSampler_Init"] = wasmExports["BlockSampler_Init"])(a0, a1, a22, a32);
        var _pg_prng_seed = Module["_pg_prng_seed"] = (a0, a1) => (_pg_prng_seed = Module["_pg_prng_seed"] = wasmExports["pg_prng_seed"])(a0, a1);
        var _sampler_random_init_state = Module["_sampler_random_init_state"] = (a0, a1) => (_sampler_random_init_state = Module["_sampler_random_init_state"] = wasmExports["sampler_random_init_state"])(a0, a1);
        var _BlockSampler_HasMore = Module["_BlockSampler_HasMore"] = (a0) => (_BlockSampler_HasMore = Module["_BlockSampler_HasMore"] = wasmExports["BlockSampler_HasMore"])(a0);
        var _BlockSampler_Next = Module["_BlockSampler_Next"] = (a0) => (_BlockSampler_Next = Module["_BlockSampler_Next"] = wasmExports["BlockSampler_Next"])(a0);
        var _sampler_random_fract = Module["_sampler_random_fract"] = (a0) => (_sampler_random_fract = Module["_sampler_random_fract"] = wasmExports["sampler_random_fract"])(a0);
        var _reservoir_init_selection_state = Module["_reservoir_init_selection_state"] = (a0, a1) => (_reservoir_init_selection_state = Module["_reservoir_init_selection_state"] = wasmExports["reservoir_init_selection_state"])(a0, a1);
        var _reservoir_get_next_S = Module["_reservoir_get_next_S"] = (a0, a1, a22) => (_reservoir_get_next_S = Module["_reservoir_get_next_S"] = wasmExports["reservoir_get_next_S"])(a0, a1, a22);
        var _GetConfigOption = Module["_GetConfigOption"] = (a0, a1, a22) => (_GetConfigOption = Module["_GetConfigOption"] = wasmExports["GetConfigOption"])(a0, a1, a22);
        var _ProcessConfigFile = Module["_ProcessConfigFile"] = (a0) => (_ProcessConfigFile = Module["_ProcessConfigFile"] = wasmExports["ProcessConfigFile"])(a0);
        var _strtod = Module["_strtod"] = (a0, a1) => (_strtod = Module["_strtod"] = wasmExports["strtod"])(a0, a1);
        var _truncate_identifier = Module["_truncate_identifier"] = (a0, a1, a22) => (_truncate_identifier = Module["_truncate_identifier"] = wasmExports["truncate_identifier"])(a0, a1, a22);
        var _DefineCustomBoolVariable = Module["_DefineCustomBoolVariable"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9) => (_DefineCustomBoolVariable = Module["_DefineCustomBoolVariable"] = wasmExports["DefineCustomBoolVariable"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9);
        var _DefineCustomIntVariable = Module["_DefineCustomIntVariable"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11) => (_DefineCustomIntVariable = Module["_DefineCustomIntVariable"] = wasmExports["DefineCustomIntVariable"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11);
        var _DefineCustomRealVariable = Module["_DefineCustomRealVariable"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11) => (_DefineCustomRealVariable = Module["_DefineCustomRealVariable"] = wasmExports["DefineCustomRealVariable"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11);
        var _DefineCustomStringVariable = Module["_DefineCustomStringVariable"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9) => (_DefineCustomStringVariable = Module["_DefineCustomStringVariable"] = wasmExports["DefineCustomStringVariable"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9);
        var _DefineCustomEnumVariable = Module["_DefineCustomEnumVariable"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10) => (_DefineCustomEnumVariable = Module["_DefineCustomEnumVariable"] = wasmExports["DefineCustomEnumVariable"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10);
        var _MarkGUCPrefixReserved = Module["_MarkGUCPrefixReserved"] = (a0) => (_MarkGUCPrefixReserved = Module["_MarkGUCPrefixReserved"] = wasmExports["MarkGUCPrefixReserved"])(a0);
        var _strcspn = Module["_strcspn"] = (a0, a1) => (_strcspn = Module["_strcspn"] = wasmExports["strcspn"])(a0, a1);
        var _CacheRegisterSyscacheCallback = Module["_CacheRegisterSyscacheCallback"] = (a0, a1, a22) => (_CacheRegisterSyscacheCallback = Module["_CacheRegisterSyscacheCallback"] = wasmExports["CacheRegisterSyscacheCallback"])(a0, a1, a22);
        var _TransferExpandedObject = Module["_TransferExpandedObject"] = (a0, a1) => (_TransferExpandedObject = Module["_TransferExpandedObject"] = wasmExports["TransferExpandedObject"])(a0, a1);
        var _errsave_start = Module["_errsave_start"] = (a0, a1) => (_errsave_start = Module["_errsave_start"] = wasmExports["errsave_start"])(a0, a1);
        var _errsave_finish = Module["_errsave_finish"] = (a0, a1, a22, a32) => (_errsave_finish = Module["_errsave_finish"] = wasmExports["errsave_finish"])(a0, a1, a22, a32);
        var _pq_getmsgtext = Module["_pq_getmsgtext"] = (a0, a1, a22) => (_pq_getmsgtext = Module["_pq_getmsgtext"] = wasmExports["pq_getmsgtext"])(a0, a1, a22);
        var _pq_begintypsend = Module["_pq_begintypsend"] = (a0) => (_pq_begintypsend = Module["_pq_begintypsend"] = wasmExports["pq_begintypsend"])(a0);
        var _pq_sendtext = Module["_pq_sendtext"] = (a0, a1, a22) => (_pq_sendtext = Module["_pq_sendtext"] = wasmExports["pq_sendtext"])(a0, a1, a22);
        var _pq_endtypsend = Module["_pq_endtypsend"] = (a0) => (_pq_endtypsend = Module["_pq_endtypsend"] = wasmExports["pq_endtypsend"])(a0);
        var _downcase_truncate_identifier = Module["_downcase_truncate_identifier"] = (a0, a1, a22) => (_downcase_truncate_identifier = Module["_downcase_truncate_identifier"] = wasmExports["downcase_truncate_identifier"])(a0, a1, a22);
        var _int64_to_numeric = Module["_int64_to_numeric"] = (a0) => (_int64_to_numeric = Module["_int64_to_numeric"] = wasmExports["int64_to_numeric"])(a0);
        var _ArrayGetIntegerTypmods = Module["_ArrayGetIntegerTypmods"] = (a0, a1) => (_ArrayGetIntegerTypmods = Module["_ArrayGetIntegerTypmods"] = wasmExports["ArrayGetIntegerTypmods"])(a0, a1);
        var _text_to_cstring_buffer = Module["_text_to_cstring_buffer"] = (a0, a1, a22) => (_text_to_cstring_buffer = Module["_text_to_cstring_buffer"] = wasmExports["text_to_cstring_buffer"])(a0, a1, a22);
        var _array_contains_nulls = Module["_array_contains_nulls"] = (a0) => (_array_contains_nulls = Module["_array_contains_nulls"] = wasmExports["array_contains_nulls"])(a0);
        var _JsonbValueToJsonb = Module["_JsonbValueToJsonb"] = (a0) => (_JsonbValueToJsonb = Module["_JsonbValueToJsonb"] = wasmExports["JsonbValueToJsonb"])(a0);
        var _pushJsonbValue = Module["_pushJsonbValue"] = (a0, a1, a22) => (_pushJsonbValue = Module["_pushJsonbValue"] = wasmExports["pushJsonbValue"])(a0, a1, a22);
        var _float4in_internal = Module["_float4in_internal"] = (a0, a1, a22, a32, a42) => (_float4in_internal = Module["_float4in_internal"] = wasmExports["float4in_internal"])(a0, a1, a22, a32, a42);
        var _strtof = Module["_strtof"] = (a0, a1) => (_strtof = Module["_strtof"] = wasmExports["strtof"])(a0, a1);
        var _float_to_shortest_decimal_buf = Module["_float_to_shortest_decimal_buf"] = (a0, a1) => (_float_to_shortest_decimal_buf = Module["_float_to_shortest_decimal_buf"] = wasmExports["float_to_shortest_decimal_buf"])(a0, a1);
        var _pq_getmsgfloat4 = Module["_pq_getmsgfloat4"] = (a0) => (_pq_getmsgfloat4 = Module["_pq_getmsgfloat4"] = wasmExports["pq_getmsgfloat4"])(a0);
        var _pq_sendfloat4 = Module["_pq_sendfloat4"] = (a0, a1) => (_pq_sendfloat4 = Module["_pq_sendfloat4"] = wasmExports["pq_sendfloat4"])(a0, a1);
        var _float8in_internal = Module["_float8in_internal"] = (a0, a1, a22, a32, a42) => (_float8in_internal = Module["_float8in_internal"] = wasmExports["float8in_internal"])(a0, a1, a22, a32, a42);
        var _float8out_internal = Module["_float8out_internal"] = (a0) => (_float8out_internal = Module["_float8out_internal"] = wasmExports["float8out_internal"])(a0);
        var _pq_getmsgfloat8 = Module["_pq_getmsgfloat8"] = (a0) => (_pq_getmsgfloat8 = Module["_pq_getmsgfloat8"] = wasmExports["pq_getmsgfloat8"])(a0);
        var _pq_sendfloat8 = Module["_pq_sendfloat8"] = (a0, a1) => (_pq_sendfloat8 = Module["_pq_sendfloat8"] = wasmExports["pq_sendfloat8"])(a0, a1);
        var _log10 = Module["_log10"] = (a0) => (_log10 = Module["_log10"] = wasmExports["log10"])(a0);
        var _acos = Module["_acos"] = (a0) => (_acos = Module["_acos"] = wasmExports["acos"])(a0);
        var _asin = Module["_asin"] = (a0) => (_asin = Module["_asin"] = wasmExports["asin"])(a0);
        var _cos = Module["_cos"] = (a0) => (_cos = Module["_cos"] = wasmExports["cos"])(a0);
        var _sin = Module["_sin"] = (a0) => (_sin = Module["_sin"] = wasmExports["sin"])(a0);
        var _fmod = Module["_fmod"] = (a0, a1) => (_fmod = Module["_fmod"] = wasmExports["fmod"])(a0, a1);
        var _pg_prng_seed_check = Module["_pg_prng_seed_check"] = (a0) => (_pg_prng_seed_check = Module["_pg_prng_seed_check"] = wasmExports["pg_prng_seed_check"])(a0);
        var _construct_array = Module["_construct_array"] = (a0, a1, a22, a32, a42, a52) => (_construct_array = Module["_construct_array"] = wasmExports["construct_array"])(a0, a1, a22, a32, a42, a52);
        var _quote_literal_cstr = Module["_quote_literal_cstr"] = (a0) => (_quote_literal_cstr = Module["_quote_literal_cstr"] = wasmExports["quote_literal_cstr"])(a0);
        var _pg_inet_net_ntop = Module["_pg_inet_net_ntop"] = (a0, a1, a22, a32, a42) => (_pg_inet_net_ntop = Module["_pg_inet_net_ntop"] = wasmExports["pg_inet_net_ntop"])(a0, a1, a22, a32, a42);
        var _convert_network_to_scalar = Module["_convert_network_to_scalar"] = (a0, a1, a22) => (_convert_network_to_scalar = Module["_convert_network_to_scalar"] = wasmExports["convert_network_to_scalar"])(a0, a1, a22);
        var _pg_getnameinfo_all = Module["_pg_getnameinfo_all"] = (a0, a1, a22, a32, a42, a52, a62) => (_pg_getnameinfo_all = Module["_pg_getnameinfo_all"] = wasmExports["pg_getnameinfo_all"])(a0, a1, a22, a32, a42, a52, a62);
        var _appendStringInfoSpaces = Module["_appendStringInfoSpaces"] = (a0, a1) => (_appendStringInfoSpaces = Module["_appendStringInfoSpaces"] = wasmExports["appendStringInfoSpaces"])(a0, a1);
        var _format_type_extended = Module["_format_type_extended"] = (a0, a1, a22) => (_format_type_extended = Module["_format_type_extended"] = wasmExports["format_type_extended"])(a0, a1, a22);
        var _get_namespace_name_or_temp = Module["_get_namespace_name_or_temp"] = (a0) => (_get_namespace_name_or_temp = Module["_get_namespace_name_or_temp"] = wasmExports["get_namespace_name_or_temp"])(a0);
        var _quote_qualified_identifier = Module["_quote_qualified_identifier"] = (a0, a1) => (_quote_qualified_identifier = Module["_quote_qualified_identifier"] = wasmExports["quote_qualified_identifier"])(a0, a1);
        var _make_expanded_record_from_typeid = Module["_make_expanded_record_from_typeid"] = (a0, a1, a22) => (_make_expanded_record_from_typeid = Module["_make_expanded_record_from_typeid"] = wasmExports["make_expanded_record_from_typeid"])(a0, a1, a22);
        var _make_expanded_record_from_tupdesc = Module["_make_expanded_record_from_tupdesc"] = (a0, a1) => (_make_expanded_record_from_tupdesc = Module["_make_expanded_record_from_tupdesc"] = wasmExports["make_expanded_record_from_tupdesc"])(a0, a1);
        var _make_expanded_record_from_exprecord = Module["_make_expanded_record_from_exprecord"] = (a0, a1) => (_make_expanded_record_from_exprecord = Module["_make_expanded_record_from_exprecord"] = wasmExports["make_expanded_record_from_exprecord"])(a0, a1);
        var _expanded_record_set_tuple = Module["_expanded_record_set_tuple"] = (a0, a1, a22, a32) => (_expanded_record_set_tuple = Module["_expanded_record_set_tuple"] = wasmExports["expanded_record_set_tuple"])(a0, a1, a22, a32);
        var _domain_check = Module["_domain_check"] = (a0, a1, a22, a32, a42) => (_domain_check = Module["_domain_check"] = wasmExports["domain_check"])(a0, a1, a22, a32, a42);
        var _expanded_record_get_tuple = Module["_expanded_record_get_tuple"] = (a0) => (_expanded_record_get_tuple = Module["_expanded_record_get_tuple"] = wasmExports["expanded_record_get_tuple"])(a0);
        var _deconstruct_expanded_record = Module["_deconstruct_expanded_record"] = (a0) => (_deconstruct_expanded_record = Module["_deconstruct_expanded_record"] = wasmExports["deconstruct_expanded_record"])(a0);
        var _expanded_record_lookup_field = Module["_expanded_record_lookup_field"] = (a0, a1, a22) => (_expanded_record_lookup_field = Module["_expanded_record_lookup_field"] = wasmExports["expanded_record_lookup_field"])(a0, a1, a22);
        var _expanded_record_set_field_internal = Module["_expanded_record_set_field_internal"] = (a0, a1, a22, a32, a42, a52) => (_expanded_record_set_field_internal = Module["_expanded_record_set_field_internal"] = wasmExports["expanded_record_set_field_internal"])(a0, a1, a22, a32, a42, a52);
        var _expanded_record_set_fields = Module["_expanded_record_set_fields"] = (a0, a1, a22, a32) => (_expanded_record_set_fields = Module["_expanded_record_set_fields"] = wasmExports["expanded_record_set_fields"])(a0, a1, a22, a32);
        var _err_generic_string = Module["_err_generic_string"] = (a0, a1) => (_err_generic_string = Module["_err_generic_string"] = wasmExports["err_generic_string"])(a0, a1);
        var _forkname_to_number = Module["_forkname_to_number"] = (a0) => (_forkname_to_number = Module["_forkname_to_number"] = wasmExports["forkname_to_number"])(a0);
        var _RelidByRelfilenumber = Module["_RelidByRelfilenumber"] = (a0, a1) => (_RelidByRelfilenumber = Module["_RelidByRelfilenumber"] = wasmExports["RelidByRelfilenumber"])(a0, a1);
        var _pg_xml_init = Module["_pg_xml_init"] = (a0) => (_pg_xml_init = Module["_pg_xml_init"] = wasmExports["pg_xml_init"])(a0);
        var _xmlInitParser = Module["_xmlInitParser"] = () => (_xmlInitParser = Module["_xmlInitParser"] = wasmExports["xmlInitParser"])();
        var _xml_ereport = Module["_xml_ereport"] = (a0, a1, a22, a32) => (_xml_ereport = Module["_xml_ereport"] = wasmExports["xml_ereport"])(a0, a1, a22, a32);
        var _pg_xml_done = Module["_pg_xml_done"] = (a0, a1) => (_pg_xml_done = Module["_pg_xml_done"] = wasmExports["pg_xml_done"])(a0, a1);
        var _xmlXPathNewContext = Module["_xmlXPathNewContext"] = (a0) => (_xmlXPathNewContext = Module["_xmlXPathNewContext"] = wasmExports["xmlXPathNewContext"])(a0);
        var _xmlXPathFreeContext = Module["_xmlXPathFreeContext"] = (a0) => (_xmlXPathFreeContext = Module["_xmlXPathFreeContext"] = wasmExports["xmlXPathFreeContext"])(a0);
        var _xmlFreeDoc = Module["_xmlFreeDoc"] = (a0) => (_xmlFreeDoc = Module["_xmlFreeDoc"] = wasmExports["xmlFreeDoc"])(a0);
        var _xmlXPathCompile = Module["_xmlXPathCompile"] = (a0) => (_xmlXPathCompile = Module["_xmlXPathCompile"] = wasmExports["xmlXPathCompile"])(a0);
        var _xmlXPathCompiledEval = Module["_xmlXPathCompiledEval"] = (a0, a1) => (_xmlXPathCompiledEval = Module["_xmlXPathCompiledEval"] = wasmExports["xmlXPathCompiledEval"])(a0, a1);
        var _xmlXPathFreeCompExpr = Module["_xmlXPathFreeCompExpr"] = (a0) => (_xmlXPathFreeCompExpr = Module["_xmlXPathFreeCompExpr"] = wasmExports["xmlXPathFreeCompExpr"])(a0);
        var _xmlStrdup = Module["_xmlStrdup"] = (a0) => (_xmlStrdup = Module["_xmlStrdup"] = wasmExports["xmlStrdup"])(a0);
        var _initArrayResult = Module["_initArrayResult"] = (a0, a1, a22) => (_initArrayResult = Module["_initArrayResult"] = wasmExports["initArrayResult"])(a0, a1, a22);
        var _xmlXPathCastNodeToString = Module["_xmlXPathCastNodeToString"] = (a0) => (_xmlXPathCastNodeToString = Module["_xmlXPathCastNodeToString"] = wasmExports["xmlXPathCastNodeToString"])(a0);
        var _str_tolower = Module["_str_tolower"] = (a0, a1, a22) => (_str_tolower = Module["_str_tolower"] = wasmExports["str_tolower"])(a0, a1, a22);
        var _GetSysCacheHashValue = Module["_GetSysCacheHashValue"] = (a0, a1, a22, a32, a42) => (_GetSysCacheHashValue = Module["_GetSysCacheHashValue"] = wasmExports["GetSysCacheHashValue"])(a0, a1, a22, a32, a42);
        var ___multi3 = Module["___multi3"] = (a0, a1, a22, a32, a42) => (___multi3 = Module["___multi3"] = wasmExports["__multi3"])(a0, a1, a22, a32, a42);
        var _expand_array = Module["_expand_array"] = (a0, a1, a22) => (_expand_array = Module["_expand_array"] = wasmExports["expand_array"])(a0, a1, a22);
        var _generic_restriction_selectivity = Module["_generic_restriction_selectivity"] = (a0, a1, a22, a32, a42, a52) => (_generic_restriction_selectivity = Module["_generic_restriction_selectivity"] = wasmExports["generic_restriction_selectivity"])(a0, a1, a22, a32, a42, a52);
        var _bms_membership = Module["_bms_membership"] = (a0) => (_bms_membership = Module["_bms_membership"] = wasmExports["bms_membership"])(a0);
        var _find_join_rel = Module["_find_join_rel"] = (a0, a1) => (_find_join_rel = Module["_find_join_rel"] = wasmExports["find_join_rel"])(a0, a1);
        var _bms_is_subset = Module["_bms_is_subset"] = (a0, a1) => (_bms_is_subset = Module["_bms_is_subset"] = wasmExports["bms_is_subset"])(a0, a1);
        var _estimate_num_groups = Module["_estimate_num_groups"] = (a0, a1, a22, a32, a42) => (_estimate_num_groups = Module["_estimate_num_groups"] = wasmExports["estimate_num_groups"])(a0, a1, a22, a32, a42);
        var _pull_var_clause = Module["_pull_var_clause"] = (a0, a1) => (_pull_var_clause = Module["_pull_var_clause"] = wasmExports["pull_var_clause"])(a0, a1);
        var _genericcostestimate = Module["_genericcostestimate"] = (a0, a1, a22, a32) => (_genericcostestimate = Module["_genericcostestimate"] = wasmExports["genericcostestimate"])(a0, a1, a22, a32);
        var _clauselist_selectivity = Module["_clauselist_selectivity"] = (a0, a1, a22, a32, a42) => (_clauselist_selectivity = Module["_clauselist_selectivity"] = wasmExports["clauselist_selectivity"])(a0, a1, a22, a32, a42);
        var _get_tablespace_page_costs = Module["_get_tablespace_page_costs"] = (a0, a1, a22) => (_get_tablespace_page_costs = Module["_get_tablespace_page_costs"] = wasmExports["get_tablespace_page_costs"])(a0, a1, a22);
        var _numeric_float8_no_overflow = Module["_numeric_float8_no_overflow"] = (a0) => (_numeric_float8_no_overflow = Module["_numeric_float8_no_overflow"] = wasmExports["numeric_float8_no_overflow"])(a0);
        var _array_create_iterator = Module["_array_create_iterator"] = (a0, a1, a22) => (_array_create_iterator = Module["_array_create_iterator"] = wasmExports["array_create_iterator"])(a0, a1, a22);
        var _array_iterate = Module["_array_iterate"] = (a0, a1, a22) => (_array_iterate = Module["_array_iterate"] = wasmExports["array_iterate"])(a0, a1, a22);
        var _transformExpr = Module["_transformExpr"] = (a0, a1, a22) => (_transformExpr = Module["_transformExpr"] = wasmExports["transformExpr"])(a0, a1, a22);
        var _numeric_is_nan = Module["_numeric_is_nan"] = (a0) => (_numeric_is_nan = Module["_numeric_is_nan"] = wasmExports["numeric_is_nan"])(a0);
        var _get_attname = Module["_get_attname"] = (a0, a1, a22) => (_get_attname = Module["_get_attname"] = wasmExports["get_attname"])(a0, a1, a22);
        var _pg_get_indexdef_columns_extended = Module["_pg_get_indexdef_columns_extended"] = (a0, a1) => (_pg_get_indexdef_columns_extended = Module["_pg_get_indexdef_columns_extended"] = wasmExports["pg_get_indexdef_columns_extended"])(a0, a1);
        var _RelationIsVisible = Module["_RelationIsVisible"] = (a0) => (_RelationIsVisible = Module["_RelationIsVisible"] = wasmExports["RelationIsVisible"])(a0);
        var _exprIsLengthCoercion = Module["_exprIsLengthCoercion"] = (a0, a1) => (_exprIsLengthCoercion = Module["_exprIsLengthCoercion"] = wasmExports["exprIsLengthCoercion"])(a0, a1);
        var _get_sortgroupref_tle = Module["_get_sortgroupref_tle"] = (a0, a1) => (_get_sortgroupref_tle = Module["_get_sortgroupref_tle"] = wasmExports["get_sortgroupref_tle"])(a0, a1);
        var _strrchr = Module["_strrchr"] = (a0, a1) => (_strrchr = Module["_strrchr"] = wasmExports["strrchr"])(a0, a1);
        var _get_rel_relispartition = Module["_get_rel_relispartition"] = (a0) => (_get_rel_relispartition = Module["_get_rel_relispartition"] = wasmExports["get_rel_relispartition"])(a0);
        var _scanner_isspace = Module["_scanner_isspace"] = (a0) => (_scanner_isspace = Module["_scanner_isspace"] = wasmExports["scanner_isspace"])(a0);
        var _varstr_levenshtein = Module["_varstr_levenshtein"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_varstr_levenshtein = Module["_varstr_levenshtein"] = wasmExports["varstr_levenshtein"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _varstr_levenshtein_less_equal = Module["_varstr_levenshtein_less_equal"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82) => (_varstr_levenshtein_less_equal = Module["_varstr_levenshtein_less_equal"] = wasmExports["varstr_levenshtein_less_equal"])(a0, a1, a22, a32, a42, a52, a62, a72, a82);
        var _utf8_to_unicode = Module["_utf8_to_unicode"] = (a0) => (_utf8_to_unicode = Module["_utf8_to_unicode"] = wasmExports["utf8_to_unicode"])(a0);
        var _unpack_sql_state = Module["_unpack_sql_state"] = (a0) => (_unpack_sql_state = Module["_unpack_sql_state"] = wasmExports["unpack_sql_state"])(a0);
        var _get_role_oid = Module["_get_role_oid"] = (a0, a1) => (_get_role_oid = Module["_get_role_oid"] = wasmExports["get_role_oid"])(a0, a1);
        var _NameListToString = Module["_NameListToString"] = (a0) => (_NameListToString = Module["_NameListToString"] = wasmExports["NameListToString"])(a0);
        var _get_collation_oid = Module["_get_collation_oid"] = (a0, a1) => (_get_collation_oid = Module["_get_collation_oid"] = wasmExports["get_collation_oid"])(a0, a1);
        var _path_is_prefix_of_path = Module["_path_is_prefix_of_path"] = (a0, a1) => (_path_is_prefix_of_path = Module["_path_is_prefix_of_path"] = wasmExports["path_is_prefix_of_path"])(a0, a1);
        var _path_is_relative_and_below_cwd = Module["_path_is_relative_and_below_cwd"] = (a0) => (_path_is_relative_and_below_cwd = Module["_path_is_relative_and_below_cwd"] = wasmExports["path_is_relative_and_below_cwd"])(a0);
        var _setenv = Module["_setenv"] = (a0, a1, a22) => (_setenv = Module["_setenv"] = wasmExports["setenv"])(a0, a1, a22);
        var _pg_get_encoding_from_locale = Module["_pg_get_encoding_from_locale"] = (a0, a1) => (_pg_get_encoding_from_locale = Module["_pg_get_encoding_from_locale"] = wasmExports["pg_get_encoding_from_locale"])(a0, a1);
        var _localtime = Module["_localtime"] = (a0) => (_localtime = Module["_localtime"] = wasmExports["localtime"])(a0);
        var _strftime = Module["_strftime"] = (a0, a1, a22, a32) => (_strftime = Module["_strftime"] = wasmExports["strftime"])(a0, a1, a22, a32);
        var _get_extension_oid = Module["_get_extension_oid"] = (a0, a1) => (_get_extension_oid = Module["_get_extension_oid"] = wasmExports["get_extension_oid"])(a0, a1);
        var _IsValidJsonNumber = Module["_IsValidJsonNumber"] = (a0, a1) => (_IsValidJsonNumber = Module["_IsValidJsonNumber"] = wasmExports["IsValidJsonNumber"])(a0, a1);
        var _strlcat = Module["_strlcat"] = (a0, a1, a22) => (_strlcat = Module["_strlcat"] = wasmExports["strlcat"])(a0, a1, a22);
        var _pg_bindtextdomain = Module["_pg_bindtextdomain"] = (a0) => (_pg_bindtextdomain = Module["_pg_bindtextdomain"] = wasmExports["pg_bindtextdomain"])(a0);
        var _CacheRegisterRelcacheCallback = Module["_CacheRegisterRelcacheCallback"] = (a0, a1) => (_CacheRegisterRelcacheCallback = Module["_CacheRegisterRelcacheCallback"] = wasmExports["CacheRegisterRelcacheCallback"])(a0, a1);
        var _CachedPlanAllowsSimpleValidityCheck = Module["_CachedPlanAllowsSimpleValidityCheck"] = (a0, a1, a22) => (_CachedPlanAllowsSimpleValidityCheck = Module["_CachedPlanAllowsSimpleValidityCheck"] = wasmExports["CachedPlanAllowsSimpleValidityCheck"])(a0, a1, a22);
        var _CachedPlanIsSimplyValid = Module["_CachedPlanIsSimplyValid"] = (a0, a1, a22) => (_CachedPlanIsSimplyValid = Module["_CachedPlanIsSimplyValid"] = wasmExports["CachedPlanIsSimplyValid"])(a0, a1, a22);
        var _GetCachedExpression = Module["_GetCachedExpression"] = (a0) => (_GetCachedExpression = Module["_GetCachedExpression"] = wasmExports["GetCachedExpression"])(a0);
        var _FreeCachedExpression = Module["_FreeCachedExpression"] = (a0) => (_FreeCachedExpression = Module["_FreeCachedExpression"] = wasmExports["FreeCachedExpression"])(a0);
        var _SearchSysCacheAttName = Module["_SearchSysCacheAttName"] = (a0, a1) => (_SearchSysCacheAttName = Module["_SearchSysCacheAttName"] = wasmExports["SearchSysCacheAttName"])(a0, a1);
        var _get_func_namespace = Module["_get_func_namespace"] = (a0) => (_get_func_namespace = Module["_get_func_namespace"] = wasmExports["get_func_namespace"])(a0);
        var _get_rel_type_id = Module["_get_rel_type_id"] = (a0) => (_get_rel_type_id = Module["_get_rel_type_id"] = wasmExports["get_rel_type_id"])(a0);
        var _get_typsubscript = Module["_get_typsubscript"] = (a0, a1) => (_get_typsubscript = Module["_get_typsubscript"] = wasmExports["get_typsubscript"])(a0, a1);
        var _is_publishable_relation = Module["_is_publishable_relation"] = (a0) => (_is_publishable_relation = Module["_is_publishable_relation"] = wasmExports["is_publishable_relation"])(a0);
        var _GetRelationPublications = Module["_GetRelationPublications"] = (a0) => (_GetRelationPublications = Module["_GetRelationPublications"] = wasmExports["GetRelationPublications"])(a0);
        var _GetSchemaPublications = Module["_GetSchemaPublications"] = (a0) => (_GetSchemaPublications = Module["_GetSchemaPublications"] = wasmExports["GetSchemaPublications"])(a0);
        var _in_error_recursion_trouble = Module["_in_error_recursion_trouble"] = () => (_in_error_recursion_trouble = Module["_in_error_recursion_trouble"] = wasmExports["in_error_recursion_trouble"])();
        var _getinternalerrposition = Module["_getinternalerrposition"] = () => (_getinternalerrposition = Module["_getinternalerrposition"] = wasmExports["getinternalerrposition"])();
        var _FreeErrorData = Module["_FreeErrorData"] = (a0) => (_FreeErrorData = Module["_FreeErrorData"] = wasmExports["FreeErrorData"])(a0);
        var _GetErrorContextStack = Module["_GetErrorContextStack"] = () => (_GetErrorContextStack = Module["_GetErrorContextStack"] = wasmExports["GetErrorContextStack"])();
        var _scanner_init = Module["_scanner_init"] = (a0, a1, a22, a32) => (_scanner_init = Module["_scanner_init"] = wasmExports["scanner_init"])(a0, a1, a22, a32);
        var _scanner_finish = Module["_scanner_finish"] = (a0) => (_scanner_finish = Module["_scanner_finish"] = wasmExports["scanner_finish"])(a0);
        var _core_yylex = Module["_core_yylex"] = (a0, a1, a22) => (_core_yylex = Module["_core_yylex"] = wasmExports["core_yylex"])(a0, a1, a22);
        var _LookupTypeName = Module["_LookupTypeName"] = (a0, a1, a22, a32) => (_LookupTypeName = Module["_LookupTypeName"] = wasmExports["LookupTypeName"])(a0, a1, a22, a32);
        var _typeStringToTypeName = Module["_typeStringToTypeName"] = (a0, a1) => (_typeStringToTypeName = Module["_typeStringToTypeName"] = wasmExports["typeStringToTypeName"])(a0, a1);
        var _makeTypeNameFromNameList = Module["_makeTypeNameFromNameList"] = (a0) => (_makeTypeNameFromNameList = Module["_makeTypeNameFromNameList"] = wasmExports["makeTypeNameFromNameList"])(a0);
        var _makeBoolean = Module["_makeBoolean"] = (a0) => (_makeBoolean = Module["_makeBoolean"] = wasmExports["makeBoolean"])(a0);
        var _makeInteger = Module["_makeInteger"] = (a0) => (_makeInteger = Module["_makeInteger"] = wasmExports["makeInteger"])(a0);
        var _makeTypeName = Module["_makeTypeName"] = (a0) => (_makeTypeName = Module["_makeTypeName"] = wasmExports["makeTypeName"])(a0);
        var _list_make4_impl = Module["_list_make4_impl"] = (a0, a1, a22, a32, a42) => (_list_make4_impl = Module["_list_make4_impl"] = wasmExports["list_make4_impl"])(a0, a1, a22, a32, a42);
        var _list_member = Module["_list_member"] = (a0, a1) => (_list_member = Module["_list_member"] = wasmExports["list_member"])(a0, a1);
        var _SignalHandlerForConfigReload = Module["_SignalHandlerForConfigReload"] = (a0) => (_SignalHandlerForConfigReload = Module["_SignalHandlerForConfigReload"] = wasmExports["SignalHandlerForConfigReload"])(a0);
        var _SignalHandlerForShutdownRequest = Module["_SignalHandlerForShutdownRequest"] = (a0) => (_SignalHandlerForShutdownRequest = Module["_SignalHandlerForShutdownRequest"] = wasmExports["SignalHandlerForShutdownRequest"])(a0);
        var _send = Module["_send"] = (a0, a1, a22, a32) => (_send = Module["_send"] = wasmExports["send"])(a0, a1, a22, a32);
        var _gai_strerror = Module["_gai_strerror"] = (a0) => (_gai_strerror = Module["_gai_strerror"] = wasmExports["gai_strerror"])(a0);
        var _RegisterBackgroundWorker = Module["_RegisterBackgroundWorker"] = (a0) => (_RegisterBackgroundWorker = Module["_RegisterBackgroundWorker"] = wasmExports["RegisterBackgroundWorker"])(a0);
        var _WaitForBackgroundWorkerStartup = Module["_WaitForBackgroundWorkerStartup"] = (a0, a1) => (_WaitForBackgroundWorkerStartup = Module["_WaitForBackgroundWorkerStartup"] = wasmExports["WaitForBackgroundWorkerStartup"])(a0, a1);
        var _pg_initdb = Module["_pg_initdb"] = () => (_pg_initdb = Module["_pg_initdb"] = wasmExports["pg_initdb"])();
        var _pg_initdb_main = Module["_pg_initdb_main"] = () => (_pg_initdb_main = Module["_pg_initdb_main"] = wasmExports["pg_initdb_main"])();
        var ___cxa_throw = Module["___cxa_throw"] = (a0, a1, a22) => (___cxa_throw = Module["___cxa_throw"] = wasmExports["__cxa_throw"])(a0, a1, a22);
        var _main_repl = Module["_main_repl"] = () => (_main_repl = Module["_main_repl"] = wasmExports["main_repl"])();
        var _main = Module["_main"] = (a0, a1) => (_main = Module["_main"] = wasmExports["__main_argc_argv"])(a0, a1);
        var _list_make5_impl = Module["_list_make5_impl"] = (a0, a1, a22, a32, a42, a52) => (_list_make5_impl = Module["_list_make5_impl"] = wasmExports["list_make5_impl"])(a0, a1, a22, a32, a42, a52);
        var _lappend_xid = Module["_lappend_xid"] = (a0, a1) => (_lappend_xid = Module["_lappend_xid"] = wasmExports["lappend_xid"])(a0, a1);
        var _list_member_ptr = Module["_list_member_ptr"] = (a0, a1) => (_list_member_ptr = Module["_list_member_ptr"] = wasmExports["list_member_ptr"])(a0, a1);
        var _list_member_xid = Module["_list_member_xid"] = (a0, a1) => (_list_member_xid = Module["_list_member_xid"] = wasmExports["list_member_xid"])(a0, a1);
        var _list_append_unique_ptr = Module["_list_append_unique_ptr"] = (a0, a1) => (_list_append_unique_ptr = Module["_list_append_unique_ptr"] = wasmExports["list_append_unique_ptr"])(a0, a1);
        var _CleanQuerytext = Module["_CleanQuerytext"] = (a0, a1, a22) => (_CleanQuerytext = Module["_CleanQuerytext"] = wasmExports["CleanQuerytext"])(a0, a1, a22);
        var _EnableQueryId = Module["_EnableQueryId"] = () => (_EnableQueryId = Module["_EnableQueryId"] = wasmExports["EnableQueryId"])();
        var _make_orclause = Module["_make_orclause"] = (a0) => (_make_orclause = Module["_make_orclause"] = wasmExports["make_orclause"])(a0);
        var _join_clause_is_movable_to = Module["_join_clause_is_movable_to"] = (a0, a1) => (_join_clause_is_movable_to = Module["_join_clause_is_movable_to"] = wasmExports["join_clause_is_movable_to"])(a0, a1);
        var _make_restrictinfo = Module["_make_restrictinfo"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9) => (_make_restrictinfo = Module["_make_restrictinfo"] = wasmExports["make_restrictinfo"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9);
        var _get_plan_rowmark = Module["_get_plan_rowmark"] = (a0, a1) => (_get_plan_rowmark = Module["_get_plan_rowmark"] = wasmExports["get_plan_rowmark"])(a0, a1);
        var _add_row_identity_var = Module["_add_row_identity_var"] = (a0, a1, a22, a32) => (_add_row_identity_var = Module["_add_row_identity_var"] = wasmExports["add_row_identity_var"])(a0, a1, a22, a32);
        var _get_rel_all_updated_cols = Module["_get_rel_all_updated_cols"] = (a0, a1) => (_get_rel_all_updated_cols = Module["_get_rel_all_updated_cols"] = wasmExports["get_rel_all_updated_cols"])(a0, a1);
        var _get_baserel_parampathinfo = Module["_get_baserel_parampathinfo"] = (a0, a1, a22) => (_get_baserel_parampathinfo = Module["_get_baserel_parampathinfo"] = wasmExports["get_baserel_parampathinfo"])(a0, a1, a22);
        var _tlist_member = Module["_tlist_member"] = (a0, a1) => (_tlist_member = Module["_tlist_member"] = wasmExports["tlist_member"])(a0, a1);
        var _add_to_flat_tlist = Module["_add_to_flat_tlist"] = (a0, a1) => (_add_to_flat_tlist = Module["_add_to_flat_tlist"] = wasmExports["add_to_flat_tlist"])(a0, a1);
        var _get_sortgrouplist_exprs = Module["_get_sortgrouplist_exprs"] = (a0, a1) => (_get_sortgrouplist_exprs = Module["_get_sortgrouplist_exprs"] = wasmExports["get_sortgrouplist_exprs"])(a0, a1);
        var _get_sortgroupref_clause_noerr = Module["_get_sortgroupref_clause_noerr"] = (a0, a1) => (_get_sortgroupref_clause_noerr = Module["_get_sortgroupref_clause_noerr"] = wasmExports["get_sortgroupref_clause_noerr"])(a0, a1);
        var _grouping_is_sortable = Module["_grouping_is_sortable"] = (a0) => (_grouping_is_sortable = Module["_grouping_is_sortable"] = wasmExports["grouping_is_sortable"])(a0);
        var _copy_pathtarget = Module["_copy_pathtarget"] = (a0) => (_copy_pathtarget = Module["_copy_pathtarget"] = wasmExports["copy_pathtarget"])(a0);
        var _add_new_columns_to_pathtarget = Module["_add_new_columns_to_pathtarget"] = (a0, a1) => (_add_new_columns_to_pathtarget = Module["_add_new_columns_to_pathtarget"] = wasmExports["add_new_columns_to_pathtarget"])(a0, a1);
        var _get_translated_update_targetlist = Module["_get_translated_update_targetlist"] = (a0, a1, a22, a32) => (_get_translated_update_targetlist = Module["_get_translated_update_targetlist"] = wasmExports["get_translated_update_targetlist"])(a0, a1, a22, a32);
        var _contain_mutable_functions = Module["_contain_mutable_functions"] = (a0) => (_contain_mutable_functions = Module["_contain_mutable_functions"] = wasmExports["contain_mutable_functions"])(a0);
        var _cost_qual_eval = Module["_cost_qual_eval"] = (a0, a1, a22) => (_cost_qual_eval = Module["_cost_qual_eval"] = wasmExports["cost_qual_eval"])(a0, a1, a22);
        var _add_path = Module["_add_path"] = (a0, a1) => (_add_path = Module["_add_path"] = wasmExports["add_path"])(a0, a1);
        var _pathkeys_contained_in = Module["_pathkeys_contained_in"] = (a0, a1) => (_pathkeys_contained_in = Module["_pathkeys_contained_in"] = wasmExports["pathkeys_contained_in"])(a0, a1);
        var _cost_sort = Module["_cost_sort"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82) => (_cost_sort = Module["_cost_sort"] = wasmExports["cost_sort"])(a0, a1, a22, a32, a42, a52, a62, a72, a82);
        var _create_foreignscan_path = Module["_create_foreignscan_path"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9) => (_create_foreignscan_path = Module["_create_foreignscan_path"] = wasmExports["create_foreignscan_path"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9);
        var _create_foreign_join_path = Module["_create_foreign_join_path"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82, a9) => (_create_foreign_join_path = Module["_create_foreign_join_path"] = wasmExports["create_foreign_join_path"])(a0, a1, a22, a32, a42, a52, a62, a72, a82, a9);
        var _create_foreign_upper_path = Module["_create_foreign_upper_path"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82) => (_create_foreign_upper_path = Module["_create_foreign_upper_path"] = wasmExports["create_foreign_upper_path"])(a0, a1, a22, a32, a42, a52, a62, a72, a82);
        var _create_projection_path = Module["_create_projection_path"] = (a0, a1, a22, a32) => (_create_projection_path = Module["_create_projection_path"] = wasmExports["create_projection_path"])(a0, a1, a22, a32);
        var _create_sort_path = Module["_create_sort_path"] = (a0, a1, a22, a32, a42) => (_create_sort_path = Module["_create_sort_path"] = wasmExports["create_sort_path"])(a0, a1, a22, a32, a42);
        var _adjust_limit_rows_costs = Module["_adjust_limit_rows_costs"] = (a0, a1, a22, a32, a42) => (_adjust_limit_rows_costs = Module["_adjust_limit_rows_costs"] = wasmExports["adjust_limit_rows_costs"])(a0, a1, a22, a32, a42);
        var _extract_actual_clauses = Module["_extract_actual_clauses"] = (a0, a1) => (_extract_actual_clauses = Module["_extract_actual_clauses"] = wasmExports["extract_actual_clauses"])(a0, a1);
        var _get_agg_clause_costs = Module["_get_agg_clause_costs"] = (a0, a1, a22) => (_get_agg_clause_costs = Module["_get_agg_clause_costs"] = wasmExports["get_agg_clause_costs"])(a0, a1, a22);
        var _update_mergeclause_eclasses = Module["_update_mergeclause_eclasses"] = (a0, a1) => (_update_mergeclause_eclasses = Module["_update_mergeclause_eclasses"] = wasmExports["update_mergeclause_eclasses"])(a0, a1);
        var _set_baserel_size_estimates = Module["_set_baserel_size_estimates"] = (a0, a1) => (_set_baserel_size_estimates = Module["_set_baserel_size_estimates"] = wasmExports["set_baserel_size_estimates"])(a0, a1);
        var _make_canonical_pathkey = Module["_make_canonical_pathkey"] = (a0, a1, a22, a32, a42) => (_make_canonical_pathkey = Module["_make_canonical_pathkey"] = wasmExports["make_canonical_pathkey"])(a0, a1, a22, a32, a42);
        var _eclass_useful_for_merging = Module["_eclass_useful_for_merging"] = (a0, a1, a22) => (_eclass_useful_for_merging = Module["_eclass_useful_for_merging"] = wasmExports["eclass_useful_for_merging"])(a0, a1, a22);
        var _generate_implied_equalities_for_column = Module["_generate_implied_equalities_for_column"] = (a0, a1, a22, a32, a42) => (_generate_implied_equalities_for_column = Module["_generate_implied_equalities_for_column"] = wasmExports["generate_implied_equalities_for_column"])(a0, a1, a22, a32, a42);
        var _standard_planner = Module["_standard_planner"] = (a0, a1, a22, a32) => (_standard_planner = Module["_standard_planner"] = wasmExports["standard_planner"])(a0, a1, a22, a32);
        var _plan_create_index_workers = Module["_plan_create_index_workers"] = (a0, a1) => (_plan_create_index_workers = Module["_plan_create_index_workers"] = wasmExports["plan_create_index_workers"])(a0, a1);
        var _change_plan_targetlist = Module["_change_plan_targetlist"] = (a0, a1, a22) => (_change_plan_targetlist = Module["_change_plan_targetlist"] = wasmExports["change_plan_targetlist"])(a0, a1, a22);
        var _make_foreignscan = Module["_make_foreignscan"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_make_foreignscan = Module["_make_foreignscan"] = wasmExports["make_foreignscan"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _BeginCopyFrom = Module["_BeginCopyFrom"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_BeginCopyFrom = Module["_BeginCopyFrom"] = wasmExports["BeginCopyFrom"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _EndCopyFrom = Module["_EndCopyFrom"] = (a0) => (_EndCopyFrom = Module["_EndCopyFrom"] = wasmExports["EndCopyFrom"])(a0);
        var _ProcessCopyOptions = Module["_ProcessCopyOptions"] = (a0, a1, a22, a32) => (_ProcessCopyOptions = Module["_ProcessCopyOptions"] = wasmExports["ProcessCopyOptions"])(a0, a1, a22, a32);
        var _NextCopyFrom = Module["_NextCopyFrom"] = (a0, a1, a22, a32) => (_NextCopyFrom = Module["_NextCopyFrom"] = wasmExports["NextCopyFrom"])(a0, a1, a22, a32);
        var _defGetStreamingMode = Module["_defGetStreamingMode"] = (a0) => (_defGetStreamingMode = Module["_defGetStreamingMode"] = wasmExports["defGetStreamingMode"])(a0);
        var _plain_crypt_verify = Module["_plain_crypt_verify"] = (a0, a1, a22, a32) => (_plain_crypt_verify = Module["_plain_crypt_verify"] = wasmExports["plain_crypt_verify"])(a0, a1, a22, a32);
        var _getExtensionOfObject = Module["_getExtensionOfObject"] = (a0, a1) => (_getExtensionOfObject = Module["_getExtensionOfObject"] = wasmExports["getExtensionOfObject"])(a0, a1);
        var _nextval = Module["_nextval"] = (a0) => (_nextval = Module["_nextval"] = wasmExports["nextval"])(a0);
        var _CopyFromErrorCallback = Module["_CopyFromErrorCallback"] = (a0) => (_CopyFromErrorCallback = Module["_CopyFromErrorCallback"] = wasmExports["CopyFromErrorCallback"])(a0);
        var _GetTopMostAncestorInPublication = Module["_GetTopMostAncestorInPublication"] = (a0, a1, a22) => (_GetTopMostAncestorInPublication = Module["_GetTopMostAncestorInPublication"] = wasmExports["GetTopMostAncestorInPublication"])(a0, a1, a22);
        var _pub_collist_to_bitmapset = Module["_pub_collist_to_bitmapset"] = (a0, a1, a22) => (_pub_collist_to_bitmapset = Module["_pub_collist_to_bitmapset"] = wasmExports["pub_collist_to_bitmapset"])(a0, a1, a22);
        var _ExplainBeginOutput = Module["_ExplainBeginOutput"] = (a0) => (_ExplainBeginOutput = Module["_ExplainBeginOutput"] = wasmExports["ExplainBeginOutput"])(a0);
        var _NewExplainState = Module["_NewExplainState"] = () => (_NewExplainState = Module["_NewExplainState"] = wasmExports["NewExplainState"])();
        var _ExplainEndOutput = Module["_ExplainEndOutput"] = (a0) => (_ExplainEndOutput = Module["_ExplainEndOutput"] = wasmExports["ExplainEndOutput"])(a0);
        var _ExplainPrintPlan = Module["_ExplainPrintPlan"] = (a0, a1) => (_ExplainPrintPlan = Module["_ExplainPrintPlan"] = wasmExports["ExplainPrintPlan"])(a0, a1);
        var _ExplainPrintTriggers = Module["_ExplainPrintTriggers"] = (a0, a1) => (_ExplainPrintTriggers = Module["_ExplainPrintTriggers"] = wasmExports["ExplainPrintTriggers"])(a0, a1);
        var _ExplainPrintJITSummary = Module["_ExplainPrintJITSummary"] = (a0, a1) => (_ExplainPrintJITSummary = Module["_ExplainPrintJITSummary"] = wasmExports["ExplainPrintJITSummary"])(a0, a1);
        var _ExplainPropertyInteger = Module["_ExplainPropertyInteger"] = (a0, a1, a22, a32) => (_ExplainPropertyInteger = Module["_ExplainPropertyInteger"] = wasmExports["ExplainPropertyInteger"])(a0, a1, a22, a32);
        var _ExplainQueryText = Module["_ExplainQueryText"] = (a0, a1) => (_ExplainQueryText = Module["_ExplainQueryText"] = wasmExports["ExplainQueryText"])(a0, a1);
        var _ExplainPropertyText = Module["_ExplainPropertyText"] = (a0, a1, a22) => (_ExplainPropertyText = Module["_ExplainPropertyText"] = wasmExports["ExplainPropertyText"])(a0, a1, a22);
        var _ExplainQueryParameters = Module["_ExplainQueryParameters"] = (a0, a1, a22) => (_ExplainQueryParameters = Module["_ExplainQueryParameters"] = wasmExports["ExplainQueryParameters"])(a0, a1, a22);
        var _pg_is_ascii = Module["_pg_is_ascii"] = (a0) => (_pg_is_ascii = Module["_pg_is_ascii"] = wasmExports["pg_is_ascii"])(a0);
        var _pg_md5_encrypt = Module["_pg_md5_encrypt"] = (a0, a1, a22, a32, a42) => (_pg_md5_encrypt = Module["_pg_md5_encrypt"] = wasmExports["pg_md5_encrypt"])(a0, a1, a22, a32, a42);
        var _explicit_bzero = Module["_explicit_bzero"] = (a0, a1) => (_explicit_bzero = Module["_explicit_bzero"] = wasmExports["explicit_bzero"])(a0, a1);
        var _pg_strip_crlf = Module["_pg_strip_crlf"] = (a0) => (_pg_strip_crlf = Module["_pg_strip_crlf"] = wasmExports["pg_strip_crlf"])(a0);
        var _recv = Module["_recv"] = (a0, a1, a22, a32) => (_recv = Module["_recv"] = wasmExports["recv"])(a0, a1, a22, a32);
        var _pg_getaddrinfo_all = Module["_pg_getaddrinfo_all"] = (a0, a1, a22, a32) => (_pg_getaddrinfo_all = Module["_pg_getaddrinfo_all"] = wasmExports["pg_getaddrinfo_all"])(a0, a1, a22, a32);
        var _pg_freeaddrinfo_all = Module["_pg_freeaddrinfo_all"] = (a0, a1) => (_pg_freeaddrinfo_all = Module["_pg_freeaddrinfo_all"] = wasmExports["pg_freeaddrinfo_all"])(a0, a1);
        var _sigemptyset = Module["_sigemptyset"] = (a0) => (_sigemptyset = Module["_sigemptyset"] = wasmExports["sigemptyset"])(a0);
        var _getpeereid = Module["_getpeereid"] = (a0, a1, a22) => (_getpeereid = Module["_getpeereid"] = wasmExports["getpeereid"])(a0, a1, a22);
        var _socket = Module["_socket"] = (a0, a1, a22) => (_socket = Module["_socket"] = wasmExports["socket"])(a0, a1, a22);
        var _connect = Module["_connect"] = (a0, a1, a22) => (_connect = Module["_connect"] = wasmExports["connect"])(a0, a1, a22);
        var _setsockopt = Module["_setsockopt"] = (a0, a1, a22, a32, a42) => (_setsockopt = Module["_setsockopt"] = wasmExports["setsockopt"])(a0, a1, a22, a32, a42);
        var _getsockname = Module["_getsockname"] = (a0, a1, a22) => (_getsockname = Module["_getsockname"] = wasmExports["getsockname"])(a0, a1, a22);
        var _getsockopt = Module["_getsockopt"] = (a0, a1, a22, a32, a42) => (_getsockopt = Module["_getsockopt"] = wasmExports["getsockopt"])(a0, a1, a22, a32, a42);
        var _pg_b64_enc_len = Module["_pg_b64_enc_len"] = (a0) => (_pg_b64_enc_len = Module["_pg_b64_enc_len"] = wasmExports["pg_b64_enc_len"])(a0);
        var _pg_b64_encode = Module["_pg_b64_encode"] = (a0, a1, a22, a32) => (_pg_b64_encode = Module["_pg_b64_encode"] = wasmExports["pg_b64_encode"])(a0, a1, a22, a32);
        var _pg_b64_dec_len = Module["_pg_b64_dec_len"] = (a0) => (_pg_b64_dec_len = Module["_pg_b64_dec_len"] = wasmExports["pg_b64_dec_len"])(a0);
        var _pg_b64_decode = Module["_pg_b64_decode"] = (a0, a1, a22, a32) => (_pg_b64_decode = Module["_pg_b64_decode"] = wasmExports["pg_b64_decode"])(a0, a1, a22, a32);
        var _pg_hmac_create = Module["_pg_hmac_create"] = (a0) => (_pg_hmac_create = Module["_pg_hmac_create"] = wasmExports["pg_hmac_create"])(a0);
        var _pg_hmac_init = Module["_pg_hmac_init"] = (a0, a1, a22) => (_pg_hmac_init = Module["_pg_hmac_init"] = wasmExports["pg_hmac_init"])(a0, a1, a22);
        var _pg_hmac_update = Module["_pg_hmac_update"] = (a0, a1, a22) => (_pg_hmac_update = Module["_pg_hmac_update"] = wasmExports["pg_hmac_update"])(a0, a1, a22);
        var _pg_hmac_final = Module["_pg_hmac_final"] = (a0, a1, a22) => (_pg_hmac_final = Module["_pg_hmac_final"] = wasmExports["pg_hmac_final"])(a0, a1, a22);
        var _pg_hmac_error = Module["_pg_hmac_error"] = (a0) => (_pg_hmac_error = Module["_pg_hmac_error"] = wasmExports["pg_hmac_error"])(a0);
        var _scram_H = Module["_scram_H"] = (a0, a1, a22, a32, a42) => (_scram_H = Module["_scram_H"] = wasmExports["scram_H"])(a0, a1, a22, a32, a42);
        var _pg_saslprep = Module["_pg_saslprep"] = (a0, a1) => (_pg_saslprep = Module["_pg_saslprep"] = wasmExports["pg_saslprep"])(a0, a1);
        var _scram_build_secret = Module["_scram_build_secret"] = (a0, a1, a22, a32, a42, a52, a62) => (_scram_build_secret = Module["_scram_build_secret"] = wasmExports["scram_build_secret"])(a0, a1, a22, a32, a42, a52, a62);
        var _scram_SaltedPassword = Module["_scram_SaltedPassword"] = (a0, a1, a22, a32, a42, a52, a62, a72) => (_scram_SaltedPassword = Module["_scram_SaltedPassword"] = wasmExports["scram_SaltedPassword"])(a0, a1, a22, a32, a42, a52, a62, a72);
        var _scram_ServerKey = Module["_scram_ServerKey"] = (a0, a1, a22, a32, a42) => (_scram_ServerKey = Module["_scram_ServerKey"] = wasmExports["scram_ServerKey"])(a0, a1, a22, a32, a42);
        var _logicalrep_write_begin = Module["_logicalrep_write_begin"] = (a0, a1) => (_logicalrep_write_begin = Module["_logicalrep_write_begin"] = wasmExports["logicalrep_write_begin"])(a0, a1);
        var _logicalrep_write_commit = Module["_logicalrep_write_commit"] = (a0, a1, a22) => (_logicalrep_write_commit = Module["_logicalrep_write_commit"] = wasmExports["logicalrep_write_commit"])(a0, a1, a22);
        var _logicalrep_write_begin_prepare = Module["_logicalrep_write_begin_prepare"] = (a0, a1) => (_logicalrep_write_begin_prepare = Module["_logicalrep_write_begin_prepare"] = wasmExports["logicalrep_write_begin_prepare"])(a0, a1);
        var _logicalrep_write_prepare = Module["_logicalrep_write_prepare"] = (a0, a1, a22) => (_logicalrep_write_prepare = Module["_logicalrep_write_prepare"] = wasmExports["logicalrep_write_prepare"])(a0, a1, a22);
        var _logicalrep_write_commit_prepared = Module["_logicalrep_write_commit_prepared"] = (a0, a1, a22) => (_logicalrep_write_commit_prepared = Module["_logicalrep_write_commit_prepared"] = wasmExports["logicalrep_write_commit_prepared"])(a0, a1, a22);
        var _logicalrep_write_rollback_prepared = Module["_logicalrep_write_rollback_prepared"] = (a0, a1, a22, a32) => (_logicalrep_write_rollback_prepared = Module["_logicalrep_write_rollback_prepared"] = wasmExports["logicalrep_write_rollback_prepared"])(a0, a1, a22, a32);
        var _logicalrep_write_stream_prepare = Module["_logicalrep_write_stream_prepare"] = (a0, a1, a22) => (_logicalrep_write_stream_prepare = Module["_logicalrep_write_stream_prepare"] = wasmExports["logicalrep_write_stream_prepare"])(a0, a1, a22);
        var _logicalrep_write_origin = Module["_logicalrep_write_origin"] = (a0, a1, a22) => (_logicalrep_write_origin = Module["_logicalrep_write_origin"] = wasmExports["logicalrep_write_origin"])(a0, a1, a22);
        var _logicalrep_write_insert = Module["_logicalrep_write_insert"] = (a0, a1, a22, a32, a42, a52) => (_logicalrep_write_insert = Module["_logicalrep_write_insert"] = wasmExports["logicalrep_write_insert"])(a0, a1, a22, a32, a42, a52);
        var _logicalrep_write_update = Module["_logicalrep_write_update"] = (a0, a1, a22, a32, a42, a52, a62) => (_logicalrep_write_update = Module["_logicalrep_write_update"] = wasmExports["logicalrep_write_update"])(a0, a1, a22, a32, a42, a52, a62);
        var _logicalrep_write_delete = Module["_logicalrep_write_delete"] = (a0, a1, a22, a32, a42, a52) => (_logicalrep_write_delete = Module["_logicalrep_write_delete"] = wasmExports["logicalrep_write_delete"])(a0, a1, a22, a32, a42, a52);
        var _logicalrep_write_truncate = Module["_logicalrep_write_truncate"] = (a0, a1, a22, a32, a42, a52) => (_logicalrep_write_truncate = Module["_logicalrep_write_truncate"] = wasmExports["logicalrep_write_truncate"])(a0, a1, a22, a32, a42, a52);
        var _logicalrep_write_message = Module["_logicalrep_write_message"] = (a0, a1, a22, a32, a42, a52, a62) => (_logicalrep_write_message = Module["_logicalrep_write_message"] = wasmExports["logicalrep_write_message"])(a0, a1, a22, a32, a42, a52, a62);
        var _logicalrep_write_rel = Module["_logicalrep_write_rel"] = (a0, a1, a22, a32) => (_logicalrep_write_rel = Module["_logicalrep_write_rel"] = wasmExports["logicalrep_write_rel"])(a0, a1, a22, a32);
        var _logicalrep_write_typ = Module["_logicalrep_write_typ"] = (a0, a1, a22) => (_logicalrep_write_typ = Module["_logicalrep_write_typ"] = wasmExports["logicalrep_write_typ"])(a0, a1, a22);
        var _logicalrep_write_stream_start = Module["_logicalrep_write_stream_start"] = (a0, a1, a22) => (_logicalrep_write_stream_start = Module["_logicalrep_write_stream_start"] = wasmExports["logicalrep_write_stream_start"])(a0, a1, a22);
        var _logicalrep_write_stream_stop = Module["_logicalrep_write_stream_stop"] = (a0) => (_logicalrep_write_stream_stop = Module["_logicalrep_write_stream_stop"] = wasmExports["logicalrep_write_stream_stop"])(a0);
        var _logicalrep_write_stream_commit = Module["_logicalrep_write_stream_commit"] = (a0, a1, a22) => (_logicalrep_write_stream_commit = Module["_logicalrep_write_stream_commit"] = wasmExports["logicalrep_write_stream_commit"])(a0, a1, a22);
        var _logicalrep_write_stream_abort = Module["_logicalrep_write_stream_abort"] = (a0, a1, a22, a32, a42, a52) => (_logicalrep_write_stream_abort = Module["_logicalrep_write_stream_abort"] = wasmExports["logicalrep_write_stream_abort"])(a0, a1, a22, a32, a42, a52);
        var _OutputPluginPrepareWrite = Module["_OutputPluginPrepareWrite"] = (a0, a1) => (_OutputPluginPrepareWrite = Module["_OutputPluginPrepareWrite"] = wasmExports["OutputPluginPrepareWrite"])(a0, a1);
        var _OutputPluginWrite = Module["_OutputPluginWrite"] = (a0, a1) => (_OutputPluginWrite = Module["_OutputPluginWrite"] = wasmExports["OutputPluginWrite"])(a0, a1);
        var _OutputPluginUpdateProgress = Module["_OutputPluginUpdateProgress"] = (a0, a1) => (_OutputPluginUpdateProgress = Module["_OutputPluginUpdateProgress"] = wasmExports["OutputPluginUpdateProgress"])(a0, a1);
        var _replorigin_by_oid = Module["_replorigin_by_oid"] = (a0, a1, a22) => (_replorigin_by_oid = Module["_replorigin_by_oid"] = wasmExports["replorigin_by_oid"])(a0, a1, a22);
        var _ProcessWalRcvInterrupts = Module["_ProcessWalRcvInterrupts"] = () => (_ProcessWalRcvInterrupts = Module["_ProcessWalRcvInterrupts"] = wasmExports["ProcessWalRcvInterrupts"])();
        var _PQconnectStartParams = Module["_PQconnectStartParams"] = (a0, a1, a22) => (_PQconnectStartParams = Module["_PQconnectStartParams"] = wasmExports["PQconnectStartParams"])(a0, a1, a22);
        var _PQstatus = Module["_PQstatus"] = (a0) => (_PQstatus = Module["_PQstatus"] = wasmExports["PQstatus"])(a0);
        var _PQsocket = Module["_PQsocket"] = (a0) => (_PQsocket = Module["_PQsocket"] = wasmExports["PQsocket"])(a0);
        var _PQconnectPoll = Module["_PQconnectPoll"] = (a0) => (_PQconnectPoll = Module["_PQconnectPoll"] = wasmExports["PQconnectPoll"])(a0);
        var _PQconnectionUsedPassword = Module["_PQconnectionUsedPassword"] = (a0) => (_PQconnectionUsedPassword = Module["_PQconnectionUsedPassword"] = wasmExports["PQconnectionUsedPassword"])(a0);
        var _PQfinish = Module["_PQfinish"] = (a0) => (_PQfinish = Module["_PQfinish"] = wasmExports["PQfinish"])(a0);
        var _PQresultStatus = Module["_PQresultStatus"] = (a0) => (_PQresultStatus = Module["_PQresultStatus"] = wasmExports["PQresultStatus"])(a0);
        var _PQclear = Module["_PQclear"] = (a0) => (_PQclear = Module["_PQclear"] = wasmExports["PQclear"])(a0);
        var _PQerrorMessage = Module["_PQerrorMessage"] = (a0) => (_PQerrorMessage = Module["_PQerrorMessage"] = wasmExports["PQerrorMessage"])(a0);
        var _PQnfields = Module["_PQnfields"] = (a0) => (_PQnfields = Module["_PQnfields"] = wasmExports["PQnfields"])(a0);
        var _PQntuples = Module["_PQntuples"] = (a0) => (_PQntuples = Module["_PQntuples"] = wasmExports["PQntuples"])(a0);
        var _PQgetvalue = Module["_PQgetvalue"] = (a0, a1, a22) => (_PQgetvalue = Module["_PQgetvalue"] = wasmExports["PQgetvalue"])(a0, a1, a22);
        var _PQconsumeInput = Module["_PQconsumeInput"] = (a0) => (_PQconsumeInput = Module["_PQconsumeInput"] = wasmExports["PQconsumeInput"])(a0);
        var _PQgetisnull = Module["_PQgetisnull"] = (a0, a1, a22) => (_PQgetisnull = Module["_PQgetisnull"] = wasmExports["PQgetisnull"])(a0, a1, a22);
        var _PQresultErrorField = Module["_PQresultErrorField"] = (a0, a1) => (_PQresultErrorField = Module["_PQresultErrorField"] = wasmExports["PQresultErrorField"])(a0, a1);
        var _PQsendQuery = Module["_PQsendQuery"] = (a0, a1) => (_PQsendQuery = Module["_PQsendQuery"] = wasmExports["PQsendQuery"])(a0, a1);
        var _PQisBusy = Module["_PQisBusy"] = (a0) => (_PQisBusy = Module["_PQisBusy"] = wasmExports["PQisBusy"])(a0);
        var _PQgetResult = Module["_PQgetResult"] = (a0) => (_PQgetResult = Module["_PQgetResult"] = wasmExports["PQgetResult"])(a0);
        var _RelnameGetRelid = Module["_RelnameGetRelid"] = (a0) => (_RelnameGetRelid = Module["_RelnameGetRelid"] = wasmExports["RelnameGetRelid"])(a0);
        var _GetPublicationByName = Module["_GetPublicationByName"] = (a0, a1) => (_GetPublicationByName = Module["_GetPublicationByName"] = wasmExports["GetPublicationByName"])(a0, a1);
        var _function_parse_error_transpose = Module["_function_parse_error_transpose"] = (a0) => (_function_parse_error_transpose = Module["_function_parse_error_transpose"] = wasmExports["function_parse_error_transpose"])(a0);
        var _fputs = Module["_fputs"] = (a0, a1) => (_fputs = Module["_fputs"] = wasmExports["fputs"])(a0, a1);
        var _popen = Module["_popen"] = (a0, a1) => (_popen = Module["_popen"] = wasmExports["popen"])(a0, a1);
        var _float_to_shortest_decimal_bufn = Module["_float_to_shortest_decimal_bufn"] = (a0, a1) => (_float_to_shortest_decimal_bufn = Module["_float_to_shortest_decimal_bufn"] = wasmExports["float_to_shortest_decimal_bufn"])(a0, a1);
        var _pg_prng_uint64 = Module["_pg_prng_uint64"] = (a0) => (_pg_prng_uint64 = Module["_pg_prng_uint64"] = wasmExports["pg_prng_uint64"])(a0);
        var _scram_ClientKey = Module["_scram_ClientKey"] = (a0, a1, a22, a32, a42) => (_scram_ClientKey = Module["_scram_ClientKey"] = wasmExports["scram_ClientKey"])(a0, a1, a22, a32, a42);
        var _pg_encoding_dsplen = Module["_pg_encoding_dsplen"] = (a0, a1) => (_pg_encoding_dsplen = Module["_pg_encoding_dsplen"] = wasmExports["pg_encoding_dsplen"])(a0, a1);
        var _getcwd = Module["_getcwd"] = (a0, a1) => (_getcwd = Module["_getcwd"] = wasmExports["getcwd"])(a0, a1);
        var _pg_get_user_home_dir = Module["_pg_get_user_home_dir"] = (a0, a1, a22) => (_pg_get_user_home_dir = Module["_pg_get_user_home_dir"] = wasmExports["pg_get_user_home_dir"])(a0, a1, a22);
        var _nanosleep = Module["_nanosleep"] = (a0, a1) => (_nanosleep = Module["_nanosleep"] = wasmExports["nanosleep"])(a0, a1);
        var _snprintf = Module["_snprintf"] = (a0, a1, a22, a32) => (_snprintf = Module["_snprintf"] = wasmExports["snprintf"])(a0, a1, a22, a32);
        var _pg_strerror_r = Module["_pg_strerror_r"] = (a0, a1, a22) => (_pg_strerror_r = Module["_pg_strerror_r"] = wasmExports["pg_strerror_r"])(a0, a1, a22);
        var _pthread_mutex_lock = Module["_pthread_mutex_lock"] = (a0) => (_pthread_mutex_lock = Module["_pthread_mutex_lock"] = wasmExports["pthread_mutex_lock"])(a0);
        var _pthread_mutex_unlock = Module["_pthread_mutex_unlock"] = (a0) => (_pthread_mutex_unlock = Module["_pthread_mutex_unlock"] = wasmExports["pthread_mutex_unlock"])(a0);
        var _strncat = Module["_strncat"] = (a0, a1, a22) => (_strncat = Module["_strncat"] = wasmExports["strncat"])(a0, a1, a22);
        var _PQexec = Module["_PQexec"] = (a0, a1) => (_PQexec = Module["_PQexec"] = wasmExports["PQexec"])(a0, a1);
        var _PQsetSingleRowMode = Module["_PQsetSingleRowMode"] = (a0) => (_PQsetSingleRowMode = Module["_PQsetSingleRowMode"] = wasmExports["PQsetSingleRowMode"])(a0);
        var _PQcmdStatus = Module["_PQcmdStatus"] = (a0) => (_PQcmdStatus = Module["_PQcmdStatus"] = wasmExports["PQcmdStatus"])(a0);
        var _pthread_sigmask = Module["_pthread_sigmask"] = (a0, a1, a22) => (_pthread_sigmask = Module["_pthread_sigmask"] = wasmExports["pthread_sigmask"])(a0, a1, a22);
        var _sigismember = Module["_sigismember"] = (a0, a1) => (_sigismember = Module["_sigismember"] = wasmExports["sigismember"])(a0, a1);
        var _sigpending = Module["_sigpending"] = (a0) => (_sigpending = Module["_sigpending"] = wasmExports["sigpending"])(a0);
        var _sigwait = Module["_sigwait"] = (a0, a1) => (_sigwait = Module["_sigwait"] = wasmExports["sigwait"])(a0, a1);
        var _isolat1ToUTF8 = Module["_isolat1ToUTF8"] = (a0, a1, a22, a32) => (_isolat1ToUTF8 = Module["_isolat1ToUTF8"] = wasmExports["isolat1ToUTF8"])(a0, a1, a22, a32);
        var _UTF8Toisolat1 = Module["_UTF8Toisolat1"] = (a0, a1, a22, a32) => (_UTF8Toisolat1 = Module["_UTF8Toisolat1"] = wasmExports["UTF8Toisolat1"])(a0, a1, a22, a32);
        var _vfprintf = Module["_vfprintf"] = (a0, a1, a22) => (_vfprintf = Module["_vfprintf"] = wasmExports["vfprintf"])(a0, a1, a22);
        var _vsnprintf = Module["_vsnprintf"] = (a0, a1, a22, a32) => (_vsnprintf = Module["_vsnprintf"] = wasmExports["vsnprintf"])(a0, a1, a22, a32);
        var _xmlParserValidityWarning = Module["_xmlParserValidityWarning"] = (a0, a1, a22) => (_xmlParserValidityWarning = Module["_xmlParserValidityWarning"] = wasmExports["xmlParserValidityWarning"])(a0, a1, a22);
        var _xmlParserValidityError = Module["_xmlParserValidityError"] = (a0, a1, a22) => (_xmlParserValidityError = Module["_xmlParserValidityError"] = wasmExports["xmlParserValidityError"])(a0, a1, a22);
        var _xmlParserError = Module["_xmlParserError"] = (a0, a1, a22) => (_xmlParserError = Module["_xmlParserError"] = wasmExports["xmlParserError"])(a0, a1, a22);
        var _xmlParserWarning = Module["_xmlParserWarning"] = (a0, a1, a22) => (_xmlParserWarning = Module["_xmlParserWarning"] = wasmExports["xmlParserWarning"])(a0, a1, a22);
        var _fprintf = Module["_fprintf"] = (a0, a1, a22) => (_fprintf = Module["_fprintf"] = wasmExports["fprintf"])(a0, a1, a22);
        var ___xmlParserInputBufferCreateFilename = Module["___xmlParserInputBufferCreateFilename"] = (a0, a1) => (___xmlParserInputBufferCreateFilename = Module["___xmlParserInputBufferCreateFilename"] = wasmExports["__xmlParserInputBufferCreateFilename"])(a0, a1);
        var ___xmlOutputBufferCreateFilename = Module["___xmlOutputBufferCreateFilename"] = (a0, a1, a22) => (___xmlOutputBufferCreateFilename = Module["___xmlOutputBufferCreateFilename"] = wasmExports["__xmlOutputBufferCreateFilename"])(a0, a1, a22);
        var _xmlSAX2InternalSubset = Module["_xmlSAX2InternalSubset"] = (a0, a1, a22, a32) => (_xmlSAX2InternalSubset = Module["_xmlSAX2InternalSubset"] = wasmExports["xmlSAX2InternalSubset"])(a0, a1, a22, a32);
        var _xmlSAX2IsStandalone = Module["_xmlSAX2IsStandalone"] = (a0) => (_xmlSAX2IsStandalone = Module["_xmlSAX2IsStandalone"] = wasmExports["xmlSAX2IsStandalone"])(a0);
        var _xmlSAX2HasInternalSubset = Module["_xmlSAX2HasInternalSubset"] = (a0) => (_xmlSAX2HasInternalSubset = Module["_xmlSAX2HasInternalSubset"] = wasmExports["xmlSAX2HasInternalSubset"])(a0);
        var _xmlSAX2HasExternalSubset = Module["_xmlSAX2HasExternalSubset"] = (a0) => (_xmlSAX2HasExternalSubset = Module["_xmlSAX2HasExternalSubset"] = wasmExports["xmlSAX2HasExternalSubset"])(a0);
        var _xmlSAX2ResolveEntity = Module["_xmlSAX2ResolveEntity"] = (a0, a1, a22) => (_xmlSAX2ResolveEntity = Module["_xmlSAX2ResolveEntity"] = wasmExports["xmlSAX2ResolveEntity"])(a0, a1, a22);
        var _xmlSAX2GetEntity = Module["_xmlSAX2GetEntity"] = (a0, a1) => (_xmlSAX2GetEntity = Module["_xmlSAX2GetEntity"] = wasmExports["xmlSAX2GetEntity"])(a0, a1);
        var _xmlSAX2EntityDecl = Module["_xmlSAX2EntityDecl"] = (a0, a1, a22, a32, a42, a52) => (_xmlSAX2EntityDecl = Module["_xmlSAX2EntityDecl"] = wasmExports["xmlSAX2EntityDecl"])(a0, a1, a22, a32, a42, a52);
        var _xmlSAX2NotationDecl = Module["_xmlSAX2NotationDecl"] = (a0, a1, a22, a32) => (_xmlSAX2NotationDecl = Module["_xmlSAX2NotationDecl"] = wasmExports["xmlSAX2NotationDecl"])(a0, a1, a22, a32);
        var _xmlSAX2AttributeDecl = Module["_xmlSAX2AttributeDecl"] = (a0, a1, a22, a32, a42, a52, a62) => (_xmlSAX2AttributeDecl = Module["_xmlSAX2AttributeDecl"] = wasmExports["xmlSAX2AttributeDecl"])(a0, a1, a22, a32, a42, a52, a62);
        var _xmlSAX2ElementDecl = Module["_xmlSAX2ElementDecl"] = (a0, a1, a22, a32) => (_xmlSAX2ElementDecl = Module["_xmlSAX2ElementDecl"] = wasmExports["xmlSAX2ElementDecl"])(a0, a1, a22, a32);
        var _xmlSAX2UnparsedEntityDecl = Module["_xmlSAX2UnparsedEntityDecl"] = (a0, a1, a22, a32, a42) => (_xmlSAX2UnparsedEntityDecl = Module["_xmlSAX2UnparsedEntityDecl"] = wasmExports["xmlSAX2UnparsedEntityDecl"])(a0, a1, a22, a32, a42);
        var _xmlSAX2SetDocumentLocator = Module["_xmlSAX2SetDocumentLocator"] = (a0, a1) => (_xmlSAX2SetDocumentLocator = Module["_xmlSAX2SetDocumentLocator"] = wasmExports["xmlSAX2SetDocumentLocator"])(a0, a1);
        var _xmlSAX2StartDocument = Module["_xmlSAX2StartDocument"] = (a0) => (_xmlSAX2StartDocument = Module["_xmlSAX2StartDocument"] = wasmExports["xmlSAX2StartDocument"])(a0);
        var _xmlSAX2EndDocument = Module["_xmlSAX2EndDocument"] = (a0) => (_xmlSAX2EndDocument = Module["_xmlSAX2EndDocument"] = wasmExports["xmlSAX2EndDocument"])(a0);
        var _xmlSAX2StartElement = Module["_xmlSAX2StartElement"] = (a0, a1, a22) => (_xmlSAX2StartElement = Module["_xmlSAX2StartElement"] = wasmExports["xmlSAX2StartElement"])(a0, a1, a22);
        var _xmlSAX2EndElement = Module["_xmlSAX2EndElement"] = (a0, a1) => (_xmlSAX2EndElement = Module["_xmlSAX2EndElement"] = wasmExports["xmlSAX2EndElement"])(a0, a1);
        var _xmlSAX2Reference = Module["_xmlSAX2Reference"] = (a0, a1) => (_xmlSAX2Reference = Module["_xmlSAX2Reference"] = wasmExports["xmlSAX2Reference"])(a0, a1);
        var _xmlSAX2Characters = Module["_xmlSAX2Characters"] = (a0, a1, a22) => (_xmlSAX2Characters = Module["_xmlSAX2Characters"] = wasmExports["xmlSAX2Characters"])(a0, a1, a22);
        var _xmlSAX2ProcessingInstruction = Module["_xmlSAX2ProcessingInstruction"] = (a0, a1, a22) => (_xmlSAX2ProcessingInstruction = Module["_xmlSAX2ProcessingInstruction"] = wasmExports["xmlSAX2ProcessingInstruction"])(a0, a1, a22);
        var _xmlSAX2Comment = Module["_xmlSAX2Comment"] = (a0, a1) => (_xmlSAX2Comment = Module["_xmlSAX2Comment"] = wasmExports["xmlSAX2Comment"])(a0, a1);
        var _xmlSAX2GetParameterEntity = Module["_xmlSAX2GetParameterEntity"] = (a0, a1) => (_xmlSAX2GetParameterEntity = Module["_xmlSAX2GetParameterEntity"] = wasmExports["xmlSAX2GetParameterEntity"])(a0, a1);
        var _xmlSAX2CDataBlock = Module["_xmlSAX2CDataBlock"] = (a0, a1, a22) => (_xmlSAX2CDataBlock = Module["_xmlSAX2CDataBlock"] = wasmExports["xmlSAX2CDataBlock"])(a0, a1, a22);
        var _xmlSAX2ExternalSubset = Module["_xmlSAX2ExternalSubset"] = (a0, a1, a22, a32) => (_xmlSAX2ExternalSubset = Module["_xmlSAX2ExternalSubset"] = wasmExports["xmlSAX2ExternalSubset"])(a0, a1, a22, a32);
        var _xmlSAX2GetPublicId = Module["_xmlSAX2GetPublicId"] = (a0) => (_xmlSAX2GetPublicId = Module["_xmlSAX2GetPublicId"] = wasmExports["xmlSAX2GetPublicId"])(a0);
        var _xmlSAX2GetSystemId = Module["_xmlSAX2GetSystemId"] = (a0) => (_xmlSAX2GetSystemId = Module["_xmlSAX2GetSystemId"] = wasmExports["xmlSAX2GetSystemId"])(a0);
        var _xmlSAX2GetLineNumber = Module["_xmlSAX2GetLineNumber"] = (a0) => (_xmlSAX2GetLineNumber = Module["_xmlSAX2GetLineNumber"] = wasmExports["xmlSAX2GetLineNumber"])(a0);
        var _xmlSAX2GetColumnNumber = Module["_xmlSAX2GetColumnNumber"] = (a0) => (_xmlSAX2GetColumnNumber = Module["_xmlSAX2GetColumnNumber"] = wasmExports["xmlSAX2GetColumnNumber"])(a0);
        var _xmlSAX2IgnorableWhitespace = Module["_xmlSAX2IgnorableWhitespace"] = (a0, a1, a22) => (_xmlSAX2IgnorableWhitespace = Module["_xmlSAX2IgnorableWhitespace"] = wasmExports["xmlSAX2IgnorableWhitespace"])(a0, a1, a22);
        var _xmlHashDefaultDeallocator = Module["_xmlHashDefaultDeallocator"] = (a0, a1) => (_xmlHashDefaultDeallocator = Module["_xmlHashDefaultDeallocator"] = wasmExports["xmlHashDefaultDeallocator"])(a0, a1);
        var _iconv_open = Module["_iconv_open"] = (a0, a1) => (_iconv_open = Module["_iconv_open"] = wasmExports["iconv_open"])(a0, a1);
        var _iconv_close = Module["_iconv_close"] = (a0) => (_iconv_close = Module["_iconv_close"] = wasmExports["iconv_close"])(a0);
        var _iconv = Module["_iconv"] = (a0, a1, a22, a32, a42) => (_iconv = Module["_iconv"] = wasmExports["iconv"])(a0, a1, a22, a32, a42);
        var _UTF8ToHtml = Module["_UTF8ToHtml"] = (a0, a1, a22, a32) => (_UTF8ToHtml = Module["_UTF8ToHtml"] = wasmExports["UTF8ToHtml"])(a0, a1, a22, a32);
        var _xmlReadMemory = Module["_xmlReadMemory"] = (a0, a1, a22, a32, a42) => (_xmlReadMemory = Module["_xmlReadMemory"] = wasmExports["xmlReadMemory"])(a0, a1, a22, a32, a42);
        var _xmlSAX2StartElementNs = Module["_xmlSAX2StartElementNs"] = (a0, a1, a22, a32, a42, a52, a62, a72, a82) => (_xmlSAX2StartElementNs = Module["_xmlSAX2StartElementNs"] = wasmExports["xmlSAX2StartElementNs"])(a0, a1, a22, a32, a42, a52, a62, a72, a82);
        var _xmlSAX2EndElementNs = Module["_xmlSAX2EndElementNs"] = (a0, a1, a22, a32) => (_xmlSAX2EndElementNs = Module["_xmlSAX2EndElementNs"] = wasmExports["xmlSAX2EndElementNs"])(a0, a1, a22, a32);
        var ___cxa_atexit = Module["___cxa_atexit"] = (a0, a1, a22) => (___cxa_atexit = Module["___cxa_atexit"] = wasmExports["__cxa_atexit"])(a0, a1, a22);
        var _xmlDocGetRootElement = Module["_xmlDocGetRootElement"] = (a0) => (_xmlDocGetRootElement = Module["_xmlDocGetRootElement"] = wasmExports["xmlDocGetRootElement"])(a0);
        var _xmlFileMatch = Module["_xmlFileMatch"] = (a0) => (_xmlFileMatch = Module["_xmlFileMatch"] = wasmExports["xmlFileMatch"])(a0);
        var _xmlFileOpen = Module["_xmlFileOpen"] = (a0) => (_xmlFileOpen = Module["_xmlFileOpen"] = wasmExports["xmlFileOpen"])(a0);
        var _xmlFileRead = Module["_xmlFileRead"] = (a0, a1, a22) => (_xmlFileRead = Module["_xmlFileRead"] = wasmExports["xmlFileRead"])(a0, a1, a22);
        var _xmlFileClose = Module["_xmlFileClose"] = (a0) => (_xmlFileClose = Module["_xmlFileClose"] = wasmExports["xmlFileClose"])(a0);
        var _gzread = Module["_gzread"] = (a0, a1, a22) => (_gzread = Module["_gzread"] = wasmExports["gzread"])(a0, a1, a22);
        var _gzclose = Module["_gzclose"] = (a0) => (_gzclose = Module["_gzclose"] = wasmExports["gzclose"])(a0);
        var _gzdirect = Module["_gzdirect"] = (a0) => (_gzdirect = Module["_gzdirect"] = wasmExports["gzdirect"])(a0);
        var _gzdopen = Module["_gzdopen"] = (a0, a1) => (_gzdopen = Module["_gzdopen"] = wasmExports["gzdopen"])(a0, a1);
        var _gzopen = Module["_gzopen"] = (a0, a1) => (_gzopen = Module["_gzopen"] = wasmExports["gzopen"])(a0, a1);
        var _gzwrite = Module["_gzwrite"] = (a0, a1, a22) => (_gzwrite = Module["_gzwrite"] = wasmExports["gzwrite"])(a0, a1, a22);
        var _xmlUCSIsCatNd = Module["_xmlUCSIsCatNd"] = (a0) => (_xmlUCSIsCatNd = Module["_xmlUCSIsCatNd"] = wasmExports["xmlUCSIsCatNd"])(a0);
        var _xmlUCSIsCatP = Module["_xmlUCSIsCatP"] = (a0) => (_xmlUCSIsCatP = Module["_xmlUCSIsCatP"] = wasmExports["xmlUCSIsCatP"])(a0);
        var _xmlUCSIsCatZ = Module["_xmlUCSIsCatZ"] = (a0) => (_xmlUCSIsCatZ = Module["_xmlUCSIsCatZ"] = wasmExports["xmlUCSIsCatZ"])(a0);
        var _xmlUCSIsCatC = Module["_xmlUCSIsCatC"] = (a0) => (_xmlUCSIsCatC = Module["_xmlUCSIsCatC"] = wasmExports["xmlUCSIsCatC"])(a0);
        var _xmlUCSIsCatL = Module["_xmlUCSIsCatL"] = (a0) => (_xmlUCSIsCatL = Module["_xmlUCSIsCatL"] = wasmExports["xmlUCSIsCatL"])(a0);
        var _xmlUCSIsCatLu = Module["_xmlUCSIsCatLu"] = (a0) => (_xmlUCSIsCatLu = Module["_xmlUCSIsCatLu"] = wasmExports["xmlUCSIsCatLu"])(a0);
        var _xmlUCSIsCatLl = Module["_xmlUCSIsCatLl"] = (a0) => (_xmlUCSIsCatLl = Module["_xmlUCSIsCatLl"] = wasmExports["xmlUCSIsCatLl"])(a0);
        var _xmlUCSIsCatLt = Module["_xmlUCSIsCatLt"] = (a0) => (_xmlUCSIsCatLt = Module["_xmlUCSIsCatLt"] = wasmExports["xmlUCSIsCatLt"])(a0);
        var _xmlUCSIsCatLm = Module["_xmlUCSIsCatLm"] = (a0) => (_xmlUCSIsCatLm = Module["_xmlUCSIsCatLm"] = wasmExports["xmlUCSIsCatLm"])(a0);
        var _xmlUCSIsCatLo = Module["_xmlUCSIsCatLo"] = (a0) => (_xmlUCSIsCatLo = Module["_xmlUCSIsCatLo"] = wasmExports["xmlUCSIsCatLo"])(a0);
        var _xmlUCSIsCatM = Module["_xmlUCSIsCatM"] = (a0) => (_xmlUCSIsCatM = Module["_xmlUCSIsCatM"] = wasmExports["xmlUCSIsCatM"])(a0);
        var _xmlUCSIsCatMn = Module["_xmlUCSIsCatMn"] = (a0) => (_xmlUCSIsCatMn = Module["_xmlUCSIsCatMn"] = wasmExports["xmlUCSIsCatMn"])(a0);
        var _xmlUCSIsCatMc = Module["_xmlUCSIsCatMc"] = (a0) => (_xmlUCSIsCatMc = Module["_xmlUCSIsCatMc"] = wasmExports["xmlUCSIsCatMc"])(a0);
        var _xmlUCSIsCatMe = Module["_xmlUCSIsCatMe"] = (a0) => (_xmlUCSIsCatMe = Module["_xmlUCSIsCatMe"] = wasmExports["xmlUCSIsCatMe"])(a0);
        var _xmlUCSIsCatN = Module["_xmlUCSIsCatN"] = (a0) => (_xmlUCSIsCatN = Module["_xmlUCSIsCatN"] = wasmExports["xmlUCSIsCatN"])(a0);
        var _xmlUCSIsCatNl = Module["_xmlUCSIsCatNl"] = (a0) => (_xmlUCSIsCatNl = Module["_xmlUCSIsCatNl"] = wasmExports["xmlUCSIsCatNl"])(a0);
        var _xmlUCSIsCatNo = Module["_xmlUCSIsCatNo"] = (a0) => (_xmlUCSIsCatNo = Module["_xmlUCSIsCatNo"] = wasmExports["xmlUCSIsCatNo"])(a0);
        var _xmlUCSIsCatPc = Module["_xmlUCSIsCatPc"] = (a0) => (_xmlUCSIsCatPc = Module["_xmlUCSIsCatPc"] = wasmExports["xmlUCSIsCatPc"])(a0);
        var _xmlUCSIsCatPd = Module["_xmlUCSIsCatPd"] = (a0) => (_xmlUCSIsCatPd = Module["_xmlUCSIsCatPd"] = wasmExports["xmlUCSIsCatPd"])(a0);
        var _xmlUCSIsCatPs = Module["_xmlUCSIsCatPs"] = (a0) => (_xmlUCSIsCatPs = Module["_xmlUCSIsCatPs"] = wasmExports["xmlUCSIsCatPs"])(a0);
        var _xmlUCSIsCatPe = Module["_xmlUCSIsCatPe"] = (a0) => (_xmlUCSIsCatPe = Module["_xmlUCSIsCatPe"] = wasmExports["xmlUCSIsCatPe"])(a0);
        var _xmlUCSIsCatPi = Module["_xmlUCSIsCatPi"] = (a0) => (_xmlUCSIsCatPi = Module["_xmlUCSIsCatPi"] = wasmExports["xmlUCSIsCatPi"])(a0);
        var _xmlUCSIsCatPf = Module["_xmlUCSIsCatPf"] = (a0) => (_xmlUCSIsCatPf = Module["_xmlUCSIsCatPf"] = wasmExports["xmlUCSIsCatPf"])(a0);
        var _xmlUCSIsCatPo = Module["_xmlUCSIsCatPo"] = (a0) => (_xmlUCSIsCatPo = Module["_xmlUCSIsCatPo"] = wasmExports["xmlUCSIsCatPo"])(a0);
        var _xmlUCSIsCatZs = Module["_xmlUCSIsCatZs"] = (a0) => (_xmlUCSIsCatZs = Module["_xmlUCSIsCatZs"] = wasmExports["xmlUCSIsCatZs"])(a0);
        var _xmlUCSIsCatZl = Module["_xmlUCSIsCatZl"] = (a0) => (_xmlUCSIsCatZl = Module["_xmlUCSIsCatZl"] = wasmExports["xmlUCSIsCatZl"])(a0);
        var _xmlUCSIsCatZp = Module["_xmlUCSIsCatZp"] = (a0) => (_xmlUCSIsCatZp = Module["_xmlUCSIsCatZp"] = wasmExports["xmlUCSIsCatZp"])(a0);
        var _xmlUCSIsCatS = Module["_xmlUCSIsCatS"] = (a0) => (_xmlUCSIsCatS = Module["_xmlUCSIsCatS"] = wasmExports["xmlUCSIsCatS"])(a0);
        var _xmlUCSIsCatSm = Module["_xmlUCSIsCatSm"] = (a0) => (_xmlUCSIsCatSm = Module["_xmlUCSIsCatSm"] = wasmExports["xmlUCSIsCatSm"])(a0);
        var _xmlUCSIsCatSc = Module["_xmlUCSIsCatSc"] = (a0) => (_xmlUCSIsCatSc = Module["_xmlUCSIsCatSc"] = wasmExports["xmlUCSIsCatSc"])(a0);
        var _xmlUCSIsCatSk = Module["_xmlUCSIsCatSk"] = (a0) => (_xmlUCSIsCatSk = Module["_xmlUCSIsCatSk"] = wasmExports["xmlUCSIsCatSk"])(a0);
        var _xmlUCSIsCatSo = Module["_xmlUCSIsCatSo"] = (a0) => (_xmlUCSIsCatSo = Module["_xmlUCSIsCatSo"] = wasmExports["xmlUCSIsCatSo"])(a0);
        var _xmlUCSIsCatCc = Module["_xmlUCSIsCatCc"] = (a0) => (_xmlUCSIsCatCc = Module["_xmlUCSIsCatCc"] = wasmExports["xmlUCSIsCatCc"])(a0);
        var _xmlUCSIsCatCf = Module["_xmlUCSIsCatCf"] = (a0) => (_xmlUCSIsCatCf = Module["_xmlUCSIsCatCf"] = wasmExports["xmlUCSIsCatCf"])(a0);
        var _xmlUCSIsCatCo = Module["_xmlUCSIsCatCo"] = (a0) => (_xmlUCSIsCatCo = Module["_xmlUCSIsCatCo"] = wasmExports["xmlUCSIsCatCo"])(a0);
        var _xmlUCSIsAegeanNumbers = Module["_xmlUCSIsAegeanNumbers"] = (a0) => (_xmlUCSIsAegeanNumbers = Module["_xmlUCSIsAegeanNumbers"] = wasmExports["xmlUCSIsAegeanNumbers"])(a0);
        var _xmlUCSIsAlphabeticPresentationForms = Module["_xmlUCSIsAlphabeticPresentationForms"] = (a0) => (_xmlUCSIsAlphabeticPresentationForms = Module["_xmlUCSIsAlphabeticPresentationForms"] = wasmExports["xmlUCSIsAlphabeticPresentationForms"])(a0);
        var _xmlUCSIsArabic = Module["_xmlUCSIsArabic"] = (a0) => (_xmlUCSIsArabic = Module["_xmlUCSIsArabic"] = wasmExports["xmlUCSIsArabic"])(a0);
        var _xmlUCSIsArabicPresentationFormsA = Module["_xmlUCSIsArabicPresentationFormsA"] = (a0) => (_xmlUCSIsArabicPresentationFormsA = Module["_xmlUCSIsArabicPresentationFormsA"] = wasmExports["xmlUCSIsArabicPresentationFormsA"])(a0);
        var _xmlUCSIsArabicPresentationFormsB = Module["_xmlUCSIsArabicPresentationFormsB"] = (a0) => (_xmlUCSIsArabicPresentationFormsB = Module["_xmlUCSIsArabicPresentationFormsB"] = wasmExports["xmlUCSIsArabicPresentationFormsB"])(a0);
        var _xmlUCSIsArmenian = Module["_xmlUCSIsArmenian"] = (a0) => (_xmlUCSIsArmenian = Module["_xmlUCSIsArmenian"] = wasmExports["xmlUCSIsArmenian"])(a0);
        var _xmlUCSIsArrows = Module["_xmlUCSIsArrows"] = (a0) => (_xmlUCSIsArrows = Module["_xmlUCSIsArrows"] = wasmExports["xmlUCSIsArrows"])(a0);
        var _xmlUCSIsBasicLatin = Module["_xmlUCSIsBasicLatin"] = (a0) => (_xmlUCSIsBasicLatin = Module["_xmlUCSIsBasicLatin"] = wasmExports["xmlUCSIsBasicLatin"])(a0);
        var _xmlUCSIsBengali = Module["_xmlUCSIsBengali"] = (a0) => (_xmlUCSIsBengali = Module["_xmlUCSIsBengali"] = wasmExports["xmlUCSIsBengali"])(a0);
        var _xmlUCSIsBlockElements = Module["_xmlUCSIsBlockElements"] = (a0) => (_xmlUCSIsBlockElements = Module["_xmlUCSIsBlockElements"] = wasmExports["xmlUCSIsBlockElements"])(a0);
        var _xmlUCSIsBopomofo = Module["_xmlUCSIsBopomofo"] = (a0) => (_xmlUCSIsBopomofo = Module["_xmlUCSIsBopomofo"] = wasmExports["xmlUCSIsBopomofo"])(a0);
        var _xmlUCSIsBopomofoExtended = Module["_xmlUCSIsBopomofoExtended"] = (a0) => (_xmlUCSIsBopomofoExtended = Module["_xmlUCSIsBopomofoExtended"] = wasmExports["xmlUCSIsBopomofoExtended"])(a0);
        var _xmlUCSIsBoxDrawing = Module["_xmlUCSIsBoxDrawing"] = (a0) => (_xmlUCSIsBoxDrawing = Module["_xmlUCSIsBoxDrawing"] = wasmExports["xmlUCSIsBoxDrawing"])(a0);
        var _xmlUCSIsBraillePatterns = Module["_xmlUCSIsBraillePatterns"] = (a0) => (_xmlUCSIsBraillePatterns = Module["_xmlUCSIsBraillePatterns"] = wasmExports["xmlUCSIsBraillePatterns"])(a0);
        var _xmlUCSIsBuhid = Module["_xmlUCSIsBuhid"] = (a0) => (_xmlUCSIsBuhid = Module["_xmlUCSIsBuhid"] = wasmExports["xmlUCSIsBuhid"])(a0);
        var _xmlUCSIsByzantineMusicalSymbols = Module["_xmlUCSIsByzantineMusicalSymbols"] = (a0) => (_xmlUCSIsByzantineMusicalSymbols = Module["_xmlUCSIsByzantineMusicalSymbols"] = wasmExports["xmlUCSIsByzantineMusicalSymbols"])(a0);
        var _xmlUCSIsCJKCompatibility = Module["_xmlUCSIsCJKCompatibility"] = (a0) => (_xmlUCSIsCJKCompatibility = Module["_xmlUCSIsCJKCompatibility"] = wasmExports["xmlUCSIsCJKCompatibility"])(a0);
        var _xmlUCSIsCJKCompatibilityForms = Module["_xmlUCSIsCJKCompatibilityForms"] = (a0) => (_xmlUCSIsCJKCompatibilityForms = Module["_xmlUCSIsCJKCompatibilityForms"] = wasmExports["xmlUCSIsCJKCompatibilityForms"])(a0);
        var _xmlUCSIsCJKCompatibilityIdeographs = Module["_xmlUCSIsCJKCompatibilityIdeographs"] = (a0) => (_xmlUCSIsCJKCompatibilityIdeographs = Module["_xmlUCSIsCJKCompatibilityIdeographs"] = wasmExports["xmlUCSIsCJKCompatibilityIdeographs"])(a0);
        var _xmlUCSIsCJKCompatibilityIdeographsSupplement = Module["_xmlUCSIsCJKCompatibilityIdeographsSupplement"] = (a0) => (_xmlUCSIsCJKCompatibilityIdeographsSupplement = Module["_xmlUCSIsCJKCompatibilityIdeographsSupplement"] = wasmExports["xmlUCSIsCJKCompatibilityIdeographsSupplement"])(a0);
        var _xmlUCSIsCJKRadicalsSupplement = Module["_xmlUCSIsCJKRadicalsSupplement"] = (a0) => (_xmlUCSIsCJKRadicalsSupplement = Module["_xmlUCSIsCJKRadicalsSupplement"] = wasmExports["xmlUCSIsCJKRadicalsSupplement"])(a0);
        var _xmlUCSIsCJKSymbolsandPunctuation = Module["_xmlUCSIsCJKSymbolsandPunctuation"] = (a0) => (_xmlUCSIsCJKSymbolsandPunctuation = Module["_xmlUCSIsCJKSymbolsandPunctuation"] = wasmExports["xmlUCSIsCJKSymbolsandPunctuation"])(a0);
        var _xmlUCSIsCJKUnifiedIdeographs = Module["_xmlUCSIsCJKUnifiedIdeographs"] = (a0) => (_xmlUCSIsCJKUnifiedIdeographs = Module["_xmlUCSIsCJKUnifiedIdeographs"] = wasmExports["xmlUCSIsCJKUnifiedIdeographs"])(a0);
        var _xmlUCSIsCJKUnifiedIdeographsExtensionA = Module["_xmlUCSIsCJKUnifiedIdeographsExtensionA"] = (a0) => (_xmlUCSIsCJKUnifiedIdeographsExtensionA = Module["_xmlUCSIsCJKUnifiedIdeographsExtensionA"] = wasmExports["xmlUCSIsCJKUnifiedIdeographsExtensionA"])(a0);
        var _xmlUCSIsCJKUnifiedIdeographsExtensionB = Module["_xmlUCSIsCJKUnifiedIdeographsExtensionB"] = (a0) => (_xmlUCSIsCJKUnifiedIdeographsExtensionB = Module["_xmlUCSIsCJKUnifiedIdeographsExtensionB"] = wasmExports["xmlUCSIsCJKUnifiedIdeographsExtensionB"])(a0);
        var _xmlUCSIsCherokee = Module["_xmlUCSIsCherokee"] = (a0) => (_xmlUCSIsCherokee = Module["_xmlUCSIsCherokee"] = wasmExports["xmlUCSIsCherokee"])(a0);
        var _xmlUCSIsCombiningDiacriticalMarks = Module["_xmlUCSIsCombiningDiacriticalMarks"] = (a0) => (_xmlUCSIsCombiningDiacriticalMarks = Module["_xmlUCSIsCombiningDiacriticalMarks"] = wasmExports["xmlUCSIsCombiningDiacriticalMarks"])(a0);
        var _xmlUCSIsCombiningDiacriticalMarksforSymbols = Module["_xmlUCSIsCombiningDiacriticalMarksforSymbols"] = (a0) => (_xmlUCSIsCombiningDiacriticalMarksforSymbols = Module["_xmlUCSIsCombiningDiacriticalMarksforSymbols"] = wasmExports["xmlUCSIsCombiningDiacriticalMarksforSymbols"])(a0);
        var _xmlUCSIsCombiningHalfMarks = Module["_xmlUCSIsCombiningHalfMarks"] = (a0) => (_xmlUCSIsCombiningHalfMarks = Module["_xmlUCSIsCombiningHalfMarks"] = wasmExports["xmlUCSIsCombiningHalfMarks"])(a0);
        var _xmlUCSIsCombiningMarksforSymbols = Module["_xmlUCSIsCombiningMarksforSymbols"] = (a0) => (_xmlUCSIsCombiningMarksforSymbols = Module["_xmlUCSIsCombiningMarksforSymbols"] = wasmExports["xmlUCSIsCombiningMarksforSymbols"])(a0);
        var _xmlUCSIsControlPictures = Module["_xmlUCSIsControlPictures"] = (a0) => (_xmlUCSIsControlPictures = Module["_xmlUCSIsControlPictures"] = wasmExports["xmlUCSIsControlPictures"])(a0);
        var _xmlUCSIsCurrencySymbols = Module["_xmlUCSIsCurrencySymbols"] = (a0) => (_xmlUCSIsCurrencySymbols = Module["_xmlUCSIsCurrencySymbols"] = wasmExports["xmlUCSIsCurrencySymbols"])(a0);
        var _xmlUCSIsCypriotSyllabary = Module["_xmlUCSIsCypriotSyllabary"] = (a0) => (_xmlUCSIsCypriotSyllabary = Module["_xmlUCSIsCypriotSyllabary"] = wasmExports["xmlUCSIsCypriotSyllabary"])(a0);
        var _xmlUCSIsCyrillic = Module["_xmlUCSIsCyrillic"] = (a0) => (_xmlUCSIsCyrillic = Module["_xmlUCSIsCyrillic"] = wasmExports["xmlUCSIsCyrillic"])(a0);
        var _xmlUCSIsCyrillicSupplement = Module["_xmlUCSIsCyrillicSupplement"] = (a0) => (_xmlUCSIsCyrillicSupplement = Module["_xmlUCSIsCyrillicSupplement"] = wasmExports["xmlUCSIsCyrillicSupplement"])(a0);
        var _xmlUCSIsDeseret = Module["_xmlUCSIsDeseret"] = (a0) => (_xmlUCSIsDeseret = Module["_xmlUCSIsDeseret"] = wasmExports["xmlUCSIsDeseret"])(a0);
        var _xmlUCSIsDevanagari = Module["_xmlUCSIsDevanagari"] = (a0) => (_xmlUCSIsDevanagari = Module["_xmlUCSIsDevanagari"] = wasmExports["xmlUCSIsDevanagari"])(a0);
        var _xmlUCSIsDingbats = Module["_xmlUCSIsDingbats"] = (a0) => (_xmlUCSIsDingbats = Module["_xmlUCSIsDingbats"] = wasmExports["xmlUCSIsDingbats"])(a0);
        var _xmlUCSIsEnclosedAlphanumerics = Module["_xmlUCSIsEnclosedAlphanumerics"] = (a0) => (_xmlUCSIsEnclosedAlphanumerics = Module["_xmlUCSIsEnclosedAlphanumerics"] = wasmExports["xmlUCSIsEnclosedAlphanumerics"])(a0);
        var _xmlUCSIsEnclosedCJKLettersandMonths = Module["_xmlUCSIsEnclosedCJKLettersandMonths"] = (a0) => (_xmlUCSIsEnclosedCJKLettersandMonths = Module["_xmlUCSIsEnclosedCJKLettersandMonths"] = wasmExports["xmlUCSIsEnclosedCJKLettersandMonths"])(a0);
        var _xmlUCSIsEthiopic = Module["_xmlUCSIsEthiopic"] = (a0) => (_xmlUCSIsEthiopic = Module["_xmlUCSIsEthiopic"] = wasmExports["xmlUCSIsEthiopic"])(a0);
        var _xmlUCSIsGeneralPunctuation = Module["_xmlUCSIsGeneralPunctuation"] = (a0) => (_xmlUCSIsGeneralPunctuation = Module["_xmlUCSIsGeneralPunctuation"] = wasmExports["xmlUCSIsGeneralPunctuation"])(a0);
        var _xmlUCSIsGeometricShapes = Module["_xmlUCSIsGeometricShapes"] = (a0) => (_xmlUCSIsGeometricShapes = Module["_xmlUCSIsGeometricShapes"] = wasmExports["xmlUCSIsGeometricShapes"])(a0);
        var _xmlUCSIsGeorgian = Module["_xmlUCSIsGeorgian"] = (a0) => (_xmlUCSIsGeorgian = Module["_xmlUCSIsGeorgian"] = wasmExports["xmlUCSIsGeorgian"])(a0);
        var _xmlUCSIsGothic = Module["_xmlUCSIsGothic"] = (a0) => (_xmlUCSIsGothic = Module["_xmlUCSIsGothic"] = wasmExports["xmlUCSIsGothic"])(a0);
        var _xmlUCSIsGreek = Module["_xmlUCSIsGreek"] = (a0) => (_xmlUCSIsGreek = Module["_xmlUCSIsGreek"] = wasmExports["xmlUCSIsGreek"])(a0);
        var _xmlUCSIsGreekExtended = Module["_xmlUCSIsGreekExtended"] = (a0) => (_xmlUCSIsGreekExtended = Module["_xmlUCSIsGreekExtended"] = wasmExports["xmlUCSIsGreekExtended"])(a0);
        var _xmlUCSIsGreekandCoptic = Module["_xmlUCSIsGreekandCoptic"] = (a0) => (_xmlUCSIsGreekandCoptic = Module["_xmlUCSIsGreekandCoptic"] = wasmExports["xmlUCSIsGreekandCoptic"])(a0);
        var _xmlUCSIsGujarati = Module["_xmlUCSIsGujarati"] = (a0) => (_xmlUCSIsGujarati = Module["_xmlUCSIsGujarati"] = wasmExports["xmlUCSIsGujarati"])(a0);
        var _xmlUCSIsGurmukhi = Module["_xmlUCSIsGurmukhi"] = (a0) => (_xmlUCSIsGurmukhi = Module["_xmlUCSIsGurmukhi"] = wasmExports["xmlUCSIsGurmukhi"])(a0);
        var _xmlUCSIsHalfwidthandFullwidthForms = Module["_xmlUCSIsHalfwidthandFullwidthForms"] = (a0) => (_xmlUCSIsHalfwidthandFullwidthForms = Module["_xmlUCSIsHalfwidthandFullwidthForms"] = wasmExports["xmlUCSIsHalfwidthandFullwidthForms"])(a0);
        var _xmlUCSIsHangulCompatibilityJamo = Module["_xmlUCSIsHangulCompatibilityJamo"] = (a0) => (_xmlUCSIsHangulCompatibilityJamo = Module["_xmlUCSIsHangulCompatibilityJamo"] = wasmExports["xmlUCSIsHangulCompatibilityJamo"])(a0);
        var _xmlUCSIsHangulJamo = Module["_xmlUCSIsHangulJamo"] = (a0) => (_xmlUCSIsHangulJamo = Module["_xmlUCSIsHangulJamo"] = wasmExports["xmlUCSIsHangulJamo"])(a0);
        var _xmlUCSIsHangulSyllables = Module["_xmlUCSIsHangulSyllables"] = (a0) => (_xmlUCSIsHangulSyllables = Module["_xmlUCSIsHangulSyllables"] = wasmExports["xmlUCSIsHangulSyllables"])(a0);
        var _xmlUCSIsHanunoo = Module["_xmlUCSIsHanunoo"] = (a0) => (_xmlUCSIsHanunoo = Module["_xmlUCSIsHanunoo"] = wasmExports["xmlUCSIsHanunoo"])(a0);
        var _xmlUCSIsHebrew = Module["_xmlUCSIsHebrew"] = (a0) => (_xmlUCSIsHebrew = Module["_xmlUCSIsHebrew"] = wasmExports["xmlUCSIsHebrew"])(a0);
        var _xmlUCSIsHighPrivateUseSurrogates = Module["_xmlUCSIsHighPrivateUseSurrogates"] = (a0) => (_xmlUCSIsHighPrivateUseSurrogates = Module["_xmlUCSIsHighPrivateUseSurrogates"] = wasmExports["xmlUCSIsHighPrivateUseSurrogates"])(a0);
        var _xmlUCSIsHighSurrogates = Module["_xmlUCSIsHighSurrogates"] = (a0) => (_xmlUCSIsHighSurrogates = Module["_xmlUCSIsHighSurrogates"] = wasmExports["xmlUCSIsHighSurrogates"])(a0);
        var _xmlUCSIsHiragana = Module["_xmlUCSIsHiragana"] = (a0) => (_xmlUCSIsHiragana = Module["_xmlUCSIsHiragana"] = wasmExports["xmlUCSIsHiragana"])(a0);
        var _xmlUCSIsIPAExtensions = Module["_xmlUCSIsIPAExtensions"] = (a0) => (_xmlUCSIsIPAExtensions = Module["_xmlUCSIsIPAExtensions"] = wasmExports["xmlUCSIsIPAExtensions"])(a0);
        var _xmlUCSIsIdeographicDescriptionCharacters = Module["_xmlUCSIsIdeographicDescriptionCharacters"] = (a0) => (_xmlUCSIsIdeographicDescriptionCharacters = Module["_xmlUCSIsIdeographicDescriptionCharacters"] = wasmExports["xmlUCSIsIdeographicDescriptionCharacters"])(a0);
        var _xmlUCSIsKanbun = Module["_xmlUCSIsKanbun"] = (a0) => (_xmlUCSIsKanbun = Module["_xmlUCSIsKanbun"] = wasmExports["xmlUCSIsKanbun"])(a0);
        var _xmlUCSIsKangxiRadicals = Module["_xmlUCSIsKangxiRadicals"] = (a0) => (_xmlUCSIsKangxiRadicals = Module["_xmlUCSIsKangxiRadicals"] = wasmExports["xmlUCSIsKangxiRadicals"])(a0);
        var _xmlUCSIsKannada = Module["_xmlUCSIsKannada"] = (a0) => (_xmlUCSIsKannada = Module["_xmlUCSIsKannada"] = wasmExports["xmlUCSIsKannada"])(a0);
        var _xmlUCSIsKatakana = Module["_xmlUCSIsKatakana"] = (a0) => (_xmlUCSIsKatakana = Module["_xmlUCSIsKatakana"] = wasmExports["xmlUCSIsKatakana"])(a0);
        var _xmlUCSIsKatakanaPhoneticExtensions = Module["_xmlUCSIsKatakanaPhoneticExtensions"] = (a0) => (_xmlUCSIsKatakanaPhoneticExtensions = Module["_xmlUCSIsKatakanaPhoneticExtensions"] = wasmExports["xmlUCSIsKatakanaPhoneticExtensions"])(a0);
        var _xmlUCSIsKhmer = Module["_xmlUCSIsKhmer"] = (a0) => (_xmlUCSIsKhmer = Module["_xmlUCSIsKhmer"] = wasmExports["xmlUCSIsKhmer"])(a0);
        var _xmlUCSIsKhmerSymbols = Module["_xmlUCSIsKhmerSymbols"] = (a0) => (_xmlUCSIsKhmerSymbols = Module["_xmlUCSIsKhmerSymbols"] = wasmExports["xmlUCSIsKhmerSymbols"])(a0);
        var _xmlUCSIsLao = Module["_xmlUCSIsLao"] = (a0) => (_xmlUCSIsLao = Module["_xmlUCSIsLao"] = wasmExports["xmlUCSIsLao"])(a0);
        var _xmlUCSIsLatin1Supplement = Module["_xmlUCSIsLatin1Supplement"] = (a0) => (_xmlUCSIsLatin1Supplement = Module["_xmlUCSIsLatin1Supplement"] = wasmExports["xmlUCSIsLatin1Supplement"])(a0);
        var _xmlUCSIsLatinExtendedA = Module["_xmlUCSIsLatinExtendedA"] = (a0) => (_xmlUCSIsLatinExtendedA = Module["_xmlUCSIsLatinExtendedA"] = wasmExports["xmlUCSIsLatinExtendedA"])(a0);
        var _xmlUCSIsLatinExtendedB = Module["_xmlUCSIsLatinExtendedB"] = (a0) => (_xmlUCSIsLatinExtendedB = Module["_xmlUCSIsLatinExtendedB"] = wasmExports["xmlUCSIsLatinExtendedB"])(a0);
        var _xmlUCSIsLatinExtendedAdditional = Module["_xmlUCSIsLatinExtendedAdditional"] = (a0) => (_xmlUCSIsLatinExtendedAdditional = Module["_xmlUCSIsLatinExtendedAdditional"] = wasmExports["xmlUCSIsLatinExtendedAdditional"])(a0);
        var _xmlUCSIsLetterlikeSymbols = Module["_xmlUCSIsLetterlikeSymbols"] = (a0) => (_xmlUCSIsLetterlikeSymbols = Module["_xmlUCSIsLetterlikeSymbols"] = wasmExports["xmlUCSIsLetterlikeSymbols"])(a0);
        var _xmlUCSIsLimbu = Module["_xmlUCSIsLimbu"] = (a0) => (_xmlUCSIsLimbu = Module["_xmlUCSIsLimbu"] = wasmExports["xmlUCSIsLimbu"])(a0);
        var _xmlUCSIsLinearBIdeograms = Module["_xmlUCSIsLinearBIdeograms"] = (a0) => (_xmlUCSIsLinearBIdeograms = Module["_xmlUCSIsLinearBIdeograms"] = wasmExports["xmlUCSIsLinearBIdeograms"])(a0);
        var _xmlUCSIsLinearBSyllabary = Module["_xmlUCSIsLinearBSyllabary"] = (a0) => (_xmlUCSIsLinearBSyllabary = Module["_xmlUCSIsLinearBSyllabary"] = wasmExports["xmlUCSIsLinearBSyllabary"])(a0);
        var _xmlUCSIsLowSurrogates = Module["_xmlUCSIsLowSurrogates"] = (a0) => (_xmlUCSIsLowSurrogates = Module["_xmlUCSIsLowSurrogates"] = wasmExports["xmlUCSIsLowSurrogates"])(a0);
        var _xmlUCSIsMalayalam = Module["_xmlUCSIsMalayalam"] = (a0) => (_xmlUCSIsMalayalam = Module["_xmlUCSIsMalayalam"] = wasmExports["xmlUCSIsMalayalam"])(a0);
        var _xmlUCSIsMathematicalAlphanumericSymbols = Module["_xmlUCSIsMathematicalAlphanumericSymbols"] = (a0) => (_xmlUCSIsMathematicalAlphanumericSymbols = Module["_xmlUCSIsMathematicalAlphanumericSymbols"] = wasmExports["xmlUCSIsMathematicalAlphanumericSymbols"])(a0);
        var _xmlUCSIsMathematicalOperators = Module["_xmlUCSIsMathematicalOperators"] = (a0) => (_xmlUCSIsMathematicalOperators = Module["_xmlUCSIsMathematicalOperators"] = wasmExports["xmlUCSIsMathematicalOperators"])(a0);
        var _xmlUCSIsMiscellaneousMathematicalSymbolsA = Module["_xmlUCSIsMiscellaneousMathematicalSymbolsA"] = (a0) => (_xmlUCSIsMiscellaneousMathematicalSymbolsA = Module["_xmlUCSIsMiscellaneousMathematicalSymbolsA"] = wasmExports["xmlUCSIsMiscellaneousMathematicalSymbolsA"])(a0);
        var _xmlUCSIsMiscellaneousMathematicalSymbolsB = Module["_xmlUCSIsMiscellaneousMathematicalSymbolsB"] = (a0) => (_xmlUCSIsMiscellaneousMathematicalSymbolsB = Module["_xmlUCSIsMiscellaneousMathematicalSymbolsB"] = wasmExports["xmlUCSIsMiscellaneousMathematicalSymbolsB"])(a0);
        var _xmlUCSIsMiscellaneousSymbols = Module["_xmlUCSIsMiscellaneousSymbols"] = (a0) => (_xmlUCSIsMiscellaneousSymbols = Module["_xmlUCSIsMiscellaneousSymbols"] = wasmExports["xmlUCSIsMiscellaneousSymbols"])(a0);
        var _xmlUCSIsMiscellaneousSymbolsandArrows = Module["_xmlUCSIsMiscellaneousSymbolsandArrows"] = (a0) => (_xmlUCSIsMiscellaneousSymbolsandArrows = Module["_xmlUCSIsMiscellaneousSymbolsandArrows"] = wasmExports["xmlUCSIsMiscellaneousSymbolsandArrows"])(a0);
        var _xmlUCSIsMiscellaneousTechnical = Module["_xmlUCSIsMiscellaneousTechnical"] = (a0) => (_xmlUCSIsMiscellaneousTechnical = Module["_xmlUCSIsMiscellaneousTechnical"] = wasmExports["xmlUCSIsMiscellaneousTechnical"])(a0);
        var _xmlUCSIsMongolian = Module["_xmlUCSIsMongolian"] = (a0) => (_xmlUCSIsMongolian = Module["_xmlUCSIsMongolian"] = wasmExports["xmlUCSIsMongolian"])(a0);
        var _xmlUCSIsMusicalSymbols = Module["_xmlUCSIsMusicalSymbols"] = (a0) => (_xmlUCSIsMusicalSymbols = Module["_xmlUCSIsMusicalSymbols"] = wasmExports["xmlUCSIsMusicalSymbols"])(a0);
        var _xmlUCSIsMyanmar = Module["_xmlUCSIsMyanmar"] = (a0) => (_xmlUCSIsMyanmar = Module["_xmlUCSIsMyanmar"] = wasmExports["xmlUCSIsMyanmar"])(a0);
        var _xmlUCSIsNumberForms = Module["_xmlUCSIsNumberForms"] = (a0) => (_xmlUCSIsNumberForms = Module["_xmlUCSIsNumberForms"] = wasmExports["xmlUCSIsNumberForms"])(a0);
        var _xmlUCSIsOgham = Module["_xmlUCSIsOgham"] = (a0) => (_xmlUCSIsOgham = Module["_xmlUCSIsOgham"] = wasmExports["xmlUCSIsOgham"])(a0);
        var _xmlUCSIsOldItalic = Module["_xmlUCSIsOldItalic"] = (a0) => (_xmlUCSIsOldItalic = Module["_xmlUCSIsOldItalic"] = wasmExports["xmlUCSIsOldItalic"])(a0);
        var _xmlUCSIsOpticalCharacterRecognition = Module["_xmlUCSIsOpticalCharacterRecognition"] = (a0) => (_xmlUCSIsOpticalCharacterRecognition = Module["_xmlUCSIsOpticalCharacterRecognition"] = wasmExports["xmlUCSIsOpticalCharacterRecognition"])(a0);
        var _xmlUCSIsOriya = Module["_xmlUCSIsOriya"] = (a0) => (_xmlUCSIsOriya = Module["_xmlUCSIsOriya"] = wasmExports["xmlUCSIsOriya"])(a0);
        var _xmlUCSIsOsmanya = Module["_xmlUCSIsOsmanya"] = (a0) => (_xmlUCSIsOsmanya = Module["_xmlUCSIsOsmanya"] = wasmExports["xmlUCSIsOsmanya"])(a0);
        var _xmlUCSIsPhoneticExtensions = Module["_xmlUCSIsPhoneticExtensions"] = (a0) => (_xmlUCSIsPhoneticExtensions = Module["_xmlUCSIsPhoneticExtensions"] = wasmExports["xmlUCSIsPhoneticExtensions"])(a0);
        var _xmlUCSIsPrivateUse = Module["_xmlUCSIsPrivateUse"] = (a0) => (_xmlUCSIsPrivateUse = Module["_xmlUCSIsPrivateUse"] = wasmExports["xmlUCSIsPrivateUse"])(a0);
        var _xmlUCSIsPrivateUseArea = Module["_xmlUCSIsPrivateUseArea"] = (a0) => (_xmlUCSIsPrivateUseArea = Module["_xmlUCSIsPrivateUseArea"] = wasmExports["xmlUCSIsPrivateUseArea"])(a0);
        var _xmlUCSIsRunic = Module["_xmlUCSIsRunic"] = (a0) => (_xmlUCSIsRunic = Module["_xmlUCSIsRunic"] = wasmExports["xmlUCSIsRunic"])(a0);
        var _xmlUCSIsShavian = Module["_xmlUCSIsShavian"] = (a0) => (_xmlUCSIsShavian = Module["_xmlUCSIsShavian"] = wasmExports["xmlUCSIsShavian"])(a0);
        var _xmlUCSIsSinhala = Module["_xmlUCSIsSinhala"] = (a0) => (_xmlUCSIsSinhala = Module["_xmlUCSIsSinhala"] = wasmExports["xmlUCSIsSinhala"])(a0);
        var _xmlUCSIsSmallFormVariants = Module["_xmlUCSIsSmallFormVariants"] = (a0) => (_xmlUCSIsSmallFormVariants = Module["_xmlUCSIsSmallFormVariants"] = wasmExports["xmlUCSIsSmallFormVariants"])(a0);
        var _xmlUCSIsSpacingModifierLetters = Module["_xmlUCSIsSpacingModifierLetters"] = (a0) => (_xmlUCSIsSpacingModifierLetters = Module["_xmlUCSIsSpacingModifierLetters"] = wasmExports["xmlUCSIsSpacingModifierLetters"])(a0);
        var _xmlUCSIsSpecials = Module["_xmlUCSIsSpecials"] = (a0) => (_xmlUCSIsSpecials = Module["_xmlUCSIsSpecials"] = wasmExports["xmlUCSIsSpecials"])(a0);
        var _xmlUCSIsSuperscriptsandSubscripts = Module["_xmlUCSIsSuperscriptsandSubscripts"] = (a0) => (_xmlUCSIsSuperscriptsandSubscripts = Module["_xmlUCSIsSuperscriptsandSubscripts"] = wasmExports["xmlUCSIsSuperscriptsandSubscripts"])(a0);
        var _xmlUCSIsSupplementalArrowsA = Module["_xmlUCSIsSupplementalArrowsA"] = (a0) => (_xmlUCSIsSupplementalArrowsA = Module["_xmlUCSIsSupplementalArrowsA"] = wasmExports["xmlUCSIsSupplementalArrowsA"])(a0);
        var _xmlUCSIsSupplementalArrowsB = Module["_xmlUCSIsSupplementalArrowsB"] = (a0) => (_xmlUCSIsSupplementalArrowsB = Module["_xmlUCSIsSupplementalArrowsB"] = wasmExports["xmlUCSIsSupplementalArrowsB"])(a0);
        var _xmlUCSIsSupplementalMathematicalOperators = Module["_xmlUCSIsSupplementalMathematicalOperators"] = (a0) => (_xmlUCSIsSupplementalMathematicalOperators = Module["_xmlUCSIsSupplementalMathematicalOperators"] = wasmExports["xmlUCSIsSupplementalMathematicalOperators"])(a0);
        var _xmlUCSIsSupplementaryPrivateUseAreaA = Module["_xmlUCSIsSupplementaryPrivateUseAreaA"] = (a0) => (_xmlUCSIsSupplementaryPrivateUseAreaA = Module["_xmlUCSIsSupplementaryPrivateUseAreaA"] = wasmExports["xmlUCSIsSupplementaryPrivateUseAreaA"])(a0);
        var _xmlUCSIsSupplementaryPrivateUseAreaB = Module["_xmlUCSIsSupplementaryPrivateUseAreaB"] = (a0) => (_xmlUCSIsSupplementaryPrivateUseAreaB = Module["_xmlUCSIsSupplementaryPrivateUseAreaB"] = wasmExports["xmlUCSIsSupplementaryPrivateUseAreaB"])(a0);
        var _xmlUCSIsSyriac = Module["_xmlUCSIsSyriac"] = (a0) => (_xmlUCSIsSyriac = Module["_xmlUCSIsSyriac"] = wasmExports["xmlUCSIsSyriac"])(a0);
        var _xmlUCSIsTagalog = Module["_xmlUCSIsTagalog"] = (a0) => (_xmlUCSIsTagalog = Module["_xmlUCSIsTagalog"] = wasmExports["xmlUCSIsTagalog"])(a0);
        var _xmlUCSIsTagbanwa = Module["_xmlUCSIsTagbanwa"] = (a0) => (_xmlUCSIsTagbanwa = Module["_xmlUCSIsTagbanwa"] = wasmExports["xmlUCSIsTagbanwa"])(a0);
        var _xmlUCSIsTags = Module["_xmlUCSIsTags"] = (a0) => (_xmlUCSIsTags = Module["_xmlUCSIsTags"] = wasmExports["xmlUCSIsTags"])(a0);
        var _xmlUCSIsTaiLe = Module["_xmlUCSIsTaiLe"] = (a0) => (_xmlUCSIsTaiLe = Module["_xmlUCSIsTaiLe"] = wasmExports["xmlUCSIsTaiLe"])(a0);
        var _xmlUCSIsTaiXuanJingSymbols = Module["_xmlUCSIsTaiXuanJingSymbols"] = (a0) => (_xmlUCSIsTaiXuanJingSymbols = Module["_xmlUCSIsTaiXuanJingSymbols"] = wasmExports["xmlUCSIsTaiXuanJingSymbols"])(a0);
        var _xmlUCSIsTamil = Module["_xmlUCSIsTamil"] = (a0) => (_xmlUCSIsTamil = Module["_xmlUCSIsTamil"] = wasmExports["xmlUCSIsTamil"])(a0);
        var _xmlUCSIsTelugu = Module["_xmlUCSIsTelugu"] = (a0) => (_xmlUCSIsTelugu = Module["_xmlUCSIsTelugu"] = wasmExports["xmlUCSIsTelugu"])(a0);
        var _xmlUCSIsThaana = Module["_xmlUCSIsThaana"] = (a0) => (_xmlUCSIsThaana = Module["_xmlUCSIsThaana"] = wasmExports["xmlUCSIsThaana"])(a0);
        var _xmlUCSIsThai = Module["_xmlUCSIsThai"] = (a0) => (_xmlUCSIsThai = Module["_xmlUCSIsThai"] = wasmExports["xmlUCSIsThai"])(a0);
        var _xmlUCSIsTibetan = Module["_xmlUCSIsTibetan"] = (a0) => (_xmlUCSIsTibetan = Module["_xmlUCSIsTibetan"] = wasmExports["xmlUCSIsTibetan"])(a0);
        var _xmlUCSIsUgaritic = Module["_xmlUCSIsUgaritic"] = (a0) => (_xmlUCSIsUgaritic = Module["_xmlUCSIsUgaritic"] = wasmExports["xmlUCSIsUgaritic"])(a0);
        var _xmlUCSIsUnifiedCanadianAboriginalSyllabics = Module["_xmlUCSIsUnifiedCanadianAboriginalSyllabics"] = (a0) => (_xmlUCSIsUnifiedCanadianAboriginalSyllabics = Module["_xmlUCSIsUnifiedCanadianAboriginalSyllabics"] = wasmExports["xmlUCSIsUnifiedCanadianAboriginalSyllabics"])(a0);
        var _xmlUCSIsVariationSelectors = Module["_xmlUCSIsVariationSelectors"] = (a0) => (_xmlUCSIsVariationSelectors = Module["_xmlUCSIsVariationSelectors"] = wasmExports["xmlUCSIsVariationSelectors"])(a0);
        var _xmlUCSIsVariationSelectorsSupplement = Module["_xmlUCSIsVariationSelectorsSupplement"] = (a0) => (_xmlUCSIsVariationSelectorsSupplement = Module["_xmlUCSIsVariationSelectorsSupplement"] = wasmExports["xmlUCSIsVariationSelectorsSupplement"])(a0);
        var _xmlUCSIsYiRadicals = Module["_xmlUCSIsYiRadicals"] = (a0) => (_xmlUCSIsYiRadicals = Module["_xmlUCSIsYiRadicals"] = wasmExports["xmlUCSIsYiRadicals"])(a0);
        var _xmlUCSIsYiSyllables = Module["_xmlUCSIsYiSyllables"] = (a0) => (_xmlUCSIsYiSyllables = Module["_xmlUCSIsYiSyllables"] = wasmExports["xmlUCSIsYiSyllables"])(a0);
        var _xmlUCSIsYijingHexagramSymbols = Module["_xmlUCSIsYijingHexagramSymbols"] = (a0) => (_xmlUCSIsYijingHexagramSymbols = Module["_xmlUCSIsYijingHexagramSymbols"] = wasmExports["xmlUCSIsYijingHexagramSymbols"])(a0);
        var _xmlUCSIsCatCs = Module["_xmlUCSIsCatCs"] = (a0) => (_xmlUCSIsCatCs = Module["_xmlUCSIsCatCs"] = wasmExports["xmlUCSIsCatCs"])(a0);
        var ___small_fprintf = Module["___small_fprintf"] = (a0, a1, a22) => (___small_fprintf = Module["___small_fprintf"] = wasmExports["__small_fprintf"])(a0, a1, a22);
        var _xmlXPathBooleanFunction = Module["_xmlXPathBooleanFunction"] = (a0, a1) => (_xmlXPathBooleanFunction = Module["_xmlXPathBooleanFunction"] = wasmExports["xmlXPathBooleanFunction"])(a0, a1);
        var _xmlXPathCeilingFunction = Module["_xmlXPathCeilingFunction"] = (a0, a1) => (_xmlXPathCeilingFunction = Module["_xmlXPathCeilingFunction"] = wasmExports["xmlXPathCeilingFunction"])(a0, a1);
        var _xmlXPathCountFunction = Module["_xmlXPathCountFunction"] = (a0, a1) => (_xmlXPathCountFunction = Module["_xmlXPathCountFunction"] = wasmExports["xmlXPathCountFunction"])(a0, a1);
        var _xmlXPathConcatFunction = Module["_xmlXPathConcatFunction"] = (a0, a1) => (_xmlXPathConcatFunction = Module["_xmlXPathConcatFunction"] = wasmExports["xmlXPathConcatFunction"])(a0, a1);
        var _xmlXPathContainsFunction = Module["_xmlXPathContainsFunction"] = (a0, a1) => (_xmlXPathContainsFunction = Module["_xmlXPathContainsFunction"] = wasmExports["xmlXPathContainsFunction"])(a0, a1);
        var _xmlXPathIdFunction = Module["_xmlXPathIdFunction"] = (a0, a1) => (_xmlXPathIdFunction = Module["_xmlXPathIdFunction"] = wasmExports["xmlXPathIdFunction"])(a0, a1);
        var _xmlXPathFalseFunction = Module["_xmlXPathFalseFunction"] = (a0, a1) => (_xmlXPathFalseFunction = Module["_xmlXPathFalseFunction"] = wasmExports["xmlXPathFalseFunction"])(a0, a1);
        var _xmlXPathFloorFunction = Module["_xmlXPathFloorFunction"] = (a0, a1) => (_xmlXPathFloorFunction = Module["_xmlXPathFloorFunction"] = wasmExports["xmlXPathFloorFunction"])(a0, a1);
        var _xmlXPathLastFunction = Module["_xmlXPathLastFunction"] = (a0, a1) => (_xmlXPathLastFunction = Module["_xmlXPathLastFunction"] = wasmExports["xmlXPathLastFunction"])(a0, a1);
        var _xmlXPathLangFunction = Module["_xmlXPathLangFunction"] = (a0, a1) => (_xmlXPathLangFunction = Module["_xmlXPathLangFunction"] = wasmExports["xmlXPathLangFunction"])(a0, a1);
        var _xmlXPathLocalNameFunction = Module["_xmlXPathLocalNameFunction"] = (a0, a1) => (_xmlXPathLocalNameFunction = Module["_xmlXPathLocalNameFunction"] = wasmExports["xmlXPathLocalNameFunction"])(a0, a1);
        var _xmlXPathNotFunction = Module["_xmlXPathNotFunction"] = (a0, a1) => (_xmlXPathNotFunction = Module["_xmlXPathNotFunction"] = wasmExports["xmlXPathNotFunction"])(a0, a1);
        var _xmlXPathNamespaceURIFunction = Module["_xmlXPathNamespaceURIFunction"] = (a0, a1) => (_xmlXPathNamespaceURIFunction = Module["_xmlXPathNamespaceURIFunction"] = wasmExports["xmlXPathNamespaceURIFunction"])(a0, a1);
        var _xmlXPathNormalizeFunction = Module["_xmlXPathNormalizeFunction"] = (a0, a1) => (_xmlXPathNormalizeFunction = Module["_xmlXPathNormalizeFunction"] = wasmExports["xmlXPathNormalizeFunction"])(a0, a1);
        var _xmlXPathNumberFunction = Module["_xmlXPathNumberFunction"] = (a0, a1) => (_xmlXPathNumberFunction = Module["_xmlXPathNumberFunction"] = wasmExports["xmlXPathNumberFunction"])(a0, a1);
        var _xmlXPathPositionFunction = Module["_xmlXPathPositionFunction"] = (a0, a1) => (_xmlXPathPositionFunction = Module["_xmlXPathPositionFunction"] = wasmExports["xmlXPathPositionFunction"])(a0, a1);
        var _xmlXPathRoundFunction = Module["_xmlXPathRoundFunction"] = (a0, a1) => (_xmlXPathRoundFunction = Module["_xmlXPathRoundFunction"] = wasmExports["xmlXPathRoundFunction"])(a0, a1);
        var _xmlXPathStringFunction = Module["_xmlXPathStringFunction"] = (a0, a1) => (_xmlXPathStringFunction = Module["_xmlXPathStringFunction"] = wasmExports["xmlXPathStringFunction"])(a0, a1);
        var _xmlXPathStringLengthFunction = Module["_xmlXPathStringLengthFunction"] = (a0, a1) => (_xmlXPathStringLengthFunction = Module["_xmlXPathStringLengthFunction"] = wasmExports["xmlXPathStringLengthFunction"])(a0, a1);
        var _xmlXPathStartsWithFunction = Module["_xmlXPathStartsWithFunction"] = (a0, a1) => (_xmlXPathStartsWithFunction = Module["_xmlXPathStartsWithFunction"] = wasmExports["xmlXPathStartsWithFunction"])(a0, a1);
        var _xmlXPathSubstringFunction = Module["_xmlXPathSubstringFunction"] = (a0, a1) => (_xmlXPathSubstringFunction = Module["_xmlXPathSubstringFunction"] = wasmExports["xmlXPathSubstringFunction"])(a0, a1);
        var _xmlXPathSubstringBeforeFunction = Module["_xmlXPathSubstringBeforeFunction"] = (a0, a1) => (_xmlXPathSubstringBeforeFunction = Module["_xmlXPathSubstringBeforeFunction"] = wasmExports["xmlXPathSubstringBeforeFunction"])(a0, a1);
        var _xmlXPathSubstringAfterFunction = Module["_xmlXPathSubstringAfterFunction"] = (a0, a1) => (_xmlXPathSubstringAfterFunction = Module["_xmlXPathSubstringAfterFunction"] = wasmExports["xmlXPathSubstringAfterFunction"])(a0, a1);
        var _xmlXPathSumFunction = Module["_xmlXPathSumFunction"] = (a0, a1) => (_xmlXPathSumFunction = Module["_xmlXPathSumFunction"] = wasmExports["xmlXPathSumFunction"])(a0, a1);
        var _xmlXPathTrueFunction = Module["_xmlXPathTrueFunction"] = (a0, a1) => (_xmlXPathTrueFunction = Module["_xmlXPathTrueFunction"] = wasmExports["xmlXPathTrueFunction"])(a0, a1);
        var _xmlXPathTranslateFunction = Module["_xmlXPathTranslateFunction"] = (a0, a1) => (_xmlXPathTranslateFunction = Module["_xmlXPathTranslateFunction"] = wasmExports["xmlXPathTranslateFunction"])(a0, a1);
        var _xmlXPathNextSelf = Module["_xmlXPathNextSelf"] = (a0, a1) => (_xmlXPathNextSelf = Module["_xmlXPathNextSelf"] = wasmExports["xmlXPathNextSelf"])(a0, a1);
        var _xmlXPathNextChild = Module["_xmlXPathNextChild"] = (a0, a1) => (_xmlXPathNextChild = Module["_xmlXPathNextChild"] = wasmExports["xmlXPathNextChild"])(a0, a1);
        var _xmlXPathNextDescendant = Module["_xmlXPathNextDescendant"] = (a0, a1) => (_xmlXPathNextDescendant = Module["_xmlXPathNextDescendant"] = wasmExports["xmlXPathNextDescendant"])(a0, a1);
        var _xmlXPathNextDescendantOrSelf = Module["_xmlXPathNextDescendantOrSelf"] = (a0, a1) => (_xmlXPathNextDescendantOrSelf = Module["_xmlXPathNextDescendantOrSelf"] = wasmExports["xmlXPathNextDescendantOrSelf"])(a0, a1);
        var _xmlXPathNextParent = Module["_xmlXPathNextParent"] = (a0, a1) => (_xmlXPathNextParent = Module["_xmlXPathNextParent"] = wasmExports["xmlXPathNextParent"])(a0, a1);
        var _xmlXPathNextAncestor = Module["_xmlXPathNextAncestor"] = (a0, a1) => (_xmlXPathNextAncestor = Module["_xmlXPathNextAncestor"] = wasmExports["xmlXPathNextAncestor"])(a0, a1);
        var _xmlXPathNextAncestorOrSelf = Module["_xmlXPathNextAncestorOrSelf"] = (a0, a1) => (_xmlXPathNextAncestorOrSelf = Module["_xmlXPathNextAncestorOrSelf"] = wasmExports["xmlXPathNextAncestorOrSelf"])(a0, a1);
        var _xmlXPathNextFollowingSibling = Module["_xmlXPathNextFollowingSibling"] = (a0, a1) => (_xmlXPathNextFollowingSibling = Module["_xmlXPathNextFollowingSibling"] = wasmExports["xmlXPathNextFollowingSibling"])(a0, a1);
        var _xmlXPathNextPrecedingSibling = Module["_xmlXPathNextPrecedingSibling"] = (a0, a1) => (_xmlXPathNextPrecedingSibling = Module["_xmlXPathNextPrecedingSibling"] = wasmExports["xmlXPathNextPrecedingSibling"])(a0, a1);
        var _xmlXPathNextFollowing = Module["_xmlXPathNextFollowing"] = (a0, a1) => (_xmlXPathNextFollowing = Module["_xmlXPathNextFollowing"] = wasmExports["xmlXPathNextFollowing"])(a0, a1);
        var _xmlXPathNextNamespace = Module["_xmlXPathNextNamespace"] = (a0, a1) => (_xmlXPathNextNamespace = Module["_xmlXPathNextNamespace"] = wasmExports["xmlXPathNextNamespace"])(a0, a1);
        var _xmlXPathNextAttribute = Module["_xmlXPathNextAttribute"] = (a0, a1) => (_xmlXPathNextAttribute = Module["_xmlXPathNextAttribute"] = wasmExports["xmlXPathNextAttribute"])(a0, a1);
        var _zcalloc = Module["_zcalloc"] = (a0, a1, a22) => (_zcalloc = Module["_zcalloc"] = wasmExports["zcalloc"])(a0, a1, a22);
        var _zcfree = Module["_zcfree"] = (a0, a1) => (_zcfree = Module["_zcfree"] = wasmExports["zcfree"])(a0, a1);
        var _strerror = Module["_strerror"] = (a0) => (_strerror = Module["_strerror"] = wasmExports["strerror"])(a0);
        var ___dl_seterr = (a0, a1) => (___dl_seterr = wasmExports["__dl_seterr"])(a0, a1);
        var _putc = Module["_putc"] = (a0, a1) => (_putc = Module["_putc"] = wasmExports["putc"])(a0, a1);
        var _gmtime = Module["_gmtime"] = (a0) => (_gmtime = Module["_gmtime"] = wasmExports["gmtime"])(a0);
        var _htonl = (a0) => (_htonl = wasmExports["htonl"])(a0);
        var _htons = (a0) => (_htons = wasmExports["htons"])(a0);
        var _ioctl = Module["_ioctl"] = (a0, a1, a22) => (_ioctl = Module["_ioctl"] = wasmExports["ioctl"])(a0, a1, a22);
        var _emscripten_builtin_memalign = (a0, a1) => (_emscripten_builtin_memalign = wasmExports["emscripten_builtin_memalign"])(a0, a1);
        var _ntohs = (a0) => (_ntohs = wasmExports["ntohs"])(a0);
        var _srand = Module["_srand"] = (a0) => (_srand = Module["_srand"] = wasmExports["srand"])(a0);
        var _rand = Module["_rand"] = () => (_rand = Module["_rand"] = wasmExports["rand"])();
        var __emscripten_timeout = (a0, a1) => (__emscripten_timeout = wasmExports["_emscripten_timeout"])(a0, a1);
        var ___floatsitf = Module["___floatsitf"] = (a0, a1) => (___floatsitf = Module["___floatsitf"] = wasmExports["__floatsitf"])(a0, a1);
        var ___multf3 = Module["___multf3"] = (a0, a1, a22, a32, a42) => (___multf3 = Module["___multf3"] = wasmExports["__multf3"])(a0, a1, a22, a32, a42);
        var ___extenddftf2 = Module["___extenddftf2"] = (a0, a1) => (___extenddftf2 = Module["___extenddftf2"] = wasmExports["__extenddftf2"])(a0, a1);
        var ___getf2 = Module["___getf2"] = (a0, a1, a22, a32) => (___getf2 = Module["___getf2"] = wasmExports["__getf2"])(a0, a1, a22, a32);
        var ___subtf3 = Module["___subtf3"] = (a0, a1, a22, a32, a42) => (___subtf3 = Module["___subtf3"] = wasmExports["__subtf3"])(a0, a1, a22, a32, a42);
        var ___letf2 = Module["___letf2"] = (a0, a1, a22, a32) => (___letf2 = Module["___letf2"] = wasmExports["__letf2"])(a0, a1, a22, a32);
        var ___lttf2 = Module["___lttf2"] = (a0, a1, a22, a32) => (___lttf2 = Module["___lttf2"] = wasmExports["__lttf2"])(a0, a1, a22, a32);
        var _setThrew = (a0, a1) => (_setThrew = wasmExports["setThrew"])(a0, a1);
        var __emscripten_tempret_set = (a0) => (__emscripten_tempret_set = wasmExports["_emscripten_tempret_set"])(a0);
        var __emscripten_tempret_get = () => (__emscripten_tempret_get = wasmExports["_emscripten_tempret_get"])();
        var ___fixtfsi = Module["___fixtfsi"] = (a0, a1) => (___fixtfsi = Module["___fixtfsi"] = wasmExports["__fixtfsi"])(a0, a1);
        var __emscripten_stack_restore = (a0) => (__emscripten_stack_restore = wasmExports["_emscripten_stack_restore"])(a0);
        var __emscripten_stack_alloc = (a0) => (__emscripten_stack_alloc = wasmExports["_emscripten_stack_alloc"])(a0);
        var _emscripten_stack_get_current = () => (_emscripten_stack_get_current = wasmExports["emscripten_stack_get_current"])();
        var _ScanKeywords = Module["_ScanKeywords"] = 69101716;
        var _stderr = Module["_stderr"] = 69124144;
        var _stdout = Module["_stdout"] = 69124448;
        var _CurrentMemoryContext = Module["_CurrentMemoryContext"] = 69156188;
        var _TopMemoryContext = Module["_TopMemoryContext"] = 69156192;
        var _TTSOpsVirtual = Module["_TTSOpsVirtual"] = 68962840;
        var ___THREW__ = Module["___THREW__"] = 69281700;
        var ___threwValue = Module["___threwValue"] = 69281704;
        var _error_context_stack = Module["_error_context_stack"] = 69171244;
        var _PG_exception_stack = Module["_PG_exception_stack"] = 69171248;
        var _CurrentResourceOwner = Module["_CurrentResourceOwner"] = 69156268;
        var _wal_segment_size = Module["_wal_segment_size"] = 68972040;
        var _InterruptPending = Module["_InterruptPending"] = 69162052;
        var _MyLatch = Module["_MyLatch"] = 69162220;
        var _InterruptHoldoffCount = Module["_InterruptHoldoffCount"] = 69162092;
        var _CritSectionCount = Module["_CritSectionCount"] = 69162100;
        var _pg_global_prng_state = Module["_pg_global_prng_state"] = 69267952;
        var _MyProc = Module["_MyProc"] = 69129772;
        var _GUC_check_errdetail_string = Module["_GUC_check_errdetail_string"] = 69157224;
        var _IsUnderPostmaster = Module["_IsUnderPostmaster"] = 69162125;
        var _progname = Module["_progname"] = 69125572;
        var _MyDatabaseId = Module["_MyDatabaseId"] = 69162108;
        var _MyProcPid = Module["_MyProcPid"] = 69162188;
        var _MyProcPort = Module["_MyProcPort"] = 69162208;
        var _single_mode_feed = Module["_single_mode_feed"] = 69125588;
        var _stdin = Module["_stdin"] = 69124296;
        var _SOCKET_DATA = Module["_SOCKET_DATA"] = 69185960;
        var _SOCKET_FILE = Module["_SOCKET_FILE"] = 69185956;
        var _cma_rsize = Module["_cma_rsize"] = 69125620;
        var _debug_query_string = Module["_debug_query_string"] = 69125804;
        var _cma_wsize = Module["_cma_wsize"] = 69125628;
        var _quote_all_identifiers = Module["_quote_all_identifiers"] = 69125577;
        var _TopTransactionContext = Module["_TopTransactionContext"] = 69156212;
        var _TopTransactionResourceOwner = Module["_TopTransactionResourceOwner"] = 69156276;
        var _TTSOpsMinimalTuple = Module["_TTSOpsMinimalTuple"] = 68962936;
        var _ProcessUtility_hook = Module["_ProcessUtility_hook"] = 69125992;
        var _work_mem = Module["_work_mem"] = 69095552;
        var _ParallelWorkerNumber = Module["_ParallelWorkerNumber"] = 68963384;
        var _XactIsoLevel = Module["_XactIsoLevel"] = 68971796;
        var _SnapshotAnyData = Module["_SnapshotAnyData"] = 69034440;
        var _SPI_processed = Module["_SPI_processed"] = 69126504;
        var _SPI_tuptable = Module["_SPI_tuptable"] = 69126512;
        var _SPI_result = Module["_SPI_result"] = 69126516;
        var _CacheMemoryContext = Module["_CacheMemoryContext"] = 69156204;
        var _pgBufferUsage = Module["_pgBufferUsage"] = 69127376;
        var _pgWalUsage = Module["_pgWalUsage"] = 69127488;
        var _TTSOpsHeapTuple = Module["_TTSOpsHeapTuple"] = 68962888;
        var _ExecutorStart_hook = Module["_ExecutorStart_hook"] = 69127512;
        var _ExecutorRun_hook = Module["_ExecutorRun_hook"] = 69127516;
        var _ExecutorFinish_hook = Module["_ExecutorFinish_hook"] = 69127520;
        var _ExecutorEnd_hook = Module["_ExecutorEnd_hook"] = 69127524;
        var _LocalBufferBlockPointers = Module["_LocalBufferBlockPointers"] = 69138204;
        var _BufferBlocks = Module["_BufferBlocks"] = 69132952;
        var _maintenance_work_mem = Module["_maintenance_work_mem"] = 69095568;
        var _wal_level = Module["_wal_level"] = 68972020;
        var _NBuffers = Module["_NBuffers"] = 69095576;
        var _old_snapshot_threshold = Module["_old_snapshot_threshold"] = 69156404;
        var _MainLWLockArray = Module["_MainLWLockArray"] = 69129804;
        var _ShmemVariableCache = Module["_ShmemVariableCache"] = 69128588;
        var _RmgrTable = Module["_RmgrTable"] = 68963600;
        var _process_shared_preload_libraries_in_progress = Module["_process_shared_preload_libraries_in_progress"] = 69162040;
        var _DataDir = Module["_DataDir"] = 69162104;
        var _shmem_startup_hook = Module["_shmem_startup_hook"] = 69132724;
        var _BufferDescriptors = Module["_BufferDescriptors"] = 69132948;
        var _application_name = Module["_application_name"] = 69158428;
        var _pg_crc32_table = Module["_pg_crc32_table"] = 67826528;
        var _oldSnapshotControl = Module["_oldSnapshotControl"] = 69156408;
        var _check_function_bodies = Module["_check_function_bodies"] = 69034614;
        var _cluster_name = Module["_cluster_name"] = 69034668;
        var _extra_float_digits = Module["_extra_float_digits"] = 69084196;
        var _max_parallel_maintenance_workers = Module["_max_parallel_maintenance_workers"] = 69095572;
        var _seq_page_cost = Module["_seq_page_cost"] = 69096440;
        var _cpu_tuple_cost = Module["_cpu_tuple_cost"] = 69096456;
        var _cpu_operator_cost = Module["_cpu_operator_cost"] = 69096472;
        var _Log_directory = Module["_Log_directory"] = 69172148;
        var _Log_filename = Module["_Log_filename"] = 69172152;
        var _IntervalStyle = Module["_IntervalStyle"] = 69162132;
        var _DateStyle = Module["_DateStyle"] = 69095540;
        var _xmlStructuredError = Module["_xmlStructuredError"] = 69268316;
        var _xmlStructuredErrorContext = Module["_xmlStructuredErrorContext"] = 69268324;
        var _xmlGenericErrorContext = Module["_xmlGenericErrorContext"] = 69268320;
        var _xmlGenericError = Module["_xmlGenericError"] = 69106020;
        var _xmlIsBaseCharGroup = Module["_xmlIsBaseCharGroup"] = 69105784;
        var _xmlIsDigitGroup = Module["_xmlIsDigitGroup"] = 69105816;
        var _xmlIsCombiningGroup = Module["_xmlIsCombiningGroup"] = 69105800;
        var _xmlIsExtenderGroup = Module["_xmlIsExtenderGroup"] = 69105832;
        var _xmlFree = Module["_xmlFree"] = 69105984;
        var _pg_number_of_ones = Module["_pg_number_of_ones"] = 68765008;
        var _MyStartTime = Module["_MyStartTime"] = 69162192;
        var _shmem_request_hook = Module["_shmem_request_hook"] = 69162044;
        var _ScanKeywordTokens = Module["_ScanKeywordTokens"] = 68450864;
        var _post_parse_analyze_hook = Module["_post_parse_analyze_hook"] = 69172140;
        var _ConfigReloadPending = Module["_ConfigReloadPending"] = 69172172;
        var _ShutdownRequestPending = Module["_ShutdownRequestPending"] = 69172176;
        var _planner_hook = Module["_planner_hook"] = 69172616;
        var _WalReceiverFunctions = Module["_WalReceiverFunctions"] = 69182296;
        var _check_password_hook = Module["_check_password_hook"] = 69172724;
        var _ClientAuthentication_hook = Module["_ClientAuthentication_hook"] = 69173480;
        var _IDB_STAGE = Module["_IDB_STAGE"] = 69185968;
        var _IDB_PIPE_FP = Module["_IDB_PIPE_FP"] = 69185964;
        var _pg_scram_mech = Module["_pg_scram_mech"] = 69105728;
        var _pg_g_threadlock = Module["_pg_g_threadlock"] = 69103832;
        var _pgresStatus = Module["_pgresStatus"] = 69105520;
        var _xmlIsPubidChar_tab = Module["_xmlIsPubidChar_tab"] = 68765296;
        var _xmlGetWarningsDefaultValue = Module["_xmlGetWarningsDefaultValue"] = 69106012;
        var _xmlMalloc = Module["_xmlMalloc"] = 69105988;
        var _xmlRealloc = Module["_xmlRealloc"] = 69105996;
        var _xmlLastError = Module["_xmlLastError"] = 69268336;
        var _xmlMallocAtomic = Module["_xmlMallocAtomic"] = 69105992;
        var _xmlMemStrdup = Module["_xmlMemStrdup"] = 69106e3;
        var _xmlBufferAllocScheme = Module["_xmlBufferAllocScheme"] = 69106004;
        var _xmlDefaultBufferSize = Module["_xmlDefaultBufferSize"] = 69106008;
        var _xmlParserDebugEntities = Module["_xmlParserDebugEntities"] = 69268276;
        var _xmlDoValidityCheckingDefaultValue = Module["_xmlDoValidityCheckingDefaultValue"] = 69268280;
        var _xmlLoadExtDtdDefaultValue = Module["_xmlLoadExtDtdDefaultValue"] = 69268284;
        var _xmlPedanticParserDefaultValue = Module["_xmlPedanticParserDefaultValue"] = 69268288;
        var _xmlLineNumbersDefaultValue = Module["_xmlLineNumbersDefaultValue"] = 69268292;
        var _xmlKeepBlanksDefaultValue = Module["_xmlKeepBlanksDefaultValue"] = 69106016;
        var _xmlSubstituteEntitiesDefaultValue = Module["_xmlSubstituteEntitiesDefaultValue"] = 69268296;
        var _xmlRegisterNodeDefaultValue = Module["_xmlRegisterNodeDefaultValue"] = 69268300;
        var _xmlDeregisterNodeDefaultValue = Module["_xmlDeregisterNodeDefaultValue"] = 69268304;
        var _xmlParserInputBufferCreateFilenameValue = Module["_xmlParserInputBufferCreateFilenameValue"] = 69268308;
        var _xmlOutputBufferCreateFilenameValue = Module["_xmlOutputBufferCreateFilenameValue"] = 69268312;
        var _xmlIndentTreeOutput = Module["_xmlIndentTreeOutput"] = 69106024;
        var _xmlTreeIndentString = Module["_xmlTreeIndentString"] = 69106028;
        var _xmlSaveNoEmptyTags = Module["_xmlSaveNoEmptyTags"] = 69268328;
        var _xmlDefaultSAXHandler = Module["_xmlDefaultSAXHandler"] = 69106032;
        var _xmlDefaultSAXLocator = Module["_xmlDefaultSAXLocator"] = 69106144;
        var _xmlParserMaxDepth = Module["_xmlParserMaxDepth"] = 69106804;
        var _xmlStringText = Module["_xmlStringText"] = 68767104;
        var _xmlStringComment = Module["_xmlStringComment"] = 68767119;
        var _xmlStringTextNoenc = Module["_xmlStringTextNoenc"] = 68767109;
        var _xmlXPathNAN = Module["_xmlXPathNAN"] = 69269e3;
        var _xmlXPathNINF = Module["_xmlXPathNINF"] = 69269016;
        var _xmlXPathPINF = Module["_xmlXPathPINF"] = 69269008;
        var _z_errmsg = Module["_z_errmsg"] = 69123360;
        var __length_code = Module["__length_code"] = 68786768;
        var __dist_code = Module["__dist_code"] = 68786256;
        function invoke_i(index7) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)();
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iii(index7, a1, a22) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_ii(index7, a1) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viii(index7, a1, a22, a32) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_ji(index7, a1) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
            return 0n;
          }
        }
        function invoke_vi(index7, a1) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiii(index7, a1, a22, a32, a42) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_vii(index7, a1, a22) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_v(index7) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)();
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viiiii(index7, a1, a22, a32, a42, a52) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_jiiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72, a82) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72, a82);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
            return 0n;
          }
        }
        function invoke_jiiiii(index7, a1, a22, a32, a42, a52) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
            return 0n;
          }
        }
        function invoke_viiii(index7, a1, a22, a32, a42) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72, a82) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72, a82);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_vji(index7, a1, a22) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiii(index7, a1, a22, a32) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiijii(index7, a1, a22, a32, a42, a52, a62) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_vijiji(index7, a1, a22, a32, a42, a52) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viji(index7, a1, a22, a32) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_jiiii(index7, a1, a22, a32, a42) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
            return 0n;
          }
        }
        function invoke_viiiiii(index7, a1, a22, a32, a42, a52, a62) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiiiii(index7, a1, a22, a32, a42, a52, a62) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72, a82) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72, a82);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiiii(index7, a1, a22, a32, a42, a52) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viiiiiiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11, a12) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11, a12);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viiiiiii(index7, a1, a22, a32, a42, a52, a62, a72) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_jii(index7, a1, a22) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
            return 0n;
          }
        }
        function invoke_iiij(index7, a1, a22, a32) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_di(index7, a1) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_id(index7, a1) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_ijiiiii(index7, a1, a22, a32, a42, a52, a62) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_ij(index7, a1) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiij(index7, a1, a22, a32, a42) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viiij(index7, a1, a22, a32, a42) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viiji(index7, a1, a22, a32, a42) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiji(index7, a1, a22, a32) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viiiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72, a82, a9) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72, a82, a9);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_vij(index7, a1, a22) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72, a82, a9) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72, a82, a9);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_vid(index7, a1, a22) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiiiiiiiiiiiiiii(index7, a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11, a12, a13, a14, a15, a16) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72, a82, a9, a10, a11, a12, a13, a14, a15, a16);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_vj(index7, a1) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_ijiiiiii(index7, a1, a22, a32, a42, a52, a62, a72) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viijii(index7, a1, a22, a32, a42, a52) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_iiiiiji(index7, a1, a22, a32, a42, a52, a62) {
          var sp = stackSave();
          try {
            return getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viijiiii(index7, a1, a22, a32, a42, a52, a62, a72) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32, a42, a52, a62, a72);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        function invoke_viij(index7, a1, a22, a32) {
          var sp = stackSave();
          try {
            getWasmTableEntry(index7)(a1, a22, a32);
          } catch (e6) {
            stackRestore(sp);
            if (e6 !== e6 + 0) throw e6;
            _setThrew(1, 0);
          }
        }
        Module["addRunDependency"] = addRunDependency;
        Module["removeRunDependency"] = removeRunDependency;
        Module["callMain"] = callMain;
        Module["ccall"] = ccall;
        Module["cwrap"] = cwrap;
        Module["setValue"] = setValue;
        Module["getValue"] = getValue;
        Module["UTF8ToString"] = UTF8ToString;
        Module["stringToNewUTF8"] = stringToNewUTF8;
        Module["stringToUTF8OnStack"] = stringToUTF8OnStack;
        Module["FS_createPreloadedFile"] = FS_createPreloadedFile;
        Module["FS_unlink"] = FS_unlink;
        Module["FS_createPath"] = FS_createPath;
        Module["FS_createDevice"] = FS_createDevice;
        Module["FS"] = FS;
        Module["FS_createDataFile"] = FS_createDataFile;
        Module["FS_createLazyFile"] = FS_createLazyFile;
        var calledRun;
        dependenciesFulfilled = function runCaller() {
          if (!calledRun) run();
          if (!calledRun) dependenciesFulfilled = runCaller;
        };
        function callMain(args2 = []) {
          var entryFunction = resolveGlobalSymbol("main").sym;
          ;
          if (!entryFunction) return;
          args2.unshift(thisProgram);
          var argc = args2.length;
          var argv = stackAlloc((argc + 1) * 4);
          var argv_ptr = argv;
          args2.forEach((arg) => {
            HEAPU32[argv_ptr >> 2] = stringToUTF8OnStack(arg);
            argv_ptr += 4;
          });
          HEAPU32[argv_ptr >> 2] = 0;
          try {
            var ret = entryFunction(argc, argv);
            exitJS(
              ret,
              /* implicit = */
              true
            );
            return ret;
          } catch (e6) {
            return handleException(e6);
          }
        }
        function run(args2 = arguments_) {
          if (runDependencies > 0) {
            return;
          }
          preRun();
          if (runDependencies > 0) {
            return;
          }
          function doRun() {
            if (calledRun) return;
            calledRun = true;
            Module["calledRun"] = true;
            if (ABORT) return;
            initRuntime();
            preMain();
            readyPromiseResolve(Module);
            Module["onRuntimeInitialized"]?.();
            if (shouldRunNow) callMain(args2);
            postRun();
          }
          if (Module["setStatus"]) {
            Module["setStatus"]("Running...");
            setTimeout(() => {
              setTimeout(() => Module["setStatus"](""), 1);
              doRun();
            }, 1);
          } else {
            doRun();
          }
        }
        if (Module["preInit"]) {
          if (typeof Module["preInit"] == "function") Module["preInit"] = [Module["preInit"]];
          while (Module["preInit"].length > 0) {
            Module["preInit"].pop()();
          }
        }
        var shouldRunNow = true;
        if (Module["noInitialRun"]) shouldRunNow = false;
        run();
        moduleRtn = readyPromise;
        return moduleRtn;
      };
    })();
    postgres_default = Module2;
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/fs/nodefs.js
var nodefs_exports = {};
__export(nodefs_exports, {
  NodeFS: () => m7
});
var s9, o8, m7;
var init_nodefs = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/fs/nodefs.js"() {
    "use strict";
    init_chunk_RBN4KMJ6();
    init_chunk_Y3AVQXKT();
    s9 = __toESM(require("fs"), 1);
    o8 = __toESM(require("path"), 1);
    x5();
    m7 = class extends sr {
      constructor(t6) {
        super(t6), this.rootDir = o8.resolve(t6), s9.existsSync(o8.join(this.rootDir)) || s9.mkdirSync(this.rootDir);
      }
      async init(t6, e6) {
        return this.pg = t6, { emscriptenOpts: { ...e6, preRun: [...e6.preRun || [], (r6) => {
          let c6 = r6.FS.filesystems.NODEFS;
          r6.FS.mkdir(C2), r6.FS.mount(c6, { root: this.rootDir }, C2);
        }] } };
      }
      async closeFs() {
        this.pg.Module.FS.quit();
      }
    };
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/fs/opfs-ahp.js
var opfs_ahp_exports = {};
__export(opfs_ahp_exports, {
  OpfsAhpFS: () => L4
});
var $2, G3, T2, H4, v7, O2, M, y4, b6, m8, x7, F4, P3, S3, n6, C4, D4, k6, w7, f8, I2, W2, j6, L4, p7;
var init_opfs_ahp = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/fs/opfs-ahp.js"() {
    "use strict";
    init_chunk_RBN4KMJ6();
    init_chunk_Y3AVQXKT();
    x5();
    $2 = "state.txt";
    G3 = "data";
    T2 = { DIR: 16384, FILE: 32768 };
    L4 = class extends ur {
      constructor(e6, { initialPoolSize: t6 = 1e3, maintainedPoolSize: o9 = 100, debug: i8 = false } = {}) {
        super(e6, { debug: i8 });
        L(this, n6);
        L(this, H4);
        L(this, v7);
        L(this, O2);
        L(this, M);
        L(this, y4);
        L(this, b6, /* @__PURE__ */ new Map());
        L(this, m8, /* @__PURE__ */ new Map());
        L(this, x7, 0);
        L(this, F4, /* @__PURE__ */ new Map());
        L(this, P3, /* @__PURE__ */ new Map());
        this.lastCheckpoint = 0;
        this.checkpointInterval = 1e3 * 60;
        this.poolCounter = 0;
        L(this, S3, /* @__PURE__ */ new Set());
        this.initialPoolSize = t6, this.maintainedPoolSize = o9;
      }
      async init(e6, t6) {
        return await P(this, n6, C4).call(this), super.init(e6, t6);
      }
      async syncToFs(e6 = false) {
        await this.maybeCheckpointState(), await this.maintainPool(), e6 || this.flush();
      }
      async closeFs() {
        for (let e6 of g5(this, m8).values()) e6.close();
        g5(this, y4).flush(), g5(this, y4).close(), this.pg.Module.FS.quit();
      }
      async maintainPool(e6) {
        e6 = e6 || this.maintainedPoolSize;
        let t6 = e6 - this.state.pool.length, o9 = [];
        for (let i8 = 0; i8 < t6; i8++) o9.push(new Promise(async (c6) => {
          ++this.poolCounter;
          let a9 = `${(Date.now() - 1704063600).toString(16).padStart(8, "0")}-${this.poolCounter.toString(16).padStart(8, "0")}`, h8 = await g5(this, O2).getFileHandle(a9, { create: true }), d7 = await h8.createSyncAccessHandle();
          g5(this, b6).set(a9, h8), g5(this, m8).set(a9, d7), P(this, n6, k6).call(this, { opp: "createPoolFile", args: [a9] }), this.state.pool.push(a9), c6();
        }));
        for (let i8 = 0; i8 > t6; i8--) o9.push(new Promise(async (c6) => {
          let a9 = this.state.pool.pop();
          P(this, n6, k6).call(this, { opp: "deletePoolFile", args: [a9] });
          let h8 = g5(this, b6).get(a9);
          g5(this, m8).get(a9)?.close(), await h8.remove().then(() => {
            g5(this, b6).delete(a9), g5(this, m8).delete(a9), c6();
          });
        }));
        await Promise.all(o9);
      }
      _createPoolFileState(e6) {
        this.state.pool.push(e6);
      }
      _deletePoolFileState(e6) {
        let t6 = this.state.pool.indexOf(e6);
        t6 > -1 && this.state.pool.splice(t6, 1);
      }
      async maybeCheckpointState() {
        Date.now() - this.lastCheckpoint > this.checkpointInterval && await this.checkpointState();
      }
      async checkpointState() {
        let e6 = new TextEncoder().encode(JSON.stringify(this.state));
        g5(this, y4).truncate(0), g5(this, y4).write(e6, { at: 0 }), g5(this, y4).flush(), this.lastCheckpoint = Date.now();
      }
      flush() {
        for (let e6 of g5(this, S3)) try {
          e6.flush();
        } catch {
        }
        g5(this, S3).clear();
      }
      chmod(e6, t6) {
        P(this, n6, D4).call(this, { opp: "chmod", args: [e6, t6] }, () => {
          this._chmodState(e6, t6);
        });
      }
      _chmodState(e6, t6) {
        let o9 = P(this, n6, f8).call(this, e6);
        o9.mode = t6;
      }
      close(e6) {
        let t6 = P(this, n6, I2).call(this, e6);
        g5(this, F4).delete(e6), g5(this, P3).delete(t6);
      }
      fstat(e6) {
        let t6 = P(this, n6, I2).call(this, e6);
        return this.lstat(t6);
      }
      lstat(e6) {
        let t6 = P(this, n6, f8).call(this, e6), o9 = t6.type === "file" ? g5(this, m8).get(t6.backingFilename).getSize() : 0, i8 = 4096;
        return { dev: 0, ino: 0, mode: t6.mode, nlink: 1, uid: 0, gid: 0, rdev: 0, size: o9, blksize: i8, blocks: Math.ceil(o9 / i8), atime: t6.lastModified, mtime: t6.lastModified, ctime: t6.lastModified };
      }
      mkdir(e6, t6) {
        P(this, n6, D4).call(this, { opp: "mkdir", args: [e6, t6] }, () => {
          this._mkdirState(e6, t6);
        });
      }
      _mkdirState(e6, t6) {
        let o9 = P(this, n6, w7).call(this, e6), i8 = o9.pop(), c6 = [], a9 = this.state.root;
        for (let d7 of o9) {
          if (c6.push(e6), !Object.prototype.hasOwnProperty.call(a9.children, d7)) if (t6?.recursive) this.mkdir(c6.join("/"));
          else throw new p7("ENOENT", "No such file or directory");
          if (a9.children[d7].type !== "directory") throw new p7("ENOTDIR", "Not a directory");
          a9 = a9.children[d7];
        }
        if (Object.prototype.hasOwnProperty.call(a9.children, i8)) throw new p7("EEXIST", "File exists");
        let h8 = { type: "directory", lastModified: Date.now(), mode: t6?.mode || T2.DIR, children: {} };
        a9.children[i8] = h8;
      }
      open(e6, t6, o9) {
        if (P(this, n6, f8).call(this, e6).type !== "file") throw new p7("EISDIR", "Is a directory");
        let c6 = P(this, n6, W2).call(this);
        return g5(this, F4).set(c6, e6), g5(this, P3).set(e6, c6), c6;
      }
      readdir(e6) {
        let t6 = P(this, n6, f8).call(this, e6);
        if (t6.type !== "directory") throw new p7("ENOTDIR", "Not a directory");
        return Object.keys(t6.children);
      }
      read(e6, t6, o9, i8, c6) {
        let a9 = P(this, n6, I2).call(this, e6), h8 = P(this, n6, f8).call(this, a9);
        if (h8.type !== "file") throw new p7("EISDIR", "Is a directory");
        return g5(this, m8).get(h8.backingFilename).read(new Uint8Array(t6.buffer, o9, i8), { at: c6 });
      }
      rename(e6, t6) {
        P(this, n6, D4).call(this, { opp: "rename", args: [e6, t6] }, () => {
          this._renameState(e6, t6, true);
        });
      }
      _renameState(e6, t6, o9 = false) {
        let i8 = P(this, n6, w7).call(this, e6), c6 = i8.pop(), a9 = P(this, n6, f8).call(this, i8.join("/"));
        if (!Object.prototype.hasOwnProperty.call(a9.children, c6)) throw new p7("ENOENT", "No such file or directory");
        let h8 = P(this, n6, w7).call(this, t6), d7 = h8.pop(), l7 = P(this, n6, f8).call(this, h8.join("/"));
        if (o9 && Object.prototype.hasOwnProperty.call(l7.children, d7)) {
          let u7 = l7.children[d7];
          g5(this, m8).get(u7.backingFilename).truncate(0), this.state.pool.push(u7.backingFilename);
        }
        l7.children[d7] = a9.children[c6], delete a9.children[c6];
      }
      rmdir(e6) {
        P(this, n6, D4).call(this, { opp: "rmdir", args: [e6] }, () => {
          this._rmdirState(e6);
        });
      }
      _rmdirState(e6) {
        let t6 = P(this, n6, w7).call(this, e6), o9 = t6.pop(), i8 = P(this, n6, f8).call(this, t6.join("/"));
        if (!Object.prototype.hasOwnProperty.call(i8.children, o9)) throw new p7("ENOENT", "No such file or directory");
        let c6 = i8.children[o9];
        if (c6.type !== "directory") throw new p7("ENOTDIR", "Not a directory");
        if (Object.keys(c6.children).length > 0) throw new p7("ENOTEMPTY", "Directory not empty");
        delete i8.children[o9];
      }
      truncate(e6, t6 = 0) {
        let o9 = P(this, n6, f8).call(this, e6);
        if (o9.type !== "file") throw new p7("EISDIR", "Is a directory");
        let i8 = g5(this, m8).get(o9.backingFilename);
        if (!i8) throw new p7("ENOENT", "No such file or directory");
        i8.truncate(t6), g5(this, S3).add(i8);
      }
      unlink(e6) {
        P(this, n6, D4).call(this, { opp: "unlink", args: [e6] }, () => {
          this._unlinkState(e6, true);
        });
      }
      _unlinkState(e6, t6 = false) {
        let o9 = P(this, n6, w7).call(this, e6), i8 = o9.pop(), c6 = P(this, n6, f8).call(this, o9.join("/"));
        if (!Object.prototype.hasOwnProperty.call(c6.children, i8)) throw new p7("ENOENT", "No such file or directory");
        let a9 = c6.children[i8];
        if (a9.type !== "file") throw new p7("EISDIR", "Is a directory");
        if (delete c6.children[i8], t6) {
          let h8 = g5(this, m8).get(a9.backingFilename);
          h8?.truncate(0), g5(this, S3).add(h8), g5(this, P3).has(e6) && (g5(this, F4).delete(g5(this, P3).get(e6)), g5(this, P3).delete(e6));
        }
        this.state.pool.push(a9.backingFilename);
      }
      utimes(e6, t6, o9) {
        P(this, n6, D4).call(this, { opp: "utimes", args: [e6, t6, o9] }, () => {
          this._utimesState(e6, t6, o9);
        });
      }
      _utimesState(e6, t6, o9) {
        let i8 = P(this, n6, f8).call(this, e6);
        i8.lastModified = o9;
      }
      writeFile(e6, t6, o9) {
        let i8 = P(this, n6, w7).call(this, e6), c6 = i8.pop(), a9 = P(this, n6, f8).call(this, i8.join("/"));
        if (Object.prototype.hasOwnProperty.call(a9.children, c6)) {
          let l7 = a9.children[c6];
          l7.lastModified = Date.now(), P(this, n6, k6).call(this, { opp: "setLastModified", args: [e6, l7.lastModified] });
        } else {
          if (this.state.pool.length === 0) throw new Error("No more file handles available in the pool");
          let l7 = { type: "file", lastModified: Date.now(), mode: o9?.mode || T2.FILE, backingFilename: this.state.pool.pop() };
          a9.children[c6] = l7, P(this, n6, k6).call(this, { opp: "createFileNode", args: [e6, l7] });
        }
        let h8 = a9.children[c6], d7 = g5(this, m8).get(h8.backingFilename);
        t6.length > 0 && (d7.write(typeof t6 == "string" ? new TextEncoder().encode(t6) : new Uint8Array(t6), { at: 0 }), e6.startsWith("/pg_wal") && g5(this, S3).add(d7));
      }
      _createFileNodeState(e6, t6) {
        let o9 = P(this, n6, w7).call(this, e6), i8 = o9.pop(), c6 = P(this, n6, f8).call(this, o9.join("/"));
        c6.children[i8] = t6;
        let a9 = this.state.pool.indexOf(t6.backingFilename);
        return a9 > -1 && this.state.pool.splice(a9, 1), t6;
      }
      _setLastModifiedState(e6, t6) {
        let o9 = P(this, n6, f8).call(this, e6);
        o9.lastModified = t6;
      }
      write(e6, t6, o9, i8, c6) {
        let a9 = P(this, n6, I2).call(this, e6), h8 = P(this, n6, f8).call(this, a9);
        if (h8.type !== "file") throw new p7("EISDIR", "Is a directory");
        let d7 = g5(this, m8).get(h8.backingFilename);
        if (!d7) throw new p7("EBADF", "Bad file descriptor");
        let l7 = d7.write(new Uint8Array(t6, o9, i8), { at: c6 });
        return a9.startsWith("/pg_wal") && g5(this, S3).add(d7), l7;
      }
    };
    H4 = /* @__PURE__ */ new WeakMap(), v7 = /* @__PURE__ */ new WeakMap(), O2 = /* @__PURE__ */ new WeakMap(), M = /* @__PURE__ */ new WeakMap(), y4 = /* @__PURE__ */ new WeakMap(), b6 = /* @__PURE__ */ new WeakMap(), m8 = /* @__PURE__ */ new WeakMap(), x7 = /* @__PURE__ */ new WeakMap(), F4 = /* @__PURE__ */ new WeakMap(), P3 = /* @__PURE__ */ new WeakMap(), S3 = /* @__PURE__ */ new WeakMap(), n6 = /* @__PURE__ */ new WeakSet(), C4 = async function() {
      h6(this, H4, await navigator.storage.getDirectory()), h6(this, v7, await P(this, n6, j6).call(this, this.dataDir, { create: true })), h6(this, O2, await P(this, n6, j6).call(this, G3, { from: g5(this, v7), create: true })), h6(this, M, await g5(this, v7).getFileHandle($2, { create: true })), h6(this, y4, await g5(this, M).createSyncAccessHandle());
      let e6 = new ArrayBuffer(g5(this, y4).getSize());
      g5(this, y4).read(e6, { at: 0 });
      let t6, o9 = new TextDecoder().decode(e6).split(`
`), i8 = false;
      try {
        t6 = JSON.parse(o9[0]);
      } catch {
        t6 = { root: { type: "directory", lastModified: Date.now(), mode: T2.DIR, children: {} }, pool: [] }, g5(this, y4).truncate(0), g5(this, y4).write(new TextEncoder().encode(JSON.stringify(t6)), { at: 0 }), i8 = true;
      }
      this.state = t6;
      let c6 = o9.slice(1).filter(Boolean).map((l7) => JSON.parse(l7));
      for (let l7 of c6) {
        let u7 = `_${l7.opp}State`;
        if (typeof this[u7] == "function") try {
          this[u7].bind(this)(...l7.args);
        } catch (N5) {
          console.warn("Error applying OPFS AHP WAL entry", l7, N5);
        }
      }
      let a9 = [], h8 = async (l7) => {
        if (l7.type === "file") try {
          let u7 = await g5(this, O2).getFileHandle(l7.backingFilename), N5 = await u7.createSyncAccessHandle();
          g5(this, b6).set(l7.backingFilename, u7), g5(this, m8).set(l7.backingFilename, N5);
        } catch (u7) {
          console.error("Error opening file handle for node", l7, u7);
        }
        else for (let u7 of Object.values(l7.children)) a9.push(h8(u7));
      };
      await h8(this.state.root);
      let d7 = [];
      for (let l7 of this.state.pool) d7.push(new Promise(async (u7) => {
        g5(this, b6).has(l7) && console.warn("File handle already exists for pool file", l7);
        let N5 = await g5(this, O2).getFileHandle(l7), U4 = await N5.createSyncAccessHandle();
        g5(this, b6).set(l7, N5), g5(this, m8).set(l7, U4), u7();
      }));
      await Promise.all([...a9, ...d7]), await this.maintainPool(i8 ? this.initialPoolSize : this.maintainedPoolSize);
    }, D4 = function(e6, t6) {
      let o9 = P(this, n6, k6).call(this, e6);
      try {
        t6();
      } catch (i8) {
        throw g5(this, y4).truncate(o9), i8;
      }
    }, k6 = function(e6) {
      let t6 = JSON.stringify(e6), o9 = new TextEncoder().encode(`
${t6}`), i8 = g5(this, y4).getSize();
      return g5(this, y4).write(o9, { at: i8 }), g5(this, S3).add(g5(this, y4)), i8;
    }, w7 = function(e6) {
      return e6.split("/").filter(Boolean);
    }, f8 = function(e6, t6) {
      let o9 = P(this, n6, w7).call(this, e6), i8 = t6 || this.state.root;
      for (let c6 of o9) {
        if (i8.type !== "directory") throw new p7("ENOTDIR", "Not a directory");
        if (!Object.prototype.hasOwnProperty.call(i8.children, c6)) throw new p7("ENOENT", "No such file or directory");
        i8 = i8.children[c6];
      }
      return i8;
    }, I2 = function(e6) {
      let t6 = g5(this, F4).get(e6);
      if (!t6) throw new p7("EBADF", "Bad file descriptor");
      return t6;
    }, W2 = function() {
      let e6 = ++R(this, x7)._;
      for (; g5(this, F4).has(e6); ) R(this, x7)._++;
      return e6;
    }, j6 = async function(e6, t6) {
      let o9 = P(this, n6, w7).call(this, e6), i8 = t6?.from || g5(this, H4);
      for (let c6 of o9) i8 = await i8.getDirectoryHandle(c6, { create: t6?.create });
      return i8;
    };
    p7 = class extends Error {
      constructor(A5, e6) {
        super(e6), typeof A5 == "number" ? this.code = A5 : typeof A5 == "string" && (this.code = cr[A5]);
      }
    };
  }
});

// ../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/index.js
var dist_exports2 = {};
__export(dist_exports2, {
  IdbFs: () => L5,
  MemoryFS: () => q6,
  Mutex: () => M2,
  PGlite: () => xe2,
  formatQuery: () => Nr,
  messages: () => Ie,
  parse: () => qn,
  protocol: () => _t,
  types: () => jn,
  uuid: () => Ur
});
function he2(i8) {
  let t6;
  if (i8?.startsWith("file://")) {
    if (i8 = i8.slice(7), !i8) throw new Error("Invalid dataDir, must be a valid path");
    t6 = "nodefs";
  } else i8?.startsWith("idb://") ? (i8 = i8.slice(6), t6 = "idbfs") : i8?.startsWith("opfs-ahp://") ? (i8 = i8.slice(11), t6 = "opfs-ahp") : !i8 || i8?.startsWith("memory://") ? t6 = "memoryfs" : t6 = "nodefs";
  return { dataDir: i8, fsType: t6 };
}
async function ge2(i8, t6) {
  let e6;
  if (i8 && t6 === "nodefs") {
    let { NodeFS: s10 } = await Promise.resolve().then(() => (init_nodefs(), nodefs_exports));
    e6 = new s10(i8);
  } else if (i8 && t6 === "idbfs") e6 = new L5(i8);
  else if (i8 && t6 === "opfs-ahp") {
    let { OpfsAhpFS: s10 } = await Promise.resolve().then(() => (init_opfs_ahp(), opfs_ahp_exports));
    e6 = new s10(i8);
  } else e6 = new q6();
  return e6;
}
async function ee2(i8) {
  if (Ge) {
    let t6 = require("fs"), e6 = require("zlib"), { Writable: s10 } = require("stream"), { pipeline: o9 } = require("stream/promises");
    if (!t6.existsSync(i8)) throw new Error(`Extension bundle not found: ${i8}`);
    let r6 = e6.createGunzip(), c6 = [];
    return await o9(t6.createReadStream(i8), r6, new s10({ write(m12, l7, d7) {
      c6.push(m12), d7();
    } })), new Blob(c6);
  } else {
    let t6 = await fetch(i8.toString());
    if (!t6.ok || !t6.body) return null;
    if (t6.headers.get("Content-Encoding") === "gzip") return t6.blob();
    {
      let e6 = new DecompressionStream("gzip");
      return new Response(t6.body.pipeThrough(e6)).blob();
    }
  }
}
async function be2(i8, t6) {
  for (let e6 in i8.pg_extensions) {
    let s10;
    try {
      s10 = await i8.pg_extensions[e6];
    } catch (o9) {
      console.error("Failed to fetch extension:", e6, o9);
      continue;
    }
    if (s10) {
      let o9 = new Uint8Array(await s10.arrayBuffer());
      Ie2(i8, e6, o9, t6);
    } else console.error("Could not get binary data for extension:", e6);
  }
}
function Ie2(i8, t6, e6, s10) {
  we2.default.untar(e6).forEach((r6) => {
    if (!r6.name.startsWith(".")) {
      let c6 = i8.WASM_PREFIX + "/" + r6.name;
      if (r6.name.endsWith(".so")) {
        let m12 = (...d7) => {
          s10("pgfs:ext OK", c6, d7);
        }, l7 = (...d7) => {
          s10("pgfs:ext FAIL", c6, d7);
        };
        i8.FS.createPreloadedFile(ke2(c6), r6.name.split("/").pop().slice(0, -3), r6.data, true, true, m12, l7, false);
      } else i8.FS.writeFile(c6, r6.data);
    }
  });
}
function ke2(i8) {
  let t6 = i8.lastIndexOf("/");
  return t6 > 0 ? i8.slice(0, t6) : i8;
}
var Ne2, Ue2, Ae2, Re2, Z3, De2, M2, ye2, L5, q6, we2, I3, O3, A4, k7, N2, K2, X2, Y2, U2, $3, C5, Q2, R4, F5, w8, D5, P4, Pe2, W3, te2, xe2;
var init_dist5 = __esm({
  "../node_modules/.pnpm/@electric-sql+pglite@0.2.12/node_modules/@electric-sql/pglite/dist/index.js"() {
    "use strict";
    init_chunk_RBN4KMJ6();
    init_chunk_NMYRYYP2();
    init_chunk_EL7DUS2A();
    init_chunk_IZM3GSNN();
    init_chunk_Y3AVQXKT();
    init_postgres2();
    x5();
    x5();
    x5();
    Ne2 = new Error("timeout while waiting for mutex to become available");
    Ue2 = new Error("mutex already locked");
    Ae2 = new Error("request for lock canceled");
    Re2 = function(i8, t6, e6, s10) {
      function o9(r6) {
        return r6 instanceof e6 ? r6 : new e6(function(c6) {
          c6(r6);
        });
      }
      return new (e6 || (e6 = Promise))(function(r6, c6) {
        function m12(u7) {
          try {
            d7(s10.next(u7));
          } catch (a9) {
            c6(a9);
          }
        }
        function l7(u7) {
          try {
            d7(s10.throw(u7));
          } catch (a9) {
            c6(a9);
          }
        }
        function d7(u7) {
          u7.done ? r6(u7.value) : o9(u7.value).then(m12, l7);
        }
        d7((s10 = s10.apply(i8, t6 || [])).next());
      });
    };
    Z3 = class {
      constructor(t6, e6 = Ae2) {
        this._value = t6, this._cancelError = e6, this._weightedQueues = [], this._weightedWaiters = [];
      }
      acquire(t6 = 1) {
        if (t6 <= 0) throw new Error(`invalid weight ${t6}: must be positive`);
        return new Promise((e6, s10) => {
          this._weightedQueues[t6 - 1] || (this._weightedQueues[t6 - 1] = []), this._weightedQueues[t6 - 1].push({ resolve: e6, reject: s10 }), this._dispatch();
        });
      }
      runExclusive(t6, e6 = 1) {
        return Re2(this, void 0, void 0, function* () {
          let [s10, o9] = yield this.acquire(e6);
          try {
            return yield t6(s10);
          } finally {
            o9();
          }
        });
      }
      waitForUnlock(t6 = 1) {
        if (t6 <= 0) throw new Error(`invalid weight ${t6}: must be positive`);
        return new Promise((e6) => {
          this._weightedWaiters[t6 - 1] || (this._weightedWaiters[t6 - 1] = []), this._weightedWaiters[t6 - 1].push(e6), this._dispatch();
        });
      }
      isLocked() {
        return this._value <= 0;
      }
      getValue() {
        return this._value;
      }
      setValue(t6) {
        this._value = t6, this._dispatch();
      }
      release(t6 = 1) {
        if (t6 <= 0) throw new Error(`invalid weight ${t6}: must be positive`);
        this._value += t6, this._dispatch();
      }
      cancel() {
        this._weightedQueues.forEach((t6) => t6.forEach((e6) => e6.reject(this._cancelError))), this._weightedQueues = [];
      }
      _dispatch() {
        var t6;
        for (let e6 = this._value; e6 > 0; e6--) {
          let s10 = (t6 = this._weightedQueues[e6 - 1]) === null || t6 === void 0 ? void 0 : t6.shift();
          if (!s10) continue;
          let o9 = this._value, r6 = e6;
          this._value -= e6, e6 = this._value + 1, s10.resolve([o9, this._newReleaser(r6)]);
        }
        this._drainUnlockWaiters();
      }
      _newReleaser(t6) {
        let e6 = false;
        return () => {
          e6 || (e6 = true, this.release(t6));
        };
      }
      _drainUnlockWaiters() {
        for (let t6 = this._value; t6 > 0; t6--) this._weightedWaiters[t6 - 1] && (this._weightedWaiters[t6 - 1].forEach((e6) => e6()), this._weightedWaiters[t6 - 1] = []);
      }
    };
    De2 = function(i8, t6, e6, s10) {
      function o9(r6) {
        return r6 instanceof e6 ? r6 : new e6(function(c6) {
          c6(r6);
        });
      }
      return new (e6 || (e6 = Promise))(function(r6, c6) {
        function m12(u7) {
          try {
            d7(s10.next(u7));
          } catch (a9) {
            c6(a9);
          }
        }
        function l7(u7) {
          try {
            d7(s10.throw(u7));
          } catch (a9) {
            c6(a9);
          }
        }
        function d7(u7) {
          u7.done ? r6(u7.value) : o9(u7.value).then(m12, l7);
        }
        d7((s10 = s10.apply(i8, t6 || [])).next());
      });
    };
    M2 = class {
      constructor(t6) {
        this._semaphore = new Z3(1, t6);
      }
      acquire() {
        return De2(this, void 0, void 0, function* () {
          let [, t6] = yield this._semaphore.acquire();
          return t6;
        });
      }
      runExclusive(t6) {
        return this._semaphore.runExclusive(() => t6());
      }
      isLocked() {
        return this._semaphore.isLocked();
      }
      waitForUnlock() {
        return this._semaphore.waitForUnlock();
      }
      release() {
        this._semaphore.isLocked() && this._semaphore.release();
      }
      cancel() {
        return this._semaphore.cancel();
      }
    };
    x5();
    ye2 = postgres_default;
    x5();
    x5();
    L5 = class extends sr {
      async init(t6, e6) {
        return this.pg = t6, { emscriptenOpts: { ...e6, preRun: [...e6.preRun || [], (o9) => {
          let r6 = o9.FS.filesystems.IDBFS;
          o9.FS.mkdir("/pglite"), o9.FS.mkdir(`/pglite/${this.dataDir}`), o9.FS.mount(r6, {}, `/pglite/${this.dataDir}`), o9.FS.symlink(`/pglite/${this.dataDir}`, C2);
        }] } };
      }
      initialSyncFs() {
        return new Promise((t6, e6) => {
          this.pg.Module.FS.syncfs(true, (s10) => {
            s10 ? e6(s10) : t6();
          });
        });
      }
      syncToFs(t6) {
        return new Promise((e6, s10) => {
          this.pg.Module.FS.syncfs(false, (o9) => {
            o9 ? s10(o9) : e6();
          });
        });
      }
      async closeFs() {
        let t6 = this.pg.Module.FS.filesystems.IDBFS.dbs[this.dataDir];
        t6 && t6.close(), this.pg.Module.FS.quit();
      }
    };
    x5();
    q6 = class extends sr {
      async closeFs() {
        this.pg.Module.FS.quit();
      }
    };
    x5();
    we2 = F3(or2(), 1);
    te2 = class te3 extends z3 {
      constructor(e6 = {}, s10 = {}) {
        super();
        L(this, P4);
        L(this, I3, false);
        L(this, O3, false);
        L(this, A4, false);
        L(this, k7, false);
        L(this, N2, false);
        L(this, K2, new M2());
        L(this, X2, new M2());
        L(this, Y2, new M2());
        L(this, U2, false);
        this.debug = 0;
        L(this, $3);
        L(this, C5, []);
        L(this, Q2, new ye());
        L(this, R4);
        L(this, F5);
        L(this, w8, /* @__PURE__ */ new Map());
        L(this, D5, /* @__PURE__ */ new Set());
        typeof e6 == "string" ? s10 = { dataDir: e6, ...s10 } : s10 = e6, this.dataDir = s10.dataDir, s10?.debug !== void 0 && (this.debug = s10.debug), s10?.relaxedDurability !== void 0 && h6(this, N2, s10.relaxedDurability), h6(this, $3, s10.extensions ?? {}), this.waitReady = P(this, P4, Pe2).call(this, s10 ?? {});
      }
      static async create(e6, s10) {
        let o9 = typeof e6 == "string" ? { dataDir: e6, ...s10 ?? {} } : e6 ?? {}, r6 = new te3(o9);
        return await r6.waitReady, r6;
      }
      get Module() {
        return this.mod;
      }
      get ready() {
        return g5(this, I3) && !g5(this, O3) && !g5(this, A4);
      }
      get closed() {
        return g5(this, A4);
      }
      async close() {
        await this._checkReady(), h6(this, O3, true);
        for (let e6 of g5(this, C5)) await e6();
        try {
          await this.execProtocol(k5.end()), this.mod._pg_shutdown();
        } catch (e6) {
          let s10 = e6;
          if (!(s10.name === "ExitStatus" && s10.status === 0)) throw e6;
        }
        await this.fs.closeFs(), h6(this, A4, true), h6(this, O3, false);
      }
      async [Symbol.asyncDispose]() {
        await this.close();
      }
      async _handleBlob(e6) {
        h6(this, R4, e6 ? await e6.arrayBuffer() : void 0);
      }
      async _cleanupBlob() {
        h6(this, R4, void 0);
      }
      async _getWrittenBlob() {
        if (!g5(this, F5)) return;
        let e6 = new Blob(g5(this, F5));
        return h6(this, F5, void 0), e6;
      }
      async _checkReady() {
        if (g5(this, O3)) throw new Error("PGlite is closing");
        if (g5(this, A4)) throw new Error("PGlite is closed");
        g5(this, I3) || await this.waitReady;
      }
      async execProtocolRaw(e6, { syncToFs: s10 = true } = {}) {
        let o9 = e6.length, r6 = this.mod;
        r6._interactive_write(o9), r6.HEAPU8.set(e6, 1), r6._interactive_one();
        let c6 = o9 + 2, m12 = c6 + r6._interactive_read(), l7 = r6.HEAPU8.subarray(c6, m12);
        return s10 && await this.syncToFs(), l7;
      }
      async execProtocol(e6, { syncToFs: s10 = true, throwOnError: o9 = true, onNotice: r6 } = {}) {
        let c6 = await this.execProtocolRaw(e6, { syncToFs: s10 }), m12 = [];
        return g5(this, Q2).parse(c6, (l7) => {
          if (l7 instanceof C3) {
            if (h6(this, Q2, new ye()), o9) throw l7;
          } else if (l7 instanceof ne2) this.debug > 0 && console.warn(l7), r6 && r6(l7);
          else if (l7 instanceof ee) switch (l7.text) {
            case "BEGIN":
              h6(this, k7, true);
              break;
            case "COMMIT":
            case "ROLLBACK":
              h6(this, k7, false);
              break;
          }
          else if (l7 instanceof X) {
            let d7 = g5(this, w8).get(l7.channel);
            d7 && d7.forEach((u7) => {
              queueMicrotask(() => u7(l7.payload));
            }), g5(this, D5).forEach((u7) => {
              queueMicrotask(() => u7(l7.channel, l7.payload));
            });
          }
          m12.push([l7, c6]);
        }), m12;
      }
      isInTransaction() {
        return g5(this, k7);
      }
      async syncToFs() {
        if (g5(this, U2)) return;
        h6(this, U2, true);
        let e6 = async () => {
          await g5(this, Y2).runExclusive(async () => {
            h6(this, U2, false), await this.fs.syncToFs(g5(this, N2));
          });
        };
        g5(this, N2) ? e6() : await e6();
      }
      async listen(e6, s10) {
        return g5(this, w8).has(e6) || g5(this, w8).set(e6, /* @__PURE__ */ new Set()), g5(this, w8).get(e6).add(s10), await this.exec(`LISTEN "${e6}"`), async () => {
          await this.unlisten(e6, s10);
        };
      }
      async unlisten(e6, s10) {
        s10 ? (g5(this, w8).get(e6)?.delete(s10), g5(this, w8).get(e6)?.size === 0 && (await this.exec(`UNLISTEN "${e6}"`), g5(this, w8).delete(e6))) : (await this.exec(`UNLISTEN "${e6}"`), g5(this, w8).delete(e6));
      }
      onNotification(e6) {
        return g5(this, D5).add(e6), () => {
          g5(this, D5).delete(e6);
        };
      }
      offNotification(e6) {
        g5(this, D5).delete(e6);
      }
      async dumpDataDir(e6) {
        let s10 = this.dataDir?.split("/").pop() ?? "pgdata";
        return this.fs.dumpTar(s10, e6);
      }
      _runExclusiveQuery(e6) {
        return g5(this, K2).runExclusive(e6);
      }
      _runExclusiveTransaction(e6) {
        return g5(this, X2).runExclusive(e6);
      }
    };
    I3 = /* @__PURE__ */ new WeakMap(), O3 = /* @__PURE__ */ new WeakMap(), A4 = /* @__PURE__ */ new WeakMap(), k7 = /* @__PURE__ */ new WeakMap(), N2 = /* @__PURE__ */ new WeakMap(), K2 = /* @__PURE__ */ new WeakMap(), X2 = /* @__PURE__ */ new WeakMap(), Y2 = /* @__PURE__ */ new WeakMap(), U2 = /* @__PURE__ */ new WeakMap(), $3 = /* @__PURE__ */ new WeakMap(), C5 = /* @__PURE__ */ new WeakMap(), Q2 = /* @__PURE__ */ new WeakMap(), R4 = /* @__PURE__ */ new WeakMap(), F5 = /* @__PURE__ */ new WeakMap(), w8 = /* @__PURE__ */ new WeakMap(), D5 = /* @__PURE__ */ new WeakMap(), P4 = /* @__PURE__ */ new WeakSet(), Pe2 = async function(e6) {
      if (e6.fs) this.fs = e6.fs;
      else {
        let { dataDir: a9, fsType: h8 } = he2(e6.dataDir);
        this.fs = await ge2(a9, h8);
      }
      let s10 = {}, o9 = [], r6 = [`PGDATA=${C2}`, `PREFIX=${Vr}`, `PGUSER=${e6.username ?? "postgres"}`, `PGDATABASE=${e6.database ?? "template1"}`, "MODE=REACT", "REPL=N", ...this.debug ? ["-d", this.debug.toString()] : []];
      e6.wasmModule || Er();
      let c6 = e6.fsBundle ? e6.fsBundle.arrayBuffer() : Pr(), m12;
      c6.then((a9) => {
        m12 = a9;
      });
      let l7 = { WASM_PREFIX: Vr, arguments: r6, INITIAL_MEMORY: e6.initialMemory, noExitRuntime: true, ...this.debug > 0 ? { print: console.info, printErr: console.error } : { print: () => {
      }, printErr: () => {
      } }, instantiateWasm: (a9, h8) => (Cr(a9, e6.wasmModule).then(({ instance: g10, module: b9 }) => {
        h8(g10, b9);
      }), {}), getPreloadedPackage: (a9, h8) => {
        if (a9 === "postgres.data") {
          if (m12.byteLength !== h8) throw new Error(`Invalid FS bundle size: ${m12.byteLength} !== ${h8}`);
          return m12;
        }
        throw new Error(`Unknown package: ${a9}`);
      }, preRun: [(a9) => {
        let h8 = a9.FS.makedev(64, 0), g10 = { open: (b9) => {
        }, close: (b9) => {
        }, read: (b9, G4, T4, S7, x11) => {
          let se2 = g5(this, R4);
          if (!se2) throw new Error("No /dev/blob File or Blob provided to read from");
          let H5 = new Uint8Array(se2);
          if (x11 >= H5.length) return 0;
          let ie4 = Math.min(H5.length - x11, S7);
          for (let j7 = 0; j7 < ie4; j7++) G4[T4 + j7] = H5[x11 + j7];
          return ie4;
        }, write: (b9, G4, T4, S7, x11) => (g5(this, F5) ?? h6(this, F5, []), g5(this, F5).push(G4.slice(T4, T4 + S7)), S7), llseek: (b9, G4, T4) => {
          let S7 = g5(this, R4);
          if (!S7) throw new Error("No /dev/blob File or Blob provided to llseek");
          let x11 = G4;
          if (T4 === 1 ? x11 += b9.position : T4 === 2 && (x11 = new Uint8Array(S7).length), x11 < 0) throw new a9.FS.ErrnoError(28);
          return x11;
        } };
        a9.FS.registerDevice(h8, g10), a9.FS.mkdev("/dev/blob", h8);
      }] }, { emscriptenOpts: d7 } = await this.fs.init(this, l7);
      l7 = d7;
      for (let [a9, h8] of Object.entries(g5(this, $3))) if (h8 instanceof URL) s10[a9] = ee2(h8);
      else {
        let g10 = await h8.setup(this, l7);
        if (g10.emscriptenOpts && (l7 = g10.emscriptenOpts), g10.namespaceObj) {
          let b9 = this;
          b9[a9] = g10.namespaceObj;
        }
        g10.bundlePath && (s10[a9] = ee2(g10.bundlePath)), g10.init && o9.push(g10.init), g10.close && g5(this, C5).push(g10.close);
      }
      if (l7.pg_extensions = s10, await c6, this.mod = await ye2(l7), await this.fs.initialSyncFs(), e6.loadDataDir) {
        if (this.mod.FS.analyzePath(C2 + "/PG_VERSION").exists) throw new Error("Database already exists, cannot load from tarball");
        P(this, P4, W3).call(this, "pglite: loading data from tarball"), await ce(this.mod.FS, e6.loadDataDir, C2);
      }
      this.mod.FS.analyzePath(C2 + "/PG_VERSION").exists ? P(this, P4, W3).call(this, "pglite: found DB, resuming") : P(this, P4, W3).call(this, "pglite: no db"), await be2(this.mod, (...a9) => P(this, P4, W3).call(this, ...a9));
      let u7 = this.mod._pg_initdb();
      if (!u7) throw new Error("INITDB failed to return value");
      if (u7 & 1) throw new Error("INITDB failed");
      if (u7 & 2) {
        let a9 = e6.username ?? "postgres", h8 = e6.database ?? "template1";
        if (u7 & 4) {
          if (!(u7 & 12)) throw new Error("Invalid db/user combination");
        } else if (h8 !== "template1" && a9 !== "postgres") throw new Error("INITDB created a new datadir, but an alternative db/user was requested");
      }
      await this.syncToFs(), h6(this, I3, true), await this.exec("SET search_path TO public;"), await this._initArrayTypes();
      for (let a9 of o9) await a9();
    }, W3 = function(...e6) {
      this.debug > 0 && console.log(...e6);
    };
    xe2 = te2;
    x5();
  }
});

// ../drizzle-orm/dist/pglite/session.js
var _a456, _b331, PglitePreparedQuery, _a457, _b332, _PgliteSession, PgliteSession, _a458, _b333, _PgliteTransaction, PgliteTransaction;
var init_session6 = __esm({
  "../drizzle-orm/dist/pglite/session.js"() {
    "use strict";
    init_entity();
    init_logger();
    init_pg_core();
    init_session2();
    init_sql();
    init_utils();
    init_dist5();
    init_cache();
    PglitePreparedQuery = class extends (_b331 = PgPreparedQuery, _a456 = entityKind, _b331) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, name3, _isResponseInArrayMode, customResultMapper) {
        super({ sql: queryString, params }, cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQueryConfig");
        __publicField(this, "queryConfig");
        this.client = client;
        this.queryString = queryString;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
        this.rawQueryConfig = {
          rowMode: "object",
          parsers: {
            [jn.TIMESTAMP]: (value) => value,
            [jn.TIMESTAMPTZ]: (value) => value,
            [jn.INTERVAL]: (value) => value,
            [jn.DATE]: (value) => value,
            // numeric[]
            [1231]: (value) => value,
            // timestamp[]
            [1115]: (value) => value,
            // timestamp with timezone[]
            [1185]: (value) => value,
            // interval[]
            [1187]: (value) => value,
            // date[]
            [1182]: (value) => value
          }
        };
        this.queryConfig = {
          rowMode: "array",
          parsers: {
            [jn.TIMESTAMP]: (value) => value,
            [jn.TIMESTAMPTZ]: (value) => value,
            [jn.INTERVAL]: (value) => value,
            [jn.DATE]: (value) => value,
            // numeric[]
            [1231]: (value) => value,
            // timestamp[]
            [1115]: (value) => value,
            // timestamp with timezone[]
            [1185]: (value) => value,
            // interval[]
            [1187]: (value) => value,
            // date[]
            [1182]: (value) => value
          }
        };
      }
      async execute(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.queryString, params);
        const { fields, client, queryConfig, joinsNotNullableMap, customResultMapper, queryString, rawQueryConfig } = this;
        if (!fields && !customResultMapper) {
          return this.queryWithCache(queryString, params, async () => {
            return await client.query(queryString, params, rawQueryConfig);
          });
        }
        const result = await this.queryWithCache(queryString, params, async () => {
          return await client.query(queryString, params, queryConfig);
        });
        return customResultMapper ? customResultMapper(result.rows) : result.rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      all(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.queryString, params);
        return this.queryWithCache(this.queryString, params, async () => {
          return await this.client.query(this.queryString, params, this.rawQueryConfig);
        }).then((result) => result.rows);
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(PglitePreparedQuery, _a456, "PglitePreparedQuery");
    _PgliteSession = class _PgliteSession extends (_b332 = PgSession, _a457 = entityKind, _b332) {
      constructor(client, dialect6, schema6, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, name3, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return new PglitePreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          name3,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      async transaction(transaction, config) {
        return this.client.transaction(async (client) => {
          const session = new _PgliteSession(
            client,
            this.dialect,
            this.schema,
            this.options
          );
          const tx = new PgliteTransaction(this.dialect, session, this.schema);
          if (config) {
            await tx.setTransaction(config);
          }
          return transaction(tx);
        });
      }
      async count(sql22) {
        const res = await this.execute(sql22);
        return Number(
          res["rows"][0]["count"]
        );
      }
    };
    __publicField(_PgliteSession, _a457, "PgliteSession");
    PgliteSession = _PgliteSession;
    _PgliteTransaction = class _PgliteTransaction extends (_b333 = PgTransaction, _a458 = entityKind, _b333) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _PgliteTransaction(
          this.dialect,
          this.session,
          this.schema,
          this.nestedIndex + 1
        );
        await tx.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await tx.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_PgliteTransaction, _a458, "PgliteTransaction");
    PgliteTransaction = _PgliteTransaction;
  }
});

// ../drizzle-orm/dist/pglite/driver.js
function construct2(client, config = {}) {
  const dialect6 = new PgDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const driver2 = new PgliteDriver(client, dialect6, { logger: logger2, cache: config.cache });
  const session = driver2.createSession(schema6);
  const db2 = new PgliteDatabase(dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function drizzle2(...params) {
  if (params[0] === void 0 || typeof params[0] === "string") {
    const instance2 = new xe2(params[0]);
    return construct2(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct2(client, drizzleConfig);
    if (typeof connection2 === "object") {
      const { dataDir, ...options } = connection2;
      const instance22 = new xe2(dataDir, options);
      return construct2(instance22, drizzleConfig);
    }
    const instance2 = new xe2(connection2);
    return construct2(instance2, drizzleConfig);
  }
  return construct2(params[0], params[1]);
}
var _a459, PgliteDriver, _a460, _b334, PgliteDatabase;
var init_driver2 = __esm({
  "../drizzle-orm/dist/pglite/driver.js"() {
    "use strict";
    init_dist5();
    init_entity();
    init_logger();
    init_db2();
    init_dialect2();
    init_relations();
    init_utils();
    init_session6();
    _a459 = entityKind;
    PgliteDriver = class {
      constructor(client, dialect6, options = {}) {
        this.client = client;
        this.dialect = dialect6;
        this.options = options;
      }
      createSession(schema6) {
        return new PgliteSession(this.client, this.dialect, schema6, {
          logger: this.options.logger,
          cache: this.options.cache
        });
      }
    };
    __publicField(PgliteDriver, _a459, "PgliteDriver");
    PgliteDatabase = class extends (_b334 = PgDatabase, _a460 = entityKind, _b334) {
    };
    __publicField(PgliteDatabase, _a460, "PgliteDatabase");
    ((drizzle22) => {
      function mock(config) {
        return construct2({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle2 || (drizzle2 = {}));
  }
});

// ../drizzle-orm/dist/pglite/index.js
var pglite_exports = {};
__export(pglite_exports, {
  PgliteDatabase: () => PgliteDatabase,
  PgliteDriver: () => PgliteDriver,
  PglitePreparedQuery: () => PglitePreparedQuery,
  PgliteSession: () => PgliteSession,
  PgliteTransaction: () => PgliteTransaction,
  drizzle: () => drizzle2
});
var init_pglite = __esm({
  "../drizzle-orm/dist/pglite/index.js"() {
    "use strict";
    init_driver2();
    init_session6();
  }
});

// ../drizzle-orm/dist/pglite/migrator.js
var migrator_exports2 = {};
__export(migrator_exports2, {
  migrate: () => migrate2
});
async function migrate2(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator3 = __esm({
  "../drizzle-orm/dist/pglite/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../node_modules/.pnpm/postgres-array@2.0.0/node_modules/postgres-array/index.js
var require_postgres_array = __commonJS({
  "../node_modules/.pnpm/postgres-array@2.0.0/node_modules/postgres-array/index.js"(exports2) {
    "use strict";
    exports2.parse = function(source, transform) {
      return new ArrayParser(source, transform).parse();
    };
    var ArrayParser = class _ArrayParser {
      constructor(source, transform) {
        this.source = source;
        this.transform = transform || identity;
        this.position = 0;
        this.entries = [];
        this.recorded = [];
        this.dimension = 0;
      }
      isEof() {
        return this.position >= this.source.length;
      }
      nextCharacter() {
        var character = this.source[this.position++];
        if (character === "\\") {
          return {
            value: this.source[this.position++],
            escaped: true
          };
        }
        return {
          value: character,
          escaped: false
        };
      }
      record(character) {
        this.recorded.push(character);
      }
      newEntry(includeEmpty) {
        var entry;
        if (this.recorded.length > 0 || includeEmpty) {
          entry = this.recorded.join("");
          if (entry === "NULL" && !includeEmpty) {
            entry = null;
          }
          if (entry !== null) entry = this.transform(entry);
          this.entries.push(entry);
          this.recorded = [];
        }
      }
      consumeDimensions() {
        if (this.source[0] === "[") {
          while (!this.isEof()) {
            var char4 = this.nextCharacter();
            if (char4.value === "=") break;
          }
        }
      }
      parse(nested) {
        var character, parser, quote2;
        this.consumeDimensions();
        while (!this.isEof()) {
          character = this.nextCharacter();
          if (character.value === "{" && !quote2) {
            this.dimension++;
            if (this.dimension > 1) {
              parser = new _ArrayParser(this.source.substr(this.position - 1), this.transform);
              this.entries.push(parser.parse(true));
              this.position += parser.position - 2;
            }
          } else if (character.value === "}" && !quote2) {
            this.dimension--;
            if (!this.dimension) {
              this.newEntry();
              if (nested) return this.entries;
            }
          } else if (character.value === '"' && !character.escaped) {
            if (quote2) this.newEntry(true);
            quote2 = !quote2;
          } else if (character.value === "," && !quote2) {
            this.newEntry();
          } else {
            this.record(character.value);
          }
        }
        if (this.dimension !== 0) {
          throw new Error("array dimension not balanced");
        }
        return this.entries;
      }
    };
    function identity(value) {
      return value;
    }
  }
});

// ../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/arrayParser.js
var require_arrayParser = __commonJS({
  "../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/arrayParser.js"(exports2, module2) {
    "use strict";
    var array3 = require_postgres_array();
    module2.exports = {
      create: function(source, transform) {
        return {
          parse: function() {
            return array3.parse(source, transform);
          }
        };
      }
    };
  }
});

// ../node_modules/.pnpm/postgres-date@1.0.7/node_modules/postgres-date/index.js
var require_postgres_date = __commonJS({
  "../node_modules/.pnpm/postgres-date@1.0.7/node_modules/postgres-date/index.js"(exports2, module2) {
    "use strict";
    var DATE_TIME = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/;
    var DATE = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/;
    var TIME_ZONE = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/;
    var INFINITY = /^-?infinity$/;
    module2.exports = function parseDate(isoDate) {
      if (INFINITY.test(isoDate)) {
        return Number(isoDate.replace("i", "I"));
      }
      var matches = DATE_TIME.exec(isoDate);
      if (!matches) {
        return getDate(isoDate) || null;
      }
      var isBC = !!matches[8];
      var year3 = parseInt(matches[1], 10);
      if (isBC) {
        year3 = bcYearToNegativeYear(year3);
      }
      var month = parseInt(matches[2], 10) - 1;
      var day = matches[3];
      var hour = parseInt(matches[4], 10);
      var minute = parseInt(matches[5], 10);
      var second = parseInt(matches[6], 10);
      var ms3 = matches[7];
      ms3 = ms3 ? 1e3 * parseFloat(ms3) : 0;
      var date4;
      var offset = timeZoneOffset(isoDate);
      if (offset != null) {
        date4 = new Date(Date.UTC(year3, month, day, hour, minute, second, ms3));
        if (is0To99(year3)) {
          date4.setUTCFullYear(year3);
        }
        if (offset !== 0) {
          date4.setTime(date4.getTime() - offset);
        }
      } else {
        date4 = new Date(year3, month, day, hour, minute, second, ms3);
        if (is0To99(year3)) {
          date4.setFullYear(year3);
        }
      }
      return date4;
    };
    function getDate(isoDate) {
      var matches = DATE.exec(isoDate);
      if (!matches) {
        return;
      }
      var year3 = parseInt(matches[1], 10);
      var isBC = !!matches[4];
      if (isBC) {
        year3 = bcYearToNegativeYear(year3);
      }
      var month = parseInt(matches[2], 10) - 1;
      var day = matches[3];
      var date4 = new Date(year3, month, day);
      if (is0To99(year3)) {
        date4.setFullYear(year3);
      }
      return date4;
    }
    function timeZoneOffset(isoDate) {
      if (isoDate.endsWith("+00")) {
        return 0;
      }
      var zone = TIME_ZONE.exec(isoDate.split(" ")[1]);
      if (!zone) return;
      var type = zone[1];
      if (type === "Z") {
        return 0;
      }
      var sign = type === "-" ? -1 : 1;
      var offset = parseInt(zone[2], 10) * 3600 + parseInt(zone[3] || 0, 10) * 60 + parseInt(zone[4] || 0, 10);
      return offset * sign * 1e3;
    }
    function bcYearToNegativeYear(year3) {
      return -(year3 - 1);
    }
    function is0To99(num) {
      return num >= 0 && num < 100;
    }
  }
});

// ../node_modules/.pnpm/xtend@4.0.2/node_modules/xtend/mutable.js
var require_mutable = __commonJS({
  "../node_modules/.pnpm/xtend@4.0.2/node_modules/xtend/mutable.js"(exports2, module2) {
    "use strict";
    module2.exports = extend;
    var hasOwnProperty = Object.prototype.hasOwnProperty;
    function extend(target) {
      for (var i8 = 1; i8 < arguments.length; i8++) {
        var source = arguments[i8];
        for (var key in source) {
          if (hasOwnProperty.call(source, key)) {
            target[key] = source[key];
          }
        }
      }
      return target;
    }
  }
});

// ../node_modules/.pnpm/postgres-interval@1.2.0/node_modules/postgres-interval/index.js
var require_postgres_interval = __commonJS({
  "../node_modules/.pnpm/postgres-interval@1.2.0/node_modules/postgres-interval/index.js"(exports2, module2) {
    "use strict";
    var extend = require_mutable();
    module2.exports = PostgresInterval;
    function PostgresInterval(raw2) {
      if (!(this instanceof PostgresInterval)) {
        return new PostgresInterval(raw2);
      }
      extend(this, parse6(raw2));
    }
    var properties = ["seconds", "minutes", "hours", "days", "months", "years"];
    PostgresInterval.prototype.toPostgres = function() {
      var filtered = properties.filter(this.hasOwnProperty, this);
      if (this.milliseconds && filtered.indexOf("seconds") < 0) {
        filtered.push("seconds");
      }
      if (filtered.length === 0) return "0";
      return filtered.map(function(property) {
        var value = this[property] || 0;
        if (property === "seconds" && this.milliseconds) {
          value = (value + this.milliseconds / 1e3).toFixed(6).replace(/\.?0+$/, "");
        }
        return value + " " + property;
      }, this).join(" ");
    };
    var propertiesISOEquivalent = {
      years: "Y",
      months: "M",
      days: "D",
      hours: "H",
      minutes: "M",
      seconds: "S"
    };
    var dateProperties = ["years", "months", "days"];
    var timeProperties = ["hours", "minutes", "seconds"];
    PostgresInterval.prototype.toISOString = PostgresInterval.prototype.toISO = function() {
      var datePart = dateProperties.map(buildProperty, this).join("");
      var timePart = timeProperties.map(buildProperty, this).join("");
      return "P" + datePart + "T" + timePart;
      function buildProperty(property) {
        var value = this[property] || 0;
        if (property === "seconds" && this.milliseconds) {
          value = (value + this.milliseconds / 1e3).toFixed(6).replace(/0+$/, "");
        }
        return value + propertiesISOEquivalent[property];
      }
    };
    var NUMBER = "([+-]?\\d+)";
    var YEAR = NUMBER + "\\s+years?";
    var MONTH = NUMBER + "\\s+mons?";
    var DAY = NUMBER + "\\s+days?";
    var TIME = "([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?";
    var INTERVAL = new RegExp([YEAR, MONTH, DAY, TIME].map(function(regexString) {
      return "(" + regexString + ")?";
    }).join("\\s*"));
    var positions = {
      years: 2,
      months: 4,
      days: 6,
      hours: 9,
      minutes: 10,
      seconds: 11,
      milliseconds: 12
    };
    var negatives = ["hours", "minutes", "seconds", "milliseconds"];
    function parseMilliseconds2(fraction) {
      var microseconds = fraction + "000000".slice(fraction.length);
      return parseInt(microseconds, 10) / 1e3;
    }
    function parse6(interval2) {
      if (!interval2) return {};
      var matches = INTERVAL.exec(interval2);
      var isNegative = matches[8] === "-";
      return Object.keys(positions).reduce(function(parsed, property) {
        var position = positions[property];
        var value = matches[position];
        if (!value) return parsed;
        value = property === "milliseconds" ? parseMilliseconds2(value) : parseInt(value, 10);
        if (!value) return parsed;
        if (isNegative && ~negatives.indexOf(property)) {
          value *= -1;
        }
        parsed[property] = value;
        return parsed;
      }, {});
    }
  }
});

// ../node_modules/.pnpm/postgres-bytea@1.0.0/node_modules/postgres-bytea/index.js
var require_postgres_bytea = __commonJS({
  "../node_modules/.pnpm/postgres-bytea@1.0.0/node_modules/postgres-bytea/index.js"(exports2, module2) {
    "use strict";
    module2.exports = function parseBytea(input) {
      if (/^\\x/.test(input)) {
        return new Buffer(input.substr(2), "hex");
      }
      var output = "";
      var i8 = 0;
      while (i8 < input.length) {
        if (input[i8] !== "\\") {
          output += input[i8];
          ++i8;
        } else {
          if (/[0-7]{3}/.test(input.substr(i8 + 1, 3))) {
            output += String.fromCharCode(parseInt(input.substr(i8 + 1, 3), 8));
            i8 += 4;
          } else {
            var backslashes = 1;
            while (i8 + backslashes < input.length && input[i8 + backslashes] === "\\") {
              backslashes++;
            }
            for (var k9 = 0; k9 < Math.floor(backslashes / 2); ++k9) {
              output += "\\";
            }
            i8 += Math.floor(backslashes / 2) * 2;
          }
        }
      }
      return new Buffer(output, "binary");
    };
  }
});

// ../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js
var require_textParsers = __commonJS({
  "../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/textParsers.js"(exports2, module2) {
    "use strict";
    var array3 = require_postgres_array();
    var arrayParser3 = require_arrayParser();
    var parseDate = require_postgres_date();
    var parseInterval = require_postgres_interval();
    var parseByteA = require_postgres_bytea();
    function allowNull(fn3) {
      return function nullAllowed(value) {
        if (value === null) return value;
        return fn3(value);
      };
    }
    function parseBool(value) {
      if (value === null) return value;
      return value === "TRUE" || value === "t" || value === "true" || value === "y" || value === "yes" || value === "on" || value === "1";
    }
    function parseBoolArray(value) {
      if (!value) return null;
      return array3.parse(value, parseBool);
    }
    function parseBaseTenInt(string2) {
      return parseInt(string2, 10);
    }
    function parseIntegerArray(value) {
      if (!value) return null;
      return array3.parse(value, allowNull(parseBaseTenInt));
    }
    function parseBigIntegerArray(value) {
      if (!value) return null;
      return array3.parse(value, allowNull(function(entry) {
        return parseBigInteger(entry).trim();
      }));
    }
    var parsePointArray = function(value) {
      if (!value) {
        return null;
      }
      var p11 = arrayParser3.create(value, function(entry) {
        if (entry !== null) {
          entry = parsePoint(entry);
        }
        return entry;
      });
      return p11.parse();
    };
    var parseFloatArray = function(value) {
      if (!value) {
        return null;
      }
      var p11 = arrayParser3.create(value, function(entry) {
        if (entry !== null) {
          entry = parseFloat(entry);
        }
        return entry;
      });
      return p11.parse();
    };
    var parseStringArray = function(value) {
      if (!value) {
        return null;
      }
      var p11 = arrayParser3.create(value);
      return p11.parse();
    };
    var parseDateArray = function(value) {
      if (!value) {
        return null;
      }
      var p11 = arrayParser3.create(value, function(entry) {
        if (entry !== null) {
          entry = parseDate(entry);
        }
        return entry;
      });
      return p11.parse();
    };
    var parseIntervalArray = function(value) {
      if (!value) {
        return null;
      }
      var p11 = arrayParser3.create(value, function(entry) {
        if (entry !== null) {
          entry = parseInterval(entry);
        }
        return entry;
      });
      return p11.parse();
    };
    var parseByteAArray = function(value) {
      if (!value) {
        return null;
      }
      return array3.parse(value, allowNull(parseByteA));
    };
    var parseInteger = function(value) {
      return parseInt(value, 10);
    };
    var parseBigInteger = function(value) {
      var valStr = String(value);
      if (/^\d+$/.test(valStr)) {
        return valStr;
      }
      return value;
    };
    var parseJsonArray = function(value) {
      if (!value) {
        return null;
      }
      return array3.parse(value, allowNull(JSON.parse));
    };
    var parsePoint = function(value) {
      if (value[0] !== "(") {
        return null;
      }
      value = value.substring(1, value.length - 1).split(",");
      return {
        x: parseFloat(value[0]),
        y: parseFloat(value[1])
      };
    };
    var parseCircle = function(value) {
      if (value[0] !== "<" && value[1] !== "(") {
        return null;
      }
      var point2 = "(";
      var radius = "";
      var pointParsed = false;
      for (var i8 = 2; i8 < value.length - 1; i8++) {
        if (!pointParsed) {
          point2 += value[i8];
        }
        if (value[i8] === ")") {
          pointParsed = true;
          continue;
        } else if (!pointParsed) {
          continue;
        }
        if (value[i8] === ",") {
          continue;
        }
        radius += value[i8];
      }
      var result = parsePoint(point2);
      result.radius = parseFloat(radius);
      return result;
    };
    var init3 = function(register) {
      register(20, parseBigInteger);
      register(21, parseInteger);
      register(23, parseInteger);
      register(26, parseInteger);
      register(700, parseFloat);
      register(701, parseFloat);
      register(16, parseBool);
      register(1082, parseDate);
      register(1114, parseDate);
      register(1184, parseDate);
      register(600, parsePoint);
      register(651, parseStringArray);
      register(718, parseCircle);
      register(1e3, parseBoolArray);
      register(1001, parseByteAArray);
      register(1005, parseIntegerArray);
      register(1007, parseIntegerArray);
      register(1028, parseIntegerArray);
      register(1016, parseBigIntegerArray);
      register(1017, parsePointArray);
      register(1021, parseFloatArray);
      register(1022, parseFloatArray);
      register(1231, parseFloatArray);
      register(1014, parseStringArray);
      register(1015, parseStringArray);
      register(1008, parseStringArray);
      register(1009, parseStringArray);
      register(1040, parseStringArray);
      register(1041, parseStringArray);
      register(1115, parseDateArray);
      register(1182, parseDateArray);
      register(1185, parseDateArray);
      register(1186, parseInterval);
      register(1187, parseIntervalArray);
      register(17, parseByteA);
      register(114, JSON.parse.bind(JSON));
      register(3802, JSON.parse.bind(JSON));
      register(199, parseJsonArray);
      register(3807, parseJsonArray);
      register(3907, parseStringArray);
      register(2951, parseStringArray);
      register(791, parseStringArray);
      register(1183, parseStringArray);
      register(1270, parseStringArray);
    };
    module2.exports = {
      init: init3
    };
  }
});

// ../node_modules/.pnpm/pg-int8@1.0.1/node_modules/pg-int8/index.js
var require_pg_int8 = __commonJS({
  "../node_modules/.pnpm/pg-int8@1.0.1/node_modules/pg-int8/index.js"(exports2, module2) {
    "use strict";
    var BASE = 1e6;
    function readInt8(buffer2) {
      var high = buffer2.readInt32BE(0);
      var low = buffer2.readUInt32BE(4);
      var sign = "";
      if (high < 0) {
        high = ~high + (low === 0);
        low = ~low + 1 >>> 0;
        sign = "-";
      }
      var result = "";
      var carry;
      var t6;
      var digits;
      var pad;
      var l7;
      var i8;
      {
        carry = high % BASE;
        high = high / BASE >>> 0;
        t6 = 4294967296 * carry + low;
        low = t6 / BASE >>> 0;
        digits = "" + (t6 - BASE * low);
        if (low === 0 && high === 0) {
          return sign + digits + result;
        }
        pad = "";
        l7 = 6 - digits.length;
        for (i8 = 0; i8 < l7; i8++) {
          pad += "0";
        }
        result = pad + digits + result;
      }
      {
        carry = high % BASE;
        high = high / BASE >>> 0;
        t6 = 4294967296 * carry + low;
        low = t6 / BASE >>> 0;
        digits = "" + (t6 - BASE * low);
        if (low === 0 && high === 0) {
          return sign + digits + result;
        }
        pad = "";
        l7 = 6 - digits.length;
        for (i8 = 0; i8 < l7; i8++) {
          pad += "0";
        }
        result = pad + digits + result;
      }
      {
        carry = high % BASE;
        high = high / BASE >>> 0;
        t6 = 4294967296 * carry + low;
        low = t6 / BASE >>> 0;
        digits = "" + (t6 - BASE * low);
        if (low === 0 && high === 0) {
          return sign + digits + result;
        }
        pad = "";
        l7 = 6 - digits.length;
        for (i8 = 0; i8 < l7; i8++) {
          pad += "0";
        }
        result = pad + digits + result;
      }
      {
        carry = high % BASE;
        t6 = 4294967296 * carry + low;
        digits = "" + t6 % BASE;
        return sign + digits + result;
      }
    }
    module2.exports = readInt8;
  }
});

// ../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/binaryParsers.js
var require_binaryParsers = __commonJS({
  "../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/binaryParsers.js"(exports2, module2) {
    "use strict";
    var parseInt64 = require_pg_int8();
    var parseBits = function(data, bits, offset, invert, callback) {
      offset = offset || 0;
      invert = invert || false;
      callback = callback || function(lastValue, newValue, bits2) {
        return lastValue * Math.pow(2, bits2) + newValue;
      };
      var offsetBytes = offset >> 3;
      var inv = function(value) {
        if (invert) {
          return ~value & 255;
        }
        return value;
      };
      var mask = 255;
      var firstBits = 8 - offset % 8;
      if (bits < firstBits) {
        mask = 255 << 8 - bits & 255;
        firstBits = bits;
      }
      if (offset) {
        mask = mask >> offset % 8;
      }
      var result = 0;
      if (offset % 8 + bits >= 8) {
        result = callback(0, inv(data[offsetBytes]) & mask, firstBits);
      }
      var bytes2 = bits + offset >> 3;
      for (var i8 = offsetBytes + 1; i8 < bytes2; i8++) {
        result = callback(result, inv(data[i8]), 8);
      }
      var lastBits = (bits + offset) % 8;
      if (lastBits > 0) {
        result = callback(result, inv(data[bytes2]) >> 8 - lastBits, lastBits);
      }
      return result;
    };
    var parseFloatFromBits = function(data, precisionBits, exponentBits) {
      var bias = Math.pow(2, exponentBits - 1) - 1;
      var sign = parseBits(data, 1);
      var exponent = parseBits(data, exponentBits, 1);
      if (exponent === 0) {
        return 0;
      }
      var precisionBitsCounter = 1;
      var parsePrecisionBits = function(lastValue, newValue, bits) {
        if (lastValue === 0) {
          lastValue = 1;
        }
        for (var i8 = 1; i8 <= bits; i8++) {
          precisionBitsCounter /= 2;
          if ((newValue & 1 << bits - i8) > 0) {
            lastValue += precisionBitsCounter;
          }
        }
        return lastValue;
      };
      var mantissa = parseBits(data, precisionBits, exponentBits + 1, false, parsePrecisionBits);
      if (exponent == Math.pow(2, exponentBits + 1) - 1) {
        if (mantissa === 0) {
          return sign === 0 ? Infinity : -Infinity;
        }
        return NaN;
      }
      return (sign === 0 ? 1 : -1) * Math.pow(2, exponent - bias) * mantissa;
    };
    var parseInt16 = function(value) {
      if (parseBits(value, 1) == 1) {
        return -1 * (parseBits(value, 15, 1, true) + 1);
      }
      return parseBits(value, 15, 1);
    };
    var parseInt32 = function(value) {
      if (parseBits(value, 1) == 1) {
        return -1 * (parseBits(value, 31, 1, true) + 1);
      }
      return parseBits(value, 31, 1);
    };
    var parseFloat32 = function(value) {
      return parseFloatFromBits(value, 23, 8);
    };
    var parseFloat64 = function(value) {
      return parseFloatFromBits(value, 52, 11);
    };
    var parseNumeric = function(value) {
      var sign = parseBits(value, 16, 32);
      if (sign == 49152) {
        return NaN;
      }
      var weight = Math.pow(1e4, parseBits(value, 16, 16));
      var result = 0;
      var digits = [];
      var ndigits = parseBits(value, 16);
      for (var i8 = 0; i8 < ndigits; i8++) {
        result += parseBits(value, 16, 64 + 16 * i8) * weight;
        weight /= 1e4;
      }
      var scale = Math.pow(10, parseBits(value, 16, 48));
      return (sign === 0 ? 1 : -1) * Math.round(result * scale) / scale;
    };
    var parseDate = function(isUTC, value) {
      var sign = parseBits(value, 1);
      var rawValue = parseBits(value, 63, 1);
      var result = new Date((sign === 0 ? 1 : -1) * rawValue / 1e3 + 9466848e5);
      if (!isUTC) {
        result.setTime(result.getTime() + result.getTimezoneOffset() * 6e4);
      }
      result.usec = rawValue % 1e3;
      result.getMicroSeconds = function() {
        return this.usec;
      };
      result.setMicroSeconds = function(value2) {
        this.usec = value2;
      };
      result.getUTCMicroSeconds = function() {
        return this.usec;
      };
      return result;
    };
    var parseArray = function(value) {
      var dim = parseBits(value, 32);
      var flags2 = parseBits(value, 32, 32);
      var elementType = parseBits(value, 32, 64);
      var offset = 96;
      var dims = [];
      for (var i8 = 0; i8 < dim; i8++) {
        dims[i8] = parseBits(value, 32, offset);
        offset += 32;
        offset += 32;
      }
      var parseElement = function(elementType2) {
        var length = parseBits(value, 32, offset);
        offset += 32;
        if (length == 4294967295) {
          return null;
        }
        var result;
        if (elementType2 == 23 || elementType2 == 20) {
          result = parseBits(value, length * 8, offset);
          offset += length * 8;
          return result;
        } else if (elementType2 == 25) {
          result = value.toString(this.encoding, offset >> 3, (offset += length << 3) >> 3);
          return result;
        } else {
          console.log("ERROR: ElementType not implemented: " + elementType2);
        }
      };
      var parse6 = function(dimension, elementType2) {
        var array3 = [];
        var i9;
        if (dimension.length > 1) {
          var count2 = dimension.shift();
          for (i9 = 0; i9 < count2; i9++) {
            array3[i9] = parse6(dimension, elementType2);
          }
          dimension.unshift(count2);
        } else {
          for (i9 = 0; i9 < dimension[0]; i9++) {
            array3[i9] = parseElement(elementType2);
          }
        }
        return array3;
      };
      return parse6(dims, elementType);
    };
    var parseText = function(value) {
      return value.toString("utf8");
    };
    var parseBool = function(value) {
      if (value === null) return null;
      return parseBits(value, 8) > 0;
    };
    var init3 = function(register) {
      register(20, parseInt64);
      register(21, parseInt16);
      register(23, parseInt32);
      register(26, parseInt32);
      register(1700, parseNumeric);
      register(700, parseFloat32);
      register(701, parseFloat64);
      register(16, parseBool);
      register(1114, parseDate.bind(null, false));
      register(1184, parseDate.bind(null, true));
      register(1e3, parseArray);
      register(1007, parseArray);
      register(1016, parseArray);
      register(1008, parseArray);
      register(1009, parseArray);
      register(25, parseText);
    };
    module2.exports = {
      init: init3
    };
  }
});

// ../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/builtins.js
var require_builtins = __commonJS({
  "../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/lib/builtins.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      BOOL: 16,
      BYTEA: 17,
      CHAR: 18,
      INT8: 20,
      INT2: 21,
      INT4: 23,
      REGPROC: 24,
      TEXT: 25,
      OID: 26,
      TID: 27,
      XID: 28,
      CID: 29,
      JSON: 114,
      XML: 142,
      PG_NODE_TREE: 194,
      SMGR: 210,
      PATH: 602,
      POLYGON: 604,
      CIDR: 650,
      FLOAT4: 700,
      FLOAT8: 701,
      ABSTIME: 702,
      RELTIME: 703,
      TINTERVAL: 704,
      CIRCLE: 718,
      MACADDR8: 774,
      MONEY: 790,
      MACADDR: 829,
      INET: 869,
      ACLITEM: 1033,
      BPCHAR: 1042,
      VARCHAR: 1043,
      DATE: 1082,
      TIME: 1083,
      TIMESTAMP: 1114,
      TIMESTAMPTZ: 1184,
      INTERVAL: 1186,
      TIMETZ: 1266,
      BIT: 1560,
      VARBIT: 1562,
      NUMERIC: 1700,
      REFCURSOR: 1790,
      REGPROCEDURE: 2202,
      REGOPER: 2203,
      REGOPERATOR: 2204,
      REGCLASS: 2205,
      REGTYPE: 2206,
      UUID: 2950,
      TXID_SNAPSHOT: 2970,
      PG_LSN: 3220,
      PG_NDISTINCT: 3361,
      PG_DEPENDENCIES: 3402,
      TSVECTOR: 3614,
      TSQUERY: 3615,
      GTSVECTOR: 3642,
      REGCONFIG: 3734,
      REGDICTIONARY: 3769,
      JSONB: 3802,
      REGNAMESPACE: 4089,
      REGROLE: 4096
    };
  }
});

// ../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/index.js
var require_pg_types = __commonJS({
  "../node_modules/.pnpm/pg-types@2.2.0/node_modules/pg-types/index.js"(exports2) {
    "use strict";
    var textParsers = require_textParsers();
    var binaryParsers = require_binaryParsers();
    var arrayParser3 = require_arrayParser();
    var builtinTypes = require_builtins();
    exports2.getTypeParser = getTypeParser;
    exports2.setTypeParser = setTypeParser;
    exports2.arrayParser = arrayParser3;
    exports2.builtins = builtinTypes;
    var typeParsers = {
      text: {},
      binary: {}
    };
    function noParse(val2) {
      return String(val2);
    }
    function getTypeParser(oid, format2) {
      format2 = format2 || "text";
      if (!typeParsers[format2]) {
        return noParse;
      }
      return typeParsers[format2][oid] || noParse;
    }
    function setTypeParser(oid, format2, parseFn) {
      if (typeof format2 == "function") {
        parseFn = format2;
        format2 = "text";
      }
      typeParsers[format2][oid] = parseFn;
    }
    textParsers.init(function(oid, converter) {
      typeParsers.text[oid] = converter;
    });
    binaryParsers.init(function(oid, converter) {
      typeParsers.binary[oid] = converter;
    });
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/defaults.js
var require_defaults = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/defaults.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      // database host. defaults to localhost
      host: "localhost",
      // database user's name
      user: process.platform === "win32" ? process.env.USERNAME : process.env.USER,
      // name of database to connect
      database: void 0,
      // database user's password
      password: null,
      // a Postgres connection string to be used instead of setting individual connection items
      // NOTE:  Setting this value will cause it to override any other value (such as database or user) defined
      // in the defaults object.
      connectionString: void 0,
      // database port
      port: 5432,
      // number of rows to return at a time from a prepared statement's
      // portal. 0 will return all rows at once
      rows: 0,
      // binary result mode
      binary: false,
      // Connection pool options - see https://github.com/brianc/node-pg-pool
      // number of connections to use in connection pool
      // 0 will disable connection pooling
      max: 10,
      // max milliseconds a client can go unused before it is removed
      // from the pool and destroyed
      idleTimeoutMillis: 3e4,
      client_encoding: "",
      ssl: false,
      application_name: void 0,
      fallback_application_name: void 0,
      options: void 0,
      parseInputDatesAsUTC: false,
      // max milliseconds any query using this connection will execute for before timing out in error.
      // false=unlimited
      statement_timeout: false,
      // Abort any statement that waits longer than the specified duration in milliseconds while attempting to acquire a lock.
      // false=unlimited
      lock_timeout: false,
      // Terminate any session with an open transaction that has been idle for longer than the specified duration in milliseconds
      // false=unlimited
      idle_in_transaction_session_timeout: false,
      // max milliseconds to wait for query to complete (client side)
      query_timeout: false,
      connect_timeout: 0,
      keepalives: 1,
      keepalives_idle: 0
    };
    var pgTypes = require_pg_types();
    var parseBigInteger = pgTypes.getTypeParser(20, "text");
    var parseBigIntegerArray = pgTypes.getTypeParser(1016, "text");
    module2.exports.__defineSetter__("parseInt8", function(val2) {
      pgTypes.setTypeParser(20, "text", val2 ? pgTypes.getTypeParser(23, "text") : parseBigInteger);
      pgTypes.setTypeParser(1016, "text", val2 ? pgTypes.getTypeParser(1007, "text") : parseBigIntegerArray);
    });
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/utils.js
var require_utils2 = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/utils.js"(exports2, module2) {
    "use strict";
    var defaults3 = require_defaults();
    function escapeElement(elementRepresentation) {
      const escaped = elementRepresentation.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
      return '"' + escaped + '"';
    }
    function arrayString(val2) {
      let result = "{";
      for (let i8 = 0; i8 < val2.length; i8++) {
        if (i8 > 0) {
          result = result + ",";
        }
        if (val2[i8] === null || typeof val2[i8] === "undefined") {
          result = result + "NULL";
        } else if (Array.isArray(val2[i8])) {
          result = result + arrayString(val2[i8]);
        } else if (ArrayBuffer.isView(val2[i8])) {
          let item = val2[i8];
          if (!(item instanceof Buffer)) {
            const buf = Buffer.from(item.buffer, item.byteOffset, item.byteLength);
            if (buf.length === item.byteLength) {
              item = buf;
            } else {
              item = buf.slice(item.byteOffset, item.byteOffset + item.byteLength);
            }
          }
          result += "\\\\x" + item.toString("hex");
        } else {
          result += escapeElement(prepareValue(val2[i8]));
        }
      }
      result = result + "}";
      return result;
    }
    var prepareValue = function(val2, seen) {
      if (val2 == null) {
        return null;
      }
      if (typeof val2 === "object") {
        if (val2 instanceof Buffer) {
          return val2;
        }
        if (ArrayBuffer.isView(val2)) {
          const buf = Buffer.from(val2.buffer, val2.byteOffset, val2.byteLength);
          if (buf.length === val2.byteLength) {
            return buf;
          }
          return buf.slice(val2.byteOffset, val2.byteOffset + val2.byteLength);
        }
        if (val2 instanceof Date) {
          if (defaults3.parseInputDatesAsUTC) {
            return dateToStringUTC(val2);
          } else {
            return dateToString(val2);
          }
        }
        if (Array.isArray(val2)) {
          return arrayString(val2);
        }
        return prepareObject(val2, seen);
      }
      return val2.toString();
    };
    function prepareObject(val2, seen) {
      if (val2 && typeof val2.toPostgres === "function") {
        seen = seen || [];
        if (seen.indexOf(val2) !== -1) {
          throw new Error('circular reference detected while preparing "' + val2 + '" for query');
        }
        seen.push(val2);
        return prepareValue(val2.toPostgres(prepareValue), seen);
      }
      return JSON.stringify(val2);
    }
    function dateToString(date4) {
      let offset = -date4.getTimezoneOffset();
      let year3 = date4.getFullYear();
      const isBCYear = year3 < 1;
      if (isBCYear) year3 = Math.abs(year3) + 1;
      let ret = String(year3).padStart(4, "0") + "-" + String(date4.getMonth() + 1).padStart(2, "0") + "-" + String(date4.getDate()).padStart(2, "0") + "T" + String(date4.getHours()).padStart(2, "0") + ":" + String(date4.getMinutes()).padStart(2, "0") + ":" + String(date4.getSeconds()).padStart(2, "0") + "." + String(date4.getMilliseconds()).padStart(3, "0");
      if (offset < 0) {
        ret += "-";
        offset *= -1;
      } else {
        ret += "+";
      }
      ret += String(Math.floor(offset / 60)).padStart(2, "0") + ":" + String(offset % 60).padStart(2, "0");
      if (isBCYear) ret += " BC";
      return ret;
    }
    function dateToStringUTC(date4) {
      let year3 = date4.getUTCFullYear();
      const isBCYear = year3 < 1;
      if (isBCYear) year3 = Math.abs(year3) + 1;
      let ret = String(year3).padStart(4, "0") + "-" + String(date4.getUTCMonth() + 1).padStart(2, "0") + "-" + String(date4.getUTCDate()).padStart(2, "0") + "T" + String(date4.getUTCHours()).padStart(2, "0") + ":" + String(date4.getUTCMinutes()).padStart(2, "0") + ":" + String(date4.getUTCSeconds()).padStart(2, "0") + "." + String(date4.getUTCMilliseconds()).padStart(3, "0");
      ret += "+00:00";
      if (isBCYear) ret += " BC";
      return ret;
    }
    function normalizeQueryConfig(config, values2, callback) {
      config = typeof config === "string" ? { text: config } : config;
      if (values2) {
        if (typeof values2 === "function") {
          config.callback = values2;
        } else {
          config.values = values2;
        }
      }
      if (callback) {
        config.callback = callback;
      }
      return config;
    }
    var escapeIdentifier3 = function(str) {
      return '"' + str.replace(/"/g, '""') + '"';
    };
    var escapeLiteral2 = function(str) {
      let hasBackslash = false;
      let escaped = "'";
      for (let i8 = 0; i8 < str.length; i8++) {
        const c6 = str[i8];
        if (c6 === "'") {
          escaped += c6 + c6;
        } else if (c6 === "\\") {
          escaped += c6 + c6;
          hasBackslash = true;
        } else {
          escaped += c6;
        }
      }
      escaped += "'";
      if (hasBackslash === true) {
        escaped = " E" + escaped;
      }
      return escaped;
    };
    module2.exports = {
      prepareValue: function prepareValueWrapper(value) {
        return prepareValue(value);
      },
      normalizeQueryConfig,
      escapeIdentifier: escapeIdentifier3,
      escapeLiteral: escapeLiteral2
    };
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/utils-legacy.js
var require_utils_legacy = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/utils-legacy.js"(exports2, module2) {
    "use strict";
    var nodeCrypto = require("crypto");
    function md52(string2) {
      return nodeCrypto.createHash("md5").update(string2, "utf-8").digest("hex");
    }
    function postgresMd5PasswordHash(user, password, salt) {
      const inner = md52(password + user);
      const outer = md52(Buffer.concat([Buffer.from(inner), salt]));
      return "md5" + outer;
    }
    function sha2563(text5) {
      return nodeCrypto.createHash("sha256").update(text5).digest();
    }
    function hashByName(hashName, text5) {
      hashName = hashName.replace(/(\D)-/, "$1");
      return nodeCrypto.createHash(hashName).update(text5).digest();
    }
    function hmacSha256(key, msg) {
      return nodeCrypto.createHmac("sha256", key).update(msg).digest();
    }
    async function deriveKey(password, salt, iterations) {
      return nodeCrypto.pbkdf2Sync(password, salt, iterations, 32, "sha256");
    }
    module2.exports = {
      postgresMd5PasswordHash,
      randomBytes: nodeCrypto.randomBytes,
      deriveKey,
      sha256: sha2563,
      hashByName,
      hmacSha256,
      md5: md52
    };
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/utils-webcrypto.js
var require_utils_webcrypto = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/utils-webcrypto.js"(exports2, module2) {
    "use strict";
    var nodeCrypto = require("crypto");
    module2.exports = {
      postgresMd5PasswordHash,
      randomBytes,
      deriveKey,
      sha256: sha2563,
      hashByName,
      hmacSha256,
      md5: md52
    };
    var webCrypto = nodeCrypto.webcrypto || globalThis.crypto;
    var subtleCrypto = webCrypto.subtle;
    var textEncoder = new TextEncoder();
    function randomBytes(length) {
      return webCrypto.getRandomValues(Buffer.alloc(length));
    }
    async function md52(string2) {
      try {
        return nodeCrypto.createHash("md5").update(string2, "utf-8").digest("hex");
      } catch (e6) {
        const data = typeof string2 === "string" ? textEncoder.encode(string2) : string2;
        const hash = await subtleCrypto.digest("MD5", data);
        return Array.from(new Uint8Array(hash)).map((b9) => b9.toString(16).padStart(2, "0")).join("");
      }
    }
    async function postgresMd5PasswordHash(user, password, salt) {
      const inner = await md52(password + user);
      const outer = await md52(Buffer.concat([Buffer.from(inner), salt]));
      return "md5" + outer;
    }
    async function sha2563(text5) {
      return await subtleCrypto.digest("SHA-256", text5);
    }
    async function hashByName(hashName, text5) {
      return await subtleCrypto.digest(hashName, text5);
    }
    async function hmacSha256(keyBuffer, msg) {
      const key = await subtleCrypto.importKey("raw", keyBuffer, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
      return await subtleCrypto.sign("HMAC", key, textEncoder.encode(msg));
    }
    async function deriveKey(password, salt, iterations) {
      const key = await subtleCrypto.importKey("raw", textEncoder.encode(password), "PBKDF2", false, ["deriveBits"]);
      const params = { name: "PBKDF2", hash: "SHA-256", salt, iterations };
      return await subtleCrypto.deriveBits(params, key, 32 * 8, ["deriveBits"]);
    }
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/utils.js
var require_utils3 = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/utils.js"(exports2, module2) {
    "use strict";
    var useLegacyCrypto = parseInt(process.versions && process.versions.node && process.versions.node.split(".")[0]) < 15;
    if (useLegacyCrypto) {
      module2.exports = require_utils_legacy();
    } else {
      module2.exports = require_utils_webcrypto();
    }
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/cert-signatures.js
var require_cert_signatures = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/cert-signatures.js"(exports2, module2) {
    "use strict";
    function x509Error(msg, cert) {
      return new Error("SASL channel binding: " + msg + " when parsing public certificate " + cert.toString("base64"));
    }
    function readASN1Length(data, index7) {
      let length = data[index7++];
      if (length < 128) return { length, index: index7 };
      const lengthBytes = length & 127;
      if (lengthBytes > 4) throw x509Error("bad length", data);
      length = 0;
      for (let i8 = 0; i8 < lengthBytes; i8++) {
        length = length << 8 | data[index7++];
      }
      return { length, index: index7 };
    }
    function readASN1OID(data, index7) {
      if (data[index7++] !== 6) throw x509Error("non-OID data", data);
      const { length: OIDLength, index: indexAfterOIDLength } = readASN1Length(data, index7);
      index7 = indexAfterOIDLength;
      const lastIndex = index7 + OIDLength;
      const byte1 = data[index7++];
      let oid = (byte1 / 40 >> 0) + "." + byte1 % 40;
      while (index7 < lastIndex) {
        let value = 0;
        while (index7 < lastIndex) {
          const nextByte = data[index7++];
          value = value << 7 | nextByte & 127;
          if (nextByte < 128) break;
        }
        oid += "." + value;
      }
      return { oid, index: index7 };
    }
    function expectASN1Seq(data, index7) {
      if (data[index7++] !== 48) throw x509Error("non-sequence data", data);
      return readASN1Length(data, index7);
    }
    function signatureAlgorithmHashFromCertificate(data, index7) {
      if (index7 === void 0) index7 = 0;
      index7 = expectASN1Seq(data, index7).index;
      const { length: certInfoLength, index: indexAfterCertInfoLength } = expectASN1Seq(data, index7);
      index7 = indexAfterCertInfoLength + certInfoLength;
      index7 = expectASN1Seq(data, index7).index;
      const { oid, index: indexAfterOID } = readASN1OID(data, index7);
      switch (oid) {
        // RSA
        case "1.2.840.113549.1.1.4":
          return "MD5";
        case "1.2.840.113549.1.1.5":
          return "SHA-1";
        case "1.2.840.113549.1.1.11":
          return "SHA-256";
        case "1.2.840.113549.1.1.12":
          return "SHA-384";
        case "1.2.840.113549.1.1.13":
          return "SHA-512";
        case "1.2.840.113549.1.1.14":
          return "SHA-224";
        case "1.2.840.113549.1.1.15":
          return "SHA512-224";
        case "1.2.840.113549.1.1.16":
          return "SHA512-256";
        // ECDSA
        case "1.2.840.10045.4.1":
          return "SHA-1";
        case "1.2.840.10045.4.3.1":
          return "SHA-224";
        case "1.2.840.10045.4.3.2":
          return "SHA-256";
        case "1.2.840.10045.4.3.3":
          return "SHA-384";
        case "1.2.840.10045.4.3.4":
          return "SHA-512";
        // RSASSA-PSS: hash is indicated separately
        case "1.2.840.113549.1.1.10": {
          index7 = indexAfterOID;
          index7 = expectASN1Seq(data, index7).index;
          if (data[index7++] !== 160) throw x509Error("non-tag data", data);
          index7 = readASN1Length(data, index7).index;
          index7 = expectASN1Seq(data, index7).index;
          const { oid: hashOID } = readASN1OID(data, index7);
          switch (hashOID) {
            // standalone hash OIDs
            case "1.2.840.113549.2.5":
              return "MD5";
            case "1.3.14.3.2.26":
              return "SHA-1";
            case "2.16.840.1.101.3.4.2.1":
              return "SHA-256";
            case "2.16.840.1.101.3.4.2.2":
              return "SHA-384";
            case "2.16.840.1.101.3.4.2.3":
              return "SHA-512";
          }
          throw x509Error("unknown hash OID " + hashOID, data);
        }
        // Ed25519 -- see https: return//github.com/openssl/openssl/issues/15477
        case "1.3.101.110":
        case "1.3.101.112":
          return "SHA-512";
        // Ed448 -- still not in pg 17.2 (if supported, digest would be SHAKE256 x 64 bytes)
        case "1.3.101.111":
        case "1.3.101.113":
          throw x509Error("Ed448 certificate channel binding is not currently supported by Postgres");
      }
      throw x509Error("unknown OID " + oid, data);
    }
    module2.exports = { signatureAlgorithmHashFromCertificate };
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/sasl.js
var require_sasl = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/crypto/sasl.js"(exports2, module2) {
    "use strict";
    var crypto7 = require_utils3();
    var { signatureAlgorithmHashFromCertificate } = require_cert_signatures();
    function startSession(mechanisms, stream) {
      const candidates = ["SCRAM-SHA-256"];
      if (stream) candidates.unshift("SCRAM-SHA-256-PLUS");
      const mechanism = candidates.find((candidate) => mechanisms.includes(candidate));
      if (!mechanism) {
        throw new Error("SASL: Only mechanism(s) " + candidates.join(" and ") + " are supported");
      }
      if (mechanism === "SCRAM-SHA-256-PLUS" && typeof stream.getPeerCertificate !== "function") {
        throw new Error("SASL: Mechanism SCRAM-SHA-256-PLUS requires a certificate");
      }
      const clientNonce = crypto7.randomBytes(18).toString("base64");
      const gs2Header = mechanism === "SCRAM-SHA-256-PLUS" ? "p=tls-server-end-point" : stream ? "y" : "n";
      return {
        mechanism,
        clientNonce,
        response: gs2Header + ",,n=*,r=" + clientNonce,
        message: "SASLInitialResponse"
      };
    }
    async function continueSession(session, password, serverData, stream) {
      if (session.message !== "SASLInitialResponse") {
        throw new Error("SASL: Last message was not SASLInitialResponse");
      }
      if (typeof password !== "string") {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a string");
      }
      if (password === "") {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a non-empty string");
      }
      if (typeof serverData !== "string") {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: serverData must be a string");
      }
      const sv = parseServerFirstMessage(serverData);
      if (!sv.nonce.startsWith(session.clientNonce)) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce");
      } else if (sv.nonce.length === session.clientNonce.length) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
      }
      const clientFirstMessageBare = "n=*,r=" + session.clientNonce;
      const serverFirstMessage = "r=" + sv.nonce + ",s=" + sv.salt + ",i=" + sv.iteration;
      let channelBinding = stream ? "eSws" : "biws";
      if (session.mechanism === "SCRAM-SHA-256-PLUS") {
        const peerCert = stream.getPeerCertificate().raw;
        let hashName = signatureAlgorithmHashFromCertificate(peerCert);
        if (hashName === "MD5" || hashName === "SHA-1") hashName = "SHA-256";
        const certHash = await crypto7.hashByName(hashName, peerCert);
        const bindingData = Buffer.concat([Buffer.from("p=tls-server-end-point,,"), Buffer.from(certHash)]);
        channelBinding = bindingData.toString("base64");
      }
      const clientFinalMessageWithoutProof = "c=" + channelBinding + ",r=" + sv.nonce;
      const authMessage = clientFirstMessageBare + "," + serverFirstMessage + "," + clientFinalMessageWithoutProof;
      const saltBytes = Buffer.from(sv.salt, "base64");
      const saltedPassword = await crypto7.deriveKey(password, saltBytes, sv.iteration);
      const clientKey = await crypto7.hmacSha256(saltedPassword, "Client Key");
      const storedKey = await crypto7.sha256(clientKey);
      const clientSignature = await crypto7.hmacSha256(storedKey, authMessage);
      const clientProof = xorBuffers(Buffer.from(clientKey), Buffer.from(clientSignature)).toString("base64");
      const serverKey = await crypto7.hmacSha256(saltedPassword, "Server Key");
      const serverSignatureBytes = await crypto7.hmacSha256(serverKey, authMessage);
      session.message = "SASLResponse";
      session.serverSignature = Buffer.from(serverSignatureBytes).toString("base64");
      session.response = clientFinalMessageWithoutProof + ",p=" + clientProof;
    }
    function finalizeSession(session, serverData) {
      if (session.message !== "SASLResponse") {
        throw new Error("SASL: Last message was not SASLResponse");
      }
      if (typeof serverData !== "string") {
        throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: serverData must be a string");
      }
      const { serverSignature } = parseServerFinalMessage(serverData);
      if (serverSignature !== session.serverSignature) {
        throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature does not match");
      }
    }
    function isPrintableChars(text5) {
      if (typeof text5 !== "string") {
        throw new TypeError("SASL: text must be a string");
      }
      return text5.split("").map((_7, i8) => text5.charCodeAt(i8)).every((c6) => c6 >= 33 && c6 <= 43 || c6 >= 45 && c6 <= 126);
    }
    function isBase64(text5) {
      return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(text5);
    }
    function parseAttributePairs(text5) {
      if (typeof text5 !== "string") {
        throw new TypeError("SASL: attribute pairs text must be a string");
      }
      return new Map(
        text5.split(",").map((attrValue) => {
          if (!/^.=/.test(attrValue)) {
            throw new Error("SASL: Invalid attribute pair entry");
          }
          const name3 = attrValue[0];
          const value = attrValue.substring(2);
          return [name3, value];
        })
      );
    }
    function parseServerFirstMessage(data) {
      const attrPairs = parseAttributePairs(data);
      const nonce = attrPairs.get("r");
      if (!nonce) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing");
      } else if (!isPrintableChars(nonce)) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters");
      }
      const salt = attrPairs.get("s");
      if (!salt) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing");
      } else if (!isBase64(salt)) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt must be base64");
      }
      const iterationText = attrPairs.get("i");
      if (!iterationText) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing");
      } else if (!/^[1-9][0-9]*$/.test(iterationText)) {
        throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: invalid iteration count");
      }
      const iteration = parseInt(iterationText, 10);
      return {
        nonce,
        salt,
        iteration
      };
    }
    function parseServerFinalMessage(serverData) {
      const attrPairs = parseAttributePairs(serverData);
      const serverSignature = attrPairs.get("v");
      if (!serverSignature) {
        throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing");
      } else if (!isBase64(serverSignature)) {
        throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64");
      }
      return {
        serverSignature
      };
    }
    function xorBuffers(a9, b9) {
      if (!Buffer.isBuffer(a9)) {
        throw new TypeError("first argument must be a Buffer");
      }
      if (!Buffer.isBuffer(b9)) {
        throw new TypeError("second argument must be a Buffer");
      }
      if (a9.length !== b9.length) {
        throw new Error("Buffer lengths must match");
      }
      if (a9.length === 0) {
        throw new Error("Buffers cannot be empty");
      }
      return Buffer.from(a9.map((_7, i8) => a9[i8] ^ b9[i8]));
    }
    module2.exports = {
      startSession,
      continueSession,
      finalizeSession
    };
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/type-overrides.js
var require_type_overrides = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/type-overrides.js"(exports2, module2) {
    "use strict";
    var types6 = require_pg_types();
    function TypeOverrides2(userTypes) {
      this._types = userTypes || types6;
      this.text = {};
      this.binary = {};
    }
    TypeOverrides2.prototype.getOverrides = function(format2) {
      switch (format2) {
        case "text":
          return this.text;
        case "binary":
          return this.binary;
        default:
          return {};
      }
    };
    TypeOverrides2.prototype.setTypeParser = function(oid, format2, parseFn) {
      if (typeof format2 === "function") {
        parseFn = format2;
        format2 = "text";
      }
      this.getOverrides(format2)[oid] = parseFn;
    };
    TypeOverrides2.prototype.getTypeParser = function(oid, format2) {
      format2 = format2 || "text";
      return this.getOverrides(format2)[oid] || this._types.getTypeParser(oid, format2);
    };
    module2.exports = TypeOverrides2;
  }
});

// ../node_modules/.pnpm/pg-connection-string@2.9.0/node_modules/pg-connection-string/index.js
var require_pg_connection_string = __commonJS({
  "../node_modules/.pnpm/pg-connection-string@2.9.0/node_modules/pg-connection-string/index.js"(exports2, module2) {
    "use strict";
    function parse6(str, options = {}) {
      if (str.charAt(0) === "/") {
        const config2 = str.split(" ");
        return { host: config2[0], database: config2[1] };
      }
      const config = {};
      let result;
      let dummyHost = false;
      if (/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(str)) {
        str = encodeURI(str).replace(/%25(\d\d)/g, "%$1");
      }
      try {
        result = new URL(str, "postgres://base");
      } catch (e6) {
        result = new URL(str.replace("@/", "@___DUMMY___/"), "postgres://base");
        dummyHost = true;
      }
      for (const entry of result.searchParams.entries()) {
        config[entry[0]] = entry[1];
      }
      config.user = config.user || decodeURIComponent(result.username);
      config.password = config.password || decodeURIComponent(result.password);
      if (result.protocol == "socket:") {
        config.host = decodeURI(result.pathname);
        config.database = result.searchParams.get("db");
        config.client_encoding = result.searchParams.get("encoding");
        return config;
      }
      const hostname = dummyHost ? "" : result.hostname;
      if (!config.host) {
        config.host = decodeURIComponent(hostname);
      } else if (hostname && /^%2f/i.test(hostname)) {
        result.pathname = hostname + result.pathname;
      }
      if (!config.port) {
        config.port = result.port;
      }
      const pathname = result.pathname.slice(1) || null;
      config.database = pathname ? decodeURI(pathname) : null;
      if (config.ssl === "true" || config.ssl === "1") {
        config.ssl = true;
      }
      if (config.ssl === "0") {
        config.ssl = false;
      }
      if (config.sslcert || config.sslkey || config.sslrootcert || config.sslmode) {
        config.ssl = {};
      }
      const fs9 = config.sslcert || config.sslkey || config.sslrootcert ? require("fs") : null;
      if (config.sslcert) {
        config.ssl.cert = fs9.readFileSync(config.sslcert).toString();
      }
      if (config.sslkey) {
        config.ssl.key = fs9.readFileSync(config.sslkey).toString();
      }
      if (config.sslrootcert) {
        config.ssl.ca = fs9.readFileSync(config.sslrootcert).toString();
      }
      if (options.useLibpqCompat && config.uselibpqcompat) {
        throw new Error("Both useLibpqCompat and uselibpqcompat are set. Please use only one of them.");
      }
      if (config.uselibpqcompat === "true" || options.useLibpqCompat) {
        switch (config.sslmode) {
          case "disable": {
            config.ssl = false;
            break;
          }
          case "prefer": {
            config.ssl.rejectUnauthorized = false;
            break;
          }
          case "require": {
            if (config.sslrootcert) {
              config.ssl.checkServerIdentity = function() {
              };
            } else {
              config.ssl.rejectUnauthorized = false;
            }
            break;
          }
          case "verify-ca": {
            if (!config.ssl.ca) {
              throw new Error(
                "SECURITY WARNING: Using sslmode=verify-ca requires specifying a CA with sslrootcert. If a public CA is used, verify-ca allows connections to a server that somebody else may have registered with the CA, making you vulnerable to Man-in-the-Middle attacks. Either specify a custom CA certificate with sslrootcert parameter or use sslmode=verify-full for proper security."
              );
            }
            config.ssl.checkServerIdentity = function() {
            };
            break;
          }
          case "verify-full": {
            break;
          }
        }
      } else {
        switch (config.sslmode) {
          case "disable": {
            config.ssl = false;
            break;
          }
          case "prefer":
          case "require":
          case "verify-ca":
          case "verify-full": {
            break;
          }
          case "no-verify": {
            config.ssl.rejectUnauthorized = false;
            break;
          }
        }
      }
      return config;
    }
    function toConnectionOptions(sslConfig) {
      const connectionOptions = Object.entries(sslConfig).reduce((c6, [key, value]) => {
        if (value !== void 0 && value !== null) {
          c6[key] = value;
        }
        return c6;
      }, {});
      return connectionOptions;
    }
    function toClientConfig(config) {
      const poolConfig = Object.entries(config).reduce((c6, [key, value]) => {
        if (key === "ssl") {
          const sslConfig = value;
          if (typeof sslConfig === "boolean") {
            c6[key] = sslConfig;
          }
          if (typeof sslConfig === "object") {
            c6[key] = toConnectionOptions(sslConfig);
          }
        } else if (value !== void 0 && value !== null) {
          if (key === "port") {
            if (value !== "") {
              const v11 = parseInt(value, 10);
              if (isNaN(v11)) {
                throw new Error(`Invalid ${key}: ${value}`);
              }
              c6[key] = v11;
            }
          } else {
            c6[key] = value;
          }
        }
        return c6;
      }, {});
      return poolConfig;
    }
    function parseIntoClientConfig(str) {
      return toClientConfig(parse6(str));
    }
    module2.exports = parse6;
    parse6.parse = parse6;
    parse6.toClientConfig = toClientConfig;
    parse6.parseIntoClientConfig = parseIntoClientConfig;
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/connection-parameters.js
var require_connection_parameters = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/connection-parameters.js"(exports2, module2) {
    "use strict";
    var dns = require("dns");
    var defaults3 = require_defaults();
    var parse6 = require_pg_connection_string().parse;
    var val2 = function(key, config, envVar) {
      if (envVar === void 0) {
        envVar = process.env["PG" + key.toUpperCase()];
      } else if (envVar === false) {
      } else {
        envVar = process.env[envVar];
      }
      return config[key] || envVar || defaults3[key];
    };
    var readSSLConfigFromEnvironment = function() {
      switch (process.env.PGSSLMODE) {
        case "disable":
          return false;
        case "prefer":
        case "require":
        case "verify-ca":
        case "verify-full":
          return true;
        case "no-verify":
          return { rejectUnauthorized: false };
      }
      return defaults3.ssl;
    };
    var quoteParamValue = function(value) {
      return "'" + ("" + value).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
    };
    var add = function(params, config, paramName) {
      const value = config[paramName];
      if (value !== void 0 && value !== null) {
        params.push(paramName + "=" + quoteParamValue(value));
      }
    };
    var ConnectionParameters = class {
      constructor(config) {
        config = typeof config === "string" ? parse6(config) : config || {};
        if (config.connectionString) {
          config = Object.assign({}, config, parse6(config.connectionString));
        }
        this.user = val2("user", config);
        this.database = val2("database", config);
        if (this.database === void 0) {
          this.database = this.user;
        }
        this.port = parseInt(val2("port", config), 10);
        this.host = val2("host", config);
        Object.defineProperty(this, "password", {
          configurable: true,
          enumerable: false,
          writable: true,
          value: val2("password", config)
        });
        this.binary = val2("binary", config);
        this.options = val2("options", config);
        this.ssl = typeof config.ssl === "undefined" ? readSSLConfigFromEnvironment() : config.ssl;
        if (typeof this.ssl === "string") {
          if (this.ssl === "true") {
            this.ssl = true;
          }
        }
        if (this.ssl === "no-verify") {
          this.ssl = { rejectUnauthorized: false };
        }
        if (this.ssl && this.ssl.key) {
          Object.defineProperty(this.ssl, "key", {
            enumerable: false
          });
        }
        this.client_encoding = val2("client_encoding", config);
        this.replication = val2("replication", config);
        this.isDomainSocket = !(this.host || "").indexOf("/");
        this.application_name = val2("application_name", config, "PGAPPNAME");
        this.fallback_application_name = val2("fallback_application_name", config, false);
        this.statement_timeout = val2("statement_timeout", config, false);
        this.lock_timeout = val2("lock_timeout", config, false);
        this.idle_in_transaction_session_timeout = val2("idle_in_transaction_session_timeout", config, false);
        this.query_timeout = val2("query_timeout", config, false);
        if (config.connectionTimeoutMillis === void 0) {
          this.connect_timeout = process.env.PGCONNECT_TIMEOUT || 0;
        } else {
          this.connect_timeout = Math.floor(config.connectionTimeoutMillis / 1e3);
        }
        if (config.keepAlive === false) {
          this.keepalives = 0;
        } else if (config.keepAlive === true) {
          this.keepalives = 1;
        }
        if (typeof config.keepAliveInitialDelayMillis === "number") {
          this.keepalives_idle = Math.floor(config.keepAliveInitialDelayMillis / 1e3);
        }
      }
      getLibpqConnectionString(cb) {
        const params = [];
        add(params, this, "user");
        add(params, this, "password");
        add(params, this, "port");
        add(params, this, "application_name");
        add(params, this, "fallback_application_name");
        add(params, this, "connect_timeout");
        add(params, this, "options");
        const ssl = typeof this.ssl === "object" ? this.ssl : this.ssl ? { sslmode: this.ssl } : {};
        add(params, ssl, "sslmode");
        add(params, ssl, "sslca");
        add(params, ssl, "sslkey");
        add(params, ssl, "sslcert");
        add(params, ssl, "sslrootcert");
        if (this.database) {
          params.push("dbname=" + quoteParamValue(this.database));
        }
        if (this.replication) {
          params.push("replication=" + quoteParamValue(this.replication));
        }
        if (this.host) {
          params.push("host=" + quoteParamValue(this.host));
        }
        if (this.isDomainSocket) {
          return cb(null, params.join(" "));
        }
        if (this.client_encoding) {
          params.push("client_encoding=" + quoteParamValue(this.client_encoding));
        }
        dns.lookup(this.host, function(err3, address) {
          if (err3) return cb(err3, null);
          params.push("hostaddr=" + quoteParamValue(address));
          return cb(null, params.join(" "));
        });
      }
    };
    module2.exports = ConnectionParameters;
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/result.js
var require_result = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/result.js"(exports2, module2) {
    "use strict";
    var types6 = require_pg_types();
    var matchRegexp = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/;
    var Result3 = class {
      constructor(rowMode, types7) {
        this.command = null;
        this.rowCount = null;
        this.oid = null;
        this.rows = [];
        this.fields = [];
        this._parsers = void 0;
        this._types = types7;
        this.RowCtor = null;
        this.rowAsArray = rowMode === "array";
        if (this.rowAsArray) {
          this.parseRow = this._parseRowAsArray;
        }
        this._prebuiltEmptyResultObject = null;
      }
      // adds a command complete message
      addCommandComplete(msg) {
        let match2;
        if (msg.text) {
          match2 = matchRegexp.exec(msg.text);
        } else {
          match2 = matchRegexp.exec(msg.command);
        }
        if (match2) {
          this.command = match2[1];
          if (match2[3]) {
            this.oid = parseInt(match2[2], 10);
            this.rowCount = parseInt(match2[3], 10);
          } else if (match2[2]) {
            this.rowCount = parseInt(match2[2], 10);
          }
        }
      }
      _parseRowAsArray(rowData) {
        const row = new Array(rowData.length);
        for (let i8 = 0, len = rowData.length; i8 < len; i8++) {
          const rawValue = rowData[i8];
          if (rawValue !== null) {
            row[i8] = this._parsers[i8](rawValue);
          } else {
            row[i8] = null;
          }
        }
        return row;
      }
      parseRow(rowData) {
        const row = { ...this._prebuiltEmptyResultObject };
        for (let i8 = 0, len = rowData.length; i8 < len; i8++) {
          const rawValue = rowData[i8];
          const field = this.fields[i8].name;
          if (rawValue !== null) {
            row[field] = this._parsers[i8](rawValue);
          } else {
            row[field] = null;
          }
        }
        return row;
      }
      addRow(row) {
        this.rows.push(row);
      }
      addFields(fieldDescriptions) {
        this.fields = fieldDescriptions;
        if (this.fields.length) {
          this._parsers = new Array(fieldDescriptions.length);
        }
        const row = {};
        for (let i8 = 0; i8 < fieldDescriptions.length; i8++) {
          const desc2 = fieldDescriptions[i8];
          row[desc2.name] = null;
          if (this._types) {
            this._parsers[i8] = this._types.getTypeParser(desc2.dataTypeID, desc2.format || "text");
          } else {
            this._parsers[i8] = types6.getTypeParser(desc2.dataTypeID, desc2.format || "text");
          }
        }
        this._prebuiltEmptyResultObject = { ...row };
      }
    };
    module2.exports = Result3;
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/query.js
var require_query = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/query.js"(exports2, module2) {
    "use strict";
    var { EventEmitter } = require("events");
    var Result3 = require_result();
    var utils = require_utils2();
    var Query3 = class extends EventEmitter {
      constructor(config, values2, callback) {
        super();
        config = utils.normalizeQueryConfig(config, values2, callback);
        this.text = config.text;
        this.values = config.values;
        this.rows = config.rows;
        this.types = config.types;
        this.name = config.name;
        this.queryMode = config.queryMode;
        this.binary = config.binary;
        this.portal = config.portal || "";
        this.callback = config.callback;
        this._rowMode = config.rowMode;
        if (process.domain && config.callback) {
          this.callback = process.domain.bind(config.callback);
        }
        this._result = new Result3(this._rowMode, this.types);
        this._results = this._result;
        this._canceledDueToError = false;
      }
      requiresPreparation() {
        if (this.queryMode === "extended") {
          return true;
        }
        if (this.name) {
          return true;
        }
        if (this.rows) {
          return true;
        }
        if (!this.text) {
          return false;
        }
        if (!this.values) {
          return false;
        }
        return this.values.length > 0;
      }
      _checkForMultirow() {
        if (this._result.command) {
          if (!Array.isArray(this._results)) {
            this._results = [this._result];
          }
          this._result = new Result3(this._rowMode, this._result._types);
          this._results.push(this._result);
        }
      }
      // associates row metadata from the supplied
      // message with this query object
      // metadata used when parsing row results
      handleRowDescription(msg) {
        this._checkForMultirow();
        this._result.addFields(msg.fields);
        this._accumulateRows = this.callback || !this.listeners("row").length;
      }
      handleDataRow(msg) {
        let row;
        if (this._canceledDueToError) {
          return;
        }
        try {
          row = this._result.parseRow(msg.fields);
        } catch (err3) {
          this._canceledDueToError = err3;
          return;
        }
        this.emit("row", row, this._result);
        if (this._accumulateRows) {
          this._result.addRow(row);
        }
      }
      handleCommandComplete(msg, connection2) {
        this._checkForMultirow();
        this._result.addCommandComplete(msg);
        if (this.rows) {
          connection2.sync();
        }
      }
      // if a named prepared statement is created with empty query text
      // the backend will send an emptyQuery message but *not* a command complete message
      // since we pipeline sync immediately after execute we don't need to do anything here
      // unless we have rows specified, in which case we did not pipeline the intial sync call
      handleEmptyQuery(connection2) {
        if (this.rows) {
          connection2.sync();
        }
      }
      handleError(err3, connection2) {
        if (this._canceledDueToError) {
          err3 = this._canceledDueToError;
          this._canceledDueToError = false;
        }
        if (this.callback) {
          return this.callback(err3);
        }
        this.emit("error", err3);
      }
      handleReadyForQuery(con) {
        if (this._canceledDueToError) {
          return this.handleError(this._canceledDueToError, con);
        }
        if (this.callback) {
          try {
            this.callback(null, this._results);
          } catch (err3) {
            process.nextTick(() => {
              throw err3;
            });
          }
        }
        this.emit("end", this._results);
      }
      submit(connection2) {
        if (typeof this.text !== "string" && typeof this.name !== "string") {
          return new Error("A query must have either text or a name. Supplying neither is unsupported.");
        }
        const previous = connection2.parsedStatements[this.name];
        if (this.text && previous && this.text !== previous) {
          return new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
        }
        if (this.values && !Array.isArray(this.values)) {
          return new Error("Query values must be an array");
        }
        if (this.requiresPreparation()) {
          connection2.stream.cork && connection2.stream.cork();
          try {
            this.prepare(connection2);
          } finally {
            connection2.stream.uncork && connection2.stream.uncork();
          }
        } else {
          connection2.query(this.text);
        }
        return null;
      }
      hasBeenParsed(connection2) {
        return this.name && connection2.parsedStatements[this.name];
      }
      handlePortalSuspended(connection2) {
        this._getRows(connection2, this.rows);
      }
      _getRows(connection2, rows) {
        connection2.execute({
          portal: this.portal,
          rows
        });
        if (!rows) {
          connection2.sync();
        } else {
          connection2.flush();
        }
      }
      // http://developer.postgresql.org/pgdocs/postgres/protocol-flow.html#PROTOCOL-FLOW-EXT-QUERY
      prepare(connection2) {
        if (!this.hasBeenParsed(connection2)) {
          connection2.parse({
            text: this.text,
            name: this.name,
            types: this.types
          });
        }
        try {
          connection2.bind({
            portal: this.portal,
            statement: this.name,
            values: this.values,
            binary: this.binary,
            valueMapper: utils.prepareValue
          });
        } catch (err3) {
          this.handleError(err3, connection2);
          return;
        }
        connection2.describe({
          type: "P",
          name: this.portal || ""
        });
        this._getRows(connection2, this.rows);
      }
      handleCopyInResponse(connection2) {
        connection2.sendCopyFail("No source stream defined");
      }
      handleCopyData(msg, connection2) {
      }
    };
    module2.exports = Query3;
  }
});

// ../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/messages.js
var require_messages = __commonJS({
  "../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/messages.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.NoticeMessage = exports2.DataRowMessage = exports2.CommandCompleteMessage = exports2.ReadyForQueryMessage = exports2.NotificationResponseMessage = exports2.BackendKeyDataMessage = exports2.AuthenticationMD5Password = exports2.ParameterStatusMessage = exports2.ParameterDescriptionMessage = exports2.RowDescriptionMessage = exports2.Field = exports2.CopyResponse = exports2.CopyDataMessage = exports2.DatabaseError = exports2.copyDone = exports2.emptyQuery = exports2.replicationStart = exports2.portalSuspended = exports2.noData = exports2.closeComplete = exports2.bindComplete = exports2.parseComplete = void 0;
    exports2.parseComplete = {
      name: "parseComplete",
      length: 5
    };
    exports2.bindComplete = {
      name: "bindComplete",
      length: 5
    };
    exports2.closeComplete = {
      name: "closeComplete",
      length: 5
    };
    exports2.noData = {
      name: "noData",
      length: 5
    };
    exports2.portalSuspended = {
      name: "portalSuspended",
      length: 5
    };
    exports2.replicationStart = {
      name: "replicationStart",
      length: 4
    };
    exports2.emptyQuery = {
      name: "emptyQuery",
      length: 4
    };
    exports2.copyDone = {
      name: "copyDone",
      length: 4
    };
    var DatabaseError3 = class extends Error {
      constructor(message, length, name3) {
        super(message);
        this.length = length;
        this.name = name3;
      }
    };
    exports2.DatabaseError = DatabaseError3;
    var CopyDataMessage = class {
      constructor(length, chunk) {
        this.length = length;
        this.chunk = chunk;
        this.name = "copyData";
      }
    };
    exports2.CopyDataMessage = CopyDataMessage;
    var CopyResponse = class {
      constructor(length, name3, binary4, columnCount) {
        this.length = length;
        this.name = name3;
        this.binary = binary4;
        this.columnTypes = new Array(columnCount);
      }
    };
    exports2.CopyResponse = CopyResponse;
    var Field2 = class {
      constructor(name3, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, format2) {
        this.name = name3;
        this.tableID = tableID;
        this.columnID = columnID;
        this.dataTypeID = dataTypeID;
        this.dataTypeSize = dataTypeSize;
        this.dataTypeModifier = dataTypeModifier;
        this.format = format2;
      }
    };
    exports2.Field = Field2;
    var RowDescriptionMessage = class {
      constructor(length, fieldCount) {
        this.length = length;
        this.fieldCount = fieldCount;
        this.name = "rowDescription";
        this.fields = new Array(this.fieldCount);
      }
    };
    exports2.RowDescriptionMessage = RowDescriptionMessage;
    var ParameterDescriptionMessage = class {
      constructor(length, parameterCount) {
        this.length = length;
        this.parameterCount = parameterCount;
        this.name = "parameterDescription";
        this.dataTypeIDs = new Array(this.parameterCount);
      }
    };
    exports2.ParameterDescriptionMessage = ParameterDescriptionMessage;
    var ParameterStatusMessage = class {
      constructor(length, parameterName, parameterValue) {
        this.length = length;
        this.parameterName = parameterName;
        this.parameterValue = parameterValue;
        this.name = "parameterStatus";
      }
    };
    exports2.ParameterStatusMessage = ParameterStatusMessage;
    var AuthenticationMD5Password = class {
      constructor(length, salt) {
        this.length = length;
        this.salt = salt;
        this.name = "authenticationMD5Password";
      }
    };
    exports2.AuthenticationMD5Password = AuthenticationMD5Password;
    var BackendKeyDataMessage = class {
      constructor(length, processID, secretKey) {
        this.length = length;
        this.processID = processID;
        this.secretKey = secretKey;
        this.name = "backendKeyData";
      }
    };
    exports2.BackendKeyDataMessage = BackendKeyDataMessage;
    var NotificationResponseMessage = class {
      constructor(length, processId, channel, payload) {
        this.length = length;
        this.processId = processId;
        this.channel = channel;
        this.payload = payload;
        this.name = "notification";
      }
    };
    exports2.NotificationResponseMessage = NotificationResponseMessage;
    var ReadyForQueryMessage = class {
      constructor(length, status) {
        this.length = length;
        this.status = status;
        this.name = "readyForQuery";
      }
    };
    exports2.ReadyForQueryMessage = ReadyForQueryMessage;
    var CommandCompleteMessage = class {
      constructor(length, text5) {
        this.length = length;
        this.text = text5;
        this.name = "commandComplete";
      }
    };
    exports2.CommandCompleteMessage = CommandCompleteMessage;
    var DataRowMessage = class {
      constructor(length, fields) {
        this.length = length;
        this.fields = fields;
        this.name = "dataRow";
        this.fieldCount = fields.length;
      }
    };
    exports2.DataRowMessage = DataRowMessage;
    var NoticeMessage = class {
      constructor(length, message) {
        this.length = length;
        this.message = message;
        this.name = "notice";
      }
    };
    exports2.NoticeMessage = NoticeMessage;
  }
});

// ../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/buffer-writer.js
var require_buffer_writer = __commonJS({
  "../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/buffer-writer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Writer = void 0;
    var Writer = class {
      constructor(size2 = 256) {
        this.size = size2;
        this.offset = 5;
        this.headerPosition = 0;
        this.buffer = Buffer.allocUnsafe(size2);
      }
      ensure(size2) {
        const remaining = this.buffer.length - this.offset;
        if (remaining < size2) {
          const oldBuffer = this.buffer;
          const newSize = oldBuffer.length + (oldBuffer.length >> 1) + size2;
          this.buffer = Buffer.allocUnsafe(newSize);
          oldBuffer.copy(this.buffer);
        }
      }
      addInt32(num) {
        this.ensure(4);
        this.buffer[this.offset++] = num >>> 24 & 255;
        this.buffer[this.offset++] = num >>> 16 & 255;
        this.buffer[this.offset++] = num >>> 8 & 255;
        this.buffer[this.offset++] = num >>> 0 & 255;
        return this;
      }
      addInt16(num) {
        this.ensure(2);
        this.buffer[this.offset++] = num >>> 8 & 255;
        this.buffer[this.offset++] = num >>> 0 & 255;
        return this;
      }
      addCString(string2) {
        if (!string2) {
          this.ensure(1);
        } else {
          const len = Buffer.byteLength(string2);
          this.ensure(len + 1);
          this.buffer.write(string2, this.offset, "utf-8");
          this.offset += len;
        }
        this.buffer[this.offset++] = 0;
        return this;
      }
      addString(string2 = "") {
        const len = Buffer.byteLength(string2);
        this.ensure(len);
        this.buffer.write(string2, this.offset);
        this.offset += len;
        return this;
      }
      add(otherBuffer) {
        this.ensure(otherBuffer.length);
        otherBuffer.copy(this.buffer, this.offset);
        this.offset += otherBuffer.length;
        return this;
      }
      join(code) {
        if (code) {
          this.buffer[this.headerPosition] = code;
          const length = this.offset - (this.headerPosition + 1);
          this.buffer.writeInt32BE(length, this.headerPosition + 1);
        }
        return this.buffer.slice(code ? 0 : 5, this.offset);
      }
      flush(code) {
        const result = this.join(code);
        this.offset = 5;
        this.headerPosition = 0;
        this.buffer = Buffer.allocUnsafe(this.size);
        return result;
      }
    };
    exports2.Writer = Writer;
  }
});

// ../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/serializer.js
var require_serializer = __commonJS({
  "../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/serializer.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.serialize = void 0;
    var buffer_writer_1 = require_buffer_writer();
    var writer = new buffer_writer_1.Writer();
    var startup = (opts) => {
      writer.addInt16(3).addInt16(0);
      for (const key of Object.keys(opts)) {
        writer.addCString(key).addCString(opts[key]);
      }
      writer.addCString("client_encoding").addCString("UTF8");
      const bodyBuffer = writer.addCString("").flush();
      const length = bodyBuffer.length + 4;
      return new buffer_writer_1.Writer().addInt32(length).add(bodyBuffer).flush();
    };
    var requestSsl = () => {
      const response = Buffer.allocUnsafe(8);
      response.writeInt32BE(8, 0);
      response.writeInt32BE(80877103, 4);
      return response;
    };
    var password = (password2) => {
      return writer.addCString(password2).flush(
        112
        /* code.startup */
      );
    };
    var sendSASLInitialResponseMessage = function(mechanism, initialResponse) {
      writer.addCString(mechanism).addInt32(Buffer.byteLength(initialResponse)).addString(initialResponse);
      return writer.flush(
        112
        /* code.startup */
      );
    };
    var sendSCRAMClientFinalMessage = function(additionalData) {
      return writer.addString(additionalData).flush(
        112
        /* code.startup */
      );
    };
    var query = (text5) => {
      return writer.addCString(text5).flush(
        81
        /* code.query */
      );
    };
    var emptyArray = [];
    var parse6 = (query2) => {
      const name3 = query2.name || "";
      if (name3.length > 63) {
        console.error("Warning! Postgres only supports 63 characters for query names.");
        console.error("You supplied %s (%s)", name3, name3.length);
        console.error("This can cause conflicts and silent errors executing queries");
      }
      const types6 = query2.types || emptyArray;
      const len = types6.length;
      const buffer2 = writer.addCString(name3).addCString(query2.text).addInt16(len);
      for (let i8 = 0; i8 < len; i8++) {
        buffer2.addInt32(types6[i8]);
      }
      return writer.flush(
        80
        /* code.parse */
      );
    };
    var paramWriter = new buffer_writer_1.Writer();
    var writeValues = function(values2, valueMapper) {
      for (let i8 = 0; i8 < values2.length; i8++) {
        const mappedVal = valueMapper ? valueMapper(values2[i8], i8) : values2[i8];
        if (mappedVal == null) {
          writer.addInt16(
            0
            /* ParamType.STRING */
          );
          paramWriter.addInt32(-1);
        } else if (mappedVal instanceof Buffer) {
          writer.addInt16(
            1
            /* ParamType.BINARY */
          );
          paramWriter.addInt32(mappedVal.length);
          paramWriter.add(mappedVal);
        } else {
          writer.addInt16(
            0
            /* ParamType.STRING */
          );
          paramWriter.addInt32(Buffer.byteLength(mappedVal));
          paramWriter.addString(mappedVal);
        }
      }
    };
    var bind = (config = {}) => {
      const portal = config.portal || "";
      const statement = config.statement || "";
      const binary4 = config.binary || false;
      const values2 = config.values || emptyArray;
      const len = values2.length;
      writer.addCString(portal).addCString(statement);
      writer.addInt16(len);
      writeValues(values2, config.valueMapper);
      writer.addInt16(len);
      writer.add(paramWriter.flush());
      writer.addInt16(
        binary4 ? 1 : 0
        /* ParamType.STRING */
      );
      return writer.flush(
        66
        /* code.bind */
      );
    };
    var emptyExecute = Buffer.from([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]);
    var execute = (config) => {
      if (!config || !config.portal && !config.rows) {
        return emptyExecute;
      }
      const portal = config.portal || "";
      const rows = config.rows || 0;
      const portalLength = Buffer.byteLength(portal);
      const len = 4 + portalLength + 1 + 4;
      const buff = Buffer.allocUnsafe(1 + len);
      buff[0] = 69;
      buff.writeInt32BE(len, 1);
      buff.write(portal, 5, "utf-8");
      buff[portalLength + 5] = 0;
      buff.writeUInt32BE(rows, buff.length - 4);
      return buff;
    };
    var cancel = (processID, secretKey) => {
      const buffer2 = Buffer.allocUnsafe(16);
      buffer2.writeInt32BE(16, 0);
      buffer2.writeInt16BE(1234, 4);
      buffer2.writeInt16BE(5678, 6);
      buffer2.writeInt32BE(processID, 8);
      buffer2.writeInt32BE(secretKey, 12);
      return buffer2;
    };
    var cstringMessage = (code, string2) => {
      const stringLen = Buffer.byteLength(string2);
      const len = 4 + stringLen + 1;
      const buffer2 = Buffer.allocUnsafe(1 + len);
      buffer2[0] = code;
      buffer2.writeInt32BE(len, 1);
      buffer2.write(string2, 5, "utf-8");
      buffer2[len] = 0;
      return buffer2;
    };
    var emptyDescribePortal = writer.addCString("P").flush(
      68
      /* code.describe */
    );
    var emptyDescribeStatement = writer.addCString("S").flush(
      68
      /* code.describe */
    );
    var describe = (msg) => {
      return msg.name ? cstringMessage(68, `${msg.type}${msg.name || ""}`) : msg.type === "P" ? emptyDescribePortal : emptyDescribeStatement;
    };
    var close = (msg) => {
      const text5 = `${msg.type}${msg.name || ""}`;
      return cstringMessage(67, text5);
    };
    var copyData = (chunk) => {
      return writer.add(chunk).flush(
        100
        /* code.copyFromChunk */
      );
    };
    var copyFail = (message) => {
      return cstringMessage(102, message);
    };
    var codeOnlyBuffer = (code) => Buffer.from([code, 0, 0, 0, 4]);
    var flushBuffer = codeOnlyBuffer(
      72
      /* code.flush */
    );
    var syncBuffer = codeOnlyBuffer(
      83
      /* code.sync */
    );
    var endBuffer = codeOnlyBuffer(
      88
      /* code.end */
    );
    var copyDoneBuffer = codeOnlyBuffer(
      99
      /* code.copyDone */
    );
    var serialize2 = {
      startup,
      password,
      requestSsl,
      sendSASLInitialResponseMessage,
      sendSCRAMClientFinalMessage,
      query,
      parse: parse6,
      bind,
      execute,
      describe,
      close,
      flush: () => flushBuffer,
      sync: () => syncBuffer,
      end: () => endBuffer,
      copyData,
      copyDone: () => copyDoneBuffer,
      copyFail,
      cancel
    };
    exports2.serialize = serialize2;
  }
});

// ../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/buffer-reader.js
var require_buffer_reader = __commonJS({
  "../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/buffer-reader.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.BufferReader = void 0;
    var emptyBuffer = Buffer.allocUnsafe(0);
    var BufferReader = class {
      constructor(offset = 0) {
        this.offset = offset;
        this.buffer = emptyBuffer;
        this.encoding = "utf-8";
      }
      setBuffer(offset, buffer2) {
        this.offset = offset;
        this.buffer = buffer2;
      }
      int16() {
        const result = this.buffer.readInt16BE(this.offset);
        this.offset += 2;
        return result;
      }
      byte() {
        const result = this.buffer[this.offset];
        this.offset++;
        return result;
      }
      int32() {
        const result = this.buffer.readInt32BE(this.offset);
        this.offset += 4;
        return result;
      }
      uint32() {
        const result = this.buffer.readUInt32BE(this.offset);
        this.offset += 4;
        return result;
      }
      string(length) {
        const result = this.buffer.toString(this.encoding, this.offset, this.offset + length);
        this.offset += length;
        return result;
      }
      cstring() {
        const start2 = this.offset;
        let end = start2;
        while (this.buffer[end++] !== 0) {
        }
        this.offset = end;
        return this.buffer.toString(this.encoding, start2, end - 1);
      }
      bytes(length) {
        const result = this.buffer.slice(this.offset, this.offset + length);
        this.offset += length;
        return result;
      }
    };
    exports2.BufferReader = BufferReader;
  }
});

// ../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/parser.js
var require_parser = __commonJS({
  "../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/parser.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Parser = void 0;
    var messages_1 = require_messages();
    var buffer_reader_1 = require_buffer_reader();
    var CODE_LENGTH = 1;
    var LEN_LENGTH = 4;
    var HEADER_LENGTH = CODE_LENGTH + LEN_LENGTH;
    var emptyBuffer = Buffer.allocUnsafe(0);
    var Parser = class {
      constructor(opts) {
        this.buffer = emptyBuffer;
        this.bufferLength = 0;
        this.bufferOffset = 0;
        this.reader = new buffer_reader_1.BufferReader();
        if ((opts === null || opts === void 0 ? void 0 : opts.mode) === "binary") {
          throw new Error("Binary mode not supported yet");
        }
        this.mode = (opts === null || opts === void 0 ? void 0 : opts.mode) || "text";
      }
      parse(buffer2, callback) {
        this.mergeBuffer(buffer2);
        const bufferFullLength = this.bufferOffset + this.bufferLength;
        let offset = this.bufferOffset;
        while (offset + HEADER_LENGTH <= bufferFullLength) {
          const code = this.buffer[offset];
          const length = this.buffer.readUInt32BE(offset + CODE_LENGTH);
          const fullMessageLength = CODE_LENGTH + length;
          if (fullMessageLength + offset <= bufferFullLength) {
            const message = this.handlePacket(offset + HEADER_LENGTH, code, length, this.buffer);
            callback(message);
            offset += fullMessageLength;
          } else {
            break;
          }
        }
        if (offset === bufferFullLength) {
          this.buffer = emptyBuffer;
          this.bufferLength = 0;
          this.bufferOffset = 0;
        } else {
          this.bufferLength = bufferFullLength - offset;
          this.bufferOffset = offset;
        }
      }
      mergeBuffer(buffer2) {
        if (this.bufferLength > 0) {
          const newLength = this.bufferLength + buffer2.byteLength;
          const newFullLength = newLength + this.bufferOffset;
          if (newFullLength > this.buffer.byteLength) {
            let newBuffer;
            if (newLength <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) {
              newBuffer = this.buffer;
            } else {
              let newBufferLength = this.buffer.byteLength * 2;
              while (newLength >= newBufferLength) {
                newBufferLength *= 2;
              }
              newBuffer = Buffer.allocUnsafe(newBufferLength);
            }
            this.buffer.copy(newBuffer, 0, this.bufferOffset, this.bufferOffset + this.bufferLength);
            this.buffer = newBuffer;
            this.bufferOffset = 0;
          }
          buffer2.copy(this.buffer, this.bufferOffset + this.bufferLength);
          this.bufferLength = newLength;
        } else {
          this.buffer = buffer2;
          this.bufferOffset = 0;
          this.bufferLength = buffer2.byteLength;
        }
      }
      handlePacket(offset, code, length, bytes2) {
        switch (code) {
          case 50:
            return messages_1.bindComplete;
          case 49:
            return messages_1.parseComplete;
          case 51:
            return messages_1.closeComplete;
          case 110:
            return messages_1.noData;
          case 115:
            return messages_1.portalSuspended;
          case 99:
            return messages_1.copyDone;
          case 87:
            return messages_1.replicationStart;
          case 73:
            return messages_1.emptyQuery;
          case 68:
            return this.parseDataRowMessage(offset, length, bytes2);
          case 67:
            return this.parseCommandCompleteMessage(offset, length, bytes2);
          case 90:
            return this.parseReadyForQueryMessage(offset, length, bytes2);
          case 65:
            return this.parseNotificationMessage(offset, length, bytes2);
          case 82:
            return this.parseAuthenticationResponse(offset, length, bytes2);
          case 83:
            return this.parseParameterStatusMessage(offset, length, bytes2);
          case 75:
            return this.parseBackendKeyData(offset, length, bytes2);
          case 69:
            return this.parseErrorMessage(offset, length, bytes2, "error");
          case 78:
            return this.parseErrorMessage(offset, length, bytes2, "notice");
          case 84:
            return this.parseRowDescriptionMessage(offset, length, bytes2);
          case 116:
            return this.parseParameterDescriptionMessage(offset, length, bytes2);
          case 71:
            return this.parseCopyInMessage(offset, length, bytes2);
          case 72:
            return this.parseCopyOutMessage(offset, length, bytes2);
          case 100:
            return this.parseCopyData(offset, length, bytes2);
          default:
            return new messages_1.DatabaseError("received invalid response: " + code.toString(16), length, "error");
        }
      }
      parseReadyForQueryMessage(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const status = this.reader.string(1);
        return new messages_1.ReadyForQueryMessage(length, status);
      }
      parseCommandCompleteMessage(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const text5 = this.reader.cstring();
        return new messages_1.CommandCompleteMessage(length, text5);
      }
      parseCopyData(offset, length, bytes2) {
        const chunk = bytes2.slice(offset, offset + (length - 4));
        return new messages_1.CopyDataMessage(length, chunk);
      }
      parseCopyInMessage(offset, length, bytes2) {
        return this.parseCopyMessage(offset, length, bytes2, "copyInResponse");
      }
      parseCopyOutMessage(offset, length, bytes2) {
        return this.parseCopyMessage(offset, length, bytes2, "copyOutResponse");
      }
      parseCopyMessage(offset, length, bytes2, messageName) {
        this.reader.setBuffer(offset, bytes2);
        const isBinary2 = this.reader.byte() !== 0;
        const columnCount = this.reader.int16();
        const message = new messages_1.CopyResponse(length, messageName, isBinary2, columnCount);
        for (let i8 = 0; i8 < columnCount; i8++) {
          message.columnTypes[i8] = this.reader.int16();
        }
        return message;
      }
      parseNotificationMessage(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const processId = this.reader.int32();
        const channel = this.reader.cstring();
        const payload = this.reader.cstring();
        return new messages_1.NotificationResponseMessage(length, processId, channel, payload);
      }
      parseRowDescriptionMessage(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const fieldCount = this.reader.int16();
        const message = new messages_1.RowDescriptionMessage(length, fieldCount);
        for (let i8 = 0; i8 < fieldCount; i8++) {
          message.fields[i8] = this.parseField();
        }
        return message;
      }
      parseField() {
        const name3 = this.reader.cstring();
        const tableID = this.reader.uint32();
        const columnID = this.reader.int16();
        const dataTypeID = this.reader.uint32();
        const dataTypeSize = this.reader.int16();
        const dataTypeModifier = this.reader.int32();
        const mode = this.reader.int16() === 0 ? "text" : "binary";
        return new messages_1.Field(name3, tableID, columnID, dataTypeID, dataTypeSize, dataTypeModifier, mode);
      }
      parseParameterDescriptionMessage(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const parameterCount = this.reader.int16();
        const message = new messages_1.ParameterDescriptionMessage(length, parameterCount);
        for (let i8 = 0; i8 < parameterCount; i8++) {
          message.dataTypeIDs[i8] = this.reader.int32();
        }
        return message;
      }
      parseDataRowMessage(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const fieldCount = this.reader.int16();
        const fields = new Array(fieldCount);
        for (let i8 = 0; i8 < fieldCount; i8++) {
          const len = this.reader.int32();
          fields[i8] = len === -1 ? null : this.reader.string(len);
        }
        return new messages_1.DataRowMessage(length, fields);
      }
      parseParameterStatusMessage(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const name3 = this.reader.cstring();
        const value = this.reader.cstring();
        return new messages_1.ParameterStatusMessage(length, name3, value);
      }
      parseBackendKeyData(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const processID = this.reader.int32();
        const secretKey = this.reader.int32();
        return new messages_1.BackendKeyDataMessage(length, processID, secretKey);
      }
      parseAuthenticationResponse(offset, length, bytes2) {
        this.reader.setBuffer(offset, bytes2);
        const code = this.reader.int32();
        const message = {
          name: "authenticationOk",
          length
        };
        switch (code) {
          case 0:
            break;
          case 3:
            if (message.length === 8) {
              message.name = "authenticationCleartextPassword";
            }
            break;
          case 5:
            if (message.length === 12) {
              message.name = "authenticationMD5Password";
              const salt = this.reader.bytes(4);
              return new messages_1.AuthenticationMD5Password(length, salt);
            }
            break;
          case 10:
            {
              message.name = "authenticationSASL";
              message.mechanisms = [];
              let mechanism;
              do {
                mechanism = this.reader.cstring();
                if (mechanism) {
                  message.mechanisms.push(mechanism);
                }
              } while (mechanism);
            }
            break;
          case 11:
            message.name = "authenticationSASLContinue";
            message.data = this.reader.string(length - 8);
            break;
          case 12:
            message.name = "authenticationSASLFinal";
            message.data = this.reader.string(length - 8);
            break;
          default:
            throw new Error("Unknown authenticationOk message type " + code);
        }
        return message;
      }
      parseErrorMessage(offset, length, bytes2, name3) {
        this.reader.setBuffer(offset, bytes2);
        const fields = {};
        let fieldType = this.reader.string(1);
        while (fieldType !== "\0") {
          fields[fieldType] = this.reader.cstring();
          fieldType = this.reader.string(1);
        }
        const messageValue = fields.M;
        const message = name3 === "notice" ? new messages_1.NoticeMessage(length, messageValue) : new messages_1.DatabaseError(messageValue, length, name3);
        message.severity = fields.S;
        message.code = fields.C;
        message.detail = fields.D;
        message.hint = fields.H;
        message.position = fields.P;
        message.internalPosition = fields.p;
        message.internalQuery = fields.q;
        message.where = fields.W;
        message.schema = fields.s;
        message.table = fields.t;
        message.column = fields.c;
        message.dataType = fields.d;
        message.constraint = fields.n;
        message.file = fields.F;
        message.line = fields.L;
        message.routine = fields.R;
        return message;
      }
    };
    exports2.Parser = Parser;
  }
});

// ../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/index.js
var require_dist = __commonJS({
  "../node_modules/.pnpm/pg-protocol@1.10.0/node_modules/pg-protocol/dist/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DatabaseError = exports2.serialize = exports2.parse = void 0;
    var messages_1 = require_messages();
    Object.defineProperty(exports2, "DatabaseError", { enumerable: true, get: function() {
      return messages_1.DatabaseError;
    } });
    var serializer_1 = require_serializer();
    Object.defineProperty(exports2, "serialize", { enumerable: true, get: function() {
      return serializer_1.serialize;
    } });
    var parser_1 = require_parser();
    function parse6(stream, callback) {
      const parser = new parser_1.Parser();
      stream.on("data", (buffer2) => parser.parse(buffer2, callback));
      return new Promise((resolve2) => stream.on("end", () => resolve2()));
    }
    exports2.parse = parse6;
  }
});

// ../node_modules/.pnpm/pg-cloudflare@1.2.5/node_modules/pg-cloudflare/dist/index.js
var require_dist2 = __commonJS({
  "../node_modules/.pnpm/pg-cloudflare@1.2.5/node_modules/pg-cloudflare/dist/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.CloudflareSocket = void 0;
    var events_1 = require("events");
    var CloudflareSocket = class extends events_1.EventEmitter {
      constructor(ssl) {
        super();
        this.ssl = ssl;
        this.writable = false;
        this.destroyed = false;
        this._upgrading = false;
        this._upgraded = false;
        this._cfSocket = null;
        this._cfWriter = null;
        this._cfReader = null;
      }
      setNoDelay() {
        return this;
      }
      setKeepAlive() {
        return this;
      }
      ref() {
        return this;
      }
      unref() {
        return this;
      }
      async connect(port, host, connectListener) {
        try {
          log("connecting");
          if (connectListener)
            this.once("connect", connectListener);
          const options = this.ssl ? { secureTransport: "starttls" } : {};
          const mod = require("cloudflare:sockets");
          const connect2 = mod.connect;
          this._cfSocket = connect2(`${host}:${port}`, options);
          this._cfWriter = this._cfSocket.writable.getWriter();
          this._addClosedHandler();
          this._cfReader = this._cfSocket.readable.getReader();
          if (this.ssl) {
            this._listenOnce().catch((e6) => this.emit("error", e6));
          } else {
            this._listen().catch((e6) => this.emit("error", e6));
          }
          await this._cfWriter.ready;
          log("socket ready");
          this.writable = true;
          this.emit("connect");
          return this;
        } catch (e6) {
          this.emit("error", e6);
        }
      }
      async _listen() {
        while (true) {
          log("awaiting receive from CF socket");
          const { done, value } = await this._cfReader.read();
          log("CF socket received:", done, value);
          if (done) {
            log("done");
            break;
          }
          this.emit("data", Buffer.from(value));
        }
      }
      async _listenOnce() {
        log("awaiting first receive from CF socket");
        const { done, value } = await this._cfReader.read();
        log("First CF socket received:", done, value);
        this.emit("data", Buffer.from(value));
      }
      write(data, encoding = "utf8", callback = () => {
      }) {
        if (data.length === 0)
          return callback();
        if (typeof data === "string")
          data = Buffer.from(data, encoding);
        log("sending data direct:", data);
        this._cfWriter.write(data).then(() => {
          log("data sent");
          callback();
        }, (err3) => {
          log("send error", err3);
          callback(err3);
        });
        return true;
      }
      end(data = Buffer.alloc(0), encoding = "utf8", callback = () => {
      }) {
        log("ending CF socket");
        this.write(data, encoding, (err3) => {
          this._cfSocket.close();
          if (callback)
            callback(err3);
        });
        return this;
      }
      destroy(reason) {
        log("destroying CF socket", reason);
        this.destroyed = true;
        return this.end();
      }
      startTls(options) {
        if (this._upgraded) {
          this.emit("error", "Cannot call `startTls()` more than once on a socket");
          return;
        }
        this._cfWriter.releaseLock();
        this._cfReader.releaseLock();
        this._upgrading = true;
        this._cfSocket = this._cfSocket.startTls(options);
        this._cfWriter = this._cfSocket.writable.getWriter();
        this._cfReader = this._cfSocket.readable.getReader();
        this._addClosedHandler();
        this._listen().catch((e6) => this.emit("error", e6));
      }
      _addClosedHandler() {
        this._cfSocket.closed.then(() => {
          if (!this._upgrading) {
            log("CF socket closed");
            this._cfSocket = null;
            this.emit("close");
          } else {
            this._upgrading = false;
            this._upgraded = true;
          }
        }).catch((e6) => this.emit("error", e6));
      }
    };
    exports2.CloudflareSocket = CloudflareSocket;
    var debug = false;
    function dump(data) {
      if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
        const hex2 = Buffer.from(data).toString("hex");
        const str = new TextDecoder().decode(data);
        return `
>>> STR: "${str.replace(/\n/g, "\\n")}"
>>> HEX: ${hex2}
`;
      } else {
        return data;
      }
    }
    function log(...args2) {
      debug && console.log(...args2.map(dump));
    }
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/stream.js
var require_stream2 = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/stream.js"(exports2, module2) {
    "use strict";
    var { getStream, getSecureStream } = getStreamFuncs();
    module2.exports = {
      /**
       * Get a socket stream compatible with the current runtime environment.
       * @returns {Duplex}
       */
      getStream,
      /**
       * Get a TLS secured socket, compatible with the current environment,
       * using the socket and other settings given in `options`.
       * @returns {Duplex}
       */
      getSecureStream
    };
    function getNodejsStreamFuncs() {
      function getStream2(ssl) {
        const net2 = require("net");
        return new net2.Socket();
      }
      function getSecureStream2(options) {
        const tls2 = require("tls");
        return tls2.connect(options);
      }
      return {
        getStream: getStream2,
        getSecureStream: getSecureStream2
      };
    }
    function getCloudflareStreamFuncs() {
      function getStream2(ssl) {
        const { CloudflareSocket } = require_dist2();
        return new CloudflareSocket(ssl);
      }
      function getSecureStream2(options) {
        options.socket.startTls(options);
        return options.socket;
      }
      return {
        getStream: getStream2,
        getSecureStream: getSecureStream2
      };
    }
    function isCloudflareRuntime() {
      if (typeof navigator === "object" && navigator !== null && typeof navigator.userAgent === "string") {
        return navigator.userAgent === "Cloudflare-Workers";
      }
      if (typeof Response === "function") {
        const resp = new Response(null, { cf: { thing: true } });
        if (typeof resp.cf === "object" && resp.cf !== null && resp.cf.thing) {
          return true;
        }
      }
      return false;
    }
    function getStreamFuncs() {
      if (isCloudflareRuntime()) {
        return getCloudflareStreamFuncs();
      }
      return getNodejsStreamFuncs();
    }
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/connection.js
var require_connection = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/connection.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var { parse: parse6, serialize: serialize2 } = require_dist();
    var { getStream, getSecureStream } = require_stream2();
    var flushBuffer = serialize2.flush();
    var syncBuffer = serialize2.sync();
    var endBuffer = serialize2.end();
    var Connection4 = class extends EventEmitter {
      constructor(config) {
        super();
        config = config || {};
        this.stream = config.stream || getStream(config.ssl);
        if (typeof this.stream === "function") {
          this.stream = this.stream(config);
        }
        this._keepAlive = config.keepAlive;
        this._keepAliveInitialDelayMillis = config.keepAliveInitialDelayMillis;
        this.lastBuffer = false;
        this.parsedStatements = {};
        this.ssl = config.ssl || false;
        this._ending = false;
        this._emitMessage = false;
        const self2 = this;
        this.on("newListener", function(eventName) {
          if (eventName === "message") {
            self2._emitMessage = true;
          }
        });
      }
      connect(port, host) {
        const self2 = this;
        this._connecting = true;
        this.stream.setNoDelay(true);
        this.stream.connect(port, host);
        this.stream.once("connect", function() {
          if (self2._keepAlive) {
            self2.stream.setKeepAlive(true, self2._keepAliveInitialDelayMillis);
          }
          self2.emit("connect");
        });
        const reportStreamError = function(error2) {
          if (self2._ending && (error2.code === "ECONNRESET" || error2.code === "EPIPE")) {
            return;
          }
          self2.emit("error", error2);
        };
        this.stream.on("error", reportStreamError);
        this.stream.on("close", function() {
          self2.emit("end");
        });
        if (!this.ssl) {
          return this.attachListeners(this.stream);
        }
        this.stream.once("data", function(buffer2) {
          const responseCode = buffer2.toString("utf8");
          switch (responseCode) {
            case "S":
              break;
            case "N":
              self2.stream.end();
              return self2.emit("error", new Error("The server does not support SSL connections"));
            default:
              self2.stream.end();
              return self2.emit("error", new Error("There was an error establishing an SSL connection"));
          }
          const options = {
            socket: self2.stream
          };
          if (self2.ssl !== true) {
            Object.assign(options, self2.ssl);
            if ("key" in self2.ssl) {
              options.key = self2.ssl.key;
            }
          }
          const net2 = require("net");
          if (net2.isIP && net2.isIP(host) === 0) {
            options.servername = host;
          }
          try {
            self2.stream = getSecureStream(options);
          } catch (err3) {
            return self2.emit("error", err3);
          }
          self2.attachListeners(self2.stream);
          self2.stream.on("error", reportStreamError);
          self2.emit("sslconnect");
        });
      }
      attachListeners(stream) {
        parse6(stream, (msg) => {
          const eventName = msg.name === "error" ? "errorMessage" : msg.name;
          if (this._emitMessage) {
            this.emit("message", msg);
          }
          this.emit(eventName, msg);
        });
      }
      requestSsl() {
        this.stream.write(serialize2.requestSsl());
      }
      startup(config) {
        this.stream.write(serialize2.startup(config));
      }
      cancel(processID, secretKey) {
        this._send(serialize2.cancel(processID, secretKey));
      }
      password(password) {
        this._send(serialize2.password(password));
      }
      sendSASLInitialResponseMessage(mechanism, initialResponse) {
        this._send(serialize2.sendSASLInitialResponseMessage(mechanism, initialResponse));
      }
      sendSCRAMClientFinalMessage(additionalData) {
        this._send(serialize2.sendSCRAMClientFinalMessage(additionalData));
      }
      _send(buffer2) {
        if (!this.stream.writable) {
          return false;
        }
        return this.stream.write(buffer2);
      }
      query(text5) {
        this._send(serialize2.query(text5));
      }
      // send parse message
      parse(query) {
        this._send(serialize2.parse(query));
      }
      // send bind message
      bind(config) {
        this._send(serialize2.bind(config));
      }
      // send execute message
      execute(config) {
        this._send(serialize2.execute(config));
      }
      flush() {
        if (this.stream.writable) {
          this.stream.write(flushBuffer);
        }
      }
      sync() {
        this._ending = true;
        this._send(syncBuffer);
      }
      ref() {
        this.stream.ref();
      }
      unref() {
        this.stream.unref();
      }
      end() {
        this._ending = true;
        if (!this._connecting || !this.stream.writable) {
          this.stream.end();
          return;
        }
        return this.stream.write(endBuffer, () => {
          this.stream.end();
        });
      }
      close(msg) {
        this._send(serialize2.close(msg));
      }
      describe(msg) {
        this._send(serialize2.describe(msg));
      }
      sendCopyFromChunk(chunk) {
        this._send(serialize2.copyData(chunk));
      }
      endCopyFrom() {
        this._send(serialize2.copyDone());
      }
      sendCopyFail(msg) {
        this._send(serialize2.copyFail(msg));
      }
    };
    module2.exports = Connection4;
  }
});

// ../node_modules/.pnpm/split2@4.2.0/node_modules/split2/index.js
var require_split2 = __commonJS({
  "../node_modules/.pnpm/split2@4.2.0/node_modules/split2/index.js"(exports2, module2) {
    "use strict";
    var { Transform } = require("stream");
    var { StringDecoder } = require("string_decoder");
    var kLast = Symbol("last");
    var kDecoder = Symbol("decoder");
    function transform(chunk, enc, cb) {
      let list;
      if (this.overflow) {
        const buf = this[kDecoder].write(chunk);
        list = buf.split(this.matcher);
        if (list.length === 1) return cb();
        list.shift();
        this.overflow = false;
      } else {
        this[kLast] += this[kDecoder].write(chunk);
        list = this[kLast].split(this.matcher);
      }
      this[kLast] = list.pop();
      for (let i8 = 0; i8 < list.length; i8++) {
        try {
          push(this, this.mapper(list[i8]));
        } catch (error2) {
          return cb(error2);
        }
      }
      this.overflow = this[kLast].length > this.maxLength;
      if (this.overflow && !this.skipOverflow) {
        cb(new Error("maximum buffer reached"));
        return;
      }
      cb();
    }
    function flush2(cb) {
      this[kLast] += this[kDecoder].end();
      if (this[kLast]) {
        try {
          push(this, this.mapper(this[kLast]));
        } catch (error2) {
          return cb(error2);
        }
      }
      cb();
    }
    function push(self2, val2) {
      if (val2 !== void 0) {
        self2.push(val2);
      }
    }
    function noop4(incoming) {
      return incoming;
    }
    function split(matcher, mapper, options) {
      matcher = matcher || /\r?\n/;
      mapper = mapper || noop4;
      options = options || {};
      switch (arguments.length) {
        case 1:
          if (typeof matcher === "function") {
            mapper = matcher;
            matcher = /\r?\n/;
          } else if (typeof matcher === "object" && !(matcher instanceof RegExp) && !matcher[Symbol.split]) {
            options = matcher;
            matcher = /\r?\n/;
          }
          break;
        case 2:
          if (typeof matcher === "function") {
            options = mapper;
            mapper = matcher;
            matcher = /\r?\n/;
          } else if (typeof mapper === "object") {
            options = mapper;
            mapper = noop4;
          }
      }
      options = Object.assign({}, options);
      options.autoDestroy = true;
      options.transform = transform;
      options.flush = flush2;
      options.readableObjectMode = true;
      const stream = new Transform(options);
      stream[kLast] = "";
      stream[kDecoder] = new StringDecoder("utf8");
      stream.matcher = matcher;
      stream.mapper = mapper;
      stream.maxLength = options.maxLength;
      stream.skipOverflow = options.skipOverflow || false;
      stream.overflow = false;
      stream._destroy = function(err3, cb) {
        this._writableState.errorEmitted = false;
        cb(err3);
      };
      return stream;
    }
    module2.exports = split;
  }
});

// ../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/helper.js
var require_helper = __commonJS({
  "../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/helper.js"(exports2, module2) {
    "use strict";
    var path3 = require("path");
    var Stream6 = require("stream").Stream;
    var split = require_split2();
    var util2 = require("util");
    var defaultPort = 5432;
    var isWin = process.platform === "win32";
    var warnStream = process.stderr;
    var S_IRWXG = 56;
    var S_IRWXO = 7;
    var S_IFMT = 61440;
    var S_IFREG = 32768;
    function isRegFile(mode) {
      return (mode & S_IFMT) == S_IFREG;
    }
    var fieldNames = ["host", "port", "database", "user", "password"];
    var nrOfFields = fieldNames.length;
    var passKey = fieldNames[nrOfFields - 1];
    function warn() {
      var isWritable = warnStream instanceof Stream6 && true === warnStream.writable;
      if (isWritable) {
        var args2 = Array.prototype.slice.call(arguments).concat("\n");
        warnStream.write(util2.format.apply(util2, args2));
      }
    }
    Object.defineProperty(module2.exports, "isWin", {
      get: function() {
        return isWin;
      },
      set: function(val2) {
        isWin = val2;
      }
    });
    module2.exports.warnTo = function(stream) {
      var old = warnStream;
      warnStream = stream;
      return old;
    };
    module2.exports.getFileName = function(rawEnv) {
      var env4 = rawEnv || process.env;
      var file = env4.PGPASSFILE || (isWin ? path3.join(env4.APPDATA || "./", "postgresql", "pgpass.conf") : path3.join(env4.HOME || "./", ".pgpass"));
      return file;
    };
    module2.exports.usePgPass = function(stats, fname) {
      if (Object.prototype.hasOwnProperty.call(process.env, "PGPASSWORD")) {
        return false;
      }
      if (isWin) {
        return true;
      }
      fname = fname || "<unkn>";
      if (!isRegFile(stats.mode)) {
        warn('WARNING: password file "%s" is not a plain file', fname);
        return false;
      }
      if (stats.mode & (S_IRWXG | S_IRWXO)) {
        warn('WARNING: password file "%s" has group or world access; permissions should be u=rw (0600) or less', fname);
        return false;
      }
      return true;
    };
    var matcher = module2.exports.match = function(connInfo, entry) {
      return fieldNames.slice(0, -1).reduce(function(prev, field, idx) {
        if (idx == 1) {
          if (Number(connInfo[field] || defaultPort) === Number(entry[field])) {
            return prev && true;
          }
        }
        return prev && (entry[field] === "*" || entry[field] === connInfo[field]);
      }, true);
    };
    module2.exports.getPassword = function(connInfo, stream, cb) {
      var pass2;
      var lineStream = stream.pipe(split());
      function onLine(line2) {
        var entry = parseLine(line2);
        if (entry && isValidEntry(entry) && matcher(connInfo, entry)) {
          pass2 = entry[passKey];
          lineStream.end();
        }
      }
      var onEnd = function() {
        stream.destroy();
        cb(pass2);
      };
      var onErr = function(err3) {
        stream.destroy();
        warn("WARNING: error on reading file: %s", err3);
        cb(void 0);
      };
      stream.on("error", onErr);
      lineStream.on("data", onLine).on("end", onEnd).on("error", onErr);
    };
    var parseLine = module2.exports.parseLine = function(line2) {
      if (line2.length < 11 || line2.match(/^\s+#/)) {
        return null;
      }
      var curChar = "";
      var prevChar = "";
      var fieldIdx = 0;
      var startIdx = 0;
      var endIdx = 0;
      var obj = {};
      var isLastField = false;
      var addToObj = function(idx, i0, i1) {
        var field = line2.substring(i0, i1);
        if (!Object.hasOwnProperty.call(process.env, "PGPASS_NO_DEESCAPE")) {
          field = field.replace(/\\([:\\])/g, "$1");
        }
        obj[fieldNames[idx]] = field;
      };
      for (var i8 = 0; i8 < line2.length - 1; i8 += 1) {
        curChar = line2.charAt(i8 + 1);
        prevChar = line2.charAt(i8);
        isLastField = fieldIdx == nrOfFields - 1;
        if (isLastField) {
          addToObj(fieldIdx, startIdx);
          break;
        }
        if (i8 >= 0 && curChar == ":" && prevChar !== "\\") {
          addToObj(fieldIdx, startIdx, i8 + 1);
          startIdx = i8 + 2;
          fieldIdx += 1;
        }
      }
      obj = Object.keys(obj).length === nrOfFields ? obj : null;
      return obj;
    };
    var isValidEntry = module2.exports.isValidEntry = function(entry) {
      var rules = {
        // host
        0: function(x11) {
          return x11.length > 0;
        },
        // port
        1: function(x11) {
          if (x11 === "*") {
            return true;
          }
          x11 = Number(x11);
          return isFinite(x11) && x11 > 0 && x11 < 9007199254740992 && Math.floor(x11) === x11;
        },
        // database
        2: function(x11) {
          return x11.length > 0;
        },
        // username
        3: function(x11) {
          return x11.length > 0;
        },
        // password
        4: function(x11) {
          return x11.length > 0;
        }
      };
      for (var idx = 0; idx < fieldNames.length; idx += 1) {
        var rule = rules[idx];
        var value = entry[fieldNames[idx]] || "";
        var res = rule(value);
        if (!res) {
          return false;
        }
      }
      return true;
    };
  }
});

// ../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/index.js
var require_lib2 = __commonJS({
  "../node_modules/.pnpm/pgpass@1.0.5/node_modules/pgpass/lib/index.js"(exports2, module2) {
    "use strict";
    var path3 = require("path");
    var fs9 = require("fs");
    var helper = require_helper();
    module2.exports = function(connInfo, cb) {
      var file = helper.getFileName();
      fs9.stat(file, function(err3, stat2) {
        if (err3 || !helper.usePgPass(stat2, file)) {
          return cb(void 0);
        }
        var st2 = fs9.createReadStream(file);
        helper.getPassword(connInfo, st2, cb);
      });
    };
    module2.exports.warnTo = helper.warnTo;
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/client.js
var require_client = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/client.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var utils = require_utils2();
    var sasl = require_sasl();
    var TypeOverrides2 = require_type_overrides();
    var ConnectionParameters = require_connection_parameters();
    var Query3 = require_query();
    var defaults3 = require_defaults();
    var Connection4 = require_connection();
    var crypto7 = require_utils3();
    var Client6 = class extends EventEmitter {
      constructor(config) {
        super();
        this.connectionParameters = new ConnectionParameters(config);
        this.user = this.connectionParameters.user;
        this.database = this.connectionParameters.database;
        this.port = this.connectionParameters.port;
        this.host = this.connectionParameters.host;
        Object.defineProperty(this, "password", {
          configurable: true,
          enumerable: false,
          writable: true,
          value: this.connectionParameters.password
        });
        this.replication = this.connectionParameters.replication;
        const c6 = config || {};
        this._Promise = c6.Promise || global.Promise;
        this._types = new TypeOverrides2(c6.types);
        this._ending = false;
        this._ended = false;
        this._connecting = false;
        this._connected = false;
        this._connectionError = false;
        this._queryable = true;
        this.enableChannelBinding = Boolean(c6.enableChannelBinding);
        this.connection = c6.connection || new Connection4({
          stream: c6.stream,
          ssl: this.connectionParameters.ssl,
          keepAlive: c6.keepAlive || false,
          keepAliveInitialDelayMillis: c6.keepAliveInitialDelayMillis || 0,
          encoding: this.connectionParameters.client_encoding || "utf8"
        });
        this.queryQueue = [];
        this.binary = c6.binary || defaults3.binary;
        this.processID = null;
        this.secretKey = null;
        this.ssl = this.connectionParameters.ssl || false;
        if (this.ssl && this.ssl.key) {
          Object.defineProperty(this.ssl, "key", {
            enumerable: false
          });
        }
        this._connectionTimeoutMillis = c6.connectionTimeoutMillis || 0;
      }
      _errorAllQueries(err3) {
        const enqueueError = (query) => {
          process.nextTick(() => {
            query.handleError(err3, this.connection);
          });
        };
        if (this.activeQuery) {
          enqueueError(this.activeQuery);
          this.activeQuery = null;
        }
        this.queryQueue.forEach(enqueueError);
        this.queryQueue.length = 0;
      }
      _connect(callback) {
        const self2 = this;
        const con = this.connection;
        this._connectionCallback = callback;
        if (this._connecting || this._connected) {
          const err3 = new Error("Client has already been connected. You cannot reuse a client.");
          process.nextTick(() => {
            callback(err3);
          });
          return;
        }
        this._connecting = true;
        if (this._connectionTimeoutMillis > 0) {
          this.connectionTimeoutHandle = setTimeout(() => {
            con._ending = true;
            con.stream.destroy(new Error("timeout expired"));
          }, this._connectionTimeoutMillis);
          if (this.connectionTimeoutHandle.unref) {
            this.connectionTimeoutHandle.unref();
          }
        }
        if (this.host && this.host.indexOf("/") === 0) {
          con.connect(this.host + "/.s.PGSQL." + this.port);
        } else {
          con.connect(this.port, this.host);
        }
        con.on("connect", function() {
          if (self2.ssl) {
            con.requestSsl();
          } else {
            con.startup(self2.getStartupConf());
          }
        });
        con.on("sslconnect", function() {
          con.startup(self2.getStartupConf());
        });
        this._attachListeners(con);
        con.once("end", () => {
          const error2 = this._ending ? new Error("Connection terminated") : new Error("Connection terminated unexpectedly");
          clearTimeout(this.connectionTimeoutHandle);
          this._errorAllQueries(error2);
          this._ended = true;
          if (!this._ending) {
            if (this._connecting && !this._connectionError) {
              if (this._connectionCallback) {
                this._connectionCallback(error2);
              } else {
                this._handleErrorEvent(error2);
              }
            } else if (!this._connectionError) {
              this._handleErrorEvent(error2);
            }
          }
          process.nextTick(() => {
            this.emit("end");
          });
        });
      }
      connect(callback) {
        if (callback) {
          this._connect(callback);
          return;
        }
        return new this._Promise((resolve2, reject) => {
          this._connect((error2) => {
            if (error2) {
              reject(error2);
            } else {
              resolve2();
            }
          });
        });
      }
      _attachListeners(con) {
        con.on("authenticationCleartextPassword", this._handleAuthCleartextPassword.bind(this));
        con.on("authenticationMD5Password", this._handleAuthMD5Password.bind(this));
        con.on("authenticationSASL", this._handleAuthSASL.bind(this));
        con.on("authenticationSASLContinue", this._handleAuthSASLContinue.bind(this));
        con.on("authenticationSASLFinal", this._handleAuthSASLFinal.bind(this));
        con.on("backendKeyData", this._handleBackendKeyData.bind(this));
        con.on("error", this._handleErrorEvent.bind(this));
        con.on("errorMessage", this._handleErrorMessage.bind(this));
        con.on("readyForQuery", this._handleReadyForQuery.bind(this));
        con.on("notice", this._handleNotice.bind(this));
        con.on("rowDescription", this._handleRowDescription.bind(this));
        con.on("dataRow", this._handleDataRow.bind(this));
        con.on("portalSuspended", this._handlePortalSuspended.bind(this));
        con.on("emptyQuery", this._handleEmptyQuery.bind(this));
        con.on("commandComplete", this._handleCommandComplete.bind(this));
        con.on("parseComplete", this._handleParseComplete.bind(this));
        con.on("copyInResponse", this._handleCopyInResponse.bind(this));
        con.on("copyData", this._handleCopyData.bind(this));
        con.on("notification", this._handleNotification.bind(this));
      }
      // TODO(bmc): deprecate pgpass "built in" integration since this.password can be a function
      // it can be supplied by the user if required - this is a breaking change!
      _checkPgPass(cb) {
        const con = this.connection;
        if (typeof this.password === "function") {
          this._Promise.resolve().then(() => this.password()).then((pass2) => {
            if (pass2 !== void 0) {
              if (typeof pass2 !== "string") {
                con.emit("error", new TypeError("Password must be a string"));
                return;
              }
              this.connectionParameters.password = this.password = pass2;
            } else {
              this.connectionParameters.password = this.password = null;
            }
            cb();
          }).catch((err3) => {
            con.emit("error", err3);
          });
        } else if (this.password !== null) {
          cb();
        } else {
          try {
            const pgPass = require_lib2();
            pgPass(this.connectionParameters, (pass2) => {
              if (void 0 !== pass2) {
                this.connectionParameters.password = this.password = pass2;
              }
              cb();
            });
          } catch (e6) {
            this.emit("error", e6);
          }
        }
      }
      _handleAuthCleartextPassword(msg) {
        this._checkPgPass(() => {
          this.connection.password(this.password);
        });
      }
      _handleAuthMD5Password(msg) {
        this._checkPgPass(async () => {
          try {
            const hashedPassword = await crypto7.postgresMd5PasswordHash(this.user, this.password, msg.salt);
            this.connection.password(hashedPassword);
          } catch (e6) {
            this.emit("error", e6);
          }
        });
      }
      _handleAuthSASL(msg) {
        this._checkPgPass(() => {
          try {
            this.saslSession = sasl.startSession(msg.mechanisms, this.enableChannelBinding && this.connection.stream);
            this.connection.sendSASLInitialResponseMessage(this.saslSession.mechanism, this.saslSession.response);
          } catch (err3) {
            this.connection.emit("error", err3);
          }
        });
      }
      async _handleAuthSASLContinue(msg) {
        try {
          await sasl.continueSession(
            this.saslSession,
            this.password,
            msg.data,
            this.enableChannelBinding && this.connection.stream
          );
          this.connection.sendSCRAMClientFinalMessage(this.saslSession.response);
        } catch (err3) {
          this.connection.emit("error", err3);
        }
      }
      _handleAuthSASLFinal(msg) {
        try {
          sasl.finalizeSession(this.saslSession, msg.data);
          this.saslSession = null;
        } catch (err3) {
          this.connection.emit("error", err3);
        }
      }
      _handleBackendKeyData(msg) {
        this.processID = msg.processID;
        this.secretKey = msg.secretKey;
      }
      _handleReadyForQuery(msg) {
        if (this._connecting) {
          this._connecting = false;
          this._connected = true;
          clearTimeout(this.connectionTimeoutHandle);
          if (this._connectionCallback) {
            this._connectionCallback(null, this);
            this._connectionCallback = null;
          }
          this.emit("connect");
        }
        const { activeQuery } = this;
        this.activeQuery = null;
        this.readyForQuery = true;
        if (activeQuery) {
          activeQuery.handleReadyForQuery(this.connection);
        }
        this._pulseQueryQueue();
      }
      // if we receieve an error event or error message
      // during the connection process we handle it here
      _handleErrorWhileConnecting(err3) {
        if (this._connectionError) {
          return;
        }
        this._connectionError = true;
        clearTimeout(this.connectionTimeoutHandle);
        if (this._connectionCallback) {
          return this._connectionCallback(err3);
        }
        this.emit("error", err3);
      }
      // if we're connected and we receive an error event from the connection
      // this means the socket is dead - do a hard abort of all queries and emit
      // the socket error on the client as well
      _handleErrorEvent(err3) {
        if (this._connecting) {
          return this._handleErrorWhileConnecting(err3);
        }
        this._queryable = false;
        this._errorAllQueries(err3);
        this.emit("error", err3);
      }
      // handle error messages from the postgres backend
      _handleErrorMessage(msg) {
        if (this._connecting) {
          return this._handleErrorWhileConnecting(msg);
        }
        const activeQuery = this.activeQuery;
        if (!activeQuery) {
          this._handleErrorEvent(msg);
          return;
        }
        this.activeQuery = null;
        activeQuery.handleError(msg, this.connection);
      }
      _handleRowDescription(msg) {
        this.activeQuery.handleRowDescription(msg);
      }
      _handleDataRow(msg) {
        this.activeQuery.handleDataRow(msg);
      }
      _handlePortalSuspended(msg) {
        this.activeQuery.handlePortalSuspended(this.connection);
      }
      _handleEmptyQuery(msg) {
        this.activeQuery.handleEmptyQuery(this.connection);
      }
      _handleCommandComplete(msg) {
        if (this.activeQuery == null) {
          const error2 = new Error("Received unexpected commandComplete message from backend.");
          this._handleErrorEvent(error2);
          return;
        }
        this.activeQuery.handleCommandComplete(msg, this.connection);
      }
      _handleParseComplete() {
        if (this.activeQuery == null) {
          const error2 = new Error("Received unexpected parseComplete message from backend.");
          this._handleErrorEvent(error2);
          return;
        }
        if (this.activeQuery.name) {
          this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text;
        }
      }
      _handleCopyInResponse(msg) {
        this.activeQuery.handleCopyInResponse(this.connection);
      }
      _handleCopyData(msg) {
        this.activeQuery.handleCopyData(msg, this.connection);
      }
      _handleNotification(msg) {
        this.emit("notification", msg);
      }
      _handleNotice(msg) {
        this.emit("notice", msg);
      }
      getStartupConf() {
        const params = this.connectionParameters;
        const data = {
          user: params.user,
          database: params.database
        };
        const appName = params.application_name || params.fallback_application_name;
        if (appName) {
          data.application_name = appName;
        }
        if (params.replication) {
          data.replication = "" + params.replication;
        }
        if (params.statement_timeout) {
          data.statement_timeout = String(parseInt(params.statement_timeout, 10));
        }
        if (params.lock_timeout) {
          data.lock_timeout = String(parseInt(params.lock_timeout, 10));
        }
        if (params.idle_in_transaction_session_timeout) {
          data.idle_in_transaction_session_timeout = String(parseInt(params.idle_in_transaction_session_timeout, 10));
        }
        if (params.options) {
          data.options = params.options;
        }
        return data;
      }
      cancel(client, query) {
        if (client.activeQuery === query) {
          const con = this.connection;
          if (this.host && this.host.indexOf("/") === 0) {
            con.connect(this.host + "/.s.PGSQL." + this.port);
          } else {
            con.connect(this.port, this.host);
          }
          con.on("connect", function() {
            con.cancel(client.processID, client.secretKey);
          });
        } else if (client.queryQueue.indexOf(query) !== -1) {
          client.queryQueue.splice(client.queryQueue.indexOf(query), 1);
        }
      }
      setTypeParser(oid, format2, parseFn) {
        return this._types.setTypeParser(oid, format2, parseFn);
      }
      getTypeParser(oid, format2) {
        return this._types.getTypeParser(oid, format2);
      }
      // escapeIdentifier and escapeLiteral moved to utility functions & exported
      // on PG
      // re-exported here for backwards compatibility
      escapeIdentifier(str) {
        return utils.escapeIdentifier(str);
      }
      escapeLiteral(str) {
        return utils.escapeLiteral(str);
      }
      _pulseQueryQueue() {
        if (this.readyForQuery === true) {
          this.activeQuery = this.queryQueue.shift();
          if (this.activeQuery) {
            this.readyForQuery = false;
            this.hasExecuted = true;
            const queryError = this.activeQuery.submit(this.connection);
            if (queryError) {
              process.nextTick(() => {
                this.activeQuery.handleError(queryError, this.connection);
                this.readyForQuery = true;
                this._pulseQueryQueue();
              });
            }
          } else if (this.hasExecuted) {
            this.activeQuery = null;
            this.emit("drain");
          }
        }
      }
      query(config, values2, callback) {
        let query;
        let result;
        let readTimeout;
        let readTimeoutTimer;
        let queryCallback;
        if (config === null || config === void 0) {
          throw new TypeError("Client was passed a null or undefined query");
        } else if (typeof config.submit === "function") {
          readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
          result = query = config;
          if (typeof values2 === "function") {
            query.callback = query.callback || values2;
          }
        } else {
          readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
          query = new Query3(config, values2, callback);
          if (!query.callback) {
            result = new this._Promise((resolve2, reject) => {
              query.callback = (err3, res) => err3 ? reject(err3) : resolve2(res);
            }).catch((err3) => {
              Error.captureStackTrace(err3);
              throw err3;
            });
          }
        }
        if (readTimeout) {
          queryCallback = query.callback;
          readTimeoutTimer = setTimeout(() => {
            const error2 = new Error("Query read timeout");
            process.nextTick(() => {
              query.handleError(error2, this.connection);
            });
            queryCallback(error2);
            query.callback = () => {
            };
            const index7 = this.queryQueue.indexOf(query);
            if (index7 > -1) {
              this.queryQueue.splice(index7, 1);
            }
            this._pulseQueryQueue();
          }, readTimeout);
          query.callback = (err3, res) => {
            clearTimeout(readTimeoutTimer);
            queryCallback(err3, res);
          };
        }
        if (this.binary && !query.binary) {
          query.binary = true;
        }
        if (query._result && !query._result._types) {
          query._result._types = this._types;
        }
        if (!this._queryable) {
          process.nextTick(() => {
            query.handleError(new Error("Client has encountered a connection error and is not queryable"), this.connection);
          });
          return result;
        }
        if (this._ending) {
          process.nextTick(() => {
            query.handleError(new Error("Client was closed and is not queryable"), this.connection);
          });
          return result;
        }
        this.queryQueue.push(query);
        this._pulseQueryQueue();
        return result;
      }
      ref() {
        this.connection.ref();
      }
      unref() {
        this.connection.unref();
      }
      end(cb) {
        this._ending = true;
        if (!this.connection._connecting || this._ended) {
          if (cb) {
            cb();
          } else {
            return this._Promise.resolve();
          }
        }
        if (this.activeQuery || !this._queryable) {
          this.connection.stream.destroy();
        } else {
          this.connection.end();
        }
        if (cb) {
          this.connection.once("end", cb);
        } else {
          return new this._Promise((resolve2) => {
            this.connection.once("end", resolve2);
          });
        }
      }
    };
    Client6.Query = Query3;
    module2.exports = Client6;
  }
});

// ../node_modules/.pnpm/pg-pool@3.10.0_pg@8.16.0/node_modules/pg-pool/index.js
var require_pg_pool = __commonJS({
  "../node_modules/.pnpm/pg-pool@3.10.0_pg@8.16.0/node_modules/pg-pool/index.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var NOOP = function() {
    };
    var removeWhere = (list, predicate) => {
      const i8 = list.findIndex(predicate);
      return i8 === -1 ? void 0 : list.splice(i8, 1)[0];
    };
    var IdleItem = class {
      constructor(client, idleListener, timeoutId) {
        this.client = client;
        this.idleListener = idleListener;
        this.timeoutId = timeoutId;
      }
    };
    var PendingItem = class {
      constructor(callback) {
        this.callback = callback;
      }
    };
    function throwOnDoubleRelease() {
      throw new Error("Release called on client which has already been released to the pool.");
    }
    function promisify3(Promise2, callback) {
      if (callback) {
        return { callback, result: void 0 };
      }
      let rej;
      let res;
      const cb = function(err3, client) {
        err3 ? rej(err3) : res(client);
      };
      const result = new Promise2(function(resolve2, reject) {
        res = resolve2;
        rej = reject;
      }).catch((err3) => {
        Error.captureStackTrace(err3);
        throw err3;
      });
      return { callback: cb, result };
    }
    function makeIdleListener(pool2, client) {
      return function idleListener(err3) {
        err3.client = client;
        client.removeListener("error", idleListener);
        client.on("error", () => {
          pool2.log("additional client error after disconnection due to error", err3);
        });
        pool2._remove(client);
        pool2.emit("error", err3, client);
      };
    }
    var Pool3 = class extends EventEmitter {
      constructor(options, Client6) {
        super();
        this.options = Object.assign({}, options);
        if (options != null && "password" in options) {
          Object.defineProperty(this.options, "password", {
            configurable: true,
            enumerable: false,
            writable: true,
            value: options.password
          });
        }
        if (options != null && options.ssl && options.ssl.key) {
          Object.defineProperty(this.options.ssl, "key", {
            enumerable: false
          });
        }
        this.options.max = this.options.max || this.options.poolSize || 10;
        this.options.min = this.options.min || 0;
        this.options.maxUses = this.options.maxUses || Infinity;
        this.options.allowExitOnIdle = this.options.allowExitOnIdle || false;
        this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0;
        this.log = this.options.log || function() {
        };
        this.Client = this.options.Client || Client6 || require_lib3().Client;
        this.Promise = this.options.Promise || global.Promise;
        if (typeof this.options.idleTimeoutMillis === "undefined") {
          this.options.idleTimeoutMillis = 1e4;
        }
        this._clients = [];
        this._idle = [];
        this._expired = /* @__PURE__ */ new WeakSet();
        this._pendingQueue = [];
        this._endCallback = void 0;
        this.ending = false;
        this.ended = false;
      }
      _isFull() {
        return this._clients.length >= this.options.max;
      }
      _isAboveMin() {
        return this._clients.length > this.options.min;
      }
      _pulseQueue() {
        this.log("pulse queue");
        if (this.ended) {
          this.log("pulse queue ended");
          return;
        }
        if (this.ending) {
          this.log("pulse queue on ending");
          if (this._idle.length) {
            this._idle.slice().map((item) => {
              this._remove(item.client);
            });
          }
          if (!this._clients.length) {
            this.ended = true;
            this._endCallback();
          }
          return;
        }
        if (!this._pendingQueue.length) {
          this.log("no queued requests");
          return;
        }
        if (!this._idle.length && this._isFull()) {
          return;
        }
        const pendingItem = this._pendingQueue.shift();
        if (this._idle.length) {
          const idleItem = this._idle.pop();
          clearTimeout(idleItem.timeoutId);
          const client = idleItem.client;
          client.ref && client.ref();
          const idleListener = idleItem.idleListener;
          return this._acquireClient(client, pendingItem, idleListener, false);
        }
        if (!this._isFull()) {
          return this.newClient(pendingItem);
        }
        throw new Error("unexpected condition");
      }
      _remove(client) {
        const removed = removeWhere(this._idle, (item) => item.client === client);
        if (removed !== void 0) {
          clearTimeout(removed.timeoutId);
        }
        this._clients = this._clients.filter((c6) => c6 !== client);
        client.end();
        this.emit("remove", client);
      }
      connect(cb) {
        if (this.ending) {
          const err3 = new Error("Cannot use a pool after calling end on the pool");
          return cb ? cb(err3) : this.Promise.reject(err3);
        }
        const response = promisify3(this.Promise, cb);
        const result = response.result;
        if (this._isFull() || this._idle.length) {
          if (this._idle.length) {
            process.nextTick(() => this._pulseQueue());
          }
          if (!this.options.connectionTimeoutMillis) {
            this._pendingQueue.push(new PendingItem(response.callback));
            return result;
          }
          const queueCallback = (err3, res, done) => {
            clearTimeout(tid);
            response.callback(err3, res, done);
          };
          const pendingItem = new PendingItem(queueCallback);
          const tid = setTimeout(() => {
            removeWhere(this._pendingQueue, (i8) => i8.callback === queueCallback);
            pendingItem.timedOut = true;
            response.callback(new Error("timeout exceeded when trying to connect"));
          }, this.options.connectionTimeoutMillis);
          if (tid.unref) {
            tid.unref();
          }
          this._pendingQueue.push(pendingItem);
          return result;
        }
        this.newClient(new PendingItem(response.callback));
        return result;
      }
      newClient(pendingItem) {
        const client = new this.Client(this.options);
        this._clients.push(client);
        const idleListener = makeIdleListener(this, client);
        this.log("checking client timeout");
        let tid;
        let timeoutHit = false;
        if (this.options.connectionTimeoutMillis) {
          tid = setTimeout(() => {
            this.log("ending client due to timeout");
            timeoutHit = true;
            client.connection ? client.connection.stream.destroy() : client.end();
          }, this.options.connectionTimeoutMillis);
        }
        this.log("connecting new client");
        client.connect((err3) => {
          if (tid) {
            clearTimeout(tid);
          }
          client.on("error", idleListener);
          if (err3) {
            this.log("client failed to connect", err3);
            this._clients = this._clients.filter((c6) => c6 !== client);
            if (timeoutHit) {
              err3 = new Error("Connection terminated due to connection timeout", { cause: err3 });
            }
            this._pulseQueue();
            if (!pendingItem.timedOut) {
              pendingItem.callback(err3, void 0, NOOP);
            }
          } else {
            this.log("new client connected");
            if (this.options.maxLifetimeSeconds !== 0) {
              const maxLifetimeTimeout = setTimeout(() => {
                this.log("ending client due to expired lifetime");
                this._expired.add(client);
                const idleIndex = this._idle.findIndex((idleItem) => idleItem.client === client);
                if (idleIndex !== -1) {
                  this._acquireClient(
                    client,
                    new PendingItem((err4, client2, clientRelease) => clientRelease()),
                    idleListener,
                    false
                  );
                }
              }, this.options.maxLifetimeSeconds * 1e3);
              maxLifetimeTimeout.unref();
              client.once("end", () => clearTimeout(maxLifetimeTimeout));
            }
            return this._acquireClient(client, pendingItem, idleListener, true);
          }
        });
      }
      // acquire a client for a pending work item
      _acquireClient(client, pendingItem, idleListener, isNew) {
        if (isNew) {
          this.emit("connect", client);
        }
        this.emit("acquire", client);
        client.release = this._releaseOnce(client, idleListener);
        client.removeListener("error", idleListener);
        if (!pendingItem.timedOut) {
          if (isNew && this.options.verify) {
            this.options.verify(client, (err3) => {
              if (err3) {
                client.release(err3);
                return pendingItem.callback(err3, void 0, NOOP);
              }
              pendingItem.callback(void 0, client, client.release);
            });
          } else {
            pendingItem.callback(void 0, client, client.release);
          }
        } else {
          if (isNew && this.options.verify) {
            this.options.verify(client, client.release);
          } else {
            client.release();
          }
        }
      }
      // returns a function that wraps _release and throws if called more than once
      _releaseOnce(client, idleListener) {
        let released = false;
        return (err3) => {
          if (released) {
            throwOnDoubleRelease();
          }
          released = true;
          this._release(client, idleListener, err3);
        };
      }
      // release a client back to the poll, include an error
      // to remove it from the pool
      _release(client, idleListener, err3) {
        client.on("error", idleListener);
        client._poolUseCount = (client._poolUseCount || 0) + 1;
        this.emit("release", err3, client);
        if (err3 || this.ending || !client._queryable || client._ending || client._poolUseCount >= this.options.maxUses) {
          if (client._poolUseCount >= this.options.maxUses) {
            this.log("remove expended client");
          }
          this._remove(client);
          this._pulseQueue();
          return;
        }
        const isExpired = this._expired.has(client);
        if (isExpired) {
          this.log("remove expired client");
          this._expired.delete(client);
          this._remove(client);
          this._pulseQueue();
          return;
        }
        let tid;
        if (this.options.idleTimeoutMillis && this._isAboveMin()) {
          tid = setTimeout(() => {
            this.log("remove idle client");
            this._remove(client);
          }, this.options.idleTimeoutMillis);
          if (this.options.allowExitOnIdle) {
            tid.unref();
          }
        }
        if (this.options.allowExitOnIdle) {
          client.unref();
        }
        this._idle.push(new IdleItem(client, idleListener, tid));
        this._pulseQueue();
      }
      query(text5, values2, cb) {
        if (typeof text5 === "function") {
          const response2 = promisify3(this.Promise, text5);
          setImmediate(function() {
            return response2.callback(new Error("Passing a function as the first parameter to pool.query is not supported"));
          });
          return response2.result;
        }
        if (typeof values2 === "function") {
          cb = values2;
          values2 = void 0;
        }
        const response = promisify3(this.Promise, cb);
        cb = response.callback;
        this.connect((err3, client) => {
          if (err3) {
            return cb(err3);
          }
          let clientReleased = false;
          const onError = (err4) => {
            if (clientReleased) {
              return;
            }
            clientReleased = true;
            client.release(err4);
            cb(err4);
          };
          client.once("error", onError);
          this.log("dispatching query");
          try {
            client.query(text5, values2, (err4, res) => {
              this.log("query dispatched");
              client.removeListener("error", onError);
              if (clientReleased) {
                return;
              }
              clientReleased = true;
              client.release(err4);
              if (err4) {
                return cb(err4);
              }
              return cb(void 0, res);
            });
          } catch (err4) {
            client.release(err4);
            return cb(err4);
          }
        });
        return response.result;
      }
      end(cb) {
        this.log("ending");
        if (this.ending) {
          const err3 = new Error("Called end on pool more than once");
          return cb ? cb(err3) : this.Promise.reject(err3);
        }
        this.ending = true;
        const promised = promisify3(this.Promise, cb);
        this._endCallback = promised.callback;
        this._pulseQueue();
        return promised.result;
      }
      get waitingCount() {
        return this._pendingQueue.length;
      }
      get idleCount() {
        return this._idle.length;
      }
      get expiredCount() {
        return this._clients.reduce((acc, client) => acc + (this._expired.has(client) ? 1 : 0), 0);
      }
      get totalCount() {
        return this._clients.length;
      }
    };
    module2.exports = Pool3;
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/native/query.js
var require_query2 = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/native/query.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var util2 = require("util");
    var utils = require_utils2();
    var NativeQuery = module2.exports = function(config, values2, callback) {
      EventEmitter.call(this);
      config = utils.normalizeQueryConfig(config, values2, callback);
      this.text = config.text;
      this.values = config.values;
      this.name = config.name;
      this.queryMode = config.queryMode;
      this.callback = config.callback;
      this.state = "new";
      this._arrayMode = config.rowMode === "array";
      this._emitRowEvents = false;
      this.on(
        "newListener",
        function(event) {
          if (event === "row") this._emitRowEvents = true;
        }.bind(this)
      );
    };
    util2.inherits(NativeQuery, EventEmitter);
    var errorFieldMap = {
      sqlState: "code",
      statementPosition: "position",
      messagePrimary: "message",
      context: "where",
      schemaName: "schema",
      tableName: "table",
      columnName: "column",
      dataTypeName: "dataType",
      constraintName: "constraint",
      sourceFile: "file",
      sourceLine: "line",
      sourceFunction: "routine"
    };
    NativeQuery.prototype.handleError = function(err3) {
      const fields = this.native.pq.resultErrorFields();
      if (fields) {
        for (const key in fields) {
          const normalizedFieldName = errorFieldMap[key] || key;
          err3[normalizedFieldName] = fields[key];
        }
      }
      if (this.callback) {
        this.callback(err3);
      } else {
        this.emit("error", err3);
      }
      this.state = "error";
    };
    NativeQuery.prototype.then = function(onSuccess, onFailure) {
      return this._getPromise().then(onSuccess, onFailure);
    };
    NativeQuery.prototype.catch = function(callback) {
      return this._getPromise().catch(callback);
    };
    NativeQuery.prototype._getPromise = function() {
      if (this._promise) return this._promise;
      this._promise = new Promise(
        function(resolve2, reject) {
          this._once("end", resolve2);
          this._once("error", reject);
        }.bind(this)
      );
      return this._promise;
    };
    NativeQuery.prototype.submit = function(client) {
      this.state = "running";
      const self2 = this;
      this.native = client.native;
      client.native.arrayMode = this._arrayMode;
      let after = function(err3, rows, results) {
        client.native.arrayMode = false;
        setImmediate(function() {
          self2.emit("_done");
        });
        if (err3) {
          return self2.handleError(err3);
        }
        if (self2._emitRowEvents) {
          if (results.length > 1) {
            rows.forEach((rowOfRows, i8) => {
              rowOfRows.forEach((row) => {
                self2.emit("row", row, results[i8]);
              });
            });
          } else {
            rows.forEach(function(row) {
              self2.emit("row", row, results);
            });
          }
        }
        self2.state = "end";
        self2.emit("end", results);
        if (self2.callback) {
          self2.callback(null, results);
        }
      };
      if (process.domain) {
        after = process.domain.bind(after);
      }
      if (this.name) {
        if (this.name.length > 63) {
          console.error("Warning! Postgres only supports 63 characters for query names.");
          console.error("You supplied %s (%s)", this.name, this.name.length);
          console.error("This can cause conflicts and silent errors executing queries");
        }
        const values2 = (this.values || []).map(utils.prepareValue);
        if (client.namedQueries[this.name]) {
          if (this.text && client.namedQueries[this.name] !== this.text) {
            const err3 = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
            return after(err3);
          }
          return client.native.execute(this.name, values2, after);
        }
        return client.native.prepare(this.name, this.text, values2.length, function(err3) {
          if (err3) return after(err3);
          client.namedQueries[self2.name] = self2.text;
          return self2.native.execute(self2.name, values2, after);
        });
      } else if (this.values) {
        if (!Array.isArray(this.values)) {
          const err3 = new Error("Query values must be an array");
          return after(err3);
        }
        const vals = this.values.map(utils.prepareValue);
        client.native.query(this.text, vals, after);
      } else if (this.queryMode === "extended") {
        client.native.query(this.text, [], after);
      } else {
        client.native.query(this.text, after);
      }
    };
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/native/client.js
var require_client2 = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/native/client.js"(exports2, module2) {
    "use strict";
    var Native;
    try {
      Native = require("pg-native");
    } catch (e6) {
      throw e6;
    }
    var TypeOverrides2 = require_type_overrides();
    var EventEmitter = require("events").EventEmitter;
    var util2 = require("util");
    var ConnectionParameters = require_connection_parameters();
    var NativeQuery = require_query2();
    var Client6 = module2.exports = function(config) {
      EventEmitter.call(this);
      config = config || {};
      this._Promise = config.Promise || global.Promise;
      this._types = new TypeOverrides2(config.types);
      this.native = new Native({
        types: this._types
      });
      this._queryQueue = [];
      this._ending = false;
      this._connecting = false;
      this._connected = false;
      this._queryable = true;
      const cp = this.connectionParameters = new ConnectionParameters(config);
      if (config.nativeConnectionString) cp.nativeConnectionString = config.nativeConnectionString;
      this.user = cp.user;
      Object.defineProperty(this, "password", {
        configurable: true,
        enumerable: false,
        writable: true,
        value: cp.password
      });
      this.database = cp.database;
      this.host = cp.host;
      this.port = cp.port;
      this.namedQueries = {};
    };
    Client6.Query = NativeQuery;
    util2.inherits(Client6, EventEmitter);
    Client6.prototype._errorAllQueries = function(err3) {
      const enqueueError = (query) => {
        process.nextTick(() => {
          query.native = this.native;
          query.handleError(err3);
        });
      };
      if (this._hasActiveQuery()) {
        enqueueError(this._activeQuery);
        this._activeQuery = null;
      }
      this._queryQueue.forEach(enqueueError);
      this._queryQueue.length = 0;
    };
    Client6.prototype._connect = function(cb) {
      const self2 = this;
      if (this._connecting) {
        process.nextTick(() => cb(new Error("Client has already been connected. You cannot reuse a client.")));
        return;
      }
      this._connecting = true;
      this.connectionParameters.getLibpqConnectionString(function(err3, conString) {
        if (self2.connectionParameters.nativeConnectionString) conString = self2.connectionParameters.nativeConnectionString;
        if (err3) return cb(err3);
        self2.native.connect(conString, function(err4) {
          if (err4) {
            self2.native.end();
            return cb(err4);
          }
          self2._connected = true;
          self2.native.on("error", function(err5) {
            self2._queryable = false;
            self2._errorAllQueries(err5);
            self2.emit("error", err5);
          });
          self2.native.on("notification", function(msg) {
            self2.emit("notification", {
              channel: msg.relname,
              payload: msg.extra
            });
          });
          self2.emit("connect");
          self2._pulseQueryQueue(true);
          cb();
        });
      });
    };
    Client6.prototype.connect = function(callback) {
      if (callback) {
        this._connect(callback);
        return;
      }
      return new this._Promise((resolve2, reject) => {
        this._connect((error2) => {
          if (error2) {
            reject(error2);
          } else {
            resolve2();
          }
        });
      });
    };
    Client6.prototype.query = function(config, values2, callback) {
      let query;
      let result;
      let readTimeout;
      let readTimeoutTimer;
      let queryCallback;
      if (config === null || config === void 0) {
        throw new TypeError("Client was passed a null or undefined query");
      } else if (typeof config.submit === "function") {
        readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
        result = query = config;
        if (typeof values2 === "function") {
          config.callback = values2;
        }
      } else {
        readTimeout = config.query_timeout || this.connectionParameters.query_timeout;
        query = new NativeQuery(config, values2, callback);
        if (!query.callback) {
          let resolveOut, rejectOut;
          result = new this._Promise((resolve2, reject) => {
            resolveOut = resolve2;
            rejectOut = reject;
          }).catch((err3) => {
            Error.captureStackTrace(err3);
            throw err3;
          });
          query.callback = (err3, res) => err3 ? rejectOut(err3) : resolveOut(res);
        }
      }
      if (readTimeout) {
        queryCallback = query.callback;
        readTimeoutTimer = setTimeout(() => {
          const error2 = new Error("Query read timeout");
          process.nextTick(() => {
            query.handleError(error2, this.connection);
          });
          queryCallback(error2);
          query.callback = () => {
          };
          const index7 = this._queryQueue.indexOf(query);
          if (index7 > -1) {
            this._queryQueue.splice(index7, 1);
          }
          this._pulseQueryQueue();
        }, readTimeout);
        query.callback = (err3, res) => {
          clearTimeout(readTimeoutTimer);
          queryCallback(err3, res);
        };
      }
      if (!this._queryable) {
        query.native = this.native;
        process.nextTick(() => {
          query.handleError(new Error("Client has encountered a connection error and is not queryable"));
        });
        return result;
      }
      if (this._ending) {
        query.native = this.native;
        process.nextTick(() => {
          query.handleError(new Error("Client was closed and is not queryable"));
        });
        return result;
      }
      this._queryQueue.push(query);
      this._pulseQueryQueue();
      return result;
    };
    Client6.prototype.end = function(cb) {
      const self2 = this;
      this._ending = true;
      if (!this._connected) {
        this.once("connect", this.end.bind(this, cb));
      }
      let result;
      if (!cb) {
        result = new this._Promise(function(resolve2, reject) {
          cb = (err3) => err3 ? reject(err3) : resolve2();
        });
      }
      this.native.end(function() {
        self2._errorAllQueries(new Error("Connection terminated"));
        process.nextTick(() => {
          self2.emit("end");
          if (cb) cb();
        });
      });
      return result;
    };
    Client6.prototype._hasActiveQuery = function() {
      return this._activeQuery && this._activeQuery.state !== "error" && this._activeQuery.state !== "end";
    };
    Client6.prototype._pulseQueryQueue = function(initialConnection) {
      if (!this._connected) {
        return;
      }
      if (this._hasActiveQuery()) {
        return;
      }
      const query = this._queryQueue.shift();
      if (!query) {
        if (!initialConnection) {
          this.emit("drain");
        }
        return;
      }
      this._activeQuery = query;
      query.submit(this);
      const self2 = this;
      query.once("_done", function() {
        self2._pulseQueryQueue();
      });
    };
    Client6.prototype.cancel = function(query) {
      if (this._activeQuery === query) {
        this.native.cancel(function() {
        });
      } else if (this._queryQueue.indexOf(query) !== -1) {
        this._queryQueue.splice(this._queryQueue.indexOf(query), 1);
      }
    };
    Client6.prototype.ref = function() {
    };
    Client6.prototype.unref = function() {
    };
    Client6.prototype.setTypeParser = function(oid, format2, parseFn) {
      return this._types.setTypeParser(oid, format2, parseFn);
    };
    Client6.prototype.getTypeParser = function(oid, format2) {
      return this._types.getTypeParser(oid, format2);
    };
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/native/index.js
var require_native = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/native/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_client2();
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/index.js
var require_lib3 = __commonJS({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/lib/index.js"(exports2, module2) {
    "use strict";
    var Client6 = require_client();
    var defaults3 = require_defaults();
    var Connection4 = require_connection();
    var Result3 = require_result();
    var utils = require_utils2();
    var Pool3 = require_pg_pool();
    var TypeOverrides2 = require_type_overrides();
    var { DatabaseError: DatabaseError3 } = require_dist();
    var { escapeIdentifier: escapeIdentifier3, escapeLiteral: escapeLiteral2 } = require_utils2();
    var poolFactory = (Client7) => {
      return class BoundPool extends Pool3 {
        constructor(options) {
          super(options, Client7);
        }
      };
    };
    var PG = function(clientConstructor) {
      this.defaults = defaults3;
      this.Client = clientConstructor;
      this.Query = this.Client.Query;
      this.Pool = poolFactory(this.Client);
      this._pools = [];
      this.Connection = Connection4;
      this.types = require_pg_types();
      this.DatabaseError = DatabaseError3;
      this.TypeOverrides = TypeOverrides2;
      this.escapeIdentifier = escapeIdentifier3;
      this.escapeLiteral = escapeLiteral2;
      this.Result = Result3;
      this.utils = utils;
    };
    if (typeof process.env.NODE_PG_FORCE_NATIVE !== "undefined") {
      module2.exports = new PG(require_native());
    } else {
      module2.exports = new PG(Client6);
      Object.defineProperty(module2.exports, "native", {
        configurable: true,
        enumerable: false,
        get() {
          let native = null;
          try {
            native = new PG(require_native());
          } catch (err3) {
            if (err3.code !== "MODULE_NOT_FOUND") {
              throw err3;
            }
          }
          Object.defineProperty(module2.exports, "native", {
            value: native
          });
          return native;
        }
      });
    }
  }
});

// ../node_modules/.pnpm/pg@8.16.0/node_modules/pg/esm/index.mjs
var esm_exports = {};
__export(esm_exports, {
  Client: () => Client2,
  Connection: () => Connection,
  DatabaseError: () => DatabaseError,
  Pool: () => Pool,
  Query: () => Query,
  Result: () => Result,
  TypeOverrides: () => TypeOverrides,
  default: () => esm_default,
  defaults: () => defaults2,
  escapeIdentifier: () => escapeIdentifier,
  escapeLiteral: () => escapeLiteral,
  types: () => types3
});
var import_lib3, Client2, Pool, Connection, types3, Query, DatabaseError, escapeIdentifier, escapeLiteral, Result, TypeOverrides, defaults2, esm_default;
var init_esm3 = __esm({
  "../node_modules/.pnpm/pg@8.16.0/node_modules/pg/esm/index.mjs"() {
    "use strict";
    import_lib3 = __toESM(require_lib3(), 1);
    Client2 = import_lib3.default.Client;
    Pool = import_lib3.default.Pool;
    Connection = import_lib3.default.Connection;
    types3 = import_lib3.default.types;
    Query = import_lib3.default.Query;
    DatabaseError = import_lib3.default.DatabaseError;
    escapeIdentifier = import_lib3.default.escapeIdentifier;
    escapeLiteral = import_lib3.default.escapeLiteral;
    Result = import_lib3.default.Result;
    TypeOverrides = import_lib3.default.TypeOverrides;
    defaults2 = import_lib3.default.defaults;
    esm_default = import_lib3.default;
  }
});

// ../drizzle-orm/dist/cache/core/index.js
var init_core = __esm({
  "../drizzle-orm/dist/cache/core/index.js"() {
    "use strict";
    init_cache();
  }
});

// ../drizzle-orm/dist/node-postgres/session.js
var Pool2, types4, _a461, _b335, NodePgPreparedQuery, _a462, _b336, _NodePgSession, NodePgSession, _a463, _b337, _NodePgTransaction, NodePgTransaction;
var init_session7 = __esm({
  "../drizzle-orm/dist/node-postgres/session.js"() {
    "use strict";
    init_esm3();
    init_core();
    init_entity();
    init_logger();
    init_pg_core();
    init_session2();
    init_sql();
    init_tracing();
    init_utils();
    ({ Pool: Pool2, types: types4 } = esm_default);
    NodePgPreparedQuery = class extends (_b335 = PgPreparedQuery, _a461 = entityKind, _b335) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, name3, _isResponseInArrayMode, customResultMapper) {
        super({ sql: queryString, params }, cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQueryConfig");
        __publicField(this, "queryConfig");
        this.client = client;
        this.queryString = queryString;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
        this.rawQueryConfig = {
          name: name3,
          text: queryString,
          types: {
            // @ts-ignore
            getTypeParser: (typeId, format2) => {
              if (typeId === types4.builtins.TIMESTAMPTZ) {
                return (val2) => val2;
              }
              if (typeId === types4.builtins.TIMESTAMP) {
                return (val2) => val2;
              }
              if (typeId === types4.builtins.DATE) {
                return (val2) => val2;
              }
              if (typeId === types4.builtins.INTERVAL) {
                return (val2) => val2;
              }
              if (typeId === 1231) {
                return (val2) => val2;
              }
              if (typeId === 1115) {
                return (val2) => val2;
              }
              if (typeId === 1185) {
                return (val2) => val2;
              }
              if (typeId === 1187) {
                return (val2) => val2;
              }
              if (typeId === 1182) {
                return (val2) => val2;
              }
              return types4.getTypeParser(typeId, format2);
            }
          }
        };
        this.queryConfig = {
          name: name3,
          text: queryString,
          rowMode: "array",
          types: {
            // @ts-ignore
            getTypeParser: (typeId, format2) => {
              if (typeId === types4.builtins.TIMESTAMPTZ) {
                return (val2) => val2;
              }
              if (typeId === types4.builtins.TIMESTAMP) {
                return (val2) => val2;
              }
              if (typeId === types4.builtins.DATE) {
                return (val2) => val2;
              }
              if (typeId === types4.builtins.INTERVAL) {
                return (val2) => val2;
              }
              if (typeId === 1231) {
                return (val2) => val2;
              }
              if (typeId === 1115) {
                return (val2) => val2;
              }
              if (typeId === 1185) {
                return (val2) => val2;
              }
              if (typeId === 1187) {
                return (val2) => val2;
              }
              if (typeId === 1182) {
                return (val2) => val2;
              }
              return types4.getTypeParser(typeId, format2);
            }
          }
        };
      }
      async execute(placeholderValues = {}) {
        return tracer.startActiveSpan("drizzle.execute", async () => {
          const params = fillPlaceholders(this.params, placeholderValues);
          this.logger.logQuery(this.rawQueryConfig.text, params);
          const { fields, rawQueryConfig: rawQuery, client, queryConfig: query, joinsNotNullableMap, customResultMapper } = this;
          if (!fields && !customResultMapper) {
            return tracer.startActiveSpan("drizzle.driver.execute", async (span) => {
              span?.setAttributes({
                "drizzle.query.name": rawQuery.name,
                "drizzle.query.text": rawQuery.text,
                "drizzle.query.params": JSON.stringify(params)
              });
              return this.queryWithCache(rawQuery.text, params, async () => {
                return await client.query(rawQuery, params);
              });
            });
          }
          const result = await tracer.startActiveSpan("drizzle.driver.execute", (span) => {
            span?.setAttributes({
              "drizzle.query.name": query.name,
              "drizzle.query.text": query.text,
              "drizzle.query.params": JSON.stringify(params)
            });
            return this.queryWithCache(query.text, params, async () => {
              return await client.query(query, params);
            });
          });
          return tracer.startActiveSpan("drizzle.mapResponse", () => {
            return customResultMapper ? customResultMapper(result.rows) : result.rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
          });
        });
      }
      all(placeholderValues = {}) {
        return tracer.startActiveSpan("drizzle.execute", () => {
          const params = fillPlaceholders(this.params, placeholderValues);
          this.logger.logQuery(this.rawQueryConfig.text, params);
          return tracer.startActiveSpan("drizzle.driver.execute", (span) => {
            span?.setAttributes({
              "drizzle.query.name": this.rawQueryConfig.name,
              "drizzle.query.text": this.rawQueryConfig.text,
              "drizzle.query.params": JSON.stringify(params)
            });
            return this.queryWithCache(this.rawQueryConfig.text, params, async () => {
              return this.client.query(this.rawQueryConfig, params);
            }).then((result) => result.rows);
          });
        });
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(NodePgPreparedQuery, _a461, "NodePgPreparedQuery");
    _NodePgSession = class _NodePgSession extends (_b336 = PgSession, _a462 = entityKind, _b336) {
      constructor(client, dialect6, schema6, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, name3, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return new NodePgPreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          name3,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      async transaction(transaction, config) {
        const session = this.client instanceof Pool2 ? new _NodePgSession(await this.client.connect(), this.dialect, this.schema, this.options) : this;
        const tx = new NodePgTransaction(this.dialect, session, this.schema);
        await tx.execute(sql`begin${config ? sql` ${tx.getTransactionConfigSQL(config)}` : void 0}`);
        try {
          const result = await transaction(tx);
          await tx.execute(sql`commit`);
          return result;
        } catch (error2) {
          await tx.execute(sql`rollback`);
          throw error2;
        } finally {
          if (this.client instanceof Pool2) {
            session.client.release();
          }
        }
      }
      async count(sql22) {
        const res = await this.execute(sql22);
        return Number(
          res["rows"][0]["count"]
        );
      }
    };
    __publicField(_NodePgSession, _a462, "NodePgSession");
    NodePgSession = _NodePgSession;
    _NodePgTransaction = class _NodePgTransaction extends (_b337 = PgTransaction, _a463 = entityKind, _b337) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _NodePgTransaction(
          this.dialect,
          this.session,
          this.schema,
          this.nestedIndex + 1
        );
        await tx.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await tx.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_NodePgTransaction, _a463, "NodePgTransaction");
    NodePgTransaction = _NodePgTransaction;
  }
});

// ../drizzle-orm/dist/node-postgres/driver.js
function construct3(client, config = {}) {
  const dialect6 = new PgDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const driver2 = new NodePgDriver(client, dialect6, { logger: logger2, cache: config.cache });
  const session = driver2.createSession(schema6);
  const db2 = new NodePgDatabase(dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function drizzle3(...params) {
  if (typeof params[0] === "string") {
    const instance2 = new esm_default.Pool({
      connectionString: params[0]
    });
    return construct3(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct3(client, drizzleConfig);
    const instance2 = typeof connection2 === "string" ? new esm_default.Pool({
      connectionString: connection2
    }) : new esm_default.Pool(connection2);
    return construct3(instance2, drizzleConfig);
  }
  return construct3(params[0], params[1]);
}
var _a464, NodePgDriver, _a465, _b338, NodePgDatabase;
var init_driver3 = __esm({
  "../drizzle-orm/dist/node-postgres/driver.js"() {
    "use strict";
    init_esm3();
    init_entity();
    init_logger();
    init_db2();
    init_dialect2();
    init_relations();
    init_utils();
    init_session7();
    _a464 = entityKind;
    NodePgDriver = class {
      constructor(client, dialect6, options = {}) {
        this.client = client;
        this.dialect = dialect6;
        this.options = options;
      }
      createSession(schema6) {
        return new NodePgSession(this.client, this.dialect, schema6, {
          logger: this.options.logger,
          cache: this.options.cache
        });
      }
    };
    __publicField(NodePgDriver, _a464, "NodePgDriver");
    NodePgDatabase = class extends (_b338 = PgDatabase, _a465 = entityKind, _b338) {
    };
    __publicField(NodePgDatabase, _a465, "NodePgDatabase");
    ((drizzle22) => {
      function mock(config) {
        return construct3({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle3 || (drizzle3 = {}));
  }
});

// ../drizzle-orm/dist/node-postgres/index.js
var node_postgres_exports = {};
__export(node_postgres_exports, {
  NodePgDatabase: () => NodePgDatabase,
  NodePgDriver: () => NodePgDriver,
  NodePgPreparedQuery: () => NodePgPreparedQuery,
  NodePgSession: () => NodePgSession,
  NodePgTransaction: () => NodePgTransaction,
  drizzle: () => drizzle3
});
var init_node_postgres = __esm({
  "../drizzle-orm/dist/node-postgres/index.js"() {
    "use strict";
    init_driver3();
    init_session7();
  }
});

// ../drizzle-orm/dist/node-postgres/migrator.js
var migrator_exports3 = {};
__export(migrator_exports3, {
  migrate: () => migrate3
});
async function migrate3(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator4 = __esm({
  "../drizzle-orm/dist/node-postgres/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/query.js
function cachedError(xs) {
  if (originCache.has(xs))
    return originCache.get(xs);
  const x11 = Error.stackTraceLimit;
  Error.stackTraceLimit = 4;
  originCache.set(xs, new Error());
  Error.stackTraceLimit = x11;
  return originCache.get(xs);
}
var originCache, originStackCache, originError, CLOSE, Query2;
var init_query4 = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/query.js"() {
    "use strict";
    originCache = /* @__PURE__ */ new Map();
    originStackCache = /* @__PURE__ */ new Map();
    originError = Symbol("OriginError");
    CLOSE = {};
    Query2 = class extends Promise {
      constructor(strings, args2, handler, canceller, options = {}) {
        let resolve2, reject;
        super((a9, b9) => {
          resolve2 = a9;
          reject = b9;
        });
        this.tagged = Array.isArray(strings.raw);
        this.strings = strings;
        this.args = args2;
        this.handler = handler;
        this.canceller = canceller;
        this.options = options;
        this.state = null;
        this.statement = null;
        this.resolve = (x11) => (this.active = false, resolve2(x11));
        this.reject = (x11) => (this.active = false, reject(x11));
        this.active = false;
        this.cancelled = null;
        this.executed = false;
        this.signature = "";
        this[originError] = this.handler.debug ? new Error() : this.tagged && cachedError(this.strings);
      }
      get origin() {
        return (this.handler.debug ? this[originError].stack : this.tagged && originStackCache.has(this.strings) ? originStackCache.get(this.strings) : originStackCache.set(this.strings, this[originError].stack).get(this.strings)) || "";
      }
      static get [Symbol.species]() {
        return Promise;
      }
      cancel() {
        return this.canceller && (this.canceller(this), this.canceller = null);
      }
      simple() {
        this.options.simple = true;
        this.options.prepare = false;
        return this;
      }
      async readable() {
        this.simple();
        this.streaming = true;
        return this;
      }
      async writable() {
        this.simple();
        this.streaming = true;
        return this;
      }
      cursor(rows = 1, fn3) {
        this.options.simple = false;
        if (typeof rows === "function") {
          fn3 = rows;
          rows = 1;
        }
        this.cursorRows = rows;
        if (typeof fn3 === "function")
          return this.cursorFn = fn3, this;
        let prev;
        return {
          [Symbol.asyncIterator]: () => ({
            next: () => {
              if (this.executed && !this.active)
                return { done: true };
              prev && prev();
              const promise = new Promise((resolve2, reject) => {
                this.cursorFn = (value) => {
                  resolve2({ value, done: false });
                  return new Promise((r6) => prev = r6);
                };
                this.resolve = () => (this.active = false, resolve2({ done: true }));
                this.reject = (x11) => (this.active = false, reject(x11));
              });
              this.execute();
              return promise;
            },
            return() {
              prev && prev(CLOSE);
              return { done: true };
            }
          })
        };
      }
      describe() {
        this.options.simple = false;
        this.onlyDescribe = this.options.prepare = true;
        return this;
      }
      stream() {
        throw new Error(".stream has been renamed to .forEach");
      }
      forEach(fn3) {
        this.forEachFn = fn3;
        this.handle();
        return this;
      }
      raw() {
        this.isRaw = true;
        return this;
      }
      values() {
        this.isRaw = "values";
        return this;
      }
      async handle() {
        !this.executed && (this.executed = true) && await 1 && this.handler(this);
      }
      execute() {
        this.handle();
        return this;
      }
      then() {
        this.handle();
        return super.then.apply(this, arguments);
      }
      catch() {
        this.handle();
        return super.catch.apply(this, arguments);
      }
      finally() {
        this.handle();
        return super.finally.apply(this, arguments);
      }
    };
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/errors.js
function connection(x11, options, socket) {
  const { host, port } = socket || options;
  const error2 = Object.assign(
    new Error("write " + x11 + " " + (options.path || host + ":" + port)),
    {
      code: x11,
      errno: x11,
      address: options.path || host
    },
    options.path ? {} : { port }
  );
  Error.captureStackTrace(error2, connection);
  return error2;
}
function postgres(x11) {
  const error2 = new PostgresError(x11);
  Error.captureStackTrace(error2, postgres);
  return error2;
}
function generic(code, message) {
  const error2 = Object.assign(new Error(code + ": " + message), { code });
  Error.captureStackTrace(error2, generic);
  return error2;
}
function notSupported(x11) {
  const error2 = Object.assign(
    new Error(x11 + " (B) is not supported"),
    {
      code: "MESSAGE_NOT_SUPPORTED",
      name: x11
    }
  );
  Error.captureStackTrace(error2, notSupported);
  return error2;
}
var PostgresError, Errors;
var init_errors3 = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/errors.js"() {
    "use strict";
    PostgresError = class extends Error {
      constructor(x11) {
        super(x11.message);
        this.name = this.constructor.name;
        Object.assign(this, x11);
      }
    };
    Errors = {
      connection,
      postgres,
      generic,
      notSupported
    };
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/types.js
function handleValue(x11, parameters, types6, options) {
  let value = x11 instanceof Parameter ? x11.value : x11;
  if (value === void 0) {
    x11 instanceof Parameter ? x11.value = options.transform.undefined : value = x11 = options.transform.undefined;
    if (value === void 0)
      throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
  }
  return "$" + types6.push(
    x11 instanceof Parameter ? (parameters.push(x11.value), x11.array ? x11.array[x11.type || inferType(x11.value)] || x11.type || firstIsString(x11.value) : x11.type) : (parameters.push(x11), inferType(x11))
  );
}
function stringify(q7, string2, value, parameters, types6, options) {
  for (let i8 = 1; i8 < q7.strings.length; i8++) {
    string2 += stringifyValue(string2, value, parameters, types6, options) + q7.strings[i8];
    value = q7.args[i8];
  }
  return string2;
}
function stringifyValue(string2, value, parameters, types6, o9) {
  return value instanceof Builder ? value.build(string2, parameters, types6, o9) : value instanceof Query2 ? fragment(value, parameters, types6, o9) : value instanceof Identifier ? value.value : value && value[0] instanceof Query2 ? value.reduce((acc, x11) => acc + " " + fragment(x11, parameters, types6, o9), "") : handleValue(value, parameters, types6, o9);
}
function fragment(q7, parameters, types6, options) {
  q7.fragment = true;
  return stringify(q7, q7.strings[0], q7.args[0], parameters, types6, options);
}
function valuesBuilder(first, parameters, types6, columns, options) {
  return first.map(
    (row) => "(" + columns.map(
      (column6) => stringifyValue("values", row[column6], parameters, types6, options)
    ).join(",") + ")"
  ).join(",");
}
function values(first, rest, parameters, types6, options) {
  const multi = Array.isArray(first[0]);
  const columns = rest.length ? rest.flat() : Object.keys(multi ? first[0] : first);
  return valuesBuilder(multi ? first : [first], parameters, types6, columns, options);
}
function select(first, rest, parameters, types6, options) {
  typeof first === "string" && (first = [first].concat(rest));
  if (Array.isArray(first))
    return escapeIdentifiers(first, options);
  let value;
  const columns = rest.length ? rest.flat() : Object.keys(first);
  return columns.map((x11) => {
    value = first[x11];
    return (value instanceof Query2 ? fragment(value, parameters, types6, options) : value instanceof Identifier ? value.value : handleValue(value, parameters, types6, options)) + " as " + escapeIdentifier2(options.transform.column.to ? options.transform.column.to(x11) : x11);
  }).join(",");
}
function notTagged() {
  throw Errors.generic("NOT_TAGGED_CALL", "Query not called as a tagged template literal");
}
function firstIsString(x11) {
  if (Array.isArray(x11))
    return firstIsString(x11[0]);
  return typeof x11 === "string" ? 1009 : 0;
}
function typeHandlers(types6) {
  return Object.keys(types6).reduce((acc, k9) => {
    types6[k9].from && [].concat(types6[k9].from).forEach((x11) => acc.parsers[x11] = types6[k9].parse);
    if (types6[k9].serialize) {
      acc.serializers[types6[k9].to] = types6[k9].serialize;
      types6[k9].from && [].concat(types6[k9].from).forEach((x11) => acc.serializers[x11] = types6[k9].serialize);
    }
    return acc;
  }, { parsers: {}, serializers: {} });
}
function escapeIdentifiers(xs, { transform: { column: column6 } }) {
  return xs.map((x11) => escapeIdentifier2(column6.to ? column6.to(x11) : x11)).join(",");
}
function arrayEscape(x11) {
  return x11.replace(escapeBackslash, "\\\\").replace(escapeQuote, '\\"');
}
function arrayParserLoop(s10, x11, parser, typarray) {
  const xs = [];
  const delimiter = typarray === 1020 ? ";" : ",";
  for (; s10.i < x11.length; s10.i++) {
    s10.char = x11[s10.i];
    if (s10.quoted) {
      if (s10.char === "\\") {
        s10.str += x11[++s10.i];
      } else if (s10.char === '"') {
        xs.push(parser ? parser(s10.str) : s10.str);
        s10.str = "";
        s10.quoted = x11[s10.i + 1] === '"';
        s10.last = s10.i + 2;
      } else {
        s10.str += s10.char;
      }
    } else if (s10.char === '"') {
      s10.quoted = true;
    } else if (s10.char === "{") {
      s10.last = ++s10.i;
      xs.push(arrayParserLoop(s10, x11, parser, typarray));
    } else if (s10.char === "}") {
      s10.quoted = false;
      s10.last < s10.i && xs.push(parser ? parser(x11.slice(s10.last, s10.i)) : x11.slice(s10.last, s10.i));
      s10.last = s10.i + 1;
      break;
    } else if (s10.char === delimiter && s10.p !== "}" && s10.p !== '"') {
      xs.push(parser ? parser(x11.slice(s10.last, s10.i)) : x11.slice(s10.last, s10.i));
      s10.last = s10.i + 1;
    }
    s10.p = s10.char;
  }
  s10.last < s10.i && xs.push(parser ? parser(x11.slice(s10.last, s10.i + 1)) : x11.slice(s10.last, s10.i + 1));
  return xs;
}
function createJsonTransform(fn3) {
  return function jsonTransform(x11, column6) {
    return typeof x11 === "object" && x11 !== null && (column6.type === 114 || column6.type === 3802) ? Array.isArray(x11) ? x11.map((x12) => jsonTransform(x12, column6)) : Object.entries(x11).reduce((acc, [k9, v11]) => Object.assign(acc, { [fn3(k9)]: jsonTransform(v11, column6) }), {}) : x11;
  };
}
var types5, NotTagged, Identifier, Parameter, Builder, defaultHandlers, builders, serializers, parsers, mergeUserTypes, escapeIdentifier2, inferType, escapeBackslash, escapeQuote, arraySerializer, arrayParserState, arrayParser, toCamel, toPascal, toKebab, fromCamel, fromPascal, fromKebab, camel, pascal, kebab;
var init_types11 = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/types.js"() {
    "use strict";
    init_query4();
    init_errors3();
    types5 = {
      string: {
        to: 25,
        from: null,
        // defaults to string
        serialize: (x11) => "" + x11
      },
      number: {
        to: 0,
        from: [21, 23, 26, 700, 701],
        serialize: (x11) => "" + x11,
        parse: (x11) => +x11
      },
      json: {
        to: 114,
        from: [114, 3802],
        serialize: (x11) => JSON.stringify(x11),
        parse: (x11) => JSON.parse(x11)
      },
      boolean: {
        to: 16,
        from: 16,
        serialize: (x11) => x11 === true ? "t" : "f",
        parse: (x11) => x11 === "t"
      },
      date: {
        to: 1184,
        from: [1082, 1114, 1184],
        serialize: (x11) => (x11 instanceof Date ? x11 : new Date(x11)).toISOString(),
        parse: (x11) => new Date(x11)
      },
      bytea: {
        to: 17,
        from: 17,
        serialize: (x11) => "\\x" + Buffer.from(x11).toString("hex"),
        parse: (x11) => Buffer.from(x11.slice(2), "hex")
      }
    };
    NotTagged = class {
      then() {
        notTagged();
      }
      catch() {
        notTagged();
      }
      finally() {
        notTagged();
      }
    };
    Identifier = class extends NotTagged {
      constructor(value) {
        super();
        this.value = escapeIdentifier2(value);
      }
    };
    Parameter = class extends NotTagged {
      constructor(value, type, array3) {
        super();
        this.value = value;
        this.type = type;
        this.array = array3;
      }
    };
    Builder = class extends NotTagged {
      constructor(first, rest) {
        super();
        this.first = first;
        this.rest = rest;
      }
      build(before, parameters, types6, options) {
        const keyword = builders.map(([x11, fn3]) => ({ fn: fn3, i: before.search(x11) })).sort((a9, b9) => a9.i - b9.i).pop();
        return keyword.i === -1 ? escapeIdentifiers(this.first, options) : keyword.fn(this.first, this.rest, parameters, types6, options);
      }
    };
    defaultHandlers = typeHandlers(types5);
    builders = Object.entries({
      values,
      in: (...xs) => {
        const x11 = values(...xs);
        return x11 === "()" ? "(null)" : x11;
      },
      select,
      as: select,
      returning: select,
      "\\(": select,
      update(first, rest, parameters, types6, options) {
        return (rest.length ? rest.flat() : Object.keys(first)).map(
          (x11) => escapeIdentifier2(options.transform.column.to ? options.transform.column.to(x11) : x11) + "=" + stringifyValue("values", first[x11], parameters, types6, options)
        );
      },
      insert(first, rest, parameters, types6, options) {
        const columns = rest.length ? rest.flat() : Object.keys(Array.isArray(first) ? first[0] : first);
        return "(" + escapeIdentifiers(columns, options) + ")values" + valuesBuilder(Array.isArray(first) ? first : [first], parameters, types6, columns, options);
      }
    }).map(([x11, fn3]) => [new RegExp("((?:^|[\\s(])" + x11 + "(?:$|[\\s(]))(?![\\s\\S]*\\1)", "i"), fn3]);
    serializers = defaultHandlers.serializers;
    parsers = defaultHandlers.parsers;
    mergeUserTypes = function(types6) {
      const user = typeHandlers(types6 || {});
      return {
        serializers: Object.assign({}, serializers, user.serializers),
        parsers: Object.assign({}, parsers, user.parsers)
      };
    };
    escapeIdentifier2 = function escape2(str) {
      return '"' + str.replace(/"/g, '""').replace(/\./g, '"."') + '"';
    };
    inferType = function inferType2(x11) {
      return x11 instanceof Parameter ? x11.type : x11 instanceof Date ? 1184 : x11 instanceof Uint8Array ? 17 : x11 === true || x11 === false ? 16 : typeof x11 === "bigint" ? 20 : Array.isArray(x11) ? inferType2(x11[0]) : 0;
    };
    escapeBackslash = /\\/g;
    escapeQuote = /"/g;
    arraySerializer = function arraySerializer2(xs, serializer, options, typarray) {
      if (Array.isArray(xs) === false)
        return xs;
      if (!xs.length)
        return "{}";
      const first = xs[0];
      const delimiter = typarray === 1020 ? ";" : ",";
      if (Array.isArray(first) && !first.type)
        return "{" + xs.map((x11) => arraySerializer2(x11, serializer, options, typarray)).join(delimiter) + "}";
      return "{" + xs.map((x11) => {
        if (x11 === void 0) {
          x11 = options.transform.undefined;
          if (x11 === void 0)
            throw Errors.generic("UNDEFINED_VALUE", "Undefined values are not allowed");
        }
        return x11 === null ? "null" : '"' + arrayEscape(serializer ? serializer(x11.type ? x11.value : x11) : "" + x11) + '"';
      }).join(delimiter) + "}";
    };
    arrayParserState = {
      i: 0,
      char: null,
      str: "",
      quoted: false,
      last: 0
    };
    arrayParser = function arrayParser2(x11, parser, typarray) {
      arrayParserState.i = arrayParserState.last = 0;
      return arrayParserLoop(arrayParserState, x11, parser, typarray);
    };
    toCamel = (x11) => {
      let str = x11[0];
      for (let i8 = 1; i8 < x11.length; i8++)
        str += x11[i8] === "_" ? x11[++i8].toUpperCase() : x11[i8];
      return str;
    };
    toPascal = (x11) => {
      let str = x11[0].toUpperCase();
      for (let i8 = 1; i8 < x11.length; i8++)
        str += x11[i8] === "_" ? x11[++i8].toUpperCase() : x11[i8];
      return str;
    };
    toKebab = (x11) => x11.replace(/_/g, "-");
    fromCamel = (x11) => x11.replace(/([A-Z])/g, "_$1").toLowerCase();
    fromPascal = (x11) => (x11.slice(0, 1) + x11.slice(1).replace(/([A-Z])/g, "_$1")).toLowerCase();
    fromKebab = (x11) => x11.replace(/-/g, "_");
    toCamel.column = { from: toCamel };
    toCamel.value = { from: createJsonTransform(toCamel) };
    fromCamel.column = { to: fromCamel };
    camel = { ...toCamel };
    camel.column.to = fromCamel;
    toPascal.column = { from: toPascal };
    toPascal.value = { from: createJsonTransform(toPascal) };
    fromPascal.column = { to: fromPascal };
    pascal = { ...toPascal };
    pascal.column.to = fromPascal;
    toKebab.column = { from: toKebab };
    toKebab.value = { from: createJsonTransform(toKebab) };
    fromKebab.column = { to: fromKebab };
    kebab = { ...toKebab };
    kebab.column.to = fromKebab;
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/result.js
var Result2;
var init_result = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/result.js"() {
    "use strict";
    Result2 = class extends Array {
      constructor() {
        super();
        Object.defineProperties(this, {
          count: { value: null, writable: true },
          state: { value: null, writable: true },
          command: { value: null, writable: true },
          columns: { value: null, writable: true },
          statement: { value: null, writable: true }
        });
      }
      static get [Symbol.species]() {
        return Array;
      }
    };
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/queue.js
function Queue(initial = []) {
  let xs = initial.slice();
  let index7 = 0;
  return {
    get length() {
      return xs.length - index7;
    },
    remove: (x11) => {
      const index8 = xs.indexOf(x11);
      return index8 === -1 ? null : (xs.splice(index8, 1), x11);
    },
    push: (x11) => (xs.push(x11), x11),
    shift: () => {
      const out2 = xs[index7++];
      if (index7 === xs.length) {
        index7 = 0;
        xs = [];
      } else {
        xs[index7 - 1] = void 0;
      }
      return out2;
    }
  };
}
var queue_default;
var init_queue = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/queue.js"() {
    "use strict";
    queue_default = Queue;
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/bytes.js
function fit(x11) {
  if (buffer.length - b7.i < x11) {
    const prev = buffer, length = prev.length;
    buffer = Buffer.allocUnsafe(length + (length >> 1) + x11);
    prev.copy(buffer);
  }
}
function reset() {
  b7.i = 0;
  return b7;
}
var size, buffer, messages, b7, bytes_default;
var init_bytes = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/bytes.js"() {
    "use strict";
    size = 256;
    buffer = Buffer.allocUnsafe(size);
    messages = "BCcDdEFfHPpQSX".split("").reduce((acc, x11) => {
      const v11 = x11.charCodeAt(0);
      acc[x11] = () => {
        buffer[0] = v11;
        b7.i = 5;
        return b7;
      };
      return acc;
    }, {});
    b7 = Object.assign(reset, messages, {
      N: String.fromCharCode(0),
      i: 0,
      inc(x11) {
        b7.i += x11;
        return b7;
      },
      str(x11) {
        const length = Buffer.byteLength(x11);
        fit(length);
        b7.i += buffer.write(x11, b7.i, length, "utf8");
        return b7;
      },
      i16(x11) {
        fit(2);
        buffer.writeUInt16BE(x11, b7.i);
        b7.i += 2;
        return b7;
      },
      i32(x11, i8) {
        if (i8 || i8 === 0) {
          buffer.writeUInt32BE(x11, i8);
          return b7;
        }
        fit(4);
        buffer.writeUInt32BE(x11, b7.i);
        b7.i += 4;
        return b7;
      },
      z(x11) {
        fit(x11);
        buffer.fill(0, b7.i, b7.i + x11);
        b7.i += x11;
        return b7;
      },
      raw(x11) {
        buffer = Buffer.concat([buffer.subarray(0, b7.i), x11]);
        b7.i = buffer.length;
        return b7;
      },
      end(at2 = 1) {
        buffer.writeUInt32BE(b7.i - at2, at2);
        const out2 = buffer.subarray(0, b7.i);
        b7.i = 0;
        buffer = Buffer.allocUnsafe(size);
        return out2;
      }
    });
    bytes_default = b7;
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/connection.js
function Connection2(options, queues = {}, { onopen = noop2, onend = noop2, onclose = noop2 } = {}) {
  const {
    ssl,
    max: max2,
    user,
    host,
    port,
    database,
    parsers: parsers2,
    transform,
    onnotice,
    onnotify,
    onparameter,
    max_pipeline,
    keep_alive,
    backoff: backoff2,
    target_session_attrs
  } = options;
  const sent = queue_default(), id = uid++, backend = { pid: null, secret: null }, idleTimer = timer(end, options.idle_timeout), lifeTimer = timer(end, options.max_lifetime), connectTimer = timer(connectTimedOut, options.connect_timeout);
  let socket = null, cancelMessage, result = new Result2(), incoming = Buffer.alloc(0), needsTypes = options.fetch_types, backendParameters = {}, statements = {}, statementId = Math.random().toString(36).slice(2), statementCount = 1, closedDate = 0, remaining = 0, hostIndex = 0, retries = 0, length = 0, delay = 0, rows = 0, serverSignature = null, nextWriteTimer = null, terminated = false, incomings = null, results = null, initial = null, ending = null, stream = null, chunk = null, ended = null, nonce = null, query = null, final = null;
  const connection2 = {
    queue: queues.closed,
    idleTimer,
    connect(query2) {
      initial = query2;
      reconnect();
    },
    terminate,
    execute,
    cancel,
    end,
    count: 0,
    id
  };
  queues.closed && queues.closed.push(connection2);
  return connection2;
  async function createSocket() {
    let x11;
    try {
      x11 = options.socket ? await Promise.resolve(options.socket(options)) : new import_net.default.Socket();
    } catch (e6) {
      error2(e6);
      return;
    }
    x11.on("error", error2);
    x11.on("close", closed);
    x11.on("drain", drain);
    return x11;
  }
  async function cancel({ pid, secret }, resolve2, reject) {
    try {
      cancelMessage = bytes_default().i32(16).i32(80877102).i32(pid).i32(secret).end(16);
      await connect2();
      socket.once("error", reject);
      socket.once("close", resolve2);
    } catch (error3) {
      reject(error3);
    }
  }
  function execute(q7) {
    if (terminated)
      return queryError(q7, Errors.connection("CONNECTION_DESTROYED", options));
    if (q7.cancelled)
      return;
    try {
      q7.state = backend;
      query ? sent.push(q7) : (query = q7, query.active = true);
      build(q7);
      return write(toBuffer(q7)) && !q7.describeFirst && !q7.cursorFn && sent.length < max_pipeline && (!q7.options.onexecute || q7.options.onexecute(connection2));
    } catch (error3) {
      sent.length === 0 && write(Sync);
      errored(error3);
      return true;
    }
  }
  function toBuffer(q7) {
    if (q7.parameters.length >= 65534)
      throw Errors.generic("MAX_PARAMETERS_EXCEEDED", "Max number of parameters (65534) exceeded");
    return q7.options.simple ? bytes_default().Q().str(q7.statement.string + bytes_default.N).end() : q7.describeFirst ? Buffer.concat([describe(q7), Flush]) : q7.prepare ? q7.prepared ? prepared(q7) : Buffer.concat([describe(q7), prepared(q7)]) : unnamed(q7);
  }
  function describe(q7) {
    return Buffer.concat([
      Parse(q7.statement.string, q7.parameters, q7.statement.types, q7.statement.name),
      Describe("S", q7.statement.name)
    ]);
  }
  function prepared(q7) {
    return Buffer.concat([
      Bind(q7.parameters, q7.statement.types, q7.statement.name, q7.cursorName),
      q7.cursorFn ? Execute("", q7.cursorRows) : ExecuteUnnamed
    ]);
  }
  function unnamed(q7) {
    return Buffer.concat([
      Parse(q7.statement.string, q7.parameters, q7.statement.types),
      DescribeUnnamed,
      prepared(q7)
    ]);
  }
  function build(q7) {
    const parameters = [], types6 = [];
    const string2 = stringify(q7, q7.strings[0], q7.args[0], parameters, types6, options);
    !q7.tagged && q7.args.forEach((x11) => handleValue(x11, parameters, types6, options));
    q7.prepare = options.prepare && ("prepare" in q7.options ? q7.options.prepare : true);
    q7.string = string2;
    q7.signature = q7.prepare && types6 + string2;
    q7.onlyDescribe && delete statements[q7.signature];
    q7.parameters = q7.parameters || parameters;
    q7.prepared = q7.prepare && q7.signature in statements;
    q7.describeFirst = q7.onlyDescribe || parameters.length && !q7.prepared;
    q7.statement = q7.prepared ? statements[q7.signature] : { string: string2, types: types6, name: q7.prepare ? statementId + statementCount++ : "" };
    typeof options.debug === "function" && options.debug(id, string2, parameters, types6);
  }
  function write(x11, fn3) {
    chunk = chunk ? Buffer.concat([chunk, x11]) : Buffer.from(x11);
    if (fn3 || chunk.length >= 1024)
      return nextWrite(fn3);
    nextWriteTimer === null && (nextWriteTimer = setImmediate(nextWrite));
    return true;
  }
  function nextWrite(fn3) {
    const x11 = socket.write(chunk, fn3);
    nextWriteTimer !== null && clearImmediate(nextWriteTimer);
    chunk = nextWriteTimer = null;
    return x11;
  }
  function connectTimedOut() {
    errored(Errors.connection("CONNECT_TIMEOUT", options, socket));
    socket.destroy();
  }
  async function secure() {
    write(SSLRequest);
    const canSSL = await new Promise((r6) => socket.once("data", (x11) => r6(x11[0] === 83)));
    if (!canSSL && ssl === "prefer")
      return connected();
    socket.removeAllListeners();
    socket = import_tls.default.connect({
      socket,
      servername: import_net.default.isIP(socket.host) ? void 0 : socket.host,
      ...ssl === "require" || ssl === "allow" || ssl === "prefer" ? { rejectUnauthorized: false } : ssl === "verify-full" ? {} : typeof ssl === "object" ? ssl : {}
    });
    socket.on("secureConnect", connected);
    socket.on("error", error2);
    socket.on("close", closed);
    socket.on("drain", drain);
  }
  function drain() {
    !query && onopen(connection2);
  }
  function data(x11) {
    if (incomings) {
      incomings.push(x11);
      remaining -= x11.length;
      if (remaining > 0)
        return;
    }
    incoming = incomings ? Buffer.concat(incomings, length - remaining) : incoming.length === 0 ? x11 : Buffer.concat([incoming, x11], incoming.length + x11.length);
    while (incoming.length > 4) {
      length = incoming.readUInt32BE(1);
      if (length >= incoming.length) {
        remaining = length - incoming.length;
        incomings = [incoming];
        break;
      }
      try {
        handle2(incoming.subarray(0, length + 1));
      } catch (e6) {
        query && (query.cursorFn || query.describeFirst) && write(Sync);
        errored(e6);
      }
      incoming = incoming.subarray(length + 1);
      remaining = 0;
      incomings = null;
    }
  }
  async function connect2() {
    terminated = false;
    backendParameters = {};
    socket || (socket = await createSocket());
    if (!socket)
      return;
    connectTimer.start();
    if (options.socket)
      return ssl ? secure() : connected();
    socket.on("connect", ssl ? secure : connected);
    if (options.path)
      return socket.connect(options.path);
    socket.ssl = ssl;
    socket.connect(port[hostIndex], host[hostIndex]);
    socket.host = host[hostIndex];
    socket.port = port[hostIndex];
    hostIndex = (hostIndex + 1) % port.length;
  }
  function reconnect() {
    setTimeout(connect2, closedDate ? closedDate + delay - import_perf_hooks.performance.now() : 0);
  }
  function connected() {
    try {
      statements = {};
      needsTypes = options.fetch_types;
      statementId = Math.random().toString(36).slice(2);
      statementCount = 1;
      lifeTimer.start();
      socket.on("data", data);
      keep_alive && socket.setKeepAlive && socket.setKeepAlive(true, 1e3 * keep_alive);
      const s10 = StartupMessage();
      write(s10);
    } catch (err3) {
      error2(err3);
    }
  }
  function error2(err3) {
    if (connection2.queue === queues.connecting && options.host[retries + 1])
      return;
    errored(err3);
    while (sent.length)
      queryError(sent.shift(), err3);
  }
  function errored(err3) {
    stream && (stream.destroy(err3), stream = null);
    query && queryError(query, err3);
    initial && (queryError(initial, err3), initial = null);
  }
  function queryError(query2, err3) {
    if (query2.reserve)
      return query2.reject(err3);
    if (!err3 || typeof err3 !== "object")
      err3 = new Error(err3);
    "query" in err3 || "parameters" in err3 || Object.defineProperties(err3, {
      stack: { value: err3.stack + query2.origin.replace(/.*\n/, "\n"), enumerable: options.debug },
      query: { value: query2.string, enumerable: options.debug },
      parameters: { value: query2.parameters, enumerable: options.debug },
      args: { value: query2.args, enumerable: options.debug },
      types: { value: query2.statement && query2.statement.types, enumerable: options.debug }
    });
    query2.reject(err3);
  }
  function end() {
    return ending || (!connection2.reserved && onend(connection2), !connection2.reserved && !initial && !query && sent.length === 0 ? (terminate(), new Promise((r6) => socket && socket.readyState !== "closed" ? socket.once("close", r6) : r6())) : ending = new Promise((r6) => ended = r6));
  }
  function terminate() {
    terminated = true;
    if (stream || query || initial || sent.length)
      error2(Errors.connection("CONNECTION_DESTROYED", options));
    clearImmediate(nextWriteTimer);
    if (socket) {
      socket.removeListener("data", data);
      socket.removeListener("connect", connected);
      socket.readyState === "open" && socket.end(bytes_default().X().end());
    }
    ended && (ended(), ending = ended = null);
  }
  async function closed(hadError) {
    incoming = Buffer.alloc(0);
    remaining = 0;
    incomings = null;
    clearImmediate(nextWriteTimer);
    socket.removeListener("data", data);
    socket.removeListener("connect", connected);
    idleTimer.cancel();
    lifeTimer.cancel();
    connectTimer.cancel();
    socket.removeAllListeners();
    socket = null;
    if (initial)
      return reconnect();
    !hadError && (query || sent.length) && error2(Errors.connection("CONNECTION_CLOSED", options, socket));
    closedDate = import_perf_hooks.performance.now();
    hadError && options.shared.retries++;
    delay = (typeof backoff2 === "function" ? backoff2(options.shared.retries) : backoff2) * 1e3;
    onclose(connection2, Errors.connection("CONNECTION_CLOSED", options, socket));
  }
  function handle2(xs, x11 = xs[0]) {
    (x11 === 68 ? DataRow : (
      // D
      x11 === 100 ? CopyData : (
        // d
        x11 === 65 ? NotificationResponse : (
          // A
          x11 === 83 ? ParameterStatus : (
            // S
            x11 === 90 ? ReadyForQuery : (
              // Z
              x11 === 67 ? CommandComplete : (
                // C
                x11 === 50 ? BindComplete : (
                  // 2
                  x11 === 49 ? ParseComplete : (
                    // 1
                    x11 === 116 ? ParameterDescription : (
                      // t
                      x11 === 84 ? RowDescription : (
                        // T
                        x11 === 82 ? Authentication : (
                          // R
                          x11 === 110 ? NoData : (
                            // n
                            x11 === 75 ? BackendKeyData : (
                              // K
                              x11 === 69 ? ErrorResponse : (
                                // E
                                x11 === 115 ? PortalSuspended : (
                                  // s
                                  x11 === 51 ? CloseComplete : (
                                    // 3
                                    x11 === 71 ? CopyInResponse : (
                                      // G
                                      x11 === 78 ? NoticeResponse : (
                                        // N
                                        x11 === 72 ? CopyOutResponse : (
                                          // H
                                          x11 === 99 ? CopyDone : (
                                            // c
                                            x11 === 73 ? EmptyQueryResponse : (
                                              // I
                                              x11 === 86 ? FunctionCallResponse : (
                                                // V
                                                x11 === 118 ? NegotiateProtocolVersion : (
                                                  // v
                                                  x11 === 87 ? CopyBothResponse : (
                                                    // W
                                                    /* c8 ignore next */
                                                    UnknownMessage
                                                  )
                                                )
                                              )
                                            )
                                          )
                                        )
                                      )
                                    )
                                  )
                                )
                              )
                            )
                          )
                        )
                      )
                    )
                  )
                )
              )
            )
          )
        )
      )
    ))(xs);
  }
  function DataRow(x11) {
    let index7 = 7;
    let length2;
    let column6;
    let value;
    const row = query.isRaw ? new Array(query.statement.columns.length) : {};
    for (let i8 = 0; i8 < query.statement.columns.length; i8++) {
      column6 = query.statement.columns[i8];
      length2 = x11.readInt32BE(index7);
      index7 += 4;
      value = length2 === -1 ? null : query.isRaw === true ? x11.subarray(index7, index7 += length2) : column6.parser === void 0 ? x11.toString("utf8", index7, index7 += length2) : column6.parser.array === true ? column6.parser(x11.toString("utf8", index7 + 1, index7 += length2)) : column6.parser(x11.toString("utf8", index7, index7 += length2));
      query.isRaw ? row[i8] = query.isRaw === true ? value : transform.value.from ? transform.value.from(value, column6) : value : row[column6.name] = transform.value.from ? transform.value.from(value, column6) : value;
    }
    query.forEachFn ? query.forEachFn(transform.row.from ? transform.row.from(row) : row, result) : result[rows++] = transform.row.from ? transform.row.from(row) : row;
  }
  function ParameterStatus(x11) {
    const [k9, v11] = x11.toString("utf8", 5, x11.length - 1).split(bytes_default.N);
    backendParameters[k9] = v11;
    if (options.parameters[k9] !== v11) {
      options.parameters[k9] = v11;
      onparameter && onparameter(k9, v11);
    }
  }
  function ReadyForQuery(x11) {
    query && query.options.simple && query.resolve(results || result);
    query = results = null;
    result = new Result2();
    connectTimer.cancel();
    if (initial) {
      if (target_session_attrs) {
        if (!backendParameters.in_hot_standby || !backendParameters.default_transaction_read_only)
          return fetchState();
        else if (tryNext(target_session_attrs, backendParameters))
          return terminate();
      }
      if (needsTypes) {
        initial.reserve && (initial = null);
        return fetchArrayTypes();
      }
      initial && !initial.reserve && execute(initial);
      options.shared.retries = retries = 0;
      initial = null;
      return;
    }
    while (sent.length && (query = sent.shift()) && (query.active = true, query.cancelled))
      Connection2(options).cancel(query.state, query.cancelled.resolve, query.cancelled.reject);
    if (query)
      return;
    connection2.reserved ? !connection2.reserved.release && x11[5] === 73 ? ending ? terminate() : (connection2.reserved = null, onopen(connection2)) : connection2.reserved() : ending ? terminate() : onopen(connection2);
  }
  function CommandComplete(x11) {
    rows = 0;
    for (let i8 = x11.length - 1; i8 > 0; i8--) {
      if (x11[i8] === 32 && x11[i8 + 1] < 58 && result.count === null)
        result.count = +x11.toString("utf8", i8 + 1, x11.length - 1);
      if (x11[i8 - 1] >= 65) {
        result.command = x11.toString("utf8", 5, i8);
        result.state = backend;
        break;
      }
    }
    final && (final(), final = null);
    if (result.command === "BEGIN" && max2 !== 1 && !connection2.reserved)
      return errored(Errors.generic("UNSAFE_TRANSACTION", "Only use sql.begin, sql.reserved or max: 1"));
    if (query.options.simple)
      return BindComplete();
    if (query.cursorFn) {
      result.count && query.cursorFn(result);
      write(Sync);
    }
    query.resolve(result);
  }
  function ParseComplete() {
    query.parsing = false;
  }
  function BindComplete() {
    !result.statement && (result.statement = query.statement);
    result.columns = query.statement.columns;
  }
  function ParameterDescription(x11) {
    const length2 = x11.readUInt16BE(5);
    for (let i8 = 0; i8 < length2; ++i8)
      !query.statement.types[i8] && (query.statement.types[i8] = x11.readUInt32BE(7 + i8 * 4));
    query.prepare && (statements[query.signature] = query.statement);
    query.describeFirst && !query.onlyDescribe && (write(prepared(query)), query.describeFirst = false);
  }
  function RowDescription(x11) {
    if (result.command) {
      results = results || [result];
      results.push(result = new Result2());
      result.count = null;
      query.statement.columns = null;
    }
    const length2 = x11.readUInt16BE(5);
    let index7 = 7;
    let start2;
    query.statement.columns = Array(length2);
    for (let i8 = 0; i8 < length2; ++i8) {
      start2 = index7;
      while (x11[index7++] !== 0) ;
      const table6 = x11.readUInt32BE(index7);
      const number2 = x11.readUInt16BE(index7 + 4);
      const type = x11.readUInt32BE(index7 + 6);
      query.statement.columns[i8] = {
        name: transform.column.from ? transform.column.from(x11.toString("utf8", start2, index7 - 1)) : x11.toString("utf8", start2, index7 - 1),
        parser: parsers2[type],
        table: table6,
        number: number2,
        type
      };
      index7 += 18;
    }
    result.statement = query.statement;
    if (query.onlyDescribe)
      return query.resolve(query.statement), write(Sync);
  }
  async function Authentication(x11, type = x11.readUInt32BE(5)) {
    (type === 3 ? AuthenticationCleartextPassword : type === 5 ? AuthenticationMD5Password : type === 10 ? SASL : type === 11 ? SASLContinue : type === 12 ? SASLFinal : type !== 0 ? UnknownAuth : noop2)(x11, type);
  }
  async function AuthenticationCleartextPassword() {
    const payload = await Pass();
    write(
      bytes_default().p().str(payload).z(1).end()
    );
  }
  async function AuthenticationMD5Password(x11) {
    const payload = "md5" + await md5(
      Buffer.concat([
        Buffer.from(await md5(await Pass() + user)),
        x11.subarray(9)
      ])
    );
    write(
      bytes_default().p().str(payload).z(1).end()
    );
  }
  async function SASL() {
    nonce = (await import_crypto7.default.randomBytes(18)).toString("base64");
    bytes_default().p().str("SCRAM-SHA-256" + bytes_default.N);
    const i8 = bytes_default.i;
    write(bytes_default.inc(4).str("n,,n=*,r=" + nonce).i32(bytes_default.i - i8 - 4, i8).end());
  }
  async function SASLContinue(x11) {
    const res = x11.toString("utf8", 9).split(",").reduce((acc, x12) => (acc[x12[0]] = x12.slice(2), acc), {});
    const saltedPassword = await import_crypto7.default.pbkdf2Sync(
      await Pass(),
      Buffer.from(res.s, "base64"),
      parseInt(res.i),
      32,
      "sha256"
    );
    const clientKey = await hmac2(saltedPassword, "Client Key");
    const auth = "n=*,r=" + nonce + ",r=" + res.r + ",s=" + res.s + ",i=" + res.i + ",c=biws,r=" + res.r;
    serverSignature = (await hmac2(await hmac2(saltedPassword, "Server Key"), auth)).toString("base64");
    const payload = "c=biws,r=" + res.r + ",p=" + xor(
      clientKey,
      Buffer.from(await hmac2(await sha2562(clientKey), auth))
    ).toString("base64");
    write(
      bytes_default().p().str(payload).end()
    );
  }
  function SASLFinal(x11) {
    if (x11.toString("utf8", 9).split(bytes_default.N, 1)[0].slice(2) === serverSignature)
      return;
    errored(Errors.generic("SASL_SIGNATURE_MISMATCH", "The server did not return the correct signature"));
    socket.destroy();
  }
  function Pass() {
    return Promise.resolve(
      typeof options.pass === "function" ? options.pass() : options.pass
    );
  }
  function NoData() {
    result.statement = query.statement;
    result.statement.columns = [];
    if (query.onlyDescribe)
      return query.resolve(query.statement), write(Sync);
  }
  function BackendKeyData(x11) {
    backend.pid = x11.readUInt32BE(5);
    backend.secret = x11.readUInt32BE(9);
  }
  async function fetchArrayTypes() {
    needsTypes = false;
    const types6 = await new Query2([`
      select b.oid, b.typarray
      from pg_catalog.pg_type a
      left join pg_catalog.pg_type b on b.oid = a.typelem
      where a.typcategory = 'A'
      group by b.oid, b.typarray
      order by b.oid
    `], [], execute);
    types6.forEach(({ oid, typarray }) => addArrayType(oid, typarray));
  }
  function addArrayType(oid, typarray) {
    if (!!options.parsers[typarray] && !!options.serializers[typarray]) return;
    const parser = options.parsers[oid];
    options.shared.typeArrayMap[oid] = typarray;
    options.parsers[typarray] = (xs) => arrayParser(xs, parser, typarray);
    options.parsers[typarray].array = true;
    options.serializers[typarray] = (xs) => arraySerializer(xs, options.serializers[oid], options, typarray);
  }
  function tryNext(x11, xs) {
    return x11 === "read-write" && xs.default_transaction_read_only === "on" || x11 === "read-only" && xs.default_transaction_read_only === "off" || x11 === "primary" && xs.in_hot_standby === "on" || x11 === "standby" && xs.in_hot_standby === "off" || x11 === "prefer-standby" && xs.in_hot_standby === "off" && options.host[retries];
  }
  function fetchState() {
    const query2 = new Query2([`
      show transaction_read_only;
      select pg_catalog.pg_is_in_recovery()
    `], [], execute, null, { simple: true });
    query2.resolve = ([[a9], [b9]]) => {
      backendParameters.default_transaction_read_only = a9.transaction_read_only;
      backendParameters.in_hot_standby = b9.pg_is_in_recovery ? "on" : "off";
    };
    query2.execute();
  }
  function ErrorResponse(x11) {
    query && (query.cursorFn || query.describeFirst) && write(Sync);
    const error3 = Errors.postgres(parseError(x11));
    query && query.retried ? errored(query.retried) : query && query.prepared && retryRoutines.has(error3.routine) ? retry2(query, error3) : errored(error3);
  }
  function retry2(q7, error3) {
    delete statements[q7.signature];
    q7.retried = error3;
    execute(q7);
  }
  function NotificationResponse(x11) {
    if (!onnotify)
      return;
    let index7 = 9;
    while (x11[index7++] !== 0) ;
    onnotify(
      x11.toString("utf8", 9, index7 - 1),
      x11.toString("utf8", index7, x11.length - 1)
    );
  }
  async function PortalSuspended() {
    try {
      const x11 = await Promise.resolve(query.cursorFn(result));
      rows = 0;
      x11 === CLOSE ? write(Close(query.portal)) : (result = new Result2(), write(Execute("", query.cursorRows)));
    } catch (err3) {
      write(Sync);
      query.reject(err3);
    }
  }
  function CloseComplete() {
    result.count && query.cursorFn(result);
    query.resolve(result);
  }
  function CopyInResponse() {
    stream = new import_stream7.default.Writable({
      autoDestroy: true,
      write(chunk2, encoding, callback) {
        socket.write(bytes_default().d().raw(chunk2).end(), callback);
      },
      destroy(error3, callback) {
        callback(error3);
        socket.write(bytes_default().f().str(error3 + bytes_default.N).end());
        stream = null;
      },
      final(callback) {
        socket.write(bytes_default().c().end());
        final = callback;
      }
    });
    query.resolve(stream);
  }
  function CopyOutResponse() {
    stream = new import_stream7.default.Readable({
      read() {
        socket.resume();
      }
    });
    query.resolve(stream);
  }
  function CopyBothResponse() {
    stream = new import_stream7.default.Duplex({
      autoDestroy: true,
      read() {
        socket.resume();
      },
      /* c8 ignore next 11 */
      write(chunk2, encoding, callback) {
        socket.write(bytes_default().d().raw(chunk2).end(), callback);
      },
      destroy(error3, callback) {
        callback(error3);
        socket.write(bytes_default().f().str(error3 + bytes_default.N).end());
        stream = null;
      },
      final(callback) {
        socket.write(bytes_default().c().end());
        final = callback;
      }
    });
    query.resolve(stream);
  }
  function CopyData(x11) {
    stream && (stream.push(x11.subarray(5)) || socket.pause());
  }
  function CopyDone() {
    stream && stream.push(null);
    stream = null;
  }
  function NoticeResponse(x11) {
    onnotice ? onnotice(parseError(x11)) : console.log(parseError(x11));
  }
  function EmptyQueryResponse() {
  }
  function FunctionCallResponse() {
    errored(Errors.notSupported("FunctionCallResponse"));
  }
  function NegotiateProtocolVersion() {
    errored(Errors.notSupported("NegotiateProtocolVersion"));
  }
  function UnknownMessage(x11) {
    console.error("Postgres.js : Unknown Message:", x11[0]);
  }
  function UnknownAuth(x11, type) {
    console.error("Postgres.js : Unknown Auth:", type);
  }
  function Bind(parameters, types6, statement = "", portal = "") {
    let prev, type;
    bytes_default().B().str(portal + bytes_default.N).str(statement + bytes_default.N).i16(0).i16(parameters.length);
    parameters.forEach((x11, i8) => {
      if (x11 === null)
        return bytes_default.i32(4294967295);
      type = types6[i8];
      parameters[i8] = x11 = type in options.serializers ? options.serializers[type](x11) : "" + x11;
      prev = bytes_default.i;
      bytes_default.inc(4).str(x11).i32(bytes_default.i - prev - 4, prev);
    });
    bytes_default.i16(0);
    return bytes_default.end();
  }
  function Parse(str, parameters, types6, name3 = "") {
    bytes_default().P().str(name3 + bytes_default.N).str(str + bytes_default.N).i16(parameters.length);
    parameters.forEach((x11, i8) => bytes_default.i32(types6[i8] || 0));
    return bytes_default.end();
  }
  function Describe(x11, name3 = "") {
    return bytes_default().D().str(x11).str(name3 + bytes_default.N).end();
  }
  function Execute(portal = "", rows2 = 0) {
    return Buffer.concat([
      bytes_default().E().str(portal + bytes_default.N).i32(rows2).end(),
      Flush
    ]);
  }
  function Close(portal = "") {
    return Buffer.concat([
      bytes_default().C().str("P").str(portal + bytes_default.N).end(),
      bytes_default().S().end()
    ]);
  }
  function StartupMessage() {
    return cancelMessage || bytes_default().inc(4).i16(3).z(2).str(
      Object.entries(Object.assign(
        {
          user,
          database,
          client_encoding: "UTF8"
        },
        options.connection
      )).filter(([, v11]) => v11).map(([k9, v11]) => k9 + bytes_default.N + v11).join(bytes_default.N)
    ).z(2).end(0);
  }
}
function parseError(x11) {
  const error2 = {};
  let start2 = 5;
  for (let i8 = 5; i8 < x11.length - 1; i8++) {
    if (x11[i8] === 0) {
      error2[errorFields[x11[start2]]] = x11.toString("utf8", start2 + 1, i8);
      start2 = i8 + 1;
    }
  }
  return error2;
}
function md5(x11) {
  return import_crypto7.default.createHash("md5").update(x11).digest("hex");
}
function hmac2(key, x11) {
  return import_crypto7.default.createHmac("sha256", key).update(x11).digest();
}
function sha2562(x11) {
  return import_crypto7.default.createHash("sha256").update(x11).digest();
}
function xor(a9, b9) {
  const length = Math.max(a9.length, b9.length);
  const buffer2 = Buffer.allocUnsafe(length);
  for (let i8 = 0; i8 < length; i8++)
    buffer2[i8] = a9[i8] ^ b9[i8];
  return buffer2;
}
function timer(fn3, seconds) {
  seconds = typeof seconds === "function" ? seconds() : seconds;
  if (!seconds)
    return { cancel: noop2, start: noop2 };
  let timer2;
  return {
    cancel() {
      timer2 && (clearTimeout(timer2), timer2 = null);
    },
    start() {
      timer2 && clearTimeout(timer2);
      timer2 = setTimeout(done, seconds * 1e3, arguments);
    }
  };
  function done(args2) {
    fn3.apply(null, args2);
    timer2 = null;
  }
}
var import_net, import_tls, import_crypto7, import_stream7, import_perf_hooks, connection_default, uid, Sync, Flush, SSLRequest, ExecuteUnnamed, DescribeUnnamed, noop2, retryRoutines, errorFields;
var init_connection2 = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/connection.js"() {
    "use strict";
    import_net = __toESM(require("net"), 1);
    import_tls = __toESM(require("tls"), 1);
    import_crypto7 = __toESM(require("crypto"), 1);
    import_stream7 = __toESM(require("stream"), 1);
    import_perf_hooks = require("perf_hooks");
    init_types11();
    init_errors3();
    init_result();
    init_queue();
    init_query4();
    init_bytes();
    connection_default = Connection2;
    uid = 1;
    Sync = bytes_default().S().end();
    Flush = bytes_default().H().end();
    SSLRequest = bytes_default().i32(8).i32(80877103).end(8);
    ExecuteUnnamed = Buffer.concat([bytes_default().E().str(bytes_default.N).i32(0).end(), Sync]);
    DescribeUnnamed = bytes_default().D().str("S").str(bytes_default.N).end();
    noop2 = () => {
    };
    retryRoutines = /* @__PURE__ */ new Set([
      "FetchPreparedStatement",
      "RevalidateCachedQuery",
      "transformAssignedExpr"
    ]);
    errorFields = {
      83: "severity_local",
      // S
      86: "severity",
      // V
      67: "code",
      // C
      77: "message",
      // M
      68: "detail",
      // D
      72: "hint",
      // H
      80: "position",
      // P
      112: "internal_position",
      // p
      113: "internal_query",
      // q
      87: "where",
      // W
      115: "schema_name",
      // s
      116: "table_name",
      // t
      99: "column_name",
      // c
      100: "data type_name",
      // d
      110: "constraint_name",
      // n
      70: "file",
      // F
      76: "line",
      // L
      82: "routine"
      // R
    };
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/subscribe.js
function Subscribe(postgres2, options) {
  const subscribers = /* @__PURE__ */ new Map(), slot = "postgresjs_" + Math.random().toString(36).slice(2), state2 = {};
  let connection2, stream, ended = false;
  const sql3 = subscribe.sql = postgres2({
    ...options,
    transform: { column: {}, value: {}, row: {} },
    max: 1,
    fetch_types: false,
    idle_timeout: null,
    max_lifetime: null,
    connection: {
      ...options.connection,
      replication: "database"
    },
    onclose: async function() {
      if (ended)
        return;
      stream = null;
      state2.pid = state2.secret = void 0;
      connected(await init3(sql3, slot, options.publications));
      subscribers.forEach((event) => event.forEach(({ onsubscribe }) => onsubscribe()));
    },
    no_subscribe: true
  });
  const end = sql3.end, close = sql3.close;
  sql3.end = async () => {
    ended = true;
    stream && await new Promise((r6) => (stream.once("close", r6), stream.end()));
    return end();
  };
  sql3.close = async () => {
    stream && await new Promise((r6) => (stream.once("close", r6), stream.end()));
    return close();
  };
  return subscribe;
  async function subscribe(event, fn3, onsubscribe = noop3, onerror = noop3) {
    event = parseEvent(event);
    if (!connection2)
      connection2 = init3(sql3, slot, options.publications);
    const subscriber = { fn: fn3, onsubscribe };
    const fns = subscribers.has(event) ? subscribers.get(event).add(subscriber) : subscribers.set(event, /* @__PURE__ */ new Set([subscriber])).get(event);
    const unsubscribe = () => {
      fns.delete(subscriber);
      fns.size === 0 && subscribers.delete(event);
    };
    return connection2.then((x11) => {
      connected(x11);
      onsubscribe();
      stream && stream.on("error", onerror);
      return { unsubscribe, state: state2, sql: sql3 };
    });
  }
  function connected(x11) {
    stream = x11.stream;
    state2.pid = x11.state.pid;
    state2.secret = x11.state.secret;
  }
  async function init3(sql4, slot2, publications) {
    if (!publications)
      throw new Error("Missing publication names");
    const xs = await sql4.unsafe(
      `CREATE_REPLICATION_SLOT ${slot2} TEMPORARY LOGICAL pgoutput NOEXPORT_SNAPSHOT`
    );
    const [x11] = xs;
    const stream2 = await sql4.unsafe(
      `START_REPLICATION SLOT ${slot2} LOGICAL ${x11.consistent_point} (proto_version '1', publication_names '${publications}')`
    ).writable();
    const state3 = {
      lsn: Buffer.concat(x11.consistent_point.split("/").map((x12) => Buffer.from(("00000000" + x12).slice(-8), "hex")))
    };
    stream2.on("data", data);
    stream2.on("error", error2);
    stream2.on("close", sql4.close);
    return { stream: stream2, state: xs.state };
    function error2(e6) {
      console.error("Unexpected error during logical streaming - reconnecting", e6);
    }
    function data(x12) {
      if (x12[0] === 119) {
        parse4(x12.subarray(25), state3, sql4.options.parsers, handle2, options.transform);
      } else if (x12[0] === 107 && x12[17]) {
        state3.lsn = x12.subarray(1, 9);
        pong();
      }
    }
    function handle2(a9, b9) {
      const path3 = b9.relation.schema + "." + b9.relation.table;
      call("*", a9, b9);
      call("*:" + path3, a9, b9);
      b9.relation.keys.length && call("*:" + path3 + "=" + b9.relation.keys.map((x12) => a9[x12.name]), a9, b9);
      call(b9.command, a9, b9);
      call(b9.command + ":" + path3, a9, b9);
      b9.relation.keys.length && call(b9.command + ":" + path3 + "=" + b9.relation.keys.map((x12) => a9[x12.name]), a9, b9);
    }
    function pong() {
      const x12 = Buffer.alloc(34);
      x12[0] = "r".charCodeAt(0);
      x12.fill(state3.lsn, 1);
      x12.writeBigInt64BE(BigInt(Date.now() - Date.UTC(2e3, 0, 1)) * BigInt(1e3), 25);
      stream2.write(x12);
    }
  }
  function call(x11, a9, b9) {
    subscribers.has(x11) && subscribers.get(x11).forEach(({ fn: fn3 }) => fn3(a9, b9, x11));
  }
}
function Time(x11) {
  return new Date(Date.UTC(2e3, 0, 1) + Number(x11 / BigInt(1e3)));
}
function parse4(x11, state2, parsers2, handle2, transform) {
  const char4 = (acc, [k9, v11]) => (acc[k9.charCodeAt(0)] = v11, acc);
  Object.entries({
    R: (x12) => {
      let i8 = 1;
      const r6 = state2[x12.readUInt32BE(i8)] = {
        schema: x12.toString("utf8", i8 += 4, i8 = x12.indexOf(0, i8)) || "pg_catalog",
        table: x12.toString("utf8", i8 + 1, i8 = x12.indexOf(0, i8 + 1)),
        columns: Array(x12.readUInt16BE(i8 += 2)),
        keys: []
      };
      i8 += 2;
      let columnIndex = 0, column6;
      while (i8 < x12.length) {
        column6 = r6.columns[columnIndex++] = {
          key: x12[i8++],
          name: transform.column.from ? transform.column.from(x12.toString("utf8", i8, i8 = x12.indexOf(0, i8))) : x12.toString("utf8", i8, i8 = x12.indexOf(0, i8)),
          type: x12.readUInt32BE(i8 += 1),
          parser: parsers2[x12.readUInt32BE(i8)],
          atttypmod: x12.readUInt32BE(i8 += 4)
        };
        column6.key && r6.keys.push(column6);
        i8 += 4;
      }
    },
    Y: () => {
    },
    // Type
    O: () => {
    },
    // Origin
    B: (x12) => {
      state2.date = Time(x12.readBigInt64BE(9));
      state2.lsn = x12.subarray(1, 9);
    },
    I: (x12) => {
      let i8 = 1;
      const relation = state2[x12.readUInt32BE(i8)];
      const { row } = tuples(x12, relation.columns, i8 += 7, transform);
      handle2(row, {
        command: "insert",
        relation
      });
    },
    D: (x12) => {
      let i8 = 1;
      const relation = state2[x12.readUInt32BE(i8)];
      i8 += 4;
      const key = x12[i8] === 75;
      handle2(
        key || x12[i8] === 79 ? tuples(x12, relation.columns, i8 += 3, transform).row : null,
        {
          command: "delete",
          relation,
          key
        }
      );
    },
    U: (x12) => {
      let i8 = 1;
      const relation = state2[x12.readUInt32BE(i8)];
      i8 += 4;
      const key = x12[i8] === 75;
      const xs = key || x12[i8] === 79 ? tuples(x12, relation.columns, i8 += 3, transform) : null;
      xs && (i8 = xs.i);
      const { row } = tuples(x12, relation.columns, i8 + 3, transform);
      handle2(row, {
        command: "update",
        relation,
        key,
        old: xs && xs.row
      });
    },
    T: () => {
    },
    // Truncate,
    C: () => {
    }
    // Commit
  }).reduce(char4, {})[x11[0]](x11);
}
function tuples(x11, columns, xi, transform) {
  let type, column6, value;
  const row = transform.raw ? new Array(columns.length) : {};
  for (let i8 = 0; i8 < columns.length; i8++) {
    type = x11[xi++];
    column6 = columns[i8];
    value = type === 110 ? null : type === 117 ? void 0 : column6.parser === void 0 ? x11.toString("utf8", xi + 4, xi += 4 + x11.readUInt32BE(xi)) : column6.parser.array === true ? column6.parser(x11.toString("utf8", xi + 5, xi += 4 + x11.readUInt32BE(xi))) : column6.parser(x11.toString("utf8", xi + 4, xi += 4 + x11.readUInt32BE(xi)));
    transform.raw ? row[i8] = transform.raw === true ? value : transform.value.from ? transform.value.from(value, column6) : value : row[column6.name] = transform.value.from ? transform.value.from(value, column6) : value;
  }
  return { i: xi, row: transform.row.from ? transform.row.from(row) : row };
}
function parseEvent(x11) {
  const xs = x11.match(/^(\*|insert|update|delete)?:?([^.]+?\.?[^=]+)?=?(.+)?/i) || [];
  if (!xs)
    throw new Error("Malformed subscribe pattern: " + x11);
  const [, command, path3, key] = xs;
  return (command || "*") + (path3 ? ":" + (path3.indexOf(".") === -1 ? "public." + path3 : path3) : "") + (key ? "=" + key : "");
}
var noop3;
var init_subscribe = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/subscribe.js"() {
    "use strict";
    noop3 = () => {
    };
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/large.js
function largeObject(sql3, oid, mode = 131072 | 262144) {
  return new Promise(async (resolve2, reject) => {
    await sql3.begin(async (sql4) => {
      let finish;
      !oid && ([{ oid }] = await sql4`select lo_creat(-1) as oid`);
      const [{ fd }] = await sql4`select lo_open(${oid}, ${mode}) as fd`;
      const lo = {
        writable,
        readable,
        close: () => sql4`select lo_close(${fd})`.then(finish),
        tell: () => sql4`select lo_tell64(${fd})`,
        read: (x11) => sql4`select loread(${fd}, ${x11}) as data`,
        write: (x11) => sql4`select lowrite(${fd}, ${x11})`,
        truncate: (x11) => sql4`select lo_truncate64(${fd}, ${x11})`,
        seek: (x11, whence = 0) => sql4`select lo_lseek64(${fd}, ${x11}, ${whence})`,
        size: () => sql4`
          select
            lo_lseek64(${fd}, location, 0) as position,
            seek.size
          from (
            select
              lo_lseek64($1, 0, 2) as size,
              tell.location
            from (select lo_tell64($1) as location) tell
          ) seek
        `
      };
      resolve2(lo);
      return new Promise(async (r6) => finish = r6);
      async function readable({
        highWaterMark = 2048 * 8,
        start: start2 = 0,
        end = Infinity
      } = {}) {
        let max2 = end - start2;
        start2 && await lo.seek(start2);
        return new import_stream8.default.Readable({
          highWaterMark,
          async read(size2) {
            const l7 = size2 > max2 ? size2 - max2 : size2;
            max2 -= size2;
            const [{ data }] = await lo.read(l7);
            this.push(data);
            if (data.length < size2)
              this.push(null);
          }
        });
      }
      async function writable({
        highWaterMark = 2048 * 8,
        start: start2 = 0
      } = {}) {
        start2 && await lo.seek(start2);
        return new import_stream8.default.Writable({
          highWaterMark,
          write(chunk, encoding, callback) {
            lo.write(chunk).then(() => callback(), callback);
          }
        });
      }
    }).catch(reject);
  });
}
var import_stream8;
var init_large = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/large.js"() {
    "use strict";
    import_stream8 = __toESM(require("stream"), 1);
  }
});

// ../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/index.js
var src_exports = {};
__export(src_exports, {
  default: () => src_default
});
function Postgres(a9, b9) {
  const options = parseOptions(a9, b9), subscribe = options.no_subscribe || Subscribe(Postgres, { ...options });
  let ending = false;
  const queries = queue_default(), connecting = queue_default(), reserved = queue_default(), closed = queue_default(), ended = queue_default(), open = queue_default(), busy = queue_default(), full = queue_default(), queues = { connecting, reserved, closed, ended, open, busy, full };
  const connections = [...Array(options.max)].map(() => connection_default(options, queues, { onopen, onend, onclose }));
  const sql3 = Sql2(handler);
  Object.assign(sql3, {
    get parameters() {
      return options.parameters;
    },
    largeObject: largeObject.bind(null, sql3),
    subscribe,
    CLOSE,
    END: CLOSE,
    PostgresError,
    options,
    reserve,
    listen,
    begin,
    close,
    end
  });
  return sql3;
  function Sql2(handler2) {
    handler2.debug = options.debug;
    Object.entries(options.types).reduce((acc, [name3, type]) => {
      acc[name3] = (x11) => new Parameter(x11, type.to);
      return acc;
    }, typed);
    Object.assign(sql4, {
      types: typed,
      typed,
      unsafe,
      notify,
      array: array3,
      json: json4,
      file
    });
    return sql4;
    function typed(value, type) {
      return new Parameter(value, type);
    }
    function sql4(strings, ...args2) {
      const query = strings && Array.isArray(strings.raw) ? new Query2(strings, args2, handler2, cancel) : typeof strings === "string" && !args2.length ? new Identifier(options.transform.column.to ? options.transform.column.to(strings) : strings) : new Builder(strings, args2);
      return query;
    }
    function unsafe(string2, args2 = [], options2 = {}) {
      arguments.length === 2 && !Array.isArray(args2) && (options2 = args2, args2 = []);
      const query = new Query2([string2], args2, handler2, cancel, {
        prepare: false,
        ...options2,
        simple: "simple" in options2 ? options2.simple : args2.length === 0
      });
      return query;
    }
    function file(path3, args2 = [], options2 = {}) {
      arguments.length === 2 && !Array.isArray(args2) && (options2 = args2, args2 = []);
      const query = new Query2([], args2, (query2) => {
        import_fs8.default.readFile(path3, "utf8", (err3, string2) => {
          if (err3)
            return query2.reject(err3);
          query2.strings = [string2];
          handler2(query2);
        });
      }, cancel, {
        ...options2,
        simple: "simple" in options2 ? options2.simple : args2.length === 0
      });
      return query;
    }
  }
  async function listen(name3, fn3, onlisten) {
    const listener = { fn: fn3, onlisten };
    const sql4 = listen.sql || (listen.sql = Postgres({
      ...options,
      max: 1,
      idle_timeout: null,
      max_lifetime: null,
      fetch_types: false,
      onclose() {
        Object.entries(listen.channels).forEach(([name4, { listeners }]) => {
          delete listen.channels[name4];
          Promise.all(listeners.map((l7) => listen(name4, l7.fn, l7.onlisten).catch(() => {
          })));
        });
      },
      onnotify(c6, x11) {
        c6 in listen.channels && listen.channels[c6].listeners.forEach((l7) => l7.fn(x11));
      }
    }));
    const channels = listen.channels || (listen.channels = {}), exists2 = name3 in channels;
    if (exists2) {
      channels[name3].listeners.push(listener);
      const result2 = await channels[name3].result;
      listener.onlisten && listener.onlisten();
      return { state: result2.state, unlisten };
    }
    channels[name3] = { result: sql4`listen ${sql4.unsafe('"' + name3.replace(/"/g, '""') + '"')}`, listeners: [listener] };
    const result = await channels[name3].result;
    listener.onlisten && listener.onlisten();
    return { state: result.state, unlisten };
    async function unlisten() {
      if (name3 in channels === false)
        return;
      channels[name3].listeners = channels[name3].listeners.filter((x11) => x11 !== listener);
      if (channels[name3].listeners.length)
        return;
      delete channels[name3];
      return sql4`unlisten ${sql4.unsafe('"' + name3.replace(/"/g, '""') + '"')}`;
    }
  }
  async function notify(channel, payload) {
    return await sql3`select pg_notify(${channel}, ${"" + payload})`;
  }
  async function reserve() {
    const queue = queue_default();
    const c6 = open.length ? open.shift() : await new Promise((resolve2, reject) => {
      const query = { reserve: resolve2, reject };
      queries.push(query);
      closed.length && connect2(closed.shift(), query);
    });
    move(c6, reserved);
    c6.reserved = () => queue.length ? c6.execute(queue.shift()) : move(c6, reserved);
    c6.reserved.release = true;
    const sql4 = Sql2(handler2);
    sql4.release = () => {
      c6.reserved = null;
      onopen(c6);
    };
    return sql4;
    function handler2(q7) {
      c6.queue === full ? queue.push(q7) : c6.execute(q7) || move(c6, full);
    }
  }
  async function begin(options2, fn3) {
    !fn3 && (fn3 = options2, options2 = "");
    const queries2 = queue_default();
    let savepoints = 0, connection2, prepare = null;
    try {
      await sql3.unsafe("begin " + options2.replace(/[^a-z ]/ig, ""), [], { onexecute }).execute();
      return await Promise.race([
        scope(connection2, fn3),
        new Promise((_7, reject) => connection2.onclose = reject)
      ]);
    } catch (error2) {
      throw error2;
    }
    async function scope(c6, fn4, name3) {
      const sql4 = Sql2(handler2);
      sql4.savepoint = savepoint;
      sql4.prepare = (x11) => prepare = x11.replace(/[^a-z0-9$-_. ]/gi);
      let uncaughtError, result;
      name3 && await sql4`savepoint ${sql4(name3)}`;
      try {
        result = await new Promise((resolve2, reject) => {
          const x11 = fn4(sql4);
          Promise.resolve(Array.isArray(x11) ? Promise.all(x11) : x11).then(resolve2, reject);
        });
        if (uncaughtError)
          throw uncaughtError;
      } catch (e6) {
        await (name3 ? sql4`rollback to ${sql4(name3)}` : sql4`rollback`);
        throw e6 instanceof PostgresError && e6.code === "25P02" && uncaughtError || e6;
      }
      if (!name3) {
        prepare ? await sql4`prepare transaction '${sql4.unsafe(prepare)}'` : await sql4`commit`;
      }
      return result;
      function savepoint(name4, fn5) {
        if (name4 && Array.isArray(name4.raw))
          return savepoint((sql5) => sql5.apply(sql5, arguments));
        arguments.length === 1 && (fn5 = name4, name4 = null);
        return scope(c6, fn5, "s" + savepoints++ + (name4 ? "_" + name4 : ""));
      }
      function handler2(q7) {
        q7.catch((e6) => uncaughtError || (uncaughtError = e6));
        c6.queue === full ? queries2.push(q7) : c6.execute(q7) || move(c6, full);
      }
    }
    function onexecute(c6) {
      connection2 = c6;
      move(c6, reserved);
      c6.reserved = () => queries2.length ? c6.execute(queries2.shift()) : move(c6, reserved);
    }
  }
  function move(c6, queue) {
    c6.queue.remove(c6);
    queue.push(c6);
    c6.queue = queue;
    queue === open ? c6.idleTimer.start() : c6.idleTimer.cancel();
    return c6;
  }
  function json4(x11) {
    return new Parameter(x11, 3802);
  }
  function array3(x11, type) {
    if (!Array.isArray(x11))
      return array3(Array.from(arguments));
    return new Parameter(x11, type || (x11.length ? inferType(x11) || 25 : 0), options.shared.typeArrayMap);
  }
  function handler(query) {
    if (ending)
      return query.reject(Errors.connection("CONNECTION_ENDED", options, options));
    if (open.length)
      return go(open.shift(), query);
    if (closed.length)
      return connect2(closed.shift(), query);
    busy.length ? go(busy.shift(), query) : queries.push(query);
  }
  function go(c6, query) {
    return c6.execute(query) ? move(c6, busy) : move(c6, full);
  }
  function cancel(query) {
    return new Promise((resolve2, reject) => {
      query.state ? query.active ? connection_default(options).cancel(query.state, resolve2, reject) : query.cancelled = { resolve: resolve2, reject } : (queries.remove(query), query.cancelled = true, query.reject(Errors.generic("57014", "canceling statement due to user request")), resolve2());
    });
  }
  async function end({ timeout = null } = {}) {
    if (ending)
      return ending;
    await 1;
    let timer2;
    return ending = Promise.race([
      new Promise((r6) => timeout !== null && (timer2 = setTimeout(destroy, timeout * 1e3, r6))),
      Promise.all(connections.map((c6) => c6.end()).concat(
        listen.sql ? listen.sql.end({ timeout: 0 }) : [],
        subscribe.sql ? subscribe.sql.end({ timeout: 0 }) : []
      ))
    ]).then(() => clearTimeout(timer2));
  }
  async function close() {
    await Promise.all(connections.map((c6) => c6.end()));
  }
  async function destroy(resolve2) {
    await Promise.all(connections.map((c6) => c6.terminate()));
    while (queries.length)
      queries.shift().reject(Errors.connection("CONNECTION_DESTROYED", options));
    resolve2();
  }
  function connect2(c6, query) {
    move(c6, connecting);
    c6.connect(query);
    return c6;
  }
  function onend(c6) {
    move(c6, ended);
  }
  function onopen(c6) {
    if (queries.length === 0)
      return move(c6, open);
    let max2 = Math.ceil(queries.length / (connecting.length + 1)), ready = true;
    while (ready && queries.length && max2-- > 0) {
      const query = queries.shift();
      if (query.reserve)
        return query.reserve(c6);
      ready = c6.execute(query);
    }
    ready ? move(c6, busy) : move(c6, full);
  }
  function onclose(c6, e6) {
    move(c6, closed);
    c6.reserved = null;
    c6.onclose && (c6.onclose(e6), c6.onclose = null);
    options.onclose && options.onclose(c6.id);
    queries.length && connect2(c6, queries.shift());
  }
}
function parseOptions(a9, b9) {
  if (a9 && a9.shared)
    return a9;
  const env4 = process.env, o9 = (!a9 || typeof a9 === "string" ? b9 : a9) || {}, { url, multihost } = parseUrl2(a9), query = [...url.searchParams].reduce((a10, [b10, c6]) => (a10[b10] = c6, a10), {}), host = o9.hostname || o9.host || multihost || url.hostname || env4.PGHOST || "localhost", port = o9.port || url.port || env4.PGPORT || 5432, user = o9.user || o9.username || url.username || env4.PGUSERNAME || env4.PGUSER || osUsername();
  o9.no_prepare && (o9.prepare = false);
  query.sslmode && (query.ssl = query.sslmode, delete query.sslmode);
  "timeout" in o9 && (console.log("The timeout option is deprecated, use idle_timeout instead"), o9.idle_timeout = o9.timeout);
  query.sslrootcert === "system" && (query.ssl = "verify-full");
  const ints = ["idle_timeout", "connect_timeout", "max_lifetime", "max_pipeline", "backoff", "keep_alive"];
  const defaults3 = {
    max: 10,
    ssl: false,
    idle_timeout: null,
    connect_timeout: 30,
    max_lifetime,
    max_pipeline: 100,
    backoff,
    keep_alive: 60,
    prepare: true,
    debug: false,
    fetch_types: true,
    publications: "alltables",
    target_session_attrs: null
  };
  return {
    host: Array.isArray(host) ? host : host.split(",").map((x11) => x11.split(":")[0]),
    port: Array.isArray(port) ? port : host.split(",").map((x11) => parseInt(x11.split(":")[1] || port)),
    path: o9.path || host.indexOf("/") > -1 && host + "/.s.PGSQL." + port,
    database: o9.database || o9.db || (url.pathname || "").slice(1) || env4.PGDATABASE || user,
    user,
    pass: o9.pass || o9.password || url.password || env4.PGPASSWORD || "",
    ...Object.entries(defaults3).reduce(
      (acc, [k9, d7]) => {
        const value = k9 in o9 ? o9[k9] : k9 in query ? query[k9] === "disable" || query[k9] === "false" ? false : query[k9] : env4["PG" + k9.toUpperCase()] || d7;
        acc[k9] = typeof value === "string" && ints.includes(k9) ? +value : value;
        return acc;
      },
      {}
    ),
    connection: {
      application_name: env4.PGAPPNAME || "postgres.js",
      ...o9.connection,
      ...Object.entries(query).reduce((acc, [k9, v11]) => (k9 in defaults3 || (acc[k9] = v11), acc), {})
    },
    types: o9.types || {},
    target_session_attrs: tsa(o9, url, env4),
    onnotice: o9.onnotice,
    onnotify: o9.onnotify,
    onclose: o9.onclose,
    onparameter: o9.onparameter,
    socket: o9.socket,
    transform: parseTransform(o9.transform || { undefined: void 0 }),
    parameters: {},
    shared: { retries: 0, typeArrayMap: {} },
    ...mergeUserTypes(o9.types)
  };
}
function tsa(o9, url, env4) {
  const x11 = o9.target_session_attrs || url.searchParams.get("target_session_attrs") || env4.PGTARGETSESSIONATTRS;
  if (!x11 || ["read-write", "read-only", "primary", "standby", "prefer-standby"].includes(x11))
    return x11;
  throw new Error("target_session_attrs " + x11 + " is not supported");
}
function backoff(retries) {
  return (0.5 + Math.random() / 2) * Math.min(3 ** retries / 100, 20);
}
function max_lifetime() {
  return 60 * (30 + Math.random() * 30);
}
function parseTransform(x11) {
  return {
    undefined: x11.undefined,
    column: {
      from: typeof x11.column === "function" ? x11.column : x11.column && x11.column.from,
      to: x11.column && x11.column.to
    },
    value: {
      from: typeof x11.value === "function" ? x11.value : x11.value && x11.value.from,
      to: x11.value && x11.value.to
    },
    row: {
      from: typeof x11.row === "function" ? x11.row : x11.row && x11.row.from,
      to: x11.row && x11.row.to
    }
  };
}
function parseUrl2(url) {
  if (!url || typeof url !== "string")
    return { url: { searchParams: /* @__PURE__ */ new Map() } };
  let host = url;
  host = host.slice(host.indexOf("://") + 3).split(/[?/]/)[0];
  host = decodeURIComponent(host.slice(host.indexOf("@") + 1));
  const urlObj = new URL(url.replace(host, host.split(",")[0]));
  return {
    url: {
      username: decodeURIComponent(urlObj.username),
      password: decodeURIComponent(urlObj.password),
      host: urlObj.host,
      hostname: urlObj.hostname,
      port: urlObj.port,
      pathname: urlObj.pathname,
      searchParams: urlObj.searchParams
    },
    multihost: host.indexOf(",") > -1 && host
  };
}
function osUsername() {
  try {
    return import_os3.default.userInfo().username;
  } catch (_7) {
    return process.env.USERNAME || process.env.USER || process.env.LOGNAME;
  }
}
var import_os3, import_fs8, src_default;
var init_src2 = __esm({
  "../node_modules/.pnpm/postgres@3.4.7/node_modules/postgres/src/index.js"() {
    "use strict";
    import_os3 = __toESM(require("os"), 1);
    import_fs8 = __toESM(require("fs"), 1);
    init_types11();
    init_connection2();
    init_query4();
    init_queue();
    init_errors3();
    init_subscribe();
    init_large();
    Object.assign(Postgres, {
      PostgresError,
      toPascal,
      pascal,
      toCamel,
      camel,
      toKebab,
      kebab,
      fromPascal,
      fromCamel,
      fromKebab,
      BigInt: {
        to: 20,
        from: [20],
        parse: (x11) => BigInt(x11),
        // eslint-disable-line
        serialize: (x11) => x11.toString()
      }
    });
    src_default = Postgres;
  }
});

// ../drizzle-orm/dist/postgres-js/session.js
var _a466, _b339, PostgresJsPreparedQuery, _a467, _b340, _PostgresJsSession, PostgresJsSession, _a468, _b341, _PostgresJsTransaction, PostgresJsTransaction;
var init_session8 = __esm({
  "../drizzle-orm/dist/postgres-js/session.js"() {
    "use strict";
    init_core();
    init_entity();
    init_logger();
    init_pg_core();
    init_session2();
    init_sql();
    init_tracing();
    init_utils();
    PostgresJsPreparedQuery = class extends (_b339 = PgPreparedQuery, _a466 = entityKind, _b339) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, _isResponseInArrayMode, customResultMapper) {
        super({ sql: queryString, params }, cache5, queryMetadata, cacheConfig);
        this.client = client;
        this.queryString = queryString;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
      }
      async execute(placeholderValues = {}) {
        return tracer.startActiveSpan("drizzle.execute", async (span) => {
          const params = fillPlaceholders(this.params, placeholderValues);
          span?.setAttributes({
            "drizzle.query.text": this.queryString,
            "drizzle.query.params": JSON.stringify(params)
          });
          this.logger.logQuery(this.queryString, params);
          const { fields, queryString: query, client, joinsNotNullableMap, customResultMapper } = this;
          if (!fields && !customResultMapper) {
            return tracer.startActiveSpan("drizzle.driver.execute", () => {
              return this.queryWithCache(query, params, async () => {
                return await client.unsafe(query, params);
              });
            });
          }
          const rows = await tracer.startActiveSpan("drizzle.driver.execute", () => {
            span?.setAttributes({
              "drizzle.query.text": query,
              "drizzle.query.params": JSON.stringify(params)
            });
            return this.queryWithCache(query, params, async () => {
              return await client.unsafe(query, params).values();
            });
          });
          return tracer.startActiveSpan("drizzle.mapResponse", () => {
            return customResultMapper ? customResultMapper(rows) : rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
          });
        });
      }
      all(placeholderValues = {}) {
        return tracer.startActiveSpan("drizzle.execute", async (span) => {
          const params = fillPlaceholders(this.params, placeholderValues);
          span?.setAttributes({
            "drizzle.query.text": this.queryString,
            "drizzle.query.params": JSON.stringify(params)
          });
          this.logger.logQuery(this.queryString, params);
          return tracer.startActiveSpan("drizzle.driver.execute", () => {
            span?.setAttributes({
              "drizzle.query.text": this.queryString,
              "drizzle.query.params": JSON.stringify(params)
            });
            return this.queryWithCache(this.queryString, params, async () => {
              return this.client.unsafe(this.queryString, params);
            });
          });
        });
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(PostgresJsPreparedQuery, _a466, "PostgresJsPreparedQuery");
    _PostgresJsSession = class _PostgresJsSession extends (_b340 = PgSession, _a467 = entityKind, _b340) {
      constructor(client, dialect6, schema6, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, name3, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return new PostgresJsPreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      query(query, params) {
        this.logger.logQuery(query, params);
        return this.client.unsafe(query, params).values();
      }
      queryObjects(query, params) {
        return this.client.unsafe(query, params);
      }
      transaction(transaction, config) {
        return this.client.begin(async (client) => {
          const session = new _PostgresJsSession(
            client,
            this.dialect,
            this.schema,
            this.options
          );
          const tx = new PostgresJsTransaction(this.dialect, session, this.schema);
          if (config) {
            await tx.setTransaction(config);
          }
          return transaction(tx);
        });
      }
    };
    __publicField(_PostgresJsSession, _a467, "PostgresJsSession");
    PostgresJsSession = _PostgresJsSession;
    _PostgresJsTransaction = class _PostgresJsTransaction extends (_b341 = PgTransaction, _a468 = entityKind, _b341) {
      constructor(dialect6, session, schema6, nestedIndex = 0) {
        super(dialect6, session, schema6, nestedIndex);
        this.session = session;
      }
      transaction(transaction) {
        return this.session.client.savepoint((client) => {
          const session = new PostgresJsSession(
            client,
            this.dialect,
            this.schema,
            this.session.options
          );
          const tx = new _PostgresJsTransaction(this.dialect, session, this.schema);
          return transaction(tx);
        });
      }
    };
    __publicField(_PostgresJsTransaction, _a468, "PostgresJsTransaction");
    PostgresJsTransaction = _PostgresJsTransaction;
  }
});

// ../drizzle-orm/dist/postgres-js/driver.js
function construct4(client, config = {}) {
  const transparentParser = (val2) => val2;
  for (const type of ["1184", "1082", "1083", "1114", "1182", "1185", "1115", "1231"]) {
    client.options.parsers[type] = transparentParser;
    client.options.serializers[type] = transparentParser;
  }
  client.options.serializers["114"] = transparentParser;
  client.options.serializers["3802"] = transparentParser;
  const dialect6 = new PgDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const session = new PostgresJsSession(client, dialect6, schema6, { logger: logger2, cache: config.cache });
  const db2 = new PostgresJsDatabase(dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function drizzle4(...params) {
  if (typeof params[0] === "string") {
    const instance2 = src_default(params[0]);
    return construct4(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct4(client, drizzleConfig);
    if (typeof connection2 === "object" && connection2.url !== void 0) {
      const { url, ...config } = connection2;
      const instance22 = src_default(url, config);
      return construct4(instance22, drizzleConfig);
    }
    const instance2 = src_default(connection2);
    return construct4(instance2, drizzleConfig);
  }
  return construct4(params[0], params[1]);
}
var _a469, _b342, PostgresJsDatabase;
var init_driver4 = __esm({
  "../drizzle-orm/dist/postgres-js/driver.js"() {
    "use strict";
    init_src2();
    init_entity();
    init_logger();
    init_db2();
    init_dialect2();
    init_relations();
    init_utils();
    init_session8();
    PostgresJsDatabase = class extends (_b342 = PgDatabase, _a469 = entityKind, _b342) {
    };
    __publicField(PostgresJsDatabase, _a469, "PostgresJsDatabase");
    ((drizzle22) => {
      function mock(config) {
        return construct4({
          options: {
            parsers: {},
            serializers: {}
          }
        }, config);
      }
      drizzle22.mock = mock;
    })(drizzle4 || (drizzle4 = {}));
  }
});

// ../drizzle-orm/dist/postgres-js/index.js
var postgres_js_exports = {};
__export(postgres_js_exports, {
  PostgresJsDatabase: () => PostgresJsDatabase,
  PostgresJsPreparedQuery: () => PostgresJsPreparedQuery,
  PostgresJsSession: () => PostgresJsSession,
  PostgresJsTransaction: () => PostgresJsTransaction,
  drizzle: () => drizzle4
});
var init_postgres_js = __esm({
  "../drizzle-orm/dist/postgres-js/index.js"() {
    "use strict";
    init_driver4();
    init_session8();
  }
});

// ../drizzle-orm/dist/postgres-js/migrator.js
var migrator_exports4 = {};
__export(migrator_exports4, {
  migrate: () => migrate4
});
async function migrate4(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator5 = __esm({
  "../drizzle-orm/dist/postgres-js/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../node_modules/.pnpm/@neondatabase+serverless@0.7.2/node_modules/@neondatabase/serverless/index.mjs
function $e2(r6) {
  let e6 = 1779033703, t6 = 3144134277, n7 = 1013904242, i8 = 2773480762, s10 = 1359893119, o9 = 2600822924, u7 = 528734635, c6 = 1541459225, h8 = 0, l7 = 0, y7 = [
    1116352408,
    1899447441,
    3049323471,
    3921009573,
    961987163,
    1508970993,
    2453635748,
    2870763221,
    3624381080,
    310598401,
    607225278,
    1426881987,
    1925078388,
    2162078206,
    2614888103,
    3248222580,
    3835390401,
    4022224774,
    264347078,
    604807628,
    770255983,
    1249150122,
    1555081692,
    1996064986,
    2554220882,
    2821834349,
    2952996808,
    3210313671,
    3336571891,
    3584528711,
    113926993,
    338241895,
    666307205,
    773529912,
    1294757372,
    1396182291,
    1695183700,
    1986661051,
    2177026350,
    2456956037,
    2730485921,
    2820302411,
    3259730800,
    3345764771,
    3516065817,
    3600352804,
    4094571909,
    275423344,
    430227734,
    506948616,
    659060556,
    883997877,
    958139571,
    1322822218,
    1537002063,
    1747873779,
    1955562222,
    2024104815,
    2227730452,
    2361852424,
    2428436474,
    2756734187,
    3204031479,
    3329325298
  ], E4 = a6(
    (A5, g10) => A5 >>> g10 | A5 << 32 - g10,
    "rrot"
  ), _7 = new Uint32Array(64), P5 = new Uint8Array(64), N5 = a6(() => {
    for (let L6 = 0, G4 = 0; L6 < 16; L6++, G4 += 4) _7[L6] = P5[G4] << 24 | P5[G4 + 1] << 16 | P5[G4 + 2] << 8 | P5[G4 + 3];
    for (let L6 = 16; L6 < 64; L6++) {
      let G4 = E4(_7[L6 - 15], 7) ^ E4(_7[L6 - 15], 18) ^ _7[L6 - 15] >>> 3, ce3 = E4(_7[L6 - 2], 17) ^ E4(_7[L6 - 2], 19) ^ _7[L6 - 2] >>> 10;
      _7[L6] = _7[L6 - 16] + G4 + _7[L6 - 7] + ce3 | 0;
    }
    let A5 = e6, g10 = t6, D6 = n7, H5 = i8, Q3 = s10, W4 = o9, ue = u7, de2 = c6;
    for (let L6 = 0; L6 < 64; L6++) {
      let G4 = E4(
        Q3,
        6
      ) ^ E4(Q3, 11) ^ E4(Q3, 25), ce3 = Q3 & W4 ^ ~Q3 & ue, ye3 = de2 + G4 + ce3 + y7[L6] + _7[L6] | 0, xe3 = E4(A5, 2) ^ E4(A5, 13) ^ E4(A5, 22), he3 = A5 & g10 ^ A5 & D6 ^ g10 & D6, ie4 = xe3 + he3 | 0;
      de2 = ue, ue = W4, W4 = Q3, Q3 = H5 + ye3 | 0, H5 = D6, D6 = g10, g10 = A5, A5 = ye3 + ie4 | 0;
    }
    e6 = e6 + A5 | 0, t6 = t6 + g10 | 0, n7 = n7 + D6 | 0, i8 = i8 + H5 | 0, s10 = s10 + Q3 | 0, o9 = o9 + W4 | 0, u7 = u7 + ue | 0, c6 = c6 + de2 | 0, l7 = 0;
  }, "process"), J3 = a6((A5) => {
    typeof A5 == "string" && (A5 = new TextEncoder().encode(A5));
    for (let g10 = 0; g10 < A5.length; g10++) P5[l7++] = A5[g10], l7 === 64 && N5();
    h8 += A5.length;
  }, "add"), pe2 = a6(() => {
    if (P5[l7++] = 128, l7 == 64 && N5(), l7 + 8 > 64) {
      for (; l7 < 64; ) P5[l7++] = 0;
      N5();
    }
    for (; l7 < 58; ) P5[l7++] = 0;
    let A5 = h8 * 8;
    P5[l7++] = A5 / 1099511627776 & 255, P5[l7++] = A5 / 4294967296 & 255, P5[l7++] = A5 >>> 24, P5[l7++] = A5 >>> 16 & 255, P5[l7++] = A5 >>> 8 & 255, P5[l7++] = A5 & 255, N5();
    let g10 = new Uint8Array(32);
    return g10[0] = e6 >>> 24, g10[1] = e6 >>> 16 & 255, g10[2] = e6 >>> 8 & 255, g10[3] = e6 & 255, g10[4] = t6 >>> 24, g10[5] = t6 >>> 16 & 255, g10[6] = t6 >>> 8 & 255, g10[7] = t6 & 255, g10[8] = n7 >>> 24, g10[9] = n7 >>> 16 & 255, g10[10] = n7 >>> 8 & 255, g10[11] = n7 & 255, g10[12] = i8 >>> 24, g10[13] = i8 >>> 16 & 255, g10[14] = i8 >>> 8 & 255, g10[15] = i8 & 255, g10[16] = s10 >>> 24, g10[17] = s10 >>> 16 & 255, g10[18] = s10 >>> 8 & 255, g10[19] = s10 & 255, g10[20] = o9 >>> 24, g10[21] = o9 >>> 16 & 255, g10[22] = o9 >>> 8 & 255, g10[23] = o9 & 255, g10[24] = u7 >>> 24, g10[25] = u7 >>> 16 & 255, g10[26] = u7 >>> 8 & 255, g10[27] = u7 & 255, g10[28] = c6 >>> 24, g10[29] = c6 >>> 16 & 255, g10[30] = c6 >>> 8 & 255, g10[31] = c6 & 255, g10;
  }, "digest");
  return r6 === void 0 ? { add: J3, digest: pe2 } : (J3(r6), pe2());
}
function Go(r6) {
  return w9.getRandomValues(d6.alloc(r6));
}
function $o(r6) {
  if (r6 === "sha256") return { update: function(e6) {
    return { digest: function() {
      return d6.from($e2(e6));
    } };
  } };
  if (r6 === "md5") return { update: function(e6) {
    return { digest: function() {
      return typeof e6 == "string" ? Ke2.hashStr(e6) : Ke2.hashByteArray(
        e6
      );
    } };
  } };
  throw new Error(`Hash type '${r6}' not supported`);
}
function Ko(r6, e6) {
  if (r6 !== "sha256") throw new Error(`Only sha256 is supported (requested: '${r6}')`);
  return {
    update: function(t6) {
      return { digest: function() {
        typeof e6 == "string" && (e6 = new TextEncoder().encode(e6)), typeof t6 == "string" && (t6 = new TextEncoder().encode(t6));
        let n7 = e6.length;
        if (n7 > 64) e6 = $e2(e6);
        else if (n7 < 64) {
          let c6 = new Uint8Array(64);
          c6.set(e6), e6 = c6;
        }
        let i8 = new Uint8Array(
          64
        ), s10 = new Uint8Array(64);
        for (let c6 = 0; c6 < 64; c6++) i8[c6] = 54 ^ e6[c6], s10[c6] = 92 ^ e6[c6];
        let o9 = new Uint8Array(
          t6.length + 64
        );
        o9.set(i8, 0), o9.set(t6, 64);
        let u7 = new Uint8Array(96);
        return u7.set(s10, 0), u7.set($e2(o9), 64), d6.from($e2(u7));
      } };
    }
  };
}
function iu(...r6) {
  return r6.join("/");
}
function su(r6, e6) {
  e6(new Error("No filesystem"));
}
function lr(r6, e6 = false) {
  let { protocol: t6 } = new URL(r6), n7 = "http:" + r6.substring(t6.length), {
    username: i8,
    password: s10,
    host: o9,
    hostname: u7,
    port: c6,
    pathname: h8,
    search: l7,
    searchParams: y7,
    hash: E4
  } = new URL(n7);
  s10 = decodeURIComponent(s10);
  let _7 = i8 + ":" + s10, P5 = e6 ? Object.fromEntries(y7.entries()) : l7;
  return {
    href: r6,
    protocol: t6,
    auth: _7,
    username: i8,
    password: s10,
    host: o9,
    hostname: u7,
    port: c6,
    pathname: h8,
    search: l7,
    query: P5,
    hash: E4
  };
}
function Lu(r6) {
  return 0;
}
function lc({ socket: r6, servername: e6 }) {
  return r6.startTls(
    e6
  ), r6;
}
function Ys(r6, {
  arrayMode: e6,
  fullResults: t6,
  fetchOptions: n7,
  isolationLevel: i8,
  readOnly: s10,
  deferrable: o9,
  queryCallback: u7,
  resultCallback: c6
} = {}) {
  if (!r6) throw new Error(
    "No database connection string was provided to `neon()`. Perhaps an environment variable has not been set?"
  );
  let h8;
  try {
    h8 = lr(r6);
  } catch {
    throw new Error("Database connection string provided to `neon()` is not a valid URL. Connection string: " + String(
      r6
    ));
  }
  let { protocol: l7, username: y7, password: E4, hostname: _7, port: P5, pathname: N5 } = h8;
  if (l7 !== "postgres:" && l7 !== "postgresql:" || !y7 || !E4 || !_7 || !N5) throw new Error("Database connection string format for `neon()` should be: postgresql://user:password@host.tld/dbname?option=value");
  function J3(A5, ...g10) {
    let D6, H5;
    if (typeof A5 == "string") D6 = A5, H5 = g10[1], g10 = g10[0] ?? [];
    else {
      D6 = "";
      for (let W4 = 0; W4 < A5.length; W4++) D6 += A5[W4], W4 < g10.length && (D6 += "$" + (W4 + 1));
    }
    g10 = g10.map((W4) => (0, zs.prepareValue)(W4));
    let Q3 = { query: D6, params: g10 };
    return u7 && u7(Q3), Nc(
      pe2,
      Q3,
      H5
    );
  }
  a6(J3, "resolve"), J3.transaction = async (A5, g10) => {
    if (typeof A5 == "function" && (A5 = A5(J3)), !Array.isArray(A5)) throw new Error(Ks);
    let D6 = A5.map((H5) => {
      if (H5[Symbol.toStringTag] !== "NeonQueryPromise") throw new Error(Ks);
      return H5.parameterizedQuery;
    });
    return pe2(
      D6,
      g10
    );
  };
  async function pe2(A5, g10) {
    let D6 = n7 ?? {}, { fetchEndpoint: H5, fetchConnectionCache: Q3, fetchFunction: W4 } = _e6, ue = typeof H5 == "function" ? H5(_7, P5) : H5, de2 = Array.isArray(A5) ? { queries: A5 } : A5, L6 = e6 ?? false, G4 = t6 ?? false, ce3 = i8, ye3 = s10, xe3 = o9;
    g10 !== void 0 && (g10.arrayMode !== void 0 && (L6 = g10.arrayMode), g10.fullResults !== void 0 && (G4 = g10.fullResults), g10.fetchOptions !== void 0 && (D6 = { ...D6, ...g10.fetchOptions }), g10.isolationLevel !== void 0 && (ce3 = g10.isolationLevel), g10.readOnly !== void 0 && (ye3 = g10.readOnly), g10.deferrable !== void 0 && (xe3 = g10.deferrable));
    let he3 = { "Neon-Connection-String": r6, "Neon-Raw-Text-Output": "true", "Neon-Array-Mode": "true" };
    Q3 === true && (he3["Neon-Pool-Opt-In"] = "true"), Array.isArray(A5) && (ce3 !== void 0 && (he3["Neon-Batch-Isolation-Level"] = ce3), ye3 !== void 0 && (he3["Neon-Batch-Read-Only"] = String(ye3)), xe3 !== void 0 && (he3["Neon-Batch-Deferrable"] = String(xe3)));
    let ie4;
    try {
      ie4 = await (W4 ?? fetch)(ue, { method: "POST", body: JSON.stringify(de2), headers: he3, ...D6 });
    } catch (se2) {
      let $4 = new Ae3(`Error connecting to database: ${se2.message}`);
      throw $4.sourceError = se2, $4;
    }
    if (ie4.ok) {
      let se2 = await ie4.json();
      if (Array.isArray(A5)) {
        let $4 = se2.results;
        if (!Array.isArray($4)) throw new Ae3("Neon internal error: unexpected result format");
        return $4.map((ne3, Ce3) => Vs(ne3, {
          arrayMode: L6,
          fullResults: G4,
          parameterizedQuery: A5[Ce3],
          resultCallback: c6
        }));
      } else return Vs(se2, {
        arrayMode: L6,
        fullResults: G4,
        parameterizedQuery: A5,
        resultCallback: c6
      });
    } else {
      let { status: se2 } = ie4;
      if (se2 === 400) {
        let { message: $4, code: ne3 } = await ie4.json(), Ce3 = new Ae3($4);
        throw Ce3.code = ne3, Ce3;
      } else {
        let $4 = await ie4.text();
        throw new Ae3(`Server error (HTTP status ${se2}): ${$4}`);
      }
    }
  }
  return a6(
    pe2,
    "execute"
  ), J3;
}
function Nc(r6, e6, t6) {
  return { [Symbol.toStringTag]: "NeonQueryPromise", parameterizedQuery: e6, opts: t6, then: (n7, i8) => r6(e6, t6).then(n7, i8), catch: (n7) => r6(
    e6,
    t6
  ).catch(n7), finally: (n7) => r6(e6, t6).finally(n7) };
}
function Vs(r6, {
  arrayMode: e6,
  fullResults: t6,
  parameterizedQuery: n7,
  resultCallback: i8
}) {
  let s10 = r6.fields.map((c6) => c6.name), o9 = r6.fields.map((c6) => Se2.types.getTypeParser(c6.dataTypeID)), u7 = e6 === true ? r6.rows.map((c6) => c6.map((h8, l7) => h8 === null ? null : o9[l7](h8))) : r6.rows.map((c6) => Object.fromEntries(
    c6.map((h8, l7) => [s10[l7], h8 === null ? null : o9[l7](h8)])
  ));
  return i8 && i8(n7, r6, u7, { arrayMode: e6, fullResults: t6 }), t6 ? (r6.viaNeonFetch = true, r6.rowAsArray = e6, r6.rows = u7, r6) : u7;
}
function Qc(r6, e6) {
  if (e6) return {
    callback: e6,
    result: void 0
  };
  let t6, n7, i8 = a6(function(o9, u7) {
    o9 ? t6(o9) : n7(u7);
  }, "cb"), s10 = new r6(function(o9, u7) {
    n7 = o9, t6 = u7;
  });
  return { callback: i8, result: s10 };
}
var Xs, Ie3, eo, to, ro, no, io, a6, K3, I4, X3, _n2, We2, k8, T3, In2, Tn2, Gn2, b8, S4, v8, w9, d6, m9, p8, ge3, He2, Ho, Ge2, ri, O4, Ke2, ni, Ut2, qt2, Qt2, Wt2, ui, hi, pi, yi, Ei, _i2, Pi, Li, Xe2, et2, tt2, qi, Xt2, er2, tr, rr, nr2, ou, ir, Ni, or3, sr2, Qi, Gi, Vi, Yi, hr, Ji, Au, Xi, es, fr, rs, gt3, us, fs7, ds, ps, x8, _e6, wt2, zr, ys, gs, ws, bs, rc, Ss, vs, on2, _s, As, cn2, Ls, Ds, Os, Cc, ks, Us, Qs, Gs, wn2, At2, Ct2, zs, Sn2, Ae3, Ks, Js, Se2, En2, xn2, vn2, Zs, export_ClientBase, export_Connection, export_DatabaseError, export_Query, export_defaults, export_types;
var init_serverless = __esm({
  "../node_modules/.pnpm/@neondatabase+serverless@0.7.2/node_modules/@neondatabase/serverless/index.mjs"() {
    "use strict";
    Xs = Object.create;
    Ie3 = Object.defineProperty;
    eo = Object.getOwnPropertyDescriptor;
    to = Object.getOwnPropertyNames;
    ro = Object.getPrototypeOf;
    no = Object.prototype.hasOwnProperty;
    io = (r6, e6, t6) => e6 in r6 ? Ie3(r6, e6, { enumerable: true, configurable: true, writable: true, value: t6 }) : r6[e6] = t6;
    a6 = (r6, e6) => Ie3(r6, "name", { value: e6, configurable: true });
    K3 = (r6, e6) => () => (r6 && (e6 = r6(r6 = 0)), e6);
    I4 = (r6, e6) => () => (e6 || r6((e6 = { exports: {} }).exports, e6), e6.exports);
    X3 = (r6, e6) => {
      for (var t6 in e6)
        Ie3(r6, t6, { get: e6[t6], enumerable: true });
    };
    _n2 = (r6, e6, t6, n7) => {
      if (e6 && typeof e6 == "object" || typeof e6 == "function") for (let i8 of to(e6)) !no.call(r6, i8) && i8 !== t6 && Ie3(r6, i8, { get: () => e6[i8], enumerable: !(n7 = eo(e6, i8)) || n7.enumerable });
      return r6;
    };
    We2 = (r6, e6, t6) => (t6 = r6 != null ? Xs(ro(r6)) : {}, _n2(e6 || !r6 || !r6.__esModule ? Ie3(t6, "default", {
      value: r6,
      enumerable: true
    }) : t6, r6));
    k8 = (r6) => _n2(Ie3({}, "__esModule", { value: true }), r6);
    T3 = (r6, e6, t6) => (io(r6, typeof e6 != "symbol" ? e6 + "" : e6, t6), t6);
    In2 = I4((it2) => {
      "use strict";
      p8();
      it2.byteLength = oo3;
      it2.toByteArray = uo2;
      it2.fromByteArray = lo;
      var oe = [], ee3 = [], so3 = typeof Uint8Array < "u" ? Uint8Array : Array, It4 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      for (Ee2 = 0, An5 = It4.length; Ee2 < An5; ++Ee2)
        oe[Ee2] = It4[Ee2], ee3[It4.charCodeAt(Ee2)] = Ee2;
      var Ee2, An5;
      ee3[45] = 62;
      ee3[95] = 63;
      function Cn3(r6) {
        var e6 = r6.length;
        if (e6 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
        var t6 = r6.indexOf("=");
        t6 === -1 && (t6 = e6);
        var n7 = t6 === e6 ? 0 : 4 - t6 % 4;
        return [t6, n7];
      }
      a6(
        Cn3,
        "getLens"
      );
      function oo3(r6) {
        var e6 = Cn3(r6), t6 = e6[0], n7 = e6[1];
        return (t6 + n7) * 3 / 4 - n7;
      }
      a6(oo3, "byteLength");
      function ao2(r6, e6, t6) {
        return (e6 + t6) * 3 / 4 - t6;
      }
      a6(ao2, "_byteLength");
      function uo2(r6) {
        var e6, t6 = Cn3(r6), n7 = t6[0], i8 = t6[1], s10 = new so3(ao2(r6, n7, i8)), o9 = 0, u7 = i8 > 0 ? n7 - 4 : n7, c6;
        for (c6 = 0; c6 < u7; c6 += 4) e6 = ee3[r6.charCodeAt(c6)] << 18 | ee3[r6.charCodeAt(c6 + 1)] << 12 | ee3[r6.charCodeAt(c6 + 2)] << 6 | ee3[r6.charCodeAt(c6 + 3)], s10[o9++] = e6 >> 16 & 255, s10[o9++] = e6 >> 8 & 255, s10[o9++] = e6 & 255;
        return i8 === 2 && (e6 = ee3[r6.charCodeAt(c6)] << 2 | ee3[r6.charCodeAt(c6 + 1)] >> 4, s10[o9++] = e6 & 255), i8 === 1 && (e6 = ee3[r6.charCodeAt(
          c6
        )] << 10 | ee3[r6.charCodeAt(c6 + 1)] << 4 | ee3[r6.charCodeAt(c6 + 2)] >> 2, s10[o9++] = e6 >> 8 & 255, s10[o9++] = e6 & 255), s10;
      }
      a6(uo2, "toByteArray");
      function co(r6) {
        return oe[r6 >> 18 & 63] + oe[r6 >> 12 & 63] + oe[r6 >> 6 & 63] + oe[r6 & 63];
      }
      a6(co, "tripletToBase64");
      function ho(r6, e6, t6) {
        for (var n7, i8 = [], s10 = e6; s10 < t6; s10 += 3) n7 = (r6[s10] << 16 & 16711680) + (r6[s10 + 1] << 8 & 65280) + (r6[s10 + 2] & 255), i8.push(co(n7));
        return i8.join(
          ""
        );
      }
      a6(ho, "encodeChunk");
      function lo(r6) {
        for (var e6, t6 = r6.length, n7 = t6 % 3, i8 = [], s10 = 16383, o9 = 0, u7 = t6 - n7; o9 < u7; o9 += s10) i8.push(ho(r6, o9, o9 + s10 > u7 ? u7 : o9 + s10));
        return n7 === 1 ? (e6 = r6[t6 - 1], i8.push(oe[e6 >> 2] + oe[e6 << 4 & 63] + "==")) : n7 === 2 && (e6 = (r6[t6 - 2] << 8) + r6[t6 - 1], i8.push(oe[e6 >> 10] + oe[e6 >> 4 & 63] + oe[e6 << 2 & 63] + "=")), i8.join("");
      }
      a6(lo, "fromByteArray");
    });
    Tn2 = I4((Tt4) => {
      p8();
      Tt4.read = function(r6, e6, t6, n7, i8) {
        var s10, o9, u7 = i8 * 8 - n7 - 1, c6 = (1 << u7) - 1, h8 = c6 >> 1, l7 = -7, y7 = t6 ? i8 - 1 : 0, E4 = t6 ? -1 : 1, _7 = r6[e6 + y7];
        for (y7 += E4, s10 = _7 & (1 << -l7) - 1, _7 >>= -l7, l7 += u7; l7 > 0; s10 = s10 * 256 + r6[e6 + y7], y7 += E4, l7 -= 8) ;
        for (o9 = s10 & (1 << -l7) - 1, s10 >>= -l7, l7 += n7; l7 > 0; o9 = o9 * 256 + r6[e6 + y7], y7 += E4, l7 -= 8) ;
        if (s10 === 0) s10 = 1 - h8;
        else {
          if (s10 === c6) return o9 ? NaN : (_7 ? -1 : 1) * (1 / 0);
          o9 = o9 + Math.pow(2, n7), s10 = s10 - h8;
        }
        return (_7 ? -1 : 1) * o9 * Math.pow(2, s10 - n7);
      };
      Tt4.write = function(r6, e6, t6, n7, i8, s10) {
        var o9, u7, c6, h8 = s10 * 8 - i8 - 1, l7 = (1 << h8) - 1, y7 = l7 >> 1, E4 = i8 === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, _7 = n7 ? 0 : s10 - 1, P5 = n7 ? 1 : -1, N5 = e6 < 0 || e6 === 0 && 1 / e6 < 0 ? 1 : 0;
        for (e6 = Math.abs(e6), isNaN(e6) || e6 === 1 / 0 ? (u7 = isNaN(e6) ? 1 : 0, o9 = l7) : (o9 = Math.floor(Math.log(e6) / Math.LN2), e6 * (c6 = Math.pow(2, -o9)) < 1 && (o9--, c6 *= 2), o9 + y7 >= 1 ? e6 += E4 / c6 : e6 += E4 * Math.pow(2, 1 - y7), e6 * c6 >= 2 && (o9++, c6 /= 2), o9 + y7 >= l7 ? (u7 = 0, o9 = l7) : o9 + y7 >= 1 ? (u7 = (e6 * c6 - 1) * Math.pow(
          2,
          i8
        ), o9 = o9 + y7) : (u7 = e6 * Math.pow(2, y7 - 1) * Math.pow(2, i8), o9 = 0)); i8 >= 8; r6[t6 + _7] = u7 & 255, _7 += P5, u7 /= 256, i8 -= 8) ;
        for (o9 = o9 << i8 | u7, h8 += i8; h8 > 0; r6[t6 + _7] = o9 & 255, _7 += P5, o9 /= 256, h8 -= 8) ;
        r6[t6 + _7 - P5] |= N5 * 128;
      };
    });
    Gn2 = I4((Le2) => {
      "use strict";
      p8();
      var Pt3 = In2(), Pe3 = Tn2(), Pn4 = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
      Le2.Buffer = f9;
      Le2.SlowBuffer = wo;
      Le2.INSPECT_MAX_BYTES = 50;
      var st2 = 2147483647;
      Le2.kMaxLength = st2;
      f9.TYPED_ARRAY_SUPPORT = fo();
      !f9.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
      function fo() {
        try {
          let r6 = new Uint8Array(1), e6 = { foo: function() {
            return 42;
          } };
          return Object.setPrototypeOf(e6, Uint8Array.prototype), Object.setPrototypeOf(r6, e6), r6.foo() === 42;
        } catch {
          return false;
        }
      }
      a6(fo, "typedArraySupport");
      Object.defineProperty(
        f9.prototype,
        "parent",
        { enumerable: true, get: function() {
          if (f9.isBuffer(this)) return this.buffer;
        } }
      );
      Object.defineProperty(f9.prototype, "offset", { enumerable: true, get: function() {
        if (f9.isBuffer(
          this
        )) return this.byteOffset;
      } });
      function le2(r6) {
        if (r6 > st2) throw new RangeError('The value "' + r6 + '" is invalid for option "size"');
        let e6 = new Uint8Array(r6);
        return Object.setPrototypeOf(e6, f9.prototype), e6;
      }
      a6(le2, "createBuffer");
      function f9(r6, e6, t6) {
        if (typeof r6 == "number") {
          if (typeof e6 == "string") throw new TypeError('The "string" argument must be of type string. Received type number');
          return Ft2(r6);
        }
        return Fn2(r6, e6, t6);
      }
      a6(f9, "Buffer");
      f9.poolSize = 8192;
      function Fn2(r6, e6, t6) {
        if (typeof r6 == "string") return yo(r6, e6);
        if (ArrayBuffer.isView(r6)) return mo(r6);
        if (r6 == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof r6);
        if (ae(r6, ArrayBuffer) || r6 && ae(r6.buffer, ArrayBuffer) || typeof SharedArrayBuffer < "u" && (ae(r6, SharedArrayBuffer) || r6 && ae(r6.buffer, SharedArrayBuffer))) return Lt2(
          r6,
          e6,
          t6
        );
        if (typeof r6 == "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
        let n7 = r6.valueOf && r6.valueOf();
        if (n7 != null && n7 !== r6) return f9.from(n7, e6, t6);
        let i8 = go(r6);
        if (i8) return i8;
        if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof r6[Symbol.toPrimitive] == "function") return f9.from(r6[Symbol.toPrimitive](
          "string"
        ), e6, t6);
        throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof r6);
      }
      a6(
        Fn2,
        "from"
      );
      f9.from = function(r6, e6, t6) {
        return Fn2(r6, e6, t6);
      };
      Object.setPrototypeOf(
        f9.prototype,
        Uint8Array.prototype
      );
      Object.setPrototypeOf(f9, Uint8Array);
      function Mn2(r6) {
        if (typeof r6 != "number") throw new TypeError('"size" argument must be of type number');
        if (r6 < 0) throw new RangeError(
          'The value "' + r6 + '" is invalid for option "size"'
        );
      }
      a6(Mn2, "assertSize");
      function po(r6, e6, t6) {
        return Mn2(r6), r6 <= 0 ? le2(r6) : e6 !== void 0 ? typeof t6 == "string" ? le2(r6).fill(e6, t6) : le2(r6).fill(
          e6
        ) : le2(r6);
      }
      a6(po, "alloc");
      f9.alloc = function(r6, e6, t6) {
        return po(r6, e6, t6);
      };
      function Ft2(r6) {
        return Mn2(r6), le2(r6 < 0 ? 0 : Mt2(r6) | 0);
      }
      a6(Ft2, "allocUnsafe");
      f9.allocUnsafe = function(r6) {
        return Ft2(
          r6
        );
      };
      f9.allocUnsafeSlow = function(r6) {
        return Ft2(r6);
      };
      function yo(r6, e6) {
        if ((typeof e6 != "string" || e6 === "") && (e6 = "utf8"), !f9.isEncoding(e6)) throw new TypeError("Unknown encoding: " + e6);
        let t6 = Dn2(r6, e6) | 0, n7 = le2(t6), i8 = n7.write(r6, e6);
        return i8 !== t6 && (n7 = n7.slice(0, i8)), n7;
      }
      a6(yo, "fromString");
      function Bt2(r6) {
        let e6 = r6.length < 0 ? 0 : Mt2(r6.length) | 0, t6 = le2(e6);
        for (let n7 = 0; n7 < e6; n7 += 1) t6[n7] = r6[n7] & 255;
        return t6;
      }
      a6(Bt2, "fromArrayLike");
      function mo(r6) {
        if (ae(r6, Uint8Array)) {
          let e6 = new Uint8Array(r6);
          return Lt2(e6.buffer, e6.byteOffset, e6.byteLength);
        }
        return Bt2(
          r6
        );
      }
      a6(mo, "fromArrayView");
      function Lt2(r6, e6, t6) {
        if (e6 < 0 || r6.byteLength < e6) throw new RangeError(
          '"offset" is outside of buffer bounds'
        );
        if (r6.byteLength < e6 + (t6 || 0)) throw new RangeError(
          '"length" is outside of buffer bounds'
        );
        let n7;
        return e6 === void 0 && t6 === void 0 ? n7 = new Uint8Array(
          r6
        ) : t6 === void 0 ? n7 = new Uint8Array(r6, e6) : n7 = new Uint8Array(r6, e6, t6), Object.setPrototypeOf(
          n7,
          f9.prototype
        ), n7;
      }
      a6(Lt2, "fromArrayBuffer");
      function go(r6) {
        if (f9.isBuffer(r6)) {
          let e6 = Mt2(
            r6.length
          ) | 0, t6 = le2(e6);
          return t6.length === 0 || r6.copy(t6, 0, 0, e6), t6;
        }
        if (r6.length !== void 0)
          return typeof r6.length != "number" || Ot2(r6.length) ? le2(0) : Bt2(r6);
        if (r6.type === "Buffer" && Array.isArray(r6.data)) return Bt2(r6.data);
      }
      a6(go, "fromObject");
      function Mt2(r6) {
        if (r6 >= st2) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + st2.toString(16) + " bytes");
        return r6 | 0;
      }
      a6(Mt2, "checked");
      function wo(r6) {
        return +r6 != r6 && (r6 = 0), f9.alloc(+r6);
      }
      a6(wo, "SlowBuffer");
      f9.isBuffer = a6(function(e6) {
        return e6 != null && e6._isBuffer === true && e6 !== f9.prototype;
      }, "isBuffer");
      f9.compare = a6(function(e6, t6) {
        if (ae(e6, Uint8Array) && (e6 = f9.from(e6, e6.offset, e6.byteLength)), ae(t6, Uint8Array) && (t6 = f9.from(t6, t6.offset, t6.byteLength)), !f9.isBuffer(e6) || !f9.isBuffer(t6)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
        if (e6 === t6) return 0;
        let n7 = e6.length, i8 = t6.length;
        for (let s10 = 0, o9 = Math.min(n7, i8); s10 < o9; ++s10) if (e6[s10] !== t6[s10]) {
          n7 = e6[s10], i8 = t6[s10];
          break;
        }
        return n7 < i8 ? -1 : i8 < n7 ? 1 : 0;
      }, "compare");
      f9.isEncoding = a6(function(e6) {
        switch (String(e6).toLowerCase()) {
          case "hex":
          case "utf8":
          case "utf-8":
          case "ascii":
          case "latin1":
          case "binary":
          case "base64":
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return true;
          default:
            return false;
        }
      }, "isEncoding");
      f9.concat = a6(function(e6, t6) {
        if (!Array.isArray(e6)) throw new TypeError('"list" argument must be an Array of Buffers');
        if (e6.length === 0) return f9.alloc(0);
        let n7;
        if (t6 === void 0) for (t6 = 0, n7 = 0; n7 < e6.length; ++n7) t6 += e6[n7].length;
        let i8 = f9.allocUnsafe(t6), s10 = 0;
        for (n7 = 0; n7 < e6.length; ++n7) {
          let o9 = e6[n7];
          if (ae(o9, Uint8Array)) s10 + o9.length > i8.length ? (f9.isBuffer(
            o9
          ) || (o9 = f9.from(o9)), o9.copy(i8, s10)) : Uint8Array.prototype.set.call(i8, o9, s10);
          else if (f9.isBuffer(
            o9
          )) o9.copy(i8, s10);
          else throw new TypeError('"list" argument must be an Array of Buffers');
          s10 += o9.length;
        }
        return i8;
      }, "concat");
      function Dn2(r6, e6) {
        if (f9.isBuffer(r6)) return r6.length;
        if (ArrayBuffer.isView(r6) || ae(r6, ArrayBuffer)) return r6.byteLength;
        if (typeof r6 != "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof r6);
        let t6 = r6.length, n7 = arguments.length > 2 && arguments[2] === true;
        if (!n7 && t6 === 0) return 0;
        let i8 = false;
        for (; ; ) switch (e6) {
          case "ascii":
          case "latin1":
          case "binary":
            return t6;
          case "utf8":
          case "utf-8":
            return Rt2(r6).length;
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return t6 * 2;
          case "hex":
            return t6 >>> 1;
          case "base64":
            return Hn2(r6).length;
          default:
            if (i8) return n7 ? -1 : Rt2(r6).length;
            e6 = ("" + e6).toLowerCase(), i8 = true;
        }
      }
      a6(Dn2, "byteLength");
      f9.byteLength = Dn2;
      function bo(r6, e6, t6) {
        let n7 = false;
        if ((e6 === void 0 || e6 < 0) && (e6 = 0), e6 > this.length || ((t6 === void 0 || t6 > this.length) && (t6 = this.length), t6 <= 0) || (t6 >>>= 0, e6 >>>= 0, t6 <= e6)) return "";
        for (r6 || (r6 = "utf8"); ; ) switch (r6) {
          case "hex":
            return Po(
              this,
              e6,
              t6
            );
          case "utf8":
          case "utf-8":
            return kn2(this, e6, t6);
          case "ascii":
            return Io(
              this,
              e6,
              t6
            );
          case "latin1":
          case "binary":
            return To(this, e6, t6);
          case "base64":
            return Ao(
              this,
              e6,
              t6
            );
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return Bo(this, e6, t6);
          default:
            if (n7) throw new TypeError("Unknown encoding: " + r6);
            r6 = (r6 + "").toLowerCase(), n7 = true;
        }
      }
      a6(
        bo,
        "slowToString"
      );
      f9.prototype._isBuffer = true;
      function ve2(r6, e6, t6) {
        let n7 = r6[e6];
        r6[e6] = r6[t6], r6[t6] = n7;
      }
      a6(ve2, "swap");
      f9.prototype.swap16 = a6(function() {
        let e6 = this.length;
        if (e6 % 2 !== 0)
          throw new RangeError("Buffer size must be a multiple of 16-bits");
        for (let t6 = 0; t6 < e6; t6 += 2) ve2(this, t6, t6 + 1);
        return this;
      }, "swap16");
      f9.prototype.swap32 = a6(function() {
        let e6 = this.length;
        if (e6 % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
        for (let t6 = 0; t6 < e6; t6 += 4) ve2(this, t6, t6 + 3), ve2(this, t6 + 1, t6 + 2);
        return this;
      }, "swap32");
      f9.prototype.swap64 = a6(function() {
        let e6 = this.length;
        if (e6 % 8 !== 0) throw new RangeError(
          "Buffer size must be a multiple of 64-bits"
        );
        for (let t6 = 0; t6 < e6; t6 += 8) ve2(this, t6, t6 + 7), ve2(this, t6 + 1, t6 + 6), ve2(this, t6 + 2, t6 + 5), ve2(this, t6 + 3, t6 + 4);
        return this;
      }, "swap64");
      f9.prototype.toString = a6(function() {
        let e6 = this.length;
        return e6 === 0 ? "" : arguments.length === 0 ? kn2(
          this,
          0,
          e6
        ) : bo.apply(this, arguments);
      }, "toString");
      f9.prototype.toLocaleString = f9.prototype.toString;
      f9.prototype.equals = a6(function(e6) {
        if (!f9.isBuffer(e6)) throw new TypeError(
          "Argument must be a Buffer"
        );
        return this === e6 ? true : f9.compare(this, e6) === 0;
      }, "equals");
      f9.prototype.inspect = a6(function() {
        let e6 = "", t6 = Le2.INSPECT_MAX_BYTES;
        return e6 = this.toString(
          "hex",
          0,
          t6
        ).replace(/(.{2})/g, "$1 ").trim(), this.length > t6 && (e6 += " ... "), "<Buffer " + e6 + ">";
      }, "inspect");
      Pn4 && (f9.prototype[Pn4] = f9.prototype.inspect);
      f9.prototype.compare = a6(function(e6, t6, n7, i8, s10) {
        if (ae(e6, Uint8Array) && (e6 = f9.from(e6, e6.offset, e6.byteLength)), !f9.isBuffer(e6)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof e6);
        if (t6 === void 0 && (t6 = 0), n7 === void 0 && (n7 = e6 ? e6.length : 0), i8 === void 0 && (i8 = 0), s10 === void 0 && (s10 = this.length), t6 < 0 || n7 > e6.length || i8 < 0 || s10 > this.length) throw new RangeError("out of range index");
        if (i8 >= s10 && t6 >= n7) return 0;
        if (i8 >= s10) return -1;
        if (t6 >= n7) return 1;
        if (t6 >>>= 0, n7 >>>= 0, i8 >>>= 0, s10 >>>= 0, this === e6) return 0;
        let o9 = s10 - i8, u7 = n7 - t6, c6 = Math.min(o9, u7), h8 = this.slice(i8, s10), l7 = e6.slice(t6, n7);
        for (let y7 = 0; y7 < c6; ++y7)
          if (h8[y7] !== l7[y7]) {
            o9 = h8[y7], u7 = l7[y7];
            break;
          }
        return o9 < u7 ? -1 : u7 < o9 ? 1 : 0;
      }, "compare");
      function On2(r6, e6, t6, n7, i8) {
        if (r6.length === 0) return -1;
        if (typeof t6 == "string" ? (n7 = t6, t6 = 0) : t6 > 2147483647 ? t6 = 2147483647 : t6 < -2147483648 && (t6 = -2147483648), t6 = +t6, Ot2(t6) && (t6 = i8 ? 0 : r6.length - 1), t6 < 0 && (t6 = r6.length + t6), t6 >= r6.length) {
          if (i8) return -1;
          t6 = r6.length - 1;
        } else if (t6 < 0) if (i8) t6 = 0;
        else return -1;
        if (typeof e6 == "string" && (e6 = f9.from(e6, n7)), f9.isBuffer(e6)) return e6.length === 0 ? -1 : Bn3(r6, e6, t6, n7, i8);
        if (typeof e6 == "number") return e6 = e6 & 255, typeof Uint8Array.prototype.indexOf == "function" ? i8 ? Uint8Array.prototype.indexOf.call(r6, e6, t6) : Uint8Array.prototype.lastIndexOf.call(r6, e6, t6) : Bn3(
          r6,
          [e6],
          t6,
          n7,
          i8
        );
        throw new TypeError("val must be string, number or Buffer");
      }
      a6(On2, "bidirectionalIndexOf");
      function Bn3(r6, e6, t6, n7, i8) {
        let s10 = 1, o9 = r6.length, u7 = e6.length;
        if (n7 !== void 0 && (n7 = String(n7).toLowerCase(), n7 === "ucs2" || n7 === "ucs-2" || n7 === "utf16le" || n7 === "utf-16le")) {
          if (r6.length < 2 || e6.length < 2) return -1;
          s10 = 2, o9 /= 2, u7 /= 2, t6 /= 2;
        }
        function c6(l7, y7) {
          return s10 === 1 ? l7[y7] : l7.readUInt16BE(y7 * s10);
        }
        a6(c6, "read");
        let h8;
        if (i8) {
          let l7 = -1;
          for (h8 = t6; h8 < o9; h8++) if (c6(r6, h8) === c6(e6, l7 === -1 ? 0 : h8 - l7)) {
            if (l7 === -1 && (l7 = h8), h8 - l7 + 1 === u7) return l7 * s10;
          } else l7 !== -1 && (h8 -= h8 - l7), l7 = -1;
        } else for (t6 + u7 > o9 && (t6 = o9 - u7), h8 = t6; h8 >= 0; h8--) {
          let l7 = true;
          for (let y7 = 0; y7 < u7; y7++)
            if (c6(r6, h8 + y7) !== c6(e6, y7)) {
              l7 = false;
              break;
            }
          if (l7) return h8;
        }
        return -1;
      }
      a6(Bn3, "arrayIndexOf");
      f9.prototype.includes = a6(function(e6, t6, n7) {
        return this.indexOf(e6, t6, n7) !== -1;
      }, "includes");
      f9.prototype.indexOf = a6(function(e6, t6, n7) {
        return On2(this, e6, t6, n7, true);
      }, "indexOf");
      f9.prototype.lastIndexOf = a6(function(e6, t6, n7) {
        return On2(this, e6, t6, n7, false);
      }, "lastIndexOf");
      function So(r6, e6, t6, n7) {
        t6 = Number(t6) || 0;
        let i8 = r6.length - t6;
        n7 ? (n7 = Number(n7), n7 > i8 && (n7 = i8)) : n7 = i8;
        let s10 = e6.length;
        n7 > s10 / 2 && (n7 = s10 / 2);
        let o9;
        for (o9 = 0; o9 < n7; ++o9) {
          let u7 = parseInt(e6.substr(o9 * 2, 2), 16);
          if (Ot2(u7))
            return o9;
          r6[t6 + o9] = u7;
        }
        return o9;
      }
      a6(So, "hexWrite");
      function xo(r6, e6, t6, n7) {
        return ot2(Rt2(
          e6,
          r6.length - t6
        ), r6, t6, n7);
      }
      a6(xo, "utf8Write");
      function Eo(r6, e6, t6, n7) {
        return ot2(Mo(e6), r6, t6, n7);
      }
      a6(Eo, "asciiWrite");
      function vo(r6, e6, t6, n7) {
        return ot2(Hn2(e6), r6, t6, n7);
      }
      a6(vo, "base64Write");
      function _o(r6, e6, t6, n7) {
        return ot2(Do(e6, r6.length - t6), r6, t6, n7);
      }
      a6(_o, "ucs2Write");
      f9.prototype.write = a6(function(e6, t6, n7, i8) {
        if (t6 === void 0) i8 = "utf8", n7 = this.length, t6 = 0;
        else if (n7 === void 0 && typeof t6 == "string") i8 = t6, n7 = this.length, t6 = 0;
        else if (isFinite(t6)) t6 = t6 >>> 0, isFinite(n7) ? (n7 = n7 >>> 0, i8 === void 0 && (i8 = "utf8")) : (i8 = n7, n7 = void 0);
        else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
        let s10 = this.length - t6;
        if ((n7 === void 0 || n7 > s10) && (n7 = s10), e6.length > 0 && (n7 < 0 || t6 < 0) || t6 > this.length) throw new RangeError(
          "Attempt to write outside buffer bounds"
        );
        i8 || (i8 = "utf8");
        let o9 = false;
        for (; ; ) switch (i8) {
          case "hex":
            return So(this, e6, t6, n7);
          case "utf8":
          case "utf-8":
            return xo(this, e6, t6, n7);
          case "ascii":
          case "latin1":
          case "binary":
            return Eo(this, e6, t6, n7);
          case "base64":
            return vo(
              this,
              e6,
              t6,
              n7
            );
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return _o(this, e6, t6, n7);
          default:
            if (o9) throw new TypeError("Unknown encoding: " + i8);
            i8 = ("" + i8).toLowerCase(), o9 = true;
        }
      }, "write");
      f9.prototype.toJSON = a6(function() {
        return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
      }, "toJSON");
      function Ao(r6, e6, t6) {
        return e6 === 0 && t6 === r6.length ? Pt3.fromByteArray(r6) : Pt3.fromByteArray(r6.slice(e6, t6));
      }
      a6(Ao, "base64Slice");
      function kn2(r6, e6, t6) {
        t6 = Math.min(r6.length, t6);
        let n7 = [], i8 = e6;
        for (; i8 < t6; ) {
          let s10 = r6[i8], o9 = null, u7 = s10 > 239 ? 4 : s10 > 223 ? 3 : s10 > 191 ? 2 : 1;
          if (i8 + u7 <= t6) {
            let c6, h8, l7, y7;
            switch (u7) {
              case 1:
                s10 < 128 && (o9 = s10);
                break;
              case 2:
                c6 = r6[i8 + 1], (c6 & 192) === 128 && (y7 = (s10 & 31) << 6 | c6 & 63, y7 > 127 && (o9 = y7));
                break;
              case 3:
                c6 = r6[i8 + 1], h8 = r6[i8 + 2], (c6 & 192) === 128 && (h8 & 192) === 128 && (y7 = (s10 & 15) << 12 | (c6 & 63) << 6 | h8 & 63, y7 > 2047 && (y7 < 55296 || y7 > 57343) && (o9 = y7));
                break;
              case 4:
                c6 = r6[i8 + 1], h8 = r6[i8 + 2], l7 = r6[i8 + 3], (c6 & 192) === 128 && (h8 & 192) === 128 && (l7 & 192) === 128 && (y7 = (s10 & 15) << 18 | (c6 & 63) << 12 | (h8 & 63) << 6 | l7 & 63, y7 > 65535 && y7 < 1114112 && (o9 = y7));
            }
          }
          o9 === null ? (o9 = 65533, u7 = 1) : o9 > 65535 && (o9 -= 65536, n7.push(o9 >>> 10 & 1023 | 55296), o9 = 56320 | o9 & 1023), n7.push(o9), i8 += u7;
        }
        return Co(n7);
      }
      a6(kn2, "utf8Slice");
      var Ln2 = 4096;
      function Co(r6) {
        let e6 = r6.length;
        if (e6 <= Ln2) return String.fromCharCode.apply(String, r6);
        let t6 = "", n7 = 0;
        for (; n7 < e6; ) t6 += String.fromCharCode.apply(String, r6.slice(n7, n7 += Ln2));
        return t6;
      }
      a6(Co, "decodeCodePointsArray");
      function Io(r6, e6, t6) {
        let n7 = "";
        t6 = Math.min(r6.length, t6);
        for (let i8 = e6; i8 < t6; ++i8) n7 += String.fromCharCode(r6[i8] & 127);
        return n7;
      }
      a6(Io, "asciiSlice");
      function To(r6, e6, t6) {
        let n7 = "";
        t6 = Math.min(r6.length, t6);
        for (let i8 = e6; i8 < t6; ++i8) n7 += String.fromCharCode(r6[i8]);
        return n7;
      }
      a6(To, "latin1Slice");
      function Po(r6, e6, t6) {
        let n7 = r6.length;
        (!e6 || e6 < 0) && (e6 = 0), (!t6 || t6 < 0 || t6 > n7) && (t6 = n7);
        let i8 = "";
        for (let s10 = e6; s10 < t6; ++s10) i8 += Oo[r6[s10]];
        return i8;
      }
      a6(Po, "hexSlice");
      function Bo(r6, e6, t6) {
        let n7 = r6.slice(e6, t6), i8 = "";
        for (let s10 = 0; s10 < n7.length - 1; s10 += 2) i8 += String.fromCharCode(n7[s10] + n7[s10 + 1] * 256);
        return i8;
      }
      a6(Bo, "utf16leSlice");
      f9.prototype.slice = a6(function(e6, t6) {
        let n7 = this.length;
        e6 = ~~e6, t6 = t6 === void 0 ? n7 : ~~t6, e6 < 0 ? (e6 += n7, e6 < 0 && (e6 = 0)) : e6 > n7 && (e6 = n7), t6 < 0 ? (t6 += n7, t6 < 0 && (t6 = 0)) : t6 > n7 && (t6 = n7), t6 < e6 && (t6 = e6);
        let i8 = this.subarray(
          e6,
          t6
        );
        return Object.setPrototypeOf(i8, f9.prototype), i8;
      }, "slice");
      function U4(r6, e6, t6) {
        if (r6 % 1 !== 0 || r6 < 0) throw new RangeError("offset is not uint");
        if (r6 + e6 > t6) throw new RangeError(
          "Trying to access beyond buffer length"
        );
      }
      a6(U4, "checkOffset");
      f9.prototype.readUintLE = f9.prototype.readUIntLE = a6(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || U4(e6, t6, this.length);
        let i8 = this[e6], s10 = 1, o9 = 0;
        for (; ++o9 < t6 && (s10 *= 256); ) i8 += this[e6 + o9] * s10;
        return i8;
      }, "readUIntLE");
      f9.prototype.readUintBE = f9.prototype.readUIntBE = a6(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || U4(e6, t6, this.length);
        let i8 = this[e6 + --t6], s10 = 1;
        for (; t6 > 0 && (s10 *= 256); ) i8 += this[e6 + --t6] * s10;
        return i8;
      }, "readUIntBE");
      f9.prototype.readUint8 = f9.prototype.readUInt8 = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 1, this.length), this[e6];
      }, "readUInt8");
      f9.prototype.readUint16LE = f9.prototype.readUInt16LE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 2, this.length), this[e6] | this[e6 + 1] << 8;
      }, "readUInt16LE");
      f9.prototype.readUint16BE = f9.prototype.readUInt16BE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 2, this.length), this[e6] << 8 | this[e6 + 1];
      }, "readUInt16BE");
      f9.prototype.readUint32LE = f9.prototype.readUInt32LE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 4, this.length), (this[e6] | this[e6 + 1] << 8 | this[e6 + 2] << 16) + this[e6 + 3] * 16777216;
      }, "readUInt32LE");
      f9.prototype.readUint32BE = f9.prototype.readUInt32BE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 4, this.length), this[e6] * 16777216 + (this[e6 + 1] << 16 | this[e6 + 2] << 8 | this[e6 + 3]);
      }, "readUInt32BE");
      f9.prototype.readBigUInt64LE = me2(a6(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && je4(e6, this.length - 8);
        let i8 = t6 + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 24, s10 = this[++e6] + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + n7 * 2 ** 24;
        return BigInt(i8) + (BigInt(s10) << BigInt(32));
      }, "readBigUInt64LE"));
      f9.prototype.readBigUInt64BE = me2(a6(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && je4(e6, this.length - 8);
        let i8 = t6 * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + this[++e6], s10 = this[++e6] * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + n7;
        return (BigInt(
          i8
        ) << BigInt(32)) + BigInt(s10);
      }, "readBigUInt64BE"));
      f9.prototype.readIntLE = a6(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || U4(e6, t6, this.length);
        let i8 = this[e6], s10 = 1, o9 = 0;
        for (; ++o9 < t6 && (s10 *= 256); )
          i8 += this[e6 + o9] * s10;
        return s10 *= 128, i8 >= s10 && (i8 -= Math.pow(2, 8 * t6)), i8;
      }, "readIntLE");
      f9.prototype.readIntBE = a6(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || U4(e6, t6, this.length);
        let i8 = t6, s10 = 1, o9 = this[e6 + --i8];
        for (; i8 > 0 && (s10 *= 256); ) o9 += this[e6 + --i8] * s10;
        return s10 *= 128, o9 >= s10 && (o9 -= Math.pow(2, 8 * t6)), o9;
      }, "readIntBE");
      f9.prototype.readInt8 = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 1, this.length), this[e6] & 128 ? (255 - this[e6] + 1) * -1 : this[e6];
      }, "readInt8");
      f9.prototype.readInt16LE = a6(function(e6, t6) {
        e6 = e6 >>> 0, t6 || U4(e6, 2, this.length);
        let n7 = this[e6] | this[e6 + 1] << 8;
        return n7 & 32768 ? n7 | 4294901760 : n7;
      }, "readInt16LE");
      f9.prototype.readInt16BE = a6(
        function(e6, t6) {
          e6 = e6 >>> 0, t6 || U4(e6, 2, this.length);
          let n7 = this[e6 + 1] | this[e6] << 8;
          return n7 & 32768 ? n7 | 4294901760 : n7;
        },
        "readInt16BE"
      );
      f9.prototype.readInt32LE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 4, this.length), this[e6] | this[e6 + 1] << 8 | this[e6 + 2] << 16 | this[e6 + 3] << 24;
      }, "readInt32LE");
      f9.prototype.readInt32BE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 4, this.length), this[e6] << 24 | this[e6 + 1] << 16 | this[e6 + 2] << 8 | this[e6 + 3];
      }, "readInt32BE");
      f9.prototype.readBigInt64LE = me2(a6(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && je4(
          e6,
          this.length - 8
        );
        let i8 = this[e6 + 4] + this[e6 + 5] * 2 ** 8 + this[e6 + 6] * 2 ** 16 + (n7 << 24);
        return (BigInt(
          i8
        ) << BigInt(32)) + BigInt(t6 + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 24);
      }, "readBigInt64LE"));
      f9.prototype.readBigInt64BE = me2(a6(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && je4(e6, this.length - 8);
        let i8 = (t6 << 24) + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + this[++e6];
        return (BigInt(i8) << BigInt(32)) + BigInt(
          this[++e6] * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + n7
        );
      }, "readBigInt64BE"));
      f9.prototype.readFloatLE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 4, this.length), Pe3.read(
          this,
          e6,
          true,
          23,
          4
        );
      }, "readFloatLE");
      f9.prototype.readFloatBE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 4, this.length), Pe3.read(this, e6, false, 23, 4);
      }, "readFloatBE");
      f9.prototype.readDoubleLE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 8, this.length), Pe3.read(this, e6, true, 52, 8);
      }, "readDoubleLE");
      f9.prototype.readDoubleBE = a6(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || U4(e6, 8, this.length), Pe3.read(this, e6, false, 52, 8);
      }, "readDoubleBE");
      function z6(r6, e6, t6, n7, i8, s10) {
        if (!f9.isBuffer(
          r6
        )) throw new TypeError('"buffer" argument must be a Buffer instance');
        if (e6 > i8 || e6 < s10) throw new RangeError('"value" argument is out of bounds');
        if (t6 + n7 > r6.length) throw new RangeError(
          "Index out of range"
        );
      }
      a6(z6, "checkInt");
      f9.prototype.writeUintLE = f9.prototype.writeUIntLE = a6(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, n7 = n7 >>> 0, !i8) {
          let u7 = Math.pow(2, 8 * n7) - 1;
          z6(
            this,
            e6,
            t6,
            n7,
            u7,
            0
          );
        }
        let s10 = 1, o9 = 0;
        for (this[t6] = e6 & 255; ++o9 < n7 && (s10 *= 256); ) this[t6 + o9] = e6 / s10 & 255;
        return t6 + n7;
      }, "writeUIntLE");
      f9.prototype.writeUintBE = f9.prototype.writeUIntBE = a6(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, n7 = n7 >>> 0, !i8) {
          let u7 = Math.pow(2, 8 * n7) - 1;
          z6(this, e6, t6, n7, u7, 0);
        }
        let s10 = n7 - 1, o9 = 1;
        for (this[t6 + s10] = e6 & 255; --s10 >= 0 && (o9 *= 256); ) this[t6 + s10] = e6 / o9 & 255;
        return t6 + n7;
      }, "writeUIntBE");
      f9.prototype.writeUint8 = f9.prototype.writeUInt8 = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(this, e6, t6, 1, 255, 0), this[t6] = e6 & 255, t6 + 1;
      }, "writeUInt8");
      f9.prototype.writeUint16LE = f9.prototype.writeUInt16LE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(
          this,
          e6,
          t6,
          2,
          65535,
          0
        ), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, t6 + 2;
      }, "writeUInt16LE");
      f9.prototype.writeUint16BE = f9.prototype.writeUInt16BE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(
          this,
          e6,
          t6,
          2,
          65535,
          0
        ), this[t6] = e6 >>> 8, this[t6 + 1] = e6 & 255, t6 + 2;
      }, "writeUInt16BE");
      f9.prototype.writeUint32LE = f9.prototype.writeUInt32LE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(
          this,
          e6,
          t6,
          4,
          4294967295,
          0
        ), this[t6 + 3] = e6 >>> 24, this[t6 + 2] = e6 >>> 16, this[t6 + 1] = e6 >>> 8, this[t6] = e6 & 255, t6 + 4;
      }, "writeUInt32LE");
      f9.prototype.writeUint32BE = f9.prototype.writeUInt32BE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(this, e6, t6, 4, 4294967295, 0), this[t6] = e6 >>> 24, this[t6 + 1] = e6 >>> 16, this[t6 + 2] = e6 >>> 8, this[t6 + 3] = e6 & 255, t6 + 4;
      }, "writeUInt32BE");
      function Un2(r6, e6, t6, n7, i8) {
        jn2(
          e6,
          n7,
          i8,
          r6,
          t6,
          7
        );
        let s10 = Number(e6 & BigInt(4294967295));
        r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10;
        let o9 = Number(e6 >> BigInt(32) & BigInt(4294967295));
        return r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, t6;
      }
      a6(Un2, "wrtBigUInt64LE");
      function qn2(r6, e6, t6, n7, i8) {
        jn2(e6, n7, i8, r6, t6, 7);
        let s10 = Number(e6 & BigInt(4294967295));
        r6[t6 + 7] = s10, s10 = s10 >> 8, r6[t6 + 6] = s10, s10 = s10 >> 8, r6[t6 + 5] = s10, s10 = s10 >> 8, r6[t6 + 4] = s10;
        let o9 = Number(e6 >> BigInt(32) & BigInt(4294967295));
        return r6[t6 + 3] = o9, o9 = o9 >> 8, r6[t6 + 2] = o9, o9 = o9 >> 8, r6[t6 + 1] = o9, o9 = o9 >> 8, r6[t6] = o9, t6 + 8;
      }
      a6(qn2, "wrtBigUInt64BE");
      f9.prototype.writeBigUInt64LE = me2(a6(function(e6, t6 = 0) {
        return Un2(this, e6, t6, BigInt(0), BigInt(
          "0xffffffffffffffff"
        ));
      }, "writeBigUInt64LE"));
      f9.prototype.writeBigUInt64BE = me2(a6(function(e6, t6 = 0) {
        return qn2(this, e6, t6, BigInt(0), BigInt("0xffffffffffffffff"));
      }, "writeBigUInt64BE"));
      f9.prototype.writeIntLE = a6(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, !i8) {
          let c6 = Math.pow(
            2,
            8 * n7 - 1
          );
          z6(this, e6, t6, n7, c6 - 1, -c6);
        }
        let s10 = 0, o9 = 1, u7 = 0;
        for (this[t6] = e6 & 255; ++s10 < n7 && (o9 *= 256); ) e6 < 0 && u7 === 0 && this[t6 + s10 - 1] !== 0 && (u7 = 1), this[t6 + s10] = (e6 / o9 >> 0) - u7 & 255;
        return t6 + n7;
      }, "writeIntLE");
      f9.prototype.writeIntBE = a6(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, !i8) {
          let c6 = Math.pow(
            2,
            8 * n7 - 1
          );
          z6(this, e6, t6, n7, c6 - 1, -c6);
        }
        let s10 = n7 - 1, o9 = 1, u7 = 0;
        for (this[t6 + s10] = e6 & 255; --s10 >= 0 && (o9 *= 256); ) e6 < 0 && u7 === 0 && this[t6 + s10 + 1] !== 0 && (u7 = 1), this[t6 + s10] = (e6 / o9 >> 0) - u7 & 255;
        return t6 + n7;
      }, "writeIntBE");
      f9.prototype.writeInt8 = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(
          this,
          e6,
          t6,
          1,
          127,
          -128
        ), e6 < 0 && (e6 = 255 + e6 + 1), this[t6] = e6 & 255, t6 + 1;
      }, "writeInt8");
      f9.prototype.writeInt16LE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(this, e6, t6, 2, 32767, -32768), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, t6 + 2;
      }, "writeInt16LE");
      f9.prototype.writeInt16BE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(this, e6, t6, 2, 32767, -32768), this[t6] = e6 >>> 8, this[t6 + 1] = e6 & 255, t6 + 2;
      }, "writeInt16BE");
      f9.prototype.writeInt32LE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(this, e6, t6, 4, 2147483647, -2147483648), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, this[t6 + 2] = e6 >>> 16, this[t6 + 3] = e6 >>> 24, t6 + 4;
      }, "writeInt32LE");
      f9.prototype.writeInt32BE = a6(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || z6(this, e6, t6, 4, 2147483647, -2147483648), e6 < 0 && (e6 = 4294967295 + e6 + 1), this[t6] = e6 >>> 24, this[t6 + 1] = e6 >>> 16, this[t6 + 2] = e6 >>> 8, this[t6 + 3] = e6 & 255, t6 + 4;
      }, "writeInt32BE");
      f9.prototype.writeBigInt64LE = me2(a6(function(e6, t6 = 0) {
        return Un2(this, e6, t6, -BigInt(
          "0x8000000000000000"
        ), BigInt("0x7fffffffffffffff"));
      }, "writeBigInt64LE"));
      f9.prototype.writeBigInt64BE = me2(a6(function(e6, t6 = 0) {
        return qn2(this, e6, t6, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
      }, "writeBigInt64BE"));
      function Nn2(r6, e6, t6, n7, i8, s10) {
        if (t6 + n7 > r6.length) throw new RangeError("Index out of range");
        if (t6 < 0) throw new RangeError(
          "Index out of range"
        );
      }
      a6(Nn2, "checkIEEE754");
      function Qn2(r6, e6, t6, n7, i8) {
        return e6 = +e6, t6 = t6 >>> 0, i8 || Nn2(r6, e6, t6, 4, 34028234663852886e22, -34028234663852886e22), Pe3.write(
          r6,
          e6,
          t6,
          n7,
          23,
          4
        ), t6 + 4;
      }
      a6(Qn2, "writeFloat");
      f9.prototype.writeFloatLE = a6(function(e6, t6, n7) {
        return Qn2(
          this,
          e6,
          t6,
          true,
          n7
        );
      }, "writeFloatLE");
      f9.prototype.writeFloatBE = a6(function(e6, t6, n7) {
        return Qn2(
          this,
          e6,
          t6,
          false,
          n7
        );
      }, "writeFloatBE");
      function Wn2(r6, e6, t6, n7, i8) {
        return e6 = +e6, t6 = t6 >>> 0, i8 || Nn2(
          r6,
          e6,
          t6,
          8,
          17976931348623157e292,
          -17976931348623157e292
        ), Pe3.write(r6, e6, t6, n7, 52, 8), t6 + 8;
      }
      a6(Wn2, "writeDouble");
      f9.prototype.writeDoubleLE = a6(function(e6, t6, n7) {
        return Wn2(
          this,
          e6,
          t6,
          true,
          n7
        );
      }, "writeDoubleLE");
      f9.prototype.writeDoubleBE = a6(function(e6, t6, n7) {
        return Wn2(
          this,
          e6,
          t6,
          false,
          n7
        );
      }, "writeDoubleBE");
      f9.prototype.copy = a6(function(e6, t6, n7, i8) {
        if (!f9.isBuffer(
          e6
        )) throw new TypeError("argument should be a Buffer");
        if (n7 || (n7 = 0), !i8 && i8 !== 0 && (i8 = this.length), t6 >= e6.length && (t6 = e6.length), t6 || (t6 = 0), i8 > 0 && i8 < n7 && (i8 = n7), i8 === n7 || e6.length === 0 || this.length === 0) return 0;
        if (t6 < 0) throw new RangeError("targetStart out of bounds");
        if (n7 < 0 || n7 >= this.length) throw new RangeError("Index out of range");
        if (i8 < 0) throw new RangeError(
          "sourceEnd out of bounds"
        );
        i8 > this.length && (i8 = this.length), e6.length - t6 < i8 - n7 && (i8 = e6.length - t6 + n7);
        let s10 = i8 - n7;
        return this === e6 && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(t6, n7, i8) : Uint8Array.prototype.set.call(e6, this.subarray(n7, i8), t6), s10;
      }, "copy");
      f9.prototype.fill = a6(function(e6, t6, n7, i8) {
        if (typeof e6 == "string") {
          if (typeof t6 == "string" ? (i8 = t6, t6 = 0, n7 = this.length) : typeof n7 == "string" && (i8 = n7, n7 = this.length), i8 !== void 0 && typeof i8 != "string") throw new TypeError("encoding must be a string");
          if (typeof i8 == "string" && !f9.isEncoding(i8)) throw new TypeError("Unknown encoding: " + i8);
          if (e6.length === 1) {
            let o9 = e6.charCodeAt(0);
            (i8 === "utf8" && o9 < 128 || i8 === "latin1") && (e6 = o9);
          }
        } else typeof e6 == "number" ? e6 = e6 & 255 : typeof e6 == "boolean" && (e6 = Number(e6));
        if (t6 < 0 || this.length < t6 || this.length < n7) throw new RangeError("Out of range index");
        if (n7 <= t6) return this;
        t6 = t6 >>> 0, n7 = n7 === void 0 ? this.length : n7 >>> 0, e6 || (e6 = 0);
        let s10;
        if (typeof e6 == "number") for (s10 = t6; s10 < n7; ++s10)
          this[s10] = e6;
        else {
          let o9 = f9.isBuffer(e6) ? e6 : f9.from(e6, i8), u7 = o9.length;
          if (u7 === 0) throw new TypeError(
            'The value "' + e6 + '" is invalid for argument "value"'
          );
          for (s10 = 0; s10 < n7 - t6; ++s10) this[s10 + t6] = o9[s10 % u7];
        }
        return this;
      }, "fill");
      var Te4 = {};
      function Dt2(r6, e6, t6) {
        var n7;
        Te4[r6] = (n7 = class extends t6 {
          constructor() {
            super(), Object.defineProperty(this, "message", {
              value: e6.apply(this, arguments),
              writable: true,
              configurable: true
            }), this.name = `${this.name} [${r6}]`, this.stack, delete this.name;
          }
          get code() {
            return r6;
          }
          set code(s10) {
            Object.defineProperty(this, "code", {
              configurable: true,
              enumerable: true,
              value: s10,
              writable: true
            });
          }
          toString() {
            return `${this.name} [${r6}]: ${this.message}`;
          }
        }, a6(n7, "NodeError"), n7);
      }
      a6(Dt2, "E");
      Dt2("ERR_BUFFER_OUT_OF_BOUNDS", function(r6) {
        return r6 ? `${r6} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
      }, RangeError);
      Dt2("ERR_INVALID_ARG_TYPE", function(r6, e6) {
        return `The "${r6}" argument must be of type number. Received type ${typeof e6}`;
      }, TypeError);
      Dt2("ERR_OUT_OF_RANGE", function(r6, e6, t6) {
        let n7 = `The value of "${r6}" is out of range.`, i8 = t6;
        return Number.isInteger(t6) && Math.abs(t6) > 2 ** 32 ? i8 = Rn2(String(t6)) : typeof t6 == "bigint" && (i8 = String(t6), (t6 > BigInt(2) ** BigInt(32) || t6 < -(BigInt(2) ** BigInt(32))) && (i8 = Rn2(i8)), i8 += "n"), n7 += ` It must be ${e6}. Received ${i8}`, n7;
      }, RangeError);
      function Rn2(r6) {
        let e6 = "", t6 = r6.length, n7 = r6[0] === "-" ? 1 : 0;
        for (; t6 >= n7 + 4; t6 -= 3) e6 = `_${r6.slice(t6 - 3, t6)}${e6}`;
        return `${r6.slice(
          0,
          t6
        )}${e6}`;
      }
      a6(Rn2, "addNumericalSeparator");
      function Lo(r6, e6, t6) {
        Be2(e6, "offset"), (r6[e6] === void 0 || r6[e6 + t6] === void 0) && je4(e6, r6.length - (t6 + 1));
      }
      a6(Lo, "checkBounds");
      function jn2(r6, e6, t6, n7, i8, s10) {
        if (r6 > t6 || r6 < e6) {
          let o9 = typeof e6 == "bigint" ? "n" : "", u7;
          throw s10 > 3 ? e6 === 0 || e6 === BigInt(0) ? u7 = `>= 0${o9} and < 2${o9} ** ${(s10 + 1) * 8}${o9}` : u7 = `>= -(2${o9} ** ${(s10 + 1) * 8 - 1}${o9}) and < 2 ** ${(s10 + 1) * 8 - 1}${o9}` : u7 = `>= ${e6}${o9} and <= ${t6}${o9}`, new Te4.ERR_OUT_OF_RANGE(
            "value",
            u7,
            r6
          );
        }
        Lo(n7, i8, s10);
      }
      a6(jn2, "checkIntBI");
      function Be2(r6, e6) {
        if (typeof r6 != "number")
          throw new Te4.ERR_INVALID_ARG_TYPE(e6, "number", r6);
      }
      a6(Be2, "validateNumber");
      function je4(r6, e6, t6) {
        throw Math.floor(r6) !== r6 ? (Be2(r6, t6), new Te4.ERR_OUT_OF_RANGE(
          t6 || "offset",
          "an integer",
          r6
        )) : e6 < 0 ? new Te4.ERR_BUFFER_OUT_OF_BOUNDS() : new Te4.ERR_OUT_OF_RANGE(t6 || "offset", `>= ${t6 ? 1 : 0} and <= ${e6}`, r6);
      }
      a6(je4, "boundsError");
      var Ro = /[^+/0-9A-Za-z-_]/g;
      function Fo(r6) {
        if (r6 = r6.split("=")[0], r6 = r6.trim().replace(Ro, ""), r6.length < 2) return "";
        for (; r6.length % 4 !== 0; ) r6 = r6 + "=";
        return r6;
      }
      a6(Fo, "base64clean");
      function Rt2(r6, e6) {
        e6 = e6 || 1 / 0;
        let t6, n7 = r6.length, i8 = null, s10 = [];
        for (let o9 = 0; o9 < n7; ++o9) {
          if (t6 = r6.charCodeAt(o9), t6 > 55295 && t6 < 57344) {
            if (!i8) {
              if (t6 > 56319) {
                (e6 -= 3) > -1 && s10.push(239, 191, 189);
                continue;
              } else if (o9 + 1 === n7) {
                (e6 -= 3) > -1 && s10.push(239, 191, 189);
                continue;
              }
              i8 = t6;
              continue;
            }
            if (t6 < 56320) {
              (e6 -= 3) > -1 && s10.push(
                239,
                191,
                189
              ), i8 = t6;
              continue;
            }
            t6 = (i8 - 55296 << 10 | t6 - 56320) + 65536;
          } else i8 && (e6 -= 3) > -1 && s10.push(
            239,
            191,
            189
          );
          if (i8 = null, t6 < 128) {
            if ((e6 -= 1) < 0) break;
            s10.push(t6);
          } else if (t6 < 2048) {
            if ((e6 -= 2) < 0) break;
            s10.push(t6 >> 6 | 192, t6 & 63 | 128);
          } else if (t6 < 65536) {
            if ((e6 -= 3) < 0) break;
            s10.push(t6 >> 12 | 224, t6 >> 6 & 63 | 128, t6 & 63 | 128);
          } else if (t6 < 1114112) {
            if ((e6 -= 4) < 0) break;
            s10.push(t6 >> 18 | 240, t6 >> 12 & 63 | 128, t6 >> 6 & 63 | 128, t6 & 63 | 128);
          } else throw new Error("Invalid code point");
        }
        return s10;
      }
      a6(
        Rt2,
        "utf8ToBytes"
      );
      function Mo(r6) {
        let e6 = [];
        for (let t6 = 0; t6 < r6.length; ++t6) e6.push(r6.charCodeAt(
          t6
        ) & 255);
        return e6;
      }
      a6(Mo, "asciiToBytes");
      function Do(r6, e6) {
        let t6, n7, i8, s10 = [];
        for (let o9 = 0; o9 < r6.length && !((e6 -= 2) < 0); ++o9) t6 = r6.charCodeAt(o9), n7 = t6 >> 8, i8 = t6 % 256, s10.push(i8), s10.push(n7);
        return s10;
      }
      a6(Do, "utf16leToBytes");
      function Hn2(r6) {
        return Pt3.toByteArray(Fo(r6));
      }
      a6(Hn2, "base64ToBytes");
      function ot2(r6, e6, t6, n7) {
        let i8;
        for (i8 = 0; i8 < n7 && !(i8 + t6 >= e6.length || i8 >= r6.length); ++i8)
          e6[i8 + t6] = r6[i8];
        return i8;
      }
      a6(ot2, "blitBuffer");
      function ae(r6, e6) {
        return r6 instanceof e6 || r6 != null && r6.constructor != null && r6.constructor.name != null && r6.constructor.name === e6.name;
      }
      a6(ae, "isInstance");
      function Ot2(r6) {
        return r6 !== r6;
      }
      a6(Ot2, "numberIsNaN");
      var Oo = function() {
        let r6 = "0123456789abcdef", e6 = new Array(256);
        for (let t6 = 0; t6 < 16; ++t6) {
          let n7 = t6 * 16;
          for (let i8 = 0; i8 < 16; ++i8) e6[n7 + i8] = r6[t6] + r6[i8];
        }
        return e6;
      }();
      function me2(r6) {
        return typeof BigInt > "u" ? ko : r6;
      }
      a6(me2, "defineBigIntMethod");
      function ko() {
        throw new Error("BigInt not supported");
      }
      a6(ko, "BufferBigIntNotDefined");
    });
    p8 = K3(() => {
      "use strict";
      b8 = globalThis, S4 = globalThis.setImmediate ?? ((r6) => setTimeout(
        r6,
        0
      )), v8 = globalThis.clearImmediate ?? ((r6) => clearTimeout(r6)), w9 = globalThis.crypto ?? {};
      w9.subtle ?? (w9.subtle = {});
      d6 = typeof globalThis.Buffer == "function" && typeof globalThis.Buffer.allocUnsafe == "function" ? globalThis.Buffer : Gn2().Buffer, m9 = globalThis.process ?? {};
      m9.env ?? (m9.env = {});
      try {
        m9.nextTick(() => {
        });
      } catch {
        let e6 = Promise.resolve();
        m9.nextTick = e6.then.bind(e6);
      }
    });
    ge3 = I4((Jc, kt2) => {
      "use strict";
      p8();
      var Re3 = typeof Reflect == "object" ? Reflect : null, $n2 = Re3 && typeof Re3.apply == "function" ? Re3.apply : a6(function(e6, t6, n7) {
        return Function.prototype.apply.call(e6, t6, n7);
      }, "ReflectApply"), at2;
      Re3 && typeof Re3.ownKeys == "function" ? at2 = Re3.ownKeys : Object.getOwnPropertySymbols ? at2 = a6(function(e6) {
        return Object.getOwnPropertyNames(
          e6
        ).concat(Object.getOwnPropertySymbols(e6));
      }, "ReflectOwnKeys") : at2 = a6(function(e6) {
        return Object.getOwnPropertyNames(e6);
      }, "ReflectOwnKeys");
      function Uo(r6) {
        console && console.warn && console.warn(r6);
      }
      a6(Uo, "ProcessEmitWarning");
      var Vn3 = Number.isNaN || a6(function(e6) {
        return e6 !== e6;
      }, "NumberIsNaN");
      function B3() {
        B3.init.call(this);
      }
      a6(B3, "EventEmitter");
      kt2.exports = B3;
      kt2.exports.once = Wo;
      B3.EventEmitter = B3;
      B3.prototype._events = void 0;
      B3.prototype._eventsCount = 0;
      B3.prototype._maxListeners = void 0;
      var Kn = 10;
      function ut2(r6) {
        if (typeof r6 != "function") throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof r6);
      }
      a6(ut2, "checkListener");
      Object.defineProperty(B3, "defaultMaxListeners", { enumerable: true, get: function() {
        return Kn;
      }, set: function(r6) {
        if (typeof r6 != "number" || r6 < 0 || Vn3(r6)) throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + r6 + ".");
        Kn = r6;
      } });
      B3.init = function() {
        (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
      };
      B3.prototype.setMaxListeners = a6(function(e6) {
        if (typeof e6 != "number" || e6 < 0 || Vn3(
          e6
        )) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + e6 + ".");
        return this._maxListeners = e6, this;
      }, "setMaxListeners");
      function zn2(r6) {
        return r6._maxListeners === void 0 ? B3.defaultMaxListeners : r6._maxListeners;
      }
      a6(zn2, "_getMaxListeners");
      B3.prototype.getMaxListeners = a6(
        function() {
          return zn2(this);
        },
        "getMaxListeners"
      );
      B3.prototype.emit = a6(function(e6) {
        for (var t6 = [], n7 = 1; n7 < arguments.length; n7++)
          t6.push(arguments[n7]);
        var i8 = e6 === "error", s10 = this._events;
        if (s10 !== void 0) i8 = i8 && s10.error === void 0;
        else if (!i8) return false;
        if (i8) {
          var o9;
          if (t6.length > 0 && (o9 = t6[0]), o9 instanceof Error)
            throw o9;
          var u7 = new Error("Unhandled error." + (o9 ? " (" + o9.message + ")" : ""));
          throw u7.context = o9, u7;
        }
        var c6 = s10[e6];
        if (c6 === void 0) return false;
        if (typeof c6 == "function") $n2(c6, this, t6);
        else for (var h8 = c6.length, l7 = ei(c6, h8), n7 = 0; n7 < h8; ++n7) $n2(l7[n7], this, t6);
        return true;
      }, "emit");
      function Yn(r6, e6, t6, n7) {
        var i8, s10, o9;
        if (ut2(t6), s10 = r6._events, s10 === void 0 ? (s10 = r6._events = /* @__PURE__ */ Object.create(null), r6._eventsCount = 0) : (s10.newListener !== void 0 && (r6.emit("newListener", e6, t6.listener ? t6.listener : t6), s10 = r6._events), o9 = s10[e6]), o9 === void 0) o9 = s10[e6] = t6, ++r6._eventsCount;
        else if (typeof o9 == "function" ? o9 = s10[e6] = n7 ? [t6, o9] : [o9, t6] : n7 ? o9.unshift(t6) : o9.push(t6), i8 = zn2(r6), i8 > 0 && o9.length > i8 && !o9.warned) {
          o9.warned = true;
          var u7 = new Error("Possible EventEmitter memory leak detected. " + o9.length + " " + String(e6) + " listeners added. Use emitter.setMaxListeners() to increase limit");
          u7.name = "MaxListenersExceededWarning", u7.emitter = r6, u7.type = e6, u7.count = o9.length, Uo(u7);
        }
        return r6;
      }
      a6(Yn, "_addListener");
      B3.prototype.addListener = a6(function(e6, t6) {
        return Yn(
          this,
          e6,
          t6,
          false
        );
      }, "addListener");
      B3.prototype.on = B3.prototype.addListener;
      B3.prototype.prependListener = a6(function(e6, t6) {
        return Yn(this, e6, t6, true);
      }, "prependListener");
      function qo() {
        if (!this.fired) return this.target.removeListener(this.type, this.wrapFn), this.fired = true, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
      }
      a6(qo, "onceWrapper");
      function Zn(r6, e6, t6) {
        var n7 = {
          fired: false,
          wrapFn: void 0,
          target: r6,
          type: e6,
          listener: t6
        }, i8 = qo.bind(n7);
        return i8.listener = t6, n7.wrapFn = i8, i8;
      }
      a6(Zn, "_onceWrap");
      B3.prototype.once = a6(function(e6, t6) {
        return ut2(t6), this.on(e6, Zn(this, e6, t6)), this;
      }, "once");
      B3.prototype.prependOnceListener = a6(function(e6, t6) {
        return ut2(t6), this.prependListener(e6, Zn(this, e6, t6)), this;
      }, "prependOnceListener");
      B3.prototype.removeListener = a6(function(e6, t6) {
        var n7, i8, s10, o9, u7;
        if (ut2(t6), i8 = this._events, i8 === void 0) return this;
        if (n7 = i8[e6], n7 === void 0) return this;
        if (n7 === t6 || n7.listener === t6) --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i8[e6], i8.removeListener && this.emit("removeListener", e6, n7.listener || t6));
        else if (typeof n7 != "function") {
          for (s10 = -1, o9 = n7.length - 1; o9 >= 0; o9--)
            if (n7[o9] === t6 || n7[o9].listener === t6) {
              u7 = n7[o9].listener, s10 = o9;
              break;
            }
          if (s10 < 0) return this;
          s10 === 0 ? n7.shift() : No(n7, s10), n7.length === 1 && (i8[e6] = n7[0]), i8.removeListener !== void 0 && this.emit(
            "removeListener",
            e6,
            u7 || t6
          );
        }
        return this;
      }, "removeListener");
      B3.prototype.off = B3.prototype.removeListener;
      B3.prototype.removeAllListeners = a6(function(e6) {
        var t6, n7, i8;
        if (n7 = this._events, n7 === void 0) return this;
        if (n7.removeListener === void 0) return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : n7[e6] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete n7[e6]), this;
        if (arguments.length === 0) {
          var s10 = Object.keys(n7), o9;
          for (i8 = 0; i8 < s10.length; ++i8) o9 = s10[i8], o9 !== "removeListener" && this.removeAllListeners(o9);
          return this.removeAllListeners("removeListener"), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
        }
        if (t6 = n7[e6], typeof t6 == "function") this.removeListener(e6, t6);
        else if (t6 !== void 0) for (i8 = t6.length - 1; i8 >= 0; i8--) this.removeListener(e6, t6[i8]);
        return this;
      }, "removeAllListeners");
      function Jn(r6, e6, t6) {
        var n7 = r6._events;
        if (n7 === void 0) return [];
        var i8 = n7[e6];
        return i8 === void 0 ? [] : typeof i8 == "function" ? t6 ? [i8.listener || i8] : [i8] : t6 ? Qo(i8) : ei(i8, i8.length);
      }
      a6(Jn, "_listeners");
      B3.prototype.listeners = a6(function(e6) {
        return Jn(this, e6, true);
      }, "listeners");
      B3.prototype.rawListeners = a6(function(e6) {
        return Jn(this, e6, false);
      }, "rawListeners");
      B3.listenerCount = function(r6, e6) {
        return typeof r6.listenerCount == "function" ? r6.listenerCount(e6) : Xn.call(r6, e6);
      };
      B3.prototype.listenerCount = Xn;
      function Xn(r6) {
        var e6 = this._events;
        if (e6 !== void 0) {
          var t6 = e6[r6];
          if (typeof t6 == "function") return 1;
          if (t6 !== void 0) return t6.length;
        }
        return 0;
      }
      a6(Xn, "listenerCount");
      B3.prototype.eventNames = a6(function() {
        return this._eventsCount > 0 ? at2(this._events) : [];
      }, "eventNames");
      function ei(r6, e6) {
        for (var t6 = new Array(e6), n7 = 0; n7 < e6; ++n7) t6[n7] = r6[n7];
        return t6;
      }
      a6(ei, "arrayClone");
      function No(r6, e6) {
        for (; e6 + 1 < r6.length; e6++) r6[e6] = r6[e6 + 1];
        r6.pop();
      }
      a6(No, "spliceOne");
      function Qo(r6) {
        for (var e6 = new Array(r6.length), t6 = 0; t6 < e6.length; ++t6)
          e6[t6] = r6[t6].listener || r6[t6];
        return e6;
      }
      a6(Qo, "unwrapListeners");
      function Wo(r6, e6) {
        return new Promise(
          function(t6, n7) {
            function i8(o9) {
              r6.removeListener(e6, s10), n7(o9);
            }
            a6(i8, "errorListener");
            function s10() {
              typeof r6.removeListener == "function" && r6.removeListener("error", i8), t6([].slice.call(
                arguments
              ));
            }
            a6(s10, "resolver"), ti(r6, e6, s10, { once: true }), e6 !== "error" && jo(r6, i8, { once: true });
          }
        );
      }
      a6(Wo, "once");
      function jo(r6, e6, t6) {
        typeof r6.on == "function" && ti(r6, "error", e6, t6);
      }
      a6(
        jo,
        "addErrorHandlerIfEventEmitter"
      );
      function ti(r6, e6, t6, n7) {
        if (typeof r6.on == "function")
          n7.once ? r6.once(e6, t6) : r6.on(e6, t6);
        else if (typeof r6.addEventListener == "function") r6.addEventListener(
          e6,
          a6(function i8(s10) {
            n7.once && r6.removeEventListener(e6, i8), t6(s10);
          }, "wrapListener")
        );
        else
          throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof r6);
      }
      a6(ti, "eventTargetAgnosticAddListener");
    });
    He2 = {};
    X3(He2, { default: () => Ho });
    Ge2 = K3(() => {
      "use strict";
      p8();
      Ho = {};
    });
    ri = K3(
      () => {
        "use strict";
        p8();
        a6($e2, "sha256");
      }
    );
    ni = K3(() => {
      "use strict";
      p8();
      O4 = class O6 {
        constructor() {
          T3(
            this,
            "_dataLength",
            0
          );
          T3(this, "_bufferLength", 0);
          T3(this, "_state", new Int32Array(4));
          T3(
            this,
            "_buffer",
            new ArrayBuffer(68)
          );
          T3(this, "_buffer8");
          T3(this, "_buffer32");
          this._buffer8 = new Uint8Array(
            this._buffer,
            0,
            68
          ), this._buffer32 = new Uint32Array(this._buffer, 0, 17), this.start();
        }
        static hashByteArray(e6, t6 = false) {
          return this.onePassHasher.start().appendByteArray(e6).end(t6);
        }
        static hashStr(e6, t6 = false) {
          return this.onePassHasher.start().appendStr(e6).end(t6);
        }
        static hashAsciiStr(e6, t6 = false) {
          return this.onePassHasher.start().appendAsciiStr(e6).end(t6);
        }
        static _hex(e6) {
          let t6 = O6.hexChars, n7 = O6.hexOut, i8, s10, o9, u7;
          for (u7 = 0; u7 < 4; u7 += 1) for (s10 = u7 * 8, i8 = e6[u7], o9 = 0; o9 < 8; o9 += 2) n7[s10 + 1 + o9] = t6.charAt(i8 & 15), i8 >>>= 4, n7[s10 + 0 + o9] = t6.charAt(i8 & 15), i8 >>>= 4;
          return n7.join("");
        }
        static _md5cycle(e6, t6) {
          let n7 = e6[0], i8 = e6[1], s10 = e6[2], o9 = e6[3];
          n7 += (i8 & s10 | ~i8 & o9) + t6[0] - 680876936 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[1] - 389564586 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[2] + 606105819 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[3] - 1044525330 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[4] - 176418897 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[5] + 1200080426 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[6] - 1473231341 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[7] - 45705983 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[8] + 1770035416 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[9] - 1958414417 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[10] - 42063 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[11] - 1990404162 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[12] + 1804603682 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[13] - 40341101 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[14] - 1502002290 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[15] + 1236535329 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[1] - 165796510 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[6] - 1069501632 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[11] + 643717713 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[0] - 373897302 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[5] - 701558691 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[10] + 38016083 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[15] - 660478335 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[4] - 405537848 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[9] + 568446438 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[14] - 1019803690 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[3] - 187363961 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[8] + 1163531501 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[13] - 1444681467 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[2] - 51403784 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[7] + 1735328473 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[12] - 1926607734 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[5] - 378558 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[8] - 2022574463 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[11] + 1839030562 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[14] - 35309556 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[1] - 1530992060 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[4] + 1272893353 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[7] - 155497632 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[10] - 1094730640 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[13] + 681279174 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[0] - 358537222 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[3] - 722521979 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[6] + 76029189 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[9] - 640364487 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[12] - 421815835 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[15] + 530742520 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[2] - 995338651 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[0] - 198630844 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[7] + 1126891415 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[14] - 1416354905 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[5] - 57434055 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[12] + 1700485571 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[3] - 1894986606 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[10] - 1051523 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[1] - 2054922799 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[8] + 1873313359 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[15] - 30611744 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[6] - 1560198380 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[13] + 1309151649 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[4] - 145523070 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[11] - 1120210379 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[2] + 718787259 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[9] - 343485551 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, e6[0] = n7 + e6[0] | 0, e6[1] = i8 + e6[1] | 0, e6[2] = s10 + e6[2] | 0, e6[3] = o9 + e6[3] | 0;
        }
        start() {
          return this._dataLength = 0, this._bufferLength = 0, this._state.set(O6.stateIdentity), this;
        }
        appendStr(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9;
          for (o9 = 0; o9 < e6.length; o9 += 1) {
            if (s10 = e6.charCodeAt(o9), s10 < 128) t6[i8++] = s10;
            else if (s10 < 2048) t6[i8++] = (s10 >>> 6) + 192, t6[i8++] = s10 & 63 | 128;
            else if (s10 < 55296 || s10 > 56319) t6[i8++] = (s10 >>> 12) + 224, t6[i8++] = s10 >>> 6 & 63 | 128, t6[i8++] = s10 & 63 | 128;
            else {
              if (s10 = (s10 - 55296) * 1024 + (e6.charCodeAt(++o9) - 56320) + 65536, s10 > 1114111) throw new Error("Unicode standard supports code points up to U+10FFFF");
              t6[i8++] = (s10 >>> 18) + 240, t6[i8++] = s10 >>> 12 & 63 | 128, t6[i8++] = s10 >>> 6 & 63 | 128, t6[i8++] = s10 & 63 | 128;
            }
            i8 >= 64 && (this._dataLength += 64, O6._md5cycle(this._state, n7), i8 -= 64, n7[0] = n7[16]);
          }
          return this._bufferLength = i8, this;
        }
        appendAsciiStr(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9 = 0;
          for (; ; ) {
            for (s10 = Math.min(e6.length - o9, 64 - i8); s10--; ) t6[i8++] = e6.charCodeAt(o9++);
            if (i8 < 64) break;
            this._dataLength += 64, O6._md5cycle(
              this._state,
              n7
            ), i8 = 0;
          }
          return this._bufferLength = i8, this;
        }
        appendByteArray(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9 = 0;
          for (; ; ) {
            for (s10 = Math.min(e6.length - o9, 64 - i8); s10--; ) t6[i8++] = e6[o9++];
            if (i8 < 64) break;
            this._dataLength += 64, O6._md5cycle(
              this._state,
              n7
            ), i8 = 0;
          }
          return this._bufferLength = i8, this;
        }
        getState() {
          let e6 = this._state;
          return { buffer: String.fromCharCode.apply(null, Array.from(this._buffer8)), buflen: this._bufferLength, length: this._dataLength, state: [e6[0], e6[1], e6[2], e6[3]] };
        }
        setState(e6) {
          let t6 = e6.buffer, n7 = e6.state, i8 = this._state, s10;
          for (this._dataLength = e6.length, this._bufferLength = e6.buflen, i8[0] = n7[0], i8[1] = n7[1], i8[2] = n7[2], i8[3] = n7[3], s10 = 0; s10 < t6.length; s10 += 1) this._buffer8[s10] = t6.charCodeAt(s10);
        }
        end(e6 = false) {
          let t6 = this._bufferLength, n7 = this._buffer8, i8 = this._buffer32, s10 = (t6 >> 2) + 1;
          this._dataLength += t6;
          let o9 = this._dataLength * 8;
          if (n7[t6] = 128, n7[t6 + 1] = n7[t6 + 2] = n7[t6 + 3] = 0, i8.set(O6.buffer32Identity.subarray(s10), s10), t6 > 55 && (O6._md5cycle(this._state, i8), i8.set(O6.buffer32Identity)), o9 <= 4294967295)
            i8[14] = o9;
          else {
            let u7 = o9.toString(16).match(/(.*?)(.{0,8})$/);
            if (u7 === null) return;
            let c6 = parseInt(
              u7[2],
              16
            ), h8 = parseInt(u7[1], 16) || 0;
            i8[14] = c6, i8[15] = h8;
          }
          return O6._md5cycle(this._state, i8), e6 ? this._state : O6._hex(this._state);
        }
      };
      a6(O4, "Md5"), T3(O4, "stateIdentity", new Int32Array(
        [1732584193, -271733879, -1732584194, 271733878]
      )), T3(O4, "buffer32Identity", new Int32Array(
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      )), T3(O4, "hexChars", "0123456789abcdef"), T3(O4, "hexOut", []), T3(O4, "onePassHasher", new O4());
      Ke2 = O4;
    });
    Ut2 = {};
    X3(Ut2, { createHash: () => $o, createHmac: () => Ko, randomBytes: () => Go });
    qt2 = K3(() => {
      "use strict";
      p8();
      ri();
      ni();
      a6(Go, "randomBytes");
      a6($o, "createHash");
      a6(Ko, "createHmac");
    });
    Qt2 = I4((ii3) => {
      "use strict";
      p8();
      ii3.parse = function(r6, e6) {
        return new Nt2(r6, e6).parse();
      };
      var ct2 = class ct3 {
        constructor(e6, t6) {
          this.source = e6, this.transform = t6 || Vo2, this.position = 0, this.entries = [], this.recorded = [], this.dimension = 0;
        }
        isEof() {
          return this.position >= this.source.length;
        }
        nextCharacter() {
          var e6 = this.source[this.position++];
          return e6 === "\\" ? { value: this.source[this.position++], escaped: true } : { value: e6, escaped: false };
        }
        record(e6) {
          this.recorded.push(e6);
        }
        newEntry(e6) {
          var t6;
          (this.recorded.length > 0 || e6) && (t6 = this.recorded.join(""), t6 === "NULL" && !e6 && (t6 = null), t6 !== null && (t6 = this.transform(t6)), this.entries.push(
            t6
          ), this.recorded = []);
        }
        consumeDimensions() {
          if (this.source[0] === "[") for (; !this.isEof(); ) {
            var e6 = this.nextCharacter();
            if (e6.value === "=") break;
          }
        }
        parse(e6) {
          var t6, n7, i8;
          for (this.consumeDimensions(); !this.isEof(); ) if (t6 = this.nextCharacter(), t6.value === "{" && !i8) this.dimension++, this.dimension > 1 && (n7 = new ct3(this.source.substr(this.position - 1), this.transform), this.entries.push(
            n7.parse(true)
          ), this.position += n7.position - 2);
          else if (t6.value === "}" && !i8) {
            if (this.dimension--, !this.dimension && (this.newEntry(), e6)) return this.entries;
          } else t6.value === '"' && !t6.escaped ? (i8 && this.newEntry(true), i8 = !i8) : t6.value === "," && !i8 ? this.newEntry() : this.record(
            t6.value
          );
          if (this.dimension !== 0) throw new Error("array dimension not balanced");
          return this.entries;
        }
      };
      a6(ct2, "ArrayParser");
      var Nt2 = ct2;
      function Vo2(r6) {
        return r6;
      }
      a6(Vo2, "identity");
    });
    Wt2 = I4((yh, si2) => {
      p8();
      var zo3 = Qt2();
      si2.exports = { create: function(r6, e6) {
        return { parse: function() {
          return zo3.parse(r6, e6);
        } };
      } };
    });
    ui = I4((gh, ai) => {
      "use strict";
      p8();
      var Yo2 = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/, Zo2 = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/, Jo = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/, Xo = /^-?infinity$/;
      ai.exports = a6(function(e6) {
        if (Xo.test(e6)) return Number(e6.replace("i", "I"));
        var t6 = Yo2.exec(e6);
        if (!t6) return ea(e6) || null;
        var n7 = !!t6[8], i8 = parseInt(t6[1], 10);
        n7 && (i8 = oi(i8));
        var s10 = parseInt(
          t6[2],
          10
        ) - 1, o9 = t6[3], u7 = parseInt(t6[4], 10), c6 = parseInt(t6[5], 10), h8 = parseInt(t6[6], 10), l7 = t6[7];
        l7 = l7 ? 1e3 * parseFloat(l7) : 0;
        var y7, E4 = ta(e6);
        return E4 != null ? (y7 = new Date(Date.UTC(
          i8,
          s10,
          o9,
          u7,
          c6,
          h8,
          l7
        )), jt4(i8) && y7.setUTCFullYear(i8), E4 !== 0 && y7.setTime(y7.getTime() - E4)) : (y7 = new Date(
          i8,
          s10,
          o9,
          u7,
          c6,
          h8,
          l7
        ), jt4(i8) && y7.setFullYear(i8)), y7;
      }, "parseDate");
      function ea(r6) {
        var e6 = Zo2.exec(r6);
        if (e6) {
          var t6 = parseInt(e6[1], 10), n7 = !!e6[4];
          n7 && (t6 = oi(t6));
          var i8 = parseInt(
            e6[2],
            10
          ) - 1, s10 = e6[3], o9 = new Date(t6, i8, s10);
          return jt4(t6) && o9.setFullYear(t6), o9;
        }
      }
      a6(ea, "getDate");
      function ta(r6) {
        if (r6.endsWith("+00")) return 0;
        var e6 = Jo.exec(r6.split(" ")[1]);
        if (e6) {
          var t6 = e6[1];
          if (t6 === "Z") return 0;
          var n7 = t6 === "-" ? -1 : 1, i8 = parseInt(e6[2], 10) * 3600 + parseInt(
            e6[3] || 0,
            10
          ) * 60 + parseInt(e6[4] || 0, 10);
          return i8 * n7 * 1e3;
        }
      }
      a6(ta, "timeZoneOffset");
      function oi(r6) {
        return -(r6 - 1);
      }
      a6(oi, "bcYearToNegativeYear");
      function jt4(r6) {
        return r6 >= 0 && r6 < 100;
      }
      a6(
        jt4,
        "is0To99"
      );
    });
    hi = I4((Sh, ci2) => {
      p8();
      ci2.exports = na;
      var ra = Object.prototype.hasOwnProperty;
      function na(r6) {
        for (var e6 = 1; e6 < arguments.length; e6++) {
          var t6 = arguments[e6];
          for (var n7 in t6) ra.call(
            t6,
            n7
          ) && (r6[n7] = t6[n7]);
        }
        return r6;
      }
      a6(na, "extend");
    });
    pi = I4((vh, fi2) => {
      "use strict";
      p8();
      var ia = hi();
      fi2.exports = Fe2;
      function Fe2(r6) {
        if (!(this instanceof Fe2)) return new Fe2(r6);
        ia(this, ma(r6));
      }
      a6(Fe2, "PostgresInterval");
      var sa = ["seconds", "minutes", "hours", "days", "months", "years"];
      Fe2.prototype.toPostgres = function() {
        var r6 = sa.filter(this.hasOwnProperty, this);
        return this.milliseconds && r6.indexOf("seconds") < 0 && r6.push("seconds"), r6.length === 0 ? "0" : r6.map(function(e6) {
          var t6 = this[e6] || 0;
          return e6 === "seconds" && this.milliseconds && (t6 = (t6 + this.milliseconds / 1e3).toFixed(6).replace(
            /\.?0+$/,
            ""
          )), t6 + " " + e6;
        }, this).join(" ");
      };
      var oa = { years: "Y", months: "M", days: "D", hours: "H", minutes: "M", seconds: "S" }, aa = ["years", "months", "days"], ua = ["hours", "minutes", "seconds"];
      Fe2.prototype.toISOString = Fe2.prototype.toISO = function() {
        var r6 = aa.map(t6, this).join(""), e6 = ua.map(t6, this).join("");
        return "P" + r6 + "T" + e6;
        function t6(n7) {
          var i8 = this[n7] || 0;
          return n7 === "seconds" && this.milliseconds && (i8 = (i8 + this.milliseconds / 1e3).toFixed(6).replace(
            /0+$/,
            ""
          )), i8 + oa[n7];
        }
      };
      var Ht3 = "([+-]?\\d+)", ca = Ht3 + "\\s+years?", ha = Ht3 + "\\s+mons?", la = Ht3 + "\\s+days?", fa = "([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?", pa = new RegExp([
        ca,
        ha,
        la,
        fa
      ].map(function(r6) {
        return "(" + r6 + ")?";
      }).join("\\s*")), li2 = {
        years: 2,
        months: 4,
        days: 6,
        hours: 9,
        minutes: 10,
        seconds: 11,
        milliseconds: 12
      }, da = ["hours", "minutes", "seconds", "milliseconds"];
      function ya(r6) {
        var e6 = r6 + "000000".slice(r6.length);
        return parseInt(
          e6,
          10
        ) / 1e3;
      }
      a6(ya, "parseMilliseconds");
      function ma(r6) {
        if (!r6) return {};
        var e6 = pa.exec(
          r6
        ), t6 = e6[8] === "-";
        return Object.keys(li2).reduce(function(n7, i8) {
          var s10 = li2[i8], o9 = e6[s10];
          return !o9 || (o9 = i8 === "milliseconds" ? ya(o9) : parseInt(o9, 10), !o9) || (t6 && ~da.indexOf(i8) && (o9 *= -1), n7[i8] = o9), n7;
        }, {});
      }
      a6(ma, "parse");
    });
    yi = I4((Ch, di2) => {
      "use strict";
      p8();
      di2.exports = a6(function(e6) {
        if (/^\\x/.test(e6)) return new d6(
          e6.substr(2),
          "hex"
        );
        for (var t6 = "", n7 = 0; n7 < e6.length; ) if (e6[n7] !== "\\") t6 += e6[n7], ++n7;
        else if (/[0-7]{3}/.test(e6.substr(n7 + 1, 3))) t6 += String.fromCharCode(parseInt(e6.substr(n7 + 1, 3), 8)), n7 += 4;
        else {
          for (var i8 = 1; n7 + i8 < e6.length && e6[n7 + i8] === "\\"; ) i8++;
          for (var s10 = 0; s10 < Math.floor(i8 / 2); ++s10) t6 += "\\";
          n7 += Math.floor(i8 / 2) * 2;
        }
        return new d6(t6, "binary");
      }, "parseBytea");
    });
    Ei = I4((Ph, xi) => {
      p8();
      var Ve3 = Qt2(), ze2 = Wt2(), ht2 = ui(), gi2 = pi(), wi = yi();
      function lt3(r6) {
        return a6(function(t6) {
          return t6 === null ? t6 : r6(t6);
        }, "nullAllowed");
      }
      a6(lt3, "allowNull");
      function bi(r6) {
        return r6 === null ? r6 : r6 === "TRUE" || r6 === "t" || r6 === "true" || r6 === "y" || r6 === "yes" || r6 === "on" || r6 === "1";
      }
      a6(bi, "parseBool");
      function ga(r6) {
        return r6 ? Ve3.parse(r6, bi) : null;
      }
      a6(ga, "parseBoolArray");
      function wa(r6) {
        return parseInt(r6, 10);
      }
      a6(wa, "parseBaseTenInt");
      function Gt3(r6) {
        return r6 ? Ve3.parse(r6, lt3(wa)) : null;
      }
      a6(Gt3, "parseIntegerArray");
      function ba(r6) {
        return r6 ? Ve3.parse(r6, lt3(function(e6) {
          return Si(e6).trim();
        })) : null;
      }
      a6(ba, "parseBigIntegerArray");
      var Sa = a6(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = zt2(t6)), t6;
        });
        return e6.parse();
      }, "parsePointArray"), $t3 = a6(function(r6) {
        if (!r6)
          return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = parseFloat(t6)), t6;
        });
        return e6.parse();
      }, "parseFloatArray"), te4 = a6(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6);
        return e6.parse();
      }, "parseStringArray"), Kt2 = a6(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = ht2(t6)), t6;
        });
        return e6.parse();
      }, "parseDateArray"), xa = a6(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = gi2(t6)), t6;
        });
        return e6.parse();
      }, "parseIntervalArray"), Ea = a6(function(r6) {
        return r6 ? Ve3.parse(r6, lt3(wi)) : null;
      }, "parseByteAArray"), Vt2 = a6(function(r6) {
        return parseInt(
          r6,
          10
        );
      }, "parseInteger"), Si = a6(function(r6) {
        var e6 = String(r6);
        return /^\d+$/.test(e6) ? e6 : r6;
      }, "parseBigInteger"), mi2 = a6(
        function(r6) {
          return r6 ? Ve3.parse(r6, lt3(JSON.parse)) : null;
        },
        "parseJsonArray"
      ), zt2 = a6(function(r6) {
        return r6[0] !== "(" ? null : (r6 = r6.substring(1, r6.length - 1).split(","), { x: parseFloat(r6[0]), y: parseFloat(r6[1]) });
      }, "parsePoint"), va = a6(function(r6) {
        if (r6[0] !== "<" && r6[1] !== "(") return null;
        for (var e6 = "(", t6 = "", n7 = false, i8 = 2; i8 < r6.length - 1; i8++) {
          if (n7 || (e6 += r6[i8]), r6[i8] === ")") {
            n7 = true;
            continue;
          } else if (!n7) continue;
          r6[i8] !== "," && (t6 += r6[i8]);
        }
        var s10 = zt2(e6);
        return s10.radius = parseFloat(t6), s10;
      }, "parseCircle"), _a506 = a6(function(r6) {
        r6(
          20,
          Si
        ), r6(21, Vt2), r6(23, Vt2), r6(26, Vt2), r6(700, parseFloat), r6(701, parseFloat), r6(16, bi), r6(
          1082,
          ht2
        ), r6(1114, ht2), r6(1184, ht2), r6(600, zt2), r6(651, te4), r6(718, va), r6(1e3, ga), r6(1001, Ea), r6(
          1005,
          Gt3
        ), r6(1007, Gt3), r6(1028, Gt3), r6(1016, ba), r6(1017, Sa), r6(1021, $t3), r6(1022, $t3), r6(1231, $t3), r6(1014, te4), r6(1015, te4), r6(1008, te4), r6(1009, te4), r6(1040, te4), r6(1041, te4), r6(1115, Kt2), r6(
          1182,
          Kt2
        ), r6(1185, Kt2), r6(1186, gi2), r6(1187, xa), r6(17, wi), r6(114, JSON.parse.bind(JSON)), r6(
          3802,
          JSON.parse.bind(JSON)
        ), r6(199, mi2), r6(3807, mi2), r6(3907, te4), r6(2951, te4), r6(791, te4), r6(
          1183,
          te4
        ), r6(1270, te4);
      }, "init");
      xi.exports = { init: _a506 };
    });
    _i2 = I4((Rh, vi) => {
      "use strict";
      p8();
      var Y3 = 1e6;
      function Aa(r6) {
        var e6 = r6.readInt32BE(
          0
        ), t6 = r6.readUInt32BE(4), n7 = "";
        e6 < 0 && (e6 = ~e6 + (t6 === 0), t6 = ~t6 + 1 >>> 0, n7 = "-");
        var i8 = "", s10, o9, u7, c6, h8, l7;
        {
          if (s10 = e6 % Y3, e6 = e6 / Y3 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Y3 >>> 0, u7 = "" + (o9 - Y3 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        {
          if (s10 = e6 % Y3, e6 = e6 / Y3 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Y3 >>> 0, u7 = "" + (o9 - Y3 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        {
          if (s10 = e6 % Y3, e6 = e6 / Y3 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Y3 >>> 0, u7 = "" + (o9 - Y3 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        return s10 = e6 % Y3, o9 = 4294967296 * s10 + t6, u7 = "" + o9 % Y3, n7 + u7 + i8;
      }
      a6(Aa, "readInt8");
      vi.exports = Aa;
    });
    Pi = I4((Dh, Ti) => {
      p8();
      var Ca = _i2(), R5 = a6(function(r6, e6, t6, n7, i8) {
        t6 = t6 || 0, n7 = n7 || false, i8 = i8 || function(_7, P5, N5) {
          return _7 * Math.pow(2, N5) + P5;
        };
        var s10 = t6 >> 3, o9 = a6(function(_7) {
          return n7 ? ~_7 & 255 : _7;
        }, "inv"), u7 = 255, c6 = 8 - t6 % 8;
        e6 < c6 && (u7 = 255 << 8 - e6 & 255, c6 = e6), t6 && (u7 = u7 >> t6 % 8);
        var h8 = 0;
        t6 % 8 + e6 >= 8 && (h8 = i8(0, o9(r6[s10]) & u7, c6));
        for (var l7 = e6 + t6 >> 3, y7 = s10 + 1; y7 < l7; y7++) h8 = i8(h8, o9(r6[y7]), 8);
        var E4 = (e6 + t6) % 8;
        return E4 > 0 && (h8 = i8(h8, o9(r6[l7]) >> 8 - E4, E4)), h8;
      }, "parseBits"), Ii = a6(function(r6, e6, t6) {
        var n7 = Math.pow(2, t6 - 1) - 1, i8 = R5(r6, 1), s10 = R5(r6, t6, 1);
        if (s10 === 0) return 0;
        var o9 = 1, u7 = a6(function(h8, l7, y7) {
          h8 === 0 && (h8 = 1);
          for (var E4 = 1; E4 <= y7; E4++) o9 /= 2, (l7 & 1 << y7 - E4) > 0 && (h8 += o9);
          return h8;
        }, "parsePrecisionBits"), c6 = R5(r6, e6, t6 + 1, false, u7);
        return s10 == Math.pow(2, t6 + 1) - 1 ? c6 === 0 ? i8 === 0 ? 1 / 0 : -1 / 0 : NaN : (i8 === 0 ? 1 : -1) * Math.pow(2, s10 - n7) * c6;
      }, "parseFloatFromBits"), Ia = a6(function(r6) {
        return R5(r6, 1) == 1 ? -1 * (R5(r6, 15, 1, true) + 1) : R5(r6, 15, 1);
      }, "parseInt16"), Ai2 = a6(function(r6) {
        return R5(r6, 1) == 1 ? -1 * (R5(
          r6,
          31,
          1,
          true
        ) + 1) : R5(r6, 31, 1);
      }, "parseInt32"), Ta = a6(function(r6) {
        return Ii(r6, 23, 8);
      }, "parseFloat32"), Pa = a6(function(r6) {
        return Ii(r6, 52, 11);
      }, "parseFloat64"), Ba = a6(function(r6) {
        var e6 = R5(r6, 16, 32);
        if (e6 == 49152) return NaN;
        for (var t6 = Math.pow(1e4, R5(r6, 16, 16)), n7 = 0, i8 = [], s10 = R5(r6, 16), o9 = 0; o9 < s10; o9++) n7 += R5(r6, 16, 64 + 16 * o9) * t6, t6 /= 1e4;
        var u7 = Math.pow(10, R5(r6, 16, 48));
        return (e6 === 0 ? 1 : -1) * Math.round(n7 * u7) / u7;
      }, "parseNumeric"), Ci2 = a6(function(r6, e6) {
        var t6 = R5(
          e6,
          1
        ), n7 = R5(e6, 63, 1), i8 = new Date((t6 === 0 ? 1 : -1) * n7 / 1e3 + 9466848e5);
        return r6 || i8.setTime(i8.getTime() + i8.getTimezoneOffset() * 6e4), i8.usec = n7 % 1e3, i8.getMicroSeconds = function() {
          return this.usec;
        }, i8.setMicroSeconds = function(s10) {
          this.usec = s10;
        }, i8.getUTCMicroSeconds = function() {
          return this.usec;
        }, i8;
      }, "parseDate"), Ye2 = a6(function(r6) {
        for (var e6 = R5(r6, 32), t6 = R5(r6, 32, 32), n7 = R5(r6, 32, 64), i8 = 96, s10 = [], o9 = 0; o9 < e6; o9++) s10[o9] = R5(r6, 32, i8), i8 += 32, i8 += 32;
        var u7 = a6(function(h8) {
          var l7 = R5(r6, 32, i8);
          if (i8 += 32, l7 == 4294967295) return null;
          var y7;
          if (h8 == 23 || h8 == 20) return y7 = R5(r6, l7 * 8, i8), i8 += l7 * 8, y7;
          if (h8 == 25) return y7 = r6.toString(this.encoding, i8 >> 3, (i8 += l7 << 3) >> 3), y7;
          console.log("ERROR: ElementType not implemented: " + h8);
        }, "parseElement"), c6 = a6(function(h8, l7) {
          var y7 = [], E4;
          if (h8.length > 1) {
            var _7 = h8.shift();
            for (E4 = 0; E4 < _7; E4++) y7[E4] = c6(h8, l7);
            h8.unshift(
              _7
            );
          } else for (E4 = 0; E4 < h8[0]; E4++) y7[E4] = u7(l7);
          return y7;
        }, "parse");
        return c6(s10, n7);
      }, "parseArray"), La = a6(function(r6) {
        return r6.toString("utf8");
      }, "parseText"), Ra = a6(function(r6) {
        return r6 === null ? null : R5(r6, 8) > 0;
      }, "parseBool"), Fa = a6(function(r6) {
        r6(20, Ca), r6(21, Ia), r6(23, Ai2), r6(
          26,
          Ai2
        ), r6(1700, Ba), r6(700, Ta), r6(701, Pa), r6(16, Ra), r6(1114, Ci2.bind(null, false)), r6(1184, Ci2.bind(
          null,
          true
        )), r6(1e3, Ye2), r6(1007, Ye2), r6(1016, Ye2), r6(1008, Ye2), r6(1009, Ye2), r6(25, La);
      }, "init");
      Ti.exports = { init: Fa };
    });
    Li = I4((Uh, Bi2) => {
      p8();
      Bi2.exports = {
        BOOL: 16,
        BYTEA: 17,
        CHAR: 18,
        INT8: 20,
        INT2: 21,
        INT4: 23,
        REGPROC: 24,
        TEXT: 25,
        OID: 26,
        TID: 27,
        XID: 28,
        CID: 29,
        JSON: 114,
        XML: 142,
        PG_NODE_TREE: 194,
        SMGR: 210,
        PATH: 602,
        POLYGON: 604,
        CIDR: 650,
        FLOAT4: 700,
        FLOAT8: 701,
        ABSTIME: 702,
        RELTIME: 703,
        TINTERVAL: 704,
        CIRCLE: 718,
        MACADDR8: 774,
        MONEY: 790,
        MACADDR: 829,
        INET: 869,
        ACLITEM: 1033,
        BPCHAR: 1042,
        VARCHAR: 1043,
        DATE: 1082,
        TIME: 1083,
        TIMESTAMP: 1114,
        TIMESTAMPTZ: 1184,
        INTERVAL: 1186,
        TIMETZ: 1266,
        BIT: 1560,
        VARBIT: 1562,
        NUMERIC: 1700,
        REFCURSOR: 1790,
        REGPROCEDURE: 2202,
        REGOPER: 2203,
        REGOPERATOR: 2204,
        REGCLASS: 2205,
        REGTYPE: 2206,
        UUID: 2950,
        TXID_SNAPSHOT: 2970,
        PG_LSN: 3220,
        PG_NDISTINCT: 3361,
        PG_DEPENDENCIES: 3402,
        TSVECTOR: 3614,
        TSQUERY: 3615,
        GTSVECTOR: 3642,
        REGCONFIG: 3734,
        REGDICTIONARY: 3769,
        JSONB: 3802,
        REGNAMESPACE: 4089,
        REGROLE: 4096
      };
    });
    Xe2 = I4((Je3) => {
      p8();
      var Ma = Ei(), Da = Pi(), Oa = Wt2(), ka = Li();
      Je3.getTypeParser = Ua;
      Je3.setTypeParser = qa;
      Je3.arrayParser = Oa;
      Je3.builtins = ka;
      var Ze2 = { text: {}, binary: {} };
      function Ri2(r6) {
        return String(
          r6
        );
      }
      a6(Ri2, "noParse");
      function Ua(r6, e6) {
        return e6 = e6 || "text", Ze2[e6] && Ze2[e6][r6] || Ri2;
      }
      a6(
        Ua,
        "getTypeParser"
      );
      function qa(r6, e6, t6) {
        typeof e6 == "function" && (t6 = e6, e6 = "text"), Ze2[e6][r6] = t6;
      }
      a6(qa, "setTypeParser");
      Ma.init(function(r6, e6) {
        Ze2.text[r6] = e6;
      });
      Da.init(function(r6, e6) {
        Ze2.binary[r6] = e6;
      });
    });
    et2 = I4((jh, Yt2) => {
      "use strict";
      p8();
      Yt2.exports = {
        host: "localhost",
        user: m9.platform === "win32" ? m9.env.USERNAME : m9.env.USER,
        database: void 0,
        password: null,
        connectionString: void 0,
        port: 5432,
        rows: 0,
        binary: false,
        max: 10,
        idleTimeoutMillis: 3e4,
        client_encoding: "",
        ssl: false,
        application_name: void 0,
        fallback_application_name: void 0,
        options: void 0,
        parseInputDatesAsUTC: false,
        statement_timeout: false,
        lock_timeout: false,
        idle_in_transaction_session_timeout: false,
        query_timeout: false,
        connect_timeout: 0,
        keepalives: 1,
        keepalives_idle: 0
      };
      var Me2 = Xe2(), Na = Me2.getTypeParser(
        20,
        "text"
      ), Qa = Me2.getTypeParser(1016, "text");
      Yt2.exports.__defineSetter__("parseInt8", function(r6) {
        Me2.setTypeParser(20, "text", r6 ? Me2.getTypeParser(23, "text") : Na), Me2.setTypeParser(1016, "text", r6 ? Me2.getTypeParser(1007, "text") : Qa);
      });
    });
    tt2 = I4((Gh, Mi) => {
      "use strict";
      p8();
      var Wa = (qt2(), k8(Ut2)), ja = et2();
      function Ha(r6) {
        var e6 = r6.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
        return '"' + e6 + '"';
      }
      a6(Ha, "escapeElement");
      function Fi2(r6) {
        for (var e6 = "{", t6 = 0; t6 < r6.length; t6++) t6 > 0 && (e6 = e6 + ","), r6[t6] === null || typeof r6[t6] > "u" ? e6 = e6 + "NULL" : Array.isArray(r6[t6]) ? e6 = e6 + Fi2(r6[t6]) : r6[t6] instanceof d6 ? e6 += "\\\\x" + r6[t6].toString("hex") : e6 += Ha(ft2(r6[t6]));
        return e6 = e6 + "}", e6;
      }
      a6(Fi2, "arrayString");
      var ft2 = a6(function(r6, e6) {
        if (r6 == null) return null;
        if (r6 instanceof d6) return r6;
        if (ArrayBuffer.isView(r6)) {
          var t6 = d6.from(r6.buffer, r6.byteOffset, r6.byteLength);
          return t6.length === r6.byteLength ? t6 : t6.slice(
            r6.byteOffset,
            r6.byteOffset + r6.byteLength
          );
        }
        return r6 instanceof Date ? ja.parseInputDatesAsUTC ? Ka(r6) : $a(r6) : Array.isArray(r6) ? Fi2(r6) : typeof r6 == "object" ? Ga(r6, e6) : r6.toString();
      }, "prepareValue");
      function Ga(r6, e6) {
        if (r6 && typeof r6.toPostgres == "function") {
          if (e6 = e6 || [], e6.indexOf(r6) !== -1) throw new Error('circular reference detected while preparing "' + r6 + '" for query');
          return e6.push(r6), ft2(r6.toPostgres(ft2), e6);
        }
        return JSON.stringify(r6);
      }
      a6(Ga, "prepareObject");
      function j7(r6, e6) {
        for (r6 = "" + r6; r6.length < e6; ) r6 = "0" + r6;
        return r6;
      }
      a6(
        j7,
        "pad"
      );
      function $a(r6) {
        var e6 = -r6.getTimezoneOffset(), t6 = r6.getFullYear(), n7 = t6 < 1;
        n7 && (t6 = Math.abs(t6) + 1);
        var i8 = j7(t6, 4) + "-" + j7(r6.getMonth() + 1, 2) + "-" + j7(r6.getDate(), 2) + "T" + j7(r6.getHours(), 2) + ":" + j7(r6.getMinutes(), 2) + ":" + j7(r6.getSeconds(), 2) + "." + j7(
          r6.getMilliseconds(),
          3
        );
        return e6 < 0 ? (i8 += "-", e6 *= -1) : i8 += "+", i8 += j7(Math.floor(e6 / 60), 2) + ":" + j7(e6 % 60, 2), n7 && (i8 += " BC"), i8;
      }
      a6($a, "dateToString");
      function Ka(r6) {
        var e6 = r6.getUTCFullYear(), t6 = e6 < 1;
        t6 && (e6 = Math.abs(e6) + 1);
        var n7 = j7(e6, 4) + "-" + j7(r6.getUTCMonth() + 1, 2) + "-" + j7(r6.getUTCDate(), 2) + "T" + j7(r6.getUTCHours(), 2) + ":" + j7(r6.getUTCMinutes(), 2) + ":" + j7(r6.getUTCSeconds(), 2) + "." + j7(r6.getUTCMilliseconds(), 3);
        return n7 += "+00:00", t6 && (n7 += " BC"), n7;
      }
      a6(Ka, "dateToStringUTC");
      function Va(r6, e6, t6) {
        return r6 = typeof r6 == "string" ? { text: r6 } : r6, e6 && (typeof e6 == "function" ? r6.callback = e6 : r6.values = e6), t6 && (r6.callback = t6), r6;
      }
      a6(Va, "normalizeQueryConfig");
      var Zt2 = a6(function(r6) {
        return Wa.createHash("md5").update(r6, "utf-8").digest("hex");
      }, "md5"), za = a6(function(r6, e6, t6) {
        var n7 = Zt2(e6 + r6), i8 = Zt2(d6.concat([d6.from(n7), t6]));
        return "md5" + i8;
      }, "postgresMd5PasswordHash");
      Mi.exports = { prepareValue: a6(function(e6) {
        return ft2(
          e6
        );
      }, "prepareValueWrapper"), normalizeQueryConfig: Va, postgresMd5PasswordHash: za, md5: Zt2 };
    });
    qi = I4((Vh, Ui) => {
      "use strict";
      p8();
      var Jt2 = (qt2(), k8(Ut2));
      function Ya(r6) {
        if (r6.indexOf(
          "SCRAM-SHA-256"
        ) === -1) throw new Error("SASL: Only mechanism SCRAM-SHA-256 is currently supported");
        let e6 = Jt2.randomBytes(18).toString("base64");
        return { mechanism: "SCRAM-SHA-256", clientNonce: e6, response: "n,,n=*,r=" + e6, message: "SASLInitialResponse" };
      }
      a6(Ya, "startSession");
      function Za(r6, e6, t6) {
        if (r6.message !== "SASLInitialResponse") throw new Error(
          "SASL: Last message was not SASLInitialResponse"
        );
        if (typeof e6 != "string") throw new Error(
          "SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a string"
        );
        if (typeof t6 != "string") throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: serverData must be a string");
        let n7 = eu(t6);
        if (n7.nonce.startsWith(r6.clientNonce)) {
          if (n7.nonce.length === r6.clientNonce.length) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce");
        var i8 = d6.from(n7.salt, "base64"), s10 = nu(
          e6,
          i8,
          n7.iteration
        ), o9 = De3(s10, "Client Key"), u7 = ru(o9), c6 = "n=*,r=" + r6.clientNonce, h8 = "r=" + n7.nonce + ",s=" + n7.salt + ",i=" + n7.iteration, l7 = "c=biws,r=" + n7.nonce, y7 = c6 + "," + h8 + "," + l7, E4 = De3(u7, y7), _7 = ki(
          o9,
          E4
        ), P5 = _7.toString("base64"), N5 = De3(s10, "Server Key"), J3 = De3(N5, y7);
        r6.message = "SASLResponse", r6.serverSignature = J3.toString("base64"), r6.response = l7 + ",p=" + P5;
      }
      a6(Za, "continueSession");
      function Ja(r6, e6) {
        if (r6.message !== "SASLResponse") throw new Error("SASL: Last message was not SASLResponse");
        if (typeof e6 != "string") throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: serverData must be a string");
        let { serverSignature: t6 } = tu(
          e6
        );
        if (t6 !== r6.serverSignature) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature does not match");
      }
      a6(Ja, "finalizeSession");
      function Xa(r6) {
        if (typeof r6 != "string") throw new TypeError("SASL: text must be a string");
        return r6.split("").map(
          (e6, t6) => r6.charCodeAt(t6)
        ).every((e6) => e6 >= 33 && e6 <= 43 || e6 >= 45 && e6 <= 126);
      }
      a6(Xa, "isPrintableChars");
      function Di(r6) {
        return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(r6);
      }
      a6(Di, "isBase64");
      function Oi(r6) {
        if (typeof r6 != "string") throw new TypeError(
          "SASL: attribute pairs text must be a string"
        );
        return new Map(r6.split(",").map((e6) => {
          if (!/^.=/.test(e6)) throw new Error("SASL: Invalid attribute pair entry");
          let t6 = e6[0], n7 = e6.substring(2);
          return [t6, n7];
        }));
      }
      a6(Oi, "parseAttributePairs");
      function eu(r6) {
        let e6 = Oi(
          r6
        ), t6 = e6.get("r");
        if (t6) {
          if (!Xa(t6)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing");
        let n7 = e6.get("s");
        if (n7) {
          if (!Di(n7)) throw new Error(
            "SASL: SCRAM-SERVER-FIRST-MESSAGE: salt must be base64"
          );
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing");
        let i8 = e6.get("i");
        if (i8) {
          if (!/^[1-9][0-9]*$/.test(i8)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: invalid iteration count");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing");
        let s10 = parseInt(i8, 10);
        return { nonce: t6, salt: n7, iteration: s10 };
      }
      a6(eu, "parseServerFirstMessage");
      function tu(r6) {
        let t6 = Oi(r6).get("v");
        if (t6) {
          if (!Di(t6)) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64");
        } else throw new Error(
          "SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing"
        );
        return { serverSignature: t6 };
      }
      a6(tu, "parseServerFinalMessage");
      function ki(r6, e6) {
        if (!d6.isBuffer(r6)) throw new TypeError(
          "first argument must be a Buffer"
        );
        if (!d6.isBuffer(e6)) throw new TypeError("second argument must be a Buffer");
        if (r6.length !== e6.length) throw new Error("Buffer lengths must match");
        if (r6.length === 0) throw new Error("Buffers cannot be empty");
        return d6.from(r6.map((t6, n7) => r6[n7] ^ e6[n7]));
      }
      a6(ki, "xorBuffers");
      function ru(r6) {
        return Jt2.createHash(
          "sha256"
        ).update(r6).digest();
      }
      a6(ru, "sha256");
      function De3(r6, e6) {
        return Jt2.createHmac(
          "sha256",
          r6
        ).update(e6).digest();
      }
      a6(De3, "hmacSha256");
      function nu(r6, e6, t6) {
        for (var n7 = De3(
          r6,
          d6.concat([e6, d6.from([0, 0, 0, 1])])
        ), i8 = n7, s10 = 0; s10 < t6 - 1; s10++) n7 = De3(r6, n7), i8 = ki(i8, n7);
        return i8;
      }
      a6(nu, "Hi");
      Ui.exports = { startSession: Ya, continueSession: Za, finalizeSession: Ja };
    });
    Xt2 = {};
    X3(Xt2, { join: () => iu });
    er2 = K3(() => {
      "use strict";
      p8();
      a6(iu, "join");
    });
    tr = {};
    X3(tr, { stat: () => su });
    rr = K3(
      () => {
        "use strict";
        p8();
        a6(su, "stat");
      }
    );
    nr2 = {};
    X3(nr2, { default: () => ou });
    ir = K3(() => {
      "use strict";
      p8();
      ou = {};
    });
    Ni = {};
    X3(Ni, { StringDecoder: () => sr2 });
    Qi = K3(() => {
      "use strict";
      p8();
      or3 = class or {
        constructor(e6) {
          T3(this, "td");
          this.td = new TextDecoder(e6);
        }
        write(e6) {
          return this.td.decode(e6, { stream: true });
        }
        end(e6) {
          return this.td.decode(e6);
        }
      };
      a6(or3, "StringDecoder");
      sr2 = or3;
    });
    Gi = I4((il, Hi) => {
      "use strict";
      p8();
      var { Transform: au2 } = (ir(), k8(nr2)), { StringDecoder: uu3 } = (Qi(), k8(Ni)), we5 = Symbol("last"), pt2 = Symbol("decoder");
      function cu2(r6, e6, t6) {
        let n7;
        if (this.overflow) {
          if (n7 = this[pt2].write(r6).split(this.matcher), n7.length === 1) return t6();
          n7.shift(), this.overflow = false;
        } else this[we5] += this[pt2].write(r6), n7 = this[we5].split(this.matcher);
        this[we5] = n7.pop();
        for (let i8 = 0; i8 < n7.length; i8++) try {
          ji2(this, this.mapper(n7[i8]));
        } catch (s10) {
          return t6(
            s10
          );
        }
        if (this.overflow = this[we5].length > this.maxLength, this.overflow && !this.skipOverflow) {
          t6(new Error("maximum buffer reached"));
          return;
        }
        t6();
      }
      a6(cu2, "transform");
      function hu2(r6) {
        if (this[we5] += this[pt2].end(), this[we5]) try {
          ji2(this, this.mapper(this[we5]));
        } catch (e6) {
          return r6(e6);
        }
        r6();
      }
      a6(hu2, "flush");
      function ji2(r6, e6) {
        e6 !== void 0 && r6.push(e6);
      }
      a6(ji2, "push");
      function Wi3(r6) {
        return r6;
      }
      a6(Wi3, "noop");
      function lu(r6, e6, t6) {
        switch (r6 = r6 || /\r?\n/, e6 = e6 || Wi3, t6 = t6 || {}, arguments.length) {
          case 1:
            typeof r6 == "function" ? (e6 = r6, r6 = /\r?\n/) : typeof r6 == "object" && !(r6 instanceof RegExp) && !r6[Symbol.split] && (t6 = r6, r6 = /\r?\n/);
            break;
          case 2:
            typeof r6 == "function" ? (t6 = e6, e6 = r6, r6 = /\r?\n/) : typeof e6 == "object" && (t6 = e6, e6 = Wi3);
        }
        t6 = Object.assign({}, t6), t6.autoDestroy = true, t6.transform = cu2, t6.flush = hu2, t6.readableObjectMode = true;
        let n7 = new au2(t6);
        return n7[we5] = "", n7[pt2] = new uu3("utf8"), n7.matcher = r6, n7.mapper = e6, n7.maxLength = t6.maxLength, n7.skipOverflow = t6.skipOverflow || false, n7.overflow = false, n7._destroy = function(i8, s10) {
          this._writableState.errorEmitted = false, s10(i8);
        }, n7;
      }
      a6(lu, "split");
      Hi.exports = lu;
    });
    Vi = I4((al, fe3) => {
      "use strict";
      p8();
      var $i2 = (er2(), k8(Xt2)), fu = (ir(), k8(nr2)).Stream, pu = Gi(), Ki = (Ge2(), k8(He2)), du = 5432, dt2 = m9.platform === "win32", rt2 = m9.stderr, yu = 56, mu = 7, gu = 61440, wu = 32768;
      function bu(r6) {
        return (r6 & gu) == wu;
      }
      a6(bu, "isRegFile");
      var Oe2 = [
        "host",
        "port",
        "database",
        "user",
        "password"
      ], ar4 = Oe2.length, Su = Oe2[ar4 - 1];
      function ur4() {
        var r6 = rt2 instanceof fu && rt2.writable === true;
        if (r6) {
          var e6 = Array.prototype.slice.call(arguments).concat(`
`);
          rt2.write(Ki.format.apply(Ki, e6));
        }
      }
      a6(ur4, "warn");
      Object.defineProperty(
        fe3.exports,
        "isWin",
        { get: function() {
          return dt2;
        }, set: function(r6) {
          dt2 = r6;
        } }
      );
      fe3.exports.warnTo = function(r6) {
        var e6 = rt2;
        return rt2 = r6, e6;
      };
      fe3.exports.getFileName = function(r6) {
        var e6 = r6 || m9.env, t6 = e6.PGPASSFILE || (dt2 ? $i2.join(e6.APPDATA || "./", "postgresql", "pgpass.conf") : $i2.join(e6.HOME || "./", ".pgpass"));
        return t6;
      };
      fe3.exports.usePgPass = function(r6, e6) {
        return Object.prototype.hasOwnProperty.call(m9.env, "PGPASSWORD") ? false : dt2 ? true : (e6 = e6 || "<unkn>", bu(r6.mode) ? r6.mode & (yu | mu) ? (ur4('WARNING: password file "%s" has group or world access; permissions should be u=rw (0600) or less', e6), false) : true : (ur4(
          'WARNING: password file "%s" is not a plain file',
          e6
        ), false));
      };
      var xu = fe3.exports.match = function(r6, e6) {
        return Oe2.slice(0, -1).reduce(
          function(t6, n7, i8) {
            return i8 == 1 && Number(r6[n7] || du) === Number(e6[n7]) ? t6 && true : t6 && (e6[n7] === "*" || e6[n7] === r6[n7]);
          },
          true
        );
      };
      fe3.exports.getPassword = function(r6, e6, t6) {
        var n7, i8 = e6.pipe(pu());
        function s10(c6) {
          var h8 = Eu(
            c6
          );
          h8 && vu(h8) && xu(r6, h8) && (n7 = h8[Su], i8.end());
        }
        a6(s10, "onLine");
        var o9 = a6(function() {
          e6.destroy(), t6(n7);
        }, "onEnd"), u7 = a6(function(c6) {
          e6.destroy(), ur4("WARNING: error on reading file: %s", c6), t6(void 0);
        }, "onErr");
        e6.on("error", u7), i8.on("data", s10).on("end", o9).on(
          "error",
          u7
        );
      };
      var Eu = fe3.exports.parseLine = function(r6) {
        if (r6.length < 11 || r6.match(/^\s+#/)) return null;
        for (var e6 = "", t6 = "", n7 = 0, i8 = 0, s10 = 0, o9 = {}, u7 = false, c6 = a6(function(l7, y7, E4) {
          var _7 = r6.substring(
            y7,
            E4
          );
          Object.hasOwnProperty.call(m9.env, "PGPASS_NO_DEESCAPE") || (_7 = _7.replace(
            /\\([:\\])/g,
            "$1"
          )), o9[Oe2[l7]] = _7;
        }, "addToObj"), h8 = 0; h8 < r6.length - 1; h8 += 1) {
          if (e6 = r6.charAt(h8 + 1), t6 = r6.charAt(
            h8
          ), u7 = n7 == ar4 - 1, u7) {
            c6(n7, i8);
            break;
          }
          h8 >= 0 && e6 == ":" && t6 !== "\\" && (c6(n7, i8, h8 + 1), i8 = h8 + 2, n7 += 1);
        }
        return o9 = Object.keys(o9).length === ar4 ? o9 : null, o9;
      }, vu = fe3.exports.isValidEntry = function(r6) {
        for (var e6 = {
          0: function(o9) {
            return o9.length > 0;
          },
          1: function(o9) {
            return o9 === "*" ? true : (o9 = Number(o9), isFinite(
              o9
            ) && o9 > 0 && o9 < 9007199254740992 && Math.floor(o9) === o9);
          },
          2: function(o9) {
            return o9.length > 0;
          },
          3: function(o9) {
            return o9.length > 0;
          },
          4: function(o9) {
            return o9.length > 0;
          }
        }, t6 = 0; t6 < Oe2.length; t6 += 1) {
          var n7 = e6[t6], i8 = r6[Oe2[t6]] || "", s10 = n7(i8);
          if (!s10) return false;
        }
        return true;
      };
    });
    Yi = I4((ll, cr3) => {
      "use strict";
      p8();
      var hl = (er2(), k8(Xt2)), zi2 = (rr(), k8(tr)), yt2 = Vi();
      cr3.exports = function(r6, e6) {
        var t6 = yt2.getFileName();
        zi2.stat(t6, function(n7, i8) {
          if (n7 || !yt2.usePgPass(i8, t6)) return e6(void 0);
          var s10 = zi2.createReadStream(t6);
          yt2.getPassword(
            r6,
            s10,
            e6
          );
        });
      };
      cr3.exports.warnTo = yt2.warnTo;
    });
    hr = I4((pl, Zi2) => {
      "use strict";
      p8();
      var _u = Xe2();
      function mt3(r6) {
        this._types = r6 || _u, this.text = {}, this.binary = {};
      }
      a6(mt3, "TypeOverrides");
      mt3.prototype.getOverrides = function(r6) {
        switch (r6) {
          case "text":
            return this.text;
          case "binary":
            return this.binary;
          default:
            return {};
        }
      };
      mt3.prototype.setTypeParser = function(r6, e6, t6) {
        typeof e6 == "function" && (t6 = e6, e6 = "text"), this.getOverrides(e6)[r6] = t6;
      };
      mt3.prototype.getTypeParser = function(r6, e6) {
        return e6 = e6 || "text", this.getOverrides(e6)[r6] || this._types.getTypeParser(r6, e6);
      };
      Zi2.exports = mt3;
    });
    Ji = {};
    X3(Ji, { default: () => Au });
    Xi = K3(() => {
      "use strict";
      p8();
      Au = {};
    });
    es = {};
    X3(es, { parse: () => lr });
    fr = K3(
      () => {
        "use strict";
        p8();
        a6(lr, "parse");
      }
    );
    rs = I4((bl, ts3) => {
      "use strict";
      p8();
      var Cu = (fr(), k8(es)), pr2 = (rr(), k8(tr));
      function dr2(r6) {
        if (r6.charAt(0) === "/") {
          var t6 = r6.split(" ");
          return { host: t6[0], database: t6[1] };
        }
        var e6 = Cu.parse(/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(r6) ? encodeURI(r6).replace(
          /\%25(\d\d)/g,
          "%$1"
        ) : r6, true), t6 = e6.query;
        for (var n7 in t6) Array.isArray(t6[n7]) && (t6[n7] = t6[n7][t6[n7].length - 1]);
        var i8 = (e6.auth || ":").split(":");
        if (t6.user = i8[0], t6.password = i8.splice(1).join(":"), t6.port = e6.port, e6.protocol == "socket:") return t6.host = decodeURI(e6.pathname), t6.database = e6.query.db, t6.client_encoding = e6.query.encoding, t6;
        t6.host || (t6.host = e6.hostname);
        var s10 = e6.pathname;
        if (!t6.host && s10 && /^%2f/i.test(s10)) {
          var o9 = s10.split("/");
          t6.host = decodeURIComponent(
            o9[0]
          ), s10 = o9.splice(1).join("/");
        }
        switch (s10 && s10.charAt(0) === "/" && (s10 = s10.slice(1) || null), t6.database = s10 && decodeURI(s10), (t6.ssl === "true" || t6.ssl === "1") && (t6.ssl = true), t6.ssl === "0" && (t6.ssl = false), (t6.sslcert || t6.sslkey || t6.sslrootcert || t6.sslmode) && (t6.ssl = {}), t6.sslcert && (t6.ssl.cert = pr2.readFileSync(t6.sslcert).toString()), t6.sslkey && (t6.ssl.key = pr2.readFileSync(
          t6.sslkey
        ).toString()), t6.sslrootcert && (t6.ssl.ca = pr2.readFileSync(t6.sslrootcert).toString()), t6.sslmode) {
          case "disable": {
            t6.ssl = false;
            break;
          }
          case "prefer":
          case "require":
          case "verify-ca":
          case "verify-full":
            break;
          case "no-verify": {
            t6.ssl.rejectUnauthorized = false;
            break;
          }
        }
        return t6;
      }
      a6(dr2, "parse");
      ts3.exports = dr2;
      dr2.parse = dr2;
    });
    gt3 = I4((El, ss) => {
      "use strict";
      p8();
      var Iu = (Xi(), k8(Ji)), is3 = et2(), ns2 = rs().parse, V2 = a6(
        function(r6, e6, t6) {
          return t6 === void 0 ? t6 = m9.env["PG" + r6.toUpperCase()] : t6 === false || (t6 = m9.env[t6]), e6[r6] || t6 || is3[r6];
        },
        "val"
      ), Tu2 = a6(function() {
        switch (m9.env.PGSSLMODE) {
          case "disable":
            return false;
          case "prefer":
          case "require":
          case "verify-ca":
          case "verify-full":
            return true;
          case "no-verify":
            return { rejectUnauthorized: false };
        }
        return is3.ssl;
      }, "readSSLConfigFromEnvironment"), ke3 = a6(
        function(r6) {
          return "'" + ("" + r6).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
        },
        "quoteParamValue"
      ), re3 = a6(function(r6, e6, t6) {
        var n7 = e6[t6];
        n7 != null && r6.push(t6 + "=" + ke3(n7));
      }, "add"), mr = class mr {
        constructor(e6) {
          e6 = typeof e6 == "string" ? ns2(e6) : e6 || {}, e6.connectionString && (e6 = Object.assign({}, e6, ns2(e6.connectionString))), this.user = V2("user", e6), this.database = V2("database", e6), this.database === void 0 && (this.database = this.user), this.port = parseInt(
            V2("port", e6),
            10
          ), this.host = V2("host", e6), Object.defineProperty(this, "password", {
            configurable: true,
            enumerable: false,
            writable: true,
            value: V2("password", e6)
          }), this.binary = V2("binary", e6), this.options = V2("options", e6), this.ssl = typeof e6.ssl > "u" ? Tu2() : e6.ssl, typeof this.ssl == "string" && this.ssl === "true" && (this.ssl = true), this.ssl === "no-verify" && (this.ssl = { rejectUnauthorized: false }), this.ssl && this.ssl.key && Object.defineProperty(this.ssl, "key", { enumerable: false }), this.client_encoding = V2("client_encoding", e6), this.replication = V2("replication", e6), this.isDomainSocket = !(this.host || "").indexOf("/"), this.application_name = V2("application_name", e6, "PGAPPNAME"), this.fallback_application_name = V2("fallback_application_name", e6, false), this.statement_timeout = V2("statement_timeout", e6, false), this.lock_timeout = V2(
            "lock_timeout",
            e6,
            false
          ), this.idle_in_transaction_session_timeout = V2("idle_in_transaction_session_timeout", e6, false), this.query_timeout = V2("query_timeout", e6, false), e6.connectionTimeoutMillis === void 0 ? this.connect_timeout = m9.env.PGCONNECT_TIMEOUT || 0 : this.connect_timeout = Math.floor(e6.connectionTimeoutMillis / 1e3), e6.keepAlive === false ? this.keepalives = 0 : e6.keepAlive === true && (this.keepalives = 1), typeof e6.keepAliveInitialDelayMillis == "number" && (this.keepalives_idle = Math.floor(e6.keepAliveInitialDelayMillis / 1e3));
        }
        getLibpqConnectionString(e6) {
          var t6 = [];
          re3(t6, this, "user"), re3(t6, this, "password"), re3(t6, this, "port"), re3(t6, this, "application_name"), re3(t6, this, "fallback_application_name"), re3(t6, this, "connect_timeout"), re3(
            t6,
            this,
            "options"
          );
          var n7 = typeof this.ssl == "object" ? this.ssl : this.ssl ? { sslmode: this.ssl } : {};
          if (re3(t6, n7, "sslmode"), re3(t6, n7, "sslca"), re3(t6, n7, "sslkey"), re3(t6, n7, "sslcert"), re3(t6, n7, "sslrootcert"), this.database && t6.push("dbname=" + ke3(this.database)), this.replication && t6.push("replication=" + ke3(this.replication)), this.host && t6.push("host=" + ke3(this.host)), this.isDomainSocket) return e6(null, t6.join(" "));
          this.client_encoding && t6.push("client_encoding=" + ke3(this.client_encoding)), Iu.lookup(this.host, function(i8, s10) {
            return i8 ? e6(i8, null) : (t6.push("hostaddr=" + ke3(s10)), e6(null, t6.join(" ")));
          });
        }
      };
      a6(mr, "ConnectionParameters");
      var yr2 = mr;
      ss.exports = yr2;
    });
    us = I4((Al, as) => {
      "use strict";
      p8();
      var Pu2 = Xe2(), os4 = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/, wr = class wr {
        constructor(e6, t6) {
          this.command = null, this.rowCount = null, this.oid = null, this.rows = [], this.fields = [], this._parsers = void 0, this._types = t6, this.RowCtor = null, this.rowAsArray = e6 === "array", this.rowAsArray && (this.parseRow = this._parseRowAsArray);
        }
        addCommandComplete(e6) {
          var t6;
          e6.text ? t6 = os4.exec(e6.text) : t6 = os4.exec(e6.command), t6 && (this.command = t6[1], t6[3] ? (this.oid = parseInt(t6[2], 10), this.rowCount = parseInt(t6[3], 10)) : t6[2] && (this.rowCount = parseInt(
            t6[2],
            10
          )));
        }
        _parseRowAsArray(e6) {
          for (var t6 = new Array(e6.length), n7 = 0, i8 = e6.length; n7 < i8; n7++) {
            var s10 = e6[n7];
            s10 !== null ? t6[n7] = this._parsers[n7](s10) : t6[n7] = null;
          }
          return t6;
        }
        parseRow(e6) {
          for (var t6 = {}, n7 = 0, i8 = e6.length; n7 < i8; n7++) {
            var s10 = e6[n7], o9 = this.fields[n7].name;
            s10 !== null ? t6[o9] = this._parsers[n7](
              s10
            ) : t6[o9] = null;
          }
          return t6;
        }
        addRow(e6) {
          this.rows.push(e6);
        }
        addFields(e6) {
          this.fields = e6, this.fields.length && (this._parsers = new Array(e6.length));
          for (var t6 = 0; t6 < e6.length; t6++) {
            var n7 = e6[t6];
            this._types ? this._parsers[t6] = this._types.getTypeParser(n7.dataTypeID, n7.format || "text") : this._parsers[t6] = Pu2.getTypeParser(n7.dataTypeID, n7.format || "text");
          }
        }
      };
      a6(wr, "Result");
      var gr = wr;
      as.exports = gr;
    });
    fs7 = I4((Tl, ls) => {
      "use strict";
      p8();
      var { EventEmitter: Bu } = ge3(), cs2 = us(), hs2 = tt2(), Sr = class Sr extends Bu {
        constructor(e6, t6, n7) {
          super(), e6 = hs2.normalizeQueryConfig(e6, t6, n7), this.text = e6.text, this.values = e6.values, this.rows = e6.rows, this.types = e6.types, this.name = e6.name, this.binary = e6.binary, this.portal = e6.portal || "", this.callback = e6.callback, this._rowMode = e6.rowMode, m9.domain && e6.callback && (this.callback = m9.domain.bind(e6.callback)), this._result = new cs2(this._rowMode, this.types), this._results = this._result, this.isPreparedStatement = false, this._canceledDueToError = false, this._promise = null;
        }
        requiresPreparation() {
          return this.name || this.rows ? true : !this.text || !this.values ? false : this.values.length > 0;
        }
        _checkForMultirow() {
          this._result.command && (Array.isArray(this._results) || (this._results = [this._result]), this._result = new cs2(
            this._rowMode,
            this.types
          ), this._results.push(this._result));
        }
        handleRowDescription(e6) {
          this._checkForMultirow(), this._result.addFields(e6.fields), this._accumulateRows = this.callback || !this.listeners("row").length;
        }
        handleDataRow(e6) {
          let t6;
          if (!this._canceledDueToError) {
            try {
              t6 = this._result.parseRow(e6.fields);
            } catch (n7) {
              this._canceledDueToError = n7;
              return;
            }
            this.emit("row", t6, this._result), this._accumulateRows && this._result.addRow(t6);
          }
        }
        handleCommandComplete(e6, t6) {
          this._checkForMultirow(), this._result.addCommandComplete(e6), this.rows && t6.sync();
        }
        handleEmptyQuery(e6) {
          this.rows && e6.sync();
        }
        handleError(e6, t6) {
          if (this._canceledDueToError && (e6 = this._canceledDueToError, this._canceledDueToError = false), this.callback) return this.callback(e6);
          this.emit("error", e6);
        }
        handleReadyForQuery(e6) {
          if (this._canceledDueToError) return this.handleError(
            this._canceledDueToError,
            e6
          );
          if (this.callback) try {
            this.callback(null, this._results);
          } catch (t6) {
            m9.nextTick(() => {
              throw t6;
            });
          }
          this.emit("end", this._results);
        }
        submit(e6) {
          if (typeof this.text != "string" && typeof this.name != "string") return new Error("A query must have either text or a name. Supplying neither is unsupported.");
          let t6 = e6.parsedStatements[this.name];
          return this.text && t6 && this.text !== t6 ? new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`) : this.values && !Array.isArray(this.values) ? new Error("Query values must be an array") : (this.requiresPreparation() ? this.prepare(e6) : e6.query(this.text), null);
        }
        hasBeenParsed(e6) {
          return this.name && e6.parsedStatements[this.name];
        }
        handlePortalSuspended(e6) {
          this._getRows(e6, this.rows);
        }
        _getRows(e6, t6) {
          e6.execute(
            { portal: this.portal, rows: t6 }
          ), t6 ? e6.flush() : e6.sync();
        }
        prepare(e6) {
          this.isPreparedStatement = true, this.hasBeenParsed(e6) || e6.parse({ text: this.text, name: this.name, types: this.types });
          try {
            e6.bind({ portal: this.portal, statement: this.name, values: this.values, binary: this.binary, valueMapper: hs2.prepareValue });
          } catch (t6) {
            this.handleError(t6, e6);
            return;
          }
          e6.describe(
            { type: "P", name: this.portal || "" }
          ), this._getRows(e6, this.rows);
        }
        handleCopyInResponse(e6) {
          e6.sendCopyFail("No source stream defined");
        }
        handleCopyData(e6, t6) {
        }
      };
      a6(Sr, "Query");
      var br = Sr;
      ls.exports = br;
    });
    ds = {};
    X3(ds, { Socket: () => _e6, isIP: () => Lu });
    wt2 = K3(() => {
      "use strict";
      p8();
      ps = We2(ge3(), 1);
      a6(Lu, "isIP");
      x8 = class x11 extends ps.EventEmitter {
        constructor() {
          super(...arguments);
          T3(this, "opts", {});
          T3(this, "connecting", false);
          T3(this, "pending", true);
          T3(this, "writable", true);
          T3(this, "encrypted", false);
          T3(this, "authorized", false);
          T3(this, "destroyed", false);
          T3(this, "ws", null);
          T3(this, "writeBuffer");
          T3(this, "tlsState", 0);
          T3(
            this,
            "tlsRead"
          );
          T3(this, "tlsWrite");
        }
        static get poolQueryViaFetch() {
          return x11.opts.poolQueryViaFetch ?? x11.defaults.poolQueryViaFetch;
        }
        static set poolQueryViaFetch(t6) {
          x11.opts.poolQueryViaFetch = t6;
        }
        static get fetchEndpoint() {
          return x11.opts.fetchEndpoint ?? x11.defaults.fetchEndpoint;
        }
        static set fetchEndpoint(t6) {
          x11.opts.fetchEndpoint = t6;
        }
        static get fetchConnectionCache() {
          return x11.opts.fetchConnectionCache ?? x11.defaults.fetchConnectionCache;
        }
        static set fetchConnectionCache(t6) {
          x11.opts.fetchConnectionCache = t6;
        }
        static get fetchFunction() {
          return x11.opts.fetchFunction ?? x11.defaults.fetchFunction;
        }
        static set fetchFunction(t6) {
          x11.opts.fetchFunction = t6;
        }
        static get webSocketConstructor() {
          return x11.opts.webSocketConstructor ?? x11.defaults.webSocketConstructor;
        }
        static set webSocketConstructor(t6) {
          x11.opts.webSocketConstructor = t6;
        }
        get webSocketConstructor() {
          return this.opts.webSocketConstructor ?? x11.webSocketConstructor;
        }
        set webSocketConstructor(t6) {
          this.opts.webSocketConstructor = t6;
        }
        static get wsProxy() {
          return x11.opts.wsProxy ?? x11.defaults.wsProxy;
        }
        static set wsProxy(t6) {
          x11.opts.wsProxy = t6;
        }
        get wsProxy() {
          return this.opts.wsProxy ?? x11.wsProxy;
        }
        set wsProxy(t6) {
          this.opts.wsProxy = t6;
        }
        static get coalesceWrites() {
          return x11.opts.coalesceWrites ?? x11.defaults.coalesceWrites;
        }
        static set coalesceWrites(t6) {
          x11.opts.coalesceWrites = t6;
        }
        get coalesceWrites() {
          return this.opts.coalesceWrites ?? x11.coalesceWrites;
        }
        set coalesceWrites(t6) {
          this.opts.coalesceWrites = t6;
        }
        static get useSecureWebSocket() {
          return x11.opts.useSecureWebSocket ?? x11.defaults.useSecureWebSocket;
        }
        static set useSecureWebSocket(t6) {
          x11.opts.useSecureWebSocket = t6;
        }
        get useSecureWebSocket() {
          return this.opts.useSecureWebSocket ?? x11.useSecureWebSocket;
        }
        set useSecureWebSocket(t6) {
          this.opts.useSecureWebSocket = t6;
        }
        static get forceDisablePgSSL() {
          return x11.opts.forceDisablePgSSL ?? x11.defaults.forceDisablePgSSL;
        }
        static set forceDisablePgSSL(t6) {
          x11.opts.forceDisablePgSSL = t6;
        }
        get forceDisablePgSSL() {
          return this.opts.forceDisablePgSSL ?? x11.forceDisablePgSSL;
        }
        set forceDisablePgSSL(t6) {
          this.opts.forceDisablePgSSL = t6;
        }
        static get disableSNI() {
          return x11.opts.disableSNI ?? x11.defaults.disableSNI;
        }
        static set disableSNI(t6) {
          x11.opts.disableSNI = t6;
        }
        get disableSNI() {
          return this.opts.disableSNI ?? x11.disableSNI;
        }
        set disableSNI(t6) {
          this.opts.disableSNI = t6;
        }
        static get pipelineConnect() {
          return x11.opts.pipelineConnect ?? x11.defaults.pipelineConnect;
        }
        static set pipelineConnect(t6) {
          x11.opts.pipelineConnect = t6;
        }
        get pipelineConnect() {
          return this.opts.pipelineConnect ?? x11.pipelineConnect;
        }
        set pipelineConnect(t6) {
          this.opts.pipelineConnect = t6;
        }
        static get subtls() {
          return x11.opts.subtls ?? x11.defaults.subtls;
        }
        static set subtls(t6) {
          x11.opts.subtls = t6;
        }
        get subtls() {
          return this.opts.subtls ?? x11.subtls;
        }
        set subtls(t6) {
          this.opts.subtls = t6;
        }
        static get pipelineTLS() {
          return x11.opts.pipelineTLS ?? x11.defaults.pipelineTLS;
        }
        static set pipelineTLS(t6) {
          x11.opts.pipelineTLS = t6;
        }
        get pipelineTLS() {
          return this.opts.pipelineTLS ?? x11.pipelineTLS;
        }
        set pipelineTLS(t6) {
          this.opts.pipelineTLS = t6;
        }
        static get rootCerts() {
          return x11.opts.rootCerts ?? x11.defaults.rootCerts;
        }
        static set rootCerts(t6) {
          x11.opts.rootCerts = t6;
        }
        get rootCerts() {
          return this.opts.rootCerts ?? x11.rootCerts;
        }
        set rootCerts(t6) {
          this.opts.rootCerts = t6;
        }
        wsProxyAddrForHost(t6, n7) {
          let i8 = this.wsProxy;
          if (i8 === void 0) throw new Error("No WebSocket proxy is configured. Please see https://github.com/neondatabase/serverless/blob/main/CONFIG.md#wsproxy-string--host-string-port-number--string--string");
          return typeof i8 == "function" ? i8(t6, n7) : `${i8}?address=${t6}:${n7}`;
        }
        setNoDelay() {
          return this;
        }
        setKeepAlive() {
          return this;
        }
        ref() {
          return this;
        }
        unref() {
          return this;
        }
        connect(t6, n7, i8) {
          this.connecting = true, i8 && this.once("connect", i8);
          let s10 = a6(() => {
            this.connecting = false, this.pending = false, this.emit("connect"), this.emit("ready");
          }, "handleWebSocketOpen"), o9 = a6((c6, h8 = false) => {
            c6.binaryType = "arraybuffer", c6.addEventListener("error", (l7) => {
              this.emit("error", l7), this.emit("close");
            }), c6.addEventListener("message", (l7) => {
              if (this.tlsState === 0) {
                let y7 = d6.from(l7.data);
                this.emit(
                  "data",
                  y7
                );
              }
            }), c6.addEventListener("close", () => {
              this.emit("close");
            }), h8 ? s10() : c6.addEventListener(
              "open",
              s10
            );
          }, "configureWebSocket"), u7;
          try {
            u7 = this.wsProxyAddrForHost(n7, typeof t6 == "string" ? parseInt(t6, 10) : t6);
          } catch (c6) {
            this.emit("error", c6), this.emit("close");
            return;
          }
          try {
            let h8 = (this.useSecureWebSocket ? "wss:" : "ws:") + "//" + u7;
            if (this.webSocketConstructor !== void 0) this.ws = new this.webSocketConstructor(h8), o9(this.ws);
            else try {
              this.ws = new WebSocket(
                h8
              ), o9(this.ws);
            } catch {
              this.ws = new __unstable_WebSocket(h8), o9(this.ws);
            }
          } catch (c6) {
            let l7 = (this.useSecureWebSocket ? "https:" : "http:") + "//" + u7;
            fetch(l7, { headers: { Upgrade: "websocket" } }).then((y7) => {
              if (this.ws = y7.webSocket, this.ws == null) throw c6;
              this.ws.accept(), o9(
                this.ws,
                true
              );
            }).catch((y7) => {
              this.emit("error", new Error(`All attempts to open a WebSocket to connect to the database failed. Please refer to https://github.com/neondatabase/serverless/blob/main/CONFIG.md#websocketconstructor-typeof-websocket--undefined. Details: ${y7.message}`)), this.emit("close");
            });
          }
        }
        async startTls(t6) {
          if (this.subtls === void 0) throw new Error("For Postgres SSL connections, you must set `neonConfig.subtls` to the subtls library. See https://github.com/neondatabase/serverless/blob/main/CONFIG.md for more information.");
          this.tlsState = 1;
          let n7 = this.subtls.TrustedCert.fromPEM(this.rootCerts), i8 = new this.subtls.WebSocketReadQueue(this.ws), s10 = i8.read.bind(
            i8
          ), o9 = this.rawWrite.bind(this), [u7, c6] = await this.subtls.startTls(t6, n7, s10, o9, { useSNI: !this.disableSNI, expectPreData: this.pipelineTLS ? new Uint8Array([83]) : void 0 });
          this.tlsRead = u7, this.tlsWrite = c6, this.tlsState = 2, this.encrypted = true, this.authorized = true, this.emit(
            "secureConnection",
            this
          ), this.tlsReadLoop();
        }
        async tlsReadLoop() {
          for (; ; ) {
            let t6 = await this.tlsRead();
            if (t6 === void 0) break;
            {
              let n7 = d6.from(t6);
              this.emit("data", n7);
            }
          }
        }
        rawWrite(t6) {
          if (!this.coalesceWrites) {
            this.ws.send(t6);
            return;
          }
          if (this.writeBuffer === void 0) this.writeBuffer = t6, setTimeout(
            () => {
              this.ws.send(this.writeBuffer), this.writeBuffer = void 0;
            },
            0
          );
          else {
            let n7 = new Uint8Array(this.writeBuffer.length + t6.length);
            n7.set(this.writeBuffer), n7.set(t6, this.writeBuffer.length), this.writeBuffer = n7;
          }
        }
        write(t6, n7 = "utf8", i8 = (s10) => {
        }) {
          return t6.length === 0 ? (i8(), true) : (typeof t6 == "string" && (t6 = d6.from(t6, n7)), this.tlsState === 0 ? (this.rawWrite(t6), i8()) : this.tlsState === 1 ? this.once("secureConnection", () => {
            this.write(
              t6,
              n7,
              i8
            );
          }) : (this.tlsWrite(t6), i8()), true);
        }
        end(t6 = d6.alloc(0), n7 = "utf8", i8 = () => {
        }) {
          return this.write(t6, n7, () => {
            this.ws.close(), i8();
          }), this;
        }
        destroy() {
          return this.destroyed = true, this.end();
        }
      };
      a6(x8, "Socket"), T3(x8, "defaults", {
        poolQueryViaFetch: false,
        fetchEndpoint: (t6) => "https://" + t6 + "/sql",
        fetchConnectionCache: false,
        fetchFunction: void 0,
        webSocketConstructor: void 0,
        wsProxy: (t6) => t6 + "/v2",
        useSecureWebSocket: true,
        forceDisablePgSSL: true,
        coalesceWrites: true,
        pipelineConnect: "password",
        subtls: void 0,
        rootCerts: "",
        pipelineTLS: false,
        disableSNI: false
      }), T3(x8, "opts", {});
      _e6 = x8;
    });
    zr = I4((C6) => {
      "use strict";
      p8();
      Object.defineProperty(C6, "__esModule", { value: true });
      C6.NoticeMessage = C6.DataRowMessage = C6.CommandCompleteMessage = C6.ReadyForQueryMessage = C6.NotificationResponseMessage = C6.BackendKeyDataMessage = C6.AuthenticationMD5Password = C6.ParameterStatusMessage = C6.ParameterDescriptionMessage = C6.RowDescriptionMessage = C6.Field = C6.CopyResponse = C6.CopyDataMessage = C6.DatabaseError = C6.copyDone = C6.emptyQuery = C6.replicationStart = C6.portalSuspended = C6.noData = C6.closeComplete = C6.bindComplete = C6.parseComplete = void 0;
      C6.parseComplete = { name: "parseComplete", length: 5 };
      C6.bindComplete = { name: "bindComplete", length: 5 };
      C6.closeComplete = { name: "closeComplete", length: 5 };
      C6.noData = { name: "noData", length: 5 };
      C6.portalSuspended = { name: "portalSuspended", length: 5 };
      C6.replicationStart = { name: "replicationStart", length: 4 };
      C6.emptyQuery = { name: "emptyQuery", length: 4 };
      C6.copyDone = { name: "copyDone", length: 4 };
      var Dr = class Dr extends Error {
        constructor(e6, t6, n7) {
          super(
            e6
          ), this.length = t6, this.name = n7;
        }
      };
      a6(Dr, "DatabaseError");
      var xr = Dr;
      C6.DatabaseError = xr;
      var Or = class Or {
        constructor(e6, t6) {
          this.length = e6, this.chunk = t6, this.name = "copyData";
        }
      };
      a6(Or, "CopyDataMessage");
      var Er2 = Or;
      C6.CopyDataMessage = Er2;
      var kr = class kr {
        constructor(e6, t6, n7, i8) {
          this.length = e6, this.name = t6, this.binary = n7, this.columnTypes = new Array(i8);
        }
      };
      a6(kr, "CopyResponse");
      var vr = kr;
      C6.CopyResponse = vr;
      var Ur2 = class Ur {
        constructor(e6, t6, n7, i8, s10, o9, u7) {
          this.name = e6, this.tableID = t6, this.columnID = n7, this.dataTypeID = i8, this.dataTypeSize = s10, this.dataTypeModifier = o9, this.format = u7;
        }
      };
      a6(Ur2, "Field");
      var _r = Ur2;
      C6.Field = _r;
      var qr2 = class qr {
        constructor(e6, t6) {
          this.length = e6, this.fieldCount = t6, this.name = "rowDescription", this.fields = new Array(
            this.fieldCount
          );
        }
      };
      a6(qr2, "RowDescriptionMessage");
      var Ar = qr2;
      C6.RowDescriptionMessage = Ar;
      var Nr2 = class Nr {
        constructor(e6, t6) {
          this.length = e6, this.parameterCount = t6, this.name = "parameterDescription", this.dataTypeIDs = new Array(this.parameterCount);
        }
      };
      a6(Nr2, "ParameterDescriptionMessage");
      var Cr2 = Nr2;
      C6.ParameterDescriptionMessage = Cr2;
      var Qr = class Qr {
        constructor(e6, t6, n7) {
          this.length = e6, this.parameterName = t6, this.parameterValue = n7, this.name = "parameterStatus";
        }
      };
      a6(Qr, "ParameterStatusMessage");
      var Ir = Qr;
      C6.ParameterStatusMessage = Ir;
      var Wr2 = class Wr {
        constructor(e6, t6) {
          this.length = e6, this.salt = t6, this.name = "authenticationMD5Password";
        }
      };
      a6(Wr2, "AuthenticationMD5Password");
      var Tr = Wr2;
      C6.AuthenticationMD5Password = Tr;
      var jr2 = class jr {
        constructor(e6, t6, n7) {
          this.length = e6, this.processID = t6, this.secretKey = n7, this.name = "backendKeyData";
        }
      };
      a6(
        jr2,
        "BackendKeyDataMessage"
      );
      var Pr2 = jr2;
      C6.BackendKeyDataMessage = Pr2;
      var Hr2 = class Hr {
        constructor(e6, t6, n7, i8) {
          this.length = e6, this.processId = t6, this.channel = n7, this.payload = i8, this.name = "notification";
        }
      };
      a6(Hr2, "NotificationResponseMessage");
      var Br2 = Hr2;
      C6.NotificationResponseMessage = Br2;
      var Gr2 = class Gr {
        constructor(e6, t6) {
          this.length = e6, this.status = t6, this.name = "readyForQuery";
        }
      };
      a6(Gr2, "ReadyForQueryMessage");
      var Lr = Gr2;
      C6.ReadyForQueryMessage = Lr;
      var $r = class $r {
        constructor(e6, t6) {
          this.length = e6, this.text = t6, this.name = "commandComplete";
        }
      };
      a6($r, "CommandCompleteMessage");
      var Rr = $r;
      C6.CommandCompleteMessage = Rr;
      var Kr2 = class Kr {
        constructor(e6, t6) {
          this.length = e6, this.fields = t6, this.name = "dataRow", this.fieldCount = t6.length;
        }
      };
      a6(Kr2, "DataRowMessage");
      var Fr = Kr2;
      C6.DataRowMessage = Fr;
      var Vr2 = class Vr {
        constructor(e6, t6) {
          this.length = e6, this.message = t6, this.name = "notice";
        }
      };
      a6(Vr2, "NoticeMessage");
      var Mr = Vr2;
      C6.NoticeMessage = Mr;
    });
    ys = I4((bt2) => {
      "use strict";
      p8();
      Object.defineProperty(bt2, "__esModule", { value: true });
      bt2.Writer = void 0;
      var Zr2 = class Zr {
        constructor(e6 = 256) {
          this.size = e6, this.offset = 5, this.headerPosition = 0, this.buffer = d6.allocUnsafe(e6);
        }
        ensure(e6) {
          var t6 = this.buffer.length - this.offset;
          if (t6 < e6) {
            var n7 = this.buffer, i8 = n7.length + (n7.length >> 1) + e6;
            this.buffer = d6.allocUnsafe(
              i8
            ), n7.copy(this.buffer);
          }
        }
        addInt32(e6) {
          return this.ensure(4), this.buffer[this.offset++] = e6 >>> 24 & 255, this.buffer[this.offset++] = e6 >>> 16 & 255, this.buffer[this.offset++] = e6 >>> 8 & 255, this.buffer[this.offset++] = e6 >>> 0 & 255, this;
        }
        addInt16(e6) {
          return this.ensure(2), this.buffer[this.offset++] = e6 >>> 8 & 255, this.buffer[this.offset++] = e6 >>> 0 & 255, this;
        }
        addCString(e6) {
          if (!e6) this.ensure(1);
          else {
            var t6 = d6.byteLength(e6);
            this.ensure(t6 + 1), this.buffer.write(
              e6,
              this.offset,
              "utf-8"
            ), this.offset += t6;
          }
          return this.buffer[this.offset++] = 0, this;
        }
        addString(e6 = "") {
          var t6 = d6.byteLength(e6);
          return this.ensure(t6), this.buffer.write(e6, this.offset), this.offset += t6, this;
        }
        add(e6) {
          return this.ensure(e6.length), e6.copy(this.buffer, this.offset), this.offset += e6.length, this;
        }
        join(e6) {
          if (e6) {
            this.buffer[this.headerPosition] = e6;
            let t6 = this.offset - (this.headerPosition + 1);
            this.buffer.writeInt32BE(t6, this.headerPosition + 1);
          }
          return this.buffer.slice(e6 ? 0 : 5, this.offset);
        }
        flush(e6) {
          var t6 = this.join(e6);
          return this.offset = 5, this.headerPosition = 0, this.buffer = d6.allocUnsafe(this.size), t6;
        }
      };
      a6(Zr2, "Writer");
      var Yr3 = Zr2;
      bt2.Writer = Yr3;
    });
    gs = I4((xt2) => {
      "use strict";
      p8();
      Object.defineProperty(xt2, "__esModule", { value: true });
      xt2.serialize = void 0;
      var Jr2 = ys(), F6 = new Jr2.Writer(), Ru = a6((r6) => {
        F6.addInt16(3).addInt16(
          0
        );
        for (let n7 of Object.keys(r6)) F6.addCString(n7).addCString(r6[n7]);
        F6.addCString("client_encoding").addCString("UTF8");
        var e6 = F6.addCString("").flush(), t6 = e6.length + 4;
        return new Jr2.Writer().addInt32(t6).add(e6).flush();
      }, "startup"), Fu2 = a6(() => {
        let r6 = d6.allocUnsafe(8);
        return r6.writeInt32BE(8, 0), r6.writeInt32BE(80877103, 4), r6;
      }, "requestSsl"), Mu2 = a6((r6) => F6.addCString(r6).flush(112), "password"), Du2 = a6(function(r6, e6) {
        return F6.addCString(r6).addInt32(
          d6.byteLength(e6)
        ).addString(e6), F6.flush(112);
      }, "sendSASLInitialResponseMessage"), Ou = a6(
        function(r6) {
          return F6.addString(r6).flush(112);
        },
        "sendSCRAMClientFinalMessage"
      ), ku = a6(
        (r6) => F6.addCString(r6).flush(81),
        "query"
      ), ms3 = [], Uu = a6((r6) => {
        let e6 = r6.name || "";
        e6.length > 63 && (console.error("Warning! Postgres only supports 63 characters for query names."), console.error("You supplied %s (%s)", e6, e6.length), console.error("This can cause conflicts and silent errors executing queries"));
        let t6 = r6.types || ms3;
        for (var n7 = t6.length, i8 = F6.addCString(e6).addCString(r6.text).addInt16(n7), s10 = 0; s10 < n7; s10++) i8.addInt32(t6[s10]);
        return F6.flush(80);
      }, "parse"), Ue3 = new Jr2.Writer(), qu = a6(function(r6, e6) {
        for (let t6 = 0; t6 < r6.length; t6++) {
          let n7 = e6 ? e6(r6[t6], t6) : r6[t6];
          n7 == null ? (F6.addInt16(0), Ue3.addInt32(-1)) : n7 instanceof d6 ? (F6.addInt16(1), Ue3.addInt32(n7.length), Ue3.add(n7)) : (F6.addInt16(0), Ue3.addInt32(d6.byteLength(
            n7
          )), Ue3.addString(n7));
        }
      }, "writeValues"), Nu = a6((r6 = {}) => {
        let e6 = r6.portal || "", t6 = r6.statement || "", n7 = r6.binary || false, i8 = r6.values || ms3, s10 = i8.length;
        return F6.addCString(e6).addCString(t6), F6.addInt16(s10), qu(i8, r6.valueMapper), F6.addInt16(s10), F6.add(Ue3.flush()), F6.addInt16(n7 ? 1 : 0), F6.flush(66);
      }, "bind"), Qu = d6.from([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]), Wu = a6((r6) => {
        if (!r6 || !r6.portal && !r6.rows) return Qu;
        let e6 = r6.portal || "", t6 = r6.rows || 0, n7 = d6.byteLength(e6), i8 = 4 + n7 + 1 + 4, s10 = d6.allocUnsafe(1 + i8);
        return s10[0] = 69, s10.writeInt32BE(i8, 1), s10.write(e6, 5, "utf-8"), s10[n7 + 5] = 0, s10.writeUInt32BE(t6, s10.length - 4), s10;
      }, "execute"), ju = a6((r6, e6) => {
        let t6 = d6.allocUnsafe(16);
        return t6.writeInt32BE(16, 0), t6.writeInt16BE(1234, 4), t6.writeInt16BE(5678, 6), t6.writeInt32BE(
          r6,
          8
        ), t6.writeInt32BE(e6, 12), t6;
      }, "cancel"), Xr2 = a6(
        (r6, e6) => {
          let n7 = 4 + d6.byteLength(e6) + 1, i8 = d6.allocUnsafe(1 + n7);
          return i8[0] = r6, i8.writeInt32BE(n7, 1), i8.write(e6, 5, "utf-8"), i8[n7] = 0, i8;
        },
        "cstringMessage"
      ), Hu = F6.addCString("P").flush(68), Gu = F6.addCString("S").flush(68), $u = a6((r6) => r6.name ? Xr2(68, `${r6.type}${r6.name || ""}`) : r6.type === "P" ? Hu : Gu, "describe"), Ku = a6(
        (r6) => {
          let e6 = `${r6.type}${r6.name || ""}`;
          return Xr2(67, e6);
        },
        "close"
      ), Vu = a6((r6) => F6.add(r6).flush(
        100
      ), "copyData"), zu = a6((r6) => Xr2(102, r6), "copyFail"), St2 = a6((r6) => d6.from([r6, 0, 0, 0, 4]), "codeOnlyBuffer"), Yu = St2(72), Zu = St2(83), Ju = St2(88), Xu = St2(99), ec = {
        startup: Ru,
        password: Mu2,
        requestSsl: Fu2,
        sendSASLInitialResponseMessage: Du2,
        sendSCRAMClientFinalMessage: Ou,
        query: ku,
        parse: Uu,
        bind: Nu,
        execute: Wu,
        describe: $u,
        close: Ku,
        flush: () => Yu,
        sync: () => Zu,
        end: () => Ju,
        copyData: Vu,
        copyDone: () => Xu,
        copyFail: zu,
        cancel: ju
      };
      xt2.serialize = ec;
    });
    ws = I4((Et2) => {
      "use strict";
      p8();
      Object.defineProperty(Et2, "__esModule", { value: true });
      Et2.BufferReader = void 0;
      var tc = d6.allocUnsafe(0), tn2 = class tn {
        constructor(e6 = 0) {
          this.offset = e6, this.buffer = tc, this.encoding = "utf-8";
        }
        setBuffer(e6, t6) {
          this.offset = e6, this.buffer = t6;
        }
        int16() {
          let e6 = this.buffer.readInt16BE(this.offset);
          return this.offset += 2, e6;
        }
        byte() {
          let e6 = this.buffer[this.offset];
          return this.offset++, e6;
        }
        int32() {
          let e6 = this.buffer.readInt32BE(this.offset);
          return this.offset += 4, e6;
        }
        string(e6) {
          let t6 = this.buffer.toString(this.encoding, this.offset, this.offset + e6);
          return this.offset += e6, t6;
        }
        cstring() {
          let e6 = this.offset, t6 = e6;
          for (; this.buffer[t6++] !== 0; ) ;
          return this.offset = t6, this.buffer.toString(this.encoding, e6, t6 - 1);
        }
        bytes(e6) {
          let t6 = this.buffer.slice(this.offset, this.offset + e6);
          return this.offset += e6, t6;
        }
      };
      a6(tn2, "BufferReader");
      var en2 = tn2;
      Et2.BufferReader = en2;
    });
    bs = {};
    X3(bs, { default: () => rc });
    Ss = K3(() => {
      "use strict";
      p8();
      rc = {};
    });
    vs = I4((qe2) => {
      "use strict";
      p8();
      var nc = qe2 && qe2.__importDefault || function(r6) {
        return r6 && r6.__esModule ? r6 : { default: r6 };
      };
      Object.defineProperty(qe2, "__esModule", { value: true });
      qe2.Parser = void 0;
      var M3 = zr(), ic = ws(), sc = nc((Ss(), k8(bs))), rn2 = 1, oc = 4, xs = rn2 + oc, Es3 = d6.allocUnsafe(
        0
      ), sn2 = class sn {
        constructor(e6) {
          if (this.buffer = Es3, this.bufferLength = 0, this.bufferOffset = 0, this.reader = new ic.BufferReader(), e6?.mode === "binary") throw new Error("Binary mode not supported yet");
          this.mode = e6?.mode || "text";
        }
        parse(e6, t6) {
          this.mergeBuffer(e6);
          let n7 = this.bufferOffset + this.bufferLength, i8 = this.bufferOffset;
          for (; i8 + xs <= n7; ) {
            let s10 = this.buffer[i8], o9 = this.buffer.readUInt32BE(i8 + rn2), u7 = rn2 + o9;
            if (u7 + i8 <= n7) {
              let c6 = this.handlePacket(
                i8 + xs,
                s10,
                o9,
                this.buffer
              );
              t6(c6), i8 += u7;
            } else break;
          }
          i8 === n7 ? (this.buffer = Es3, this.bufferLength = 0, this.bufferOffset = 0) : (this.bufferLength = n7 - i8, this.bufferOffset = i8);
        }
        mergeBuffer(e6) {
          if (this.bufferLength > 0) {
            let t6 = this.bufferLength + e6.byteLength;
            if (t6 + this.bufferOffset > this.buffer.byteLength) {
              let i8;
              if (t6 <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) i8 = this.buffer;
              else {
                let s10 = this.buffer.byteLength * 2;
                for (; t6 >= s10; ) s10 *= 2;
                i8 = d6.allocUnsafe(s10);
              }
              this.buffer.copy(i8, 0, this.bufferOffset, this.bufferOffset + this.bufferLength), this.buffer = i8, this.bufferOffset = 0;
            }
            e6.copy(this.buffer, this.bufferOffset + this.bufferLength), this.bufferLength = t6;
          } else this.buffer = e6, this.bufferOffset = 0, this.bufferLength = e6.byteLength;
        }
        handlePacket(e6, t6, n7, i8) {
          switch (t6) {
            case 50:
              return M3.bindComplete;
            case 49:
              return M3.parseComplete;
            case 51:
              return M3.closeComplete;
            case 110:
              return M3.noData;
            case 115:
              return M3.portalSuspended;
            case 99:
              return M3.copyDone;
            case 87:
              return M3.replicationStart;
            case 73:
              return M3.emptyQuery;
            case 68:
              return this.parseDataRowMessage(e6, n7, i8);
            case 67:
              return this.parseCommandCompleteMessage(
                e6,
                n7,
                i8
              );
            case 90:
              return this.parseReadyForQueryMessage(e6, n7, i8);
            case 65:
              return this.parseNotificationMessage(e6, n7, i8);
            case 82:
              return this.parseAuthenticationResponse(
                e6,
                n7,
                i8
              );
            case 83:
              return this.parseParameterStatusMessage(e6, n7, i8);
            case 75:
              return this.parseBackendKeyData(e6, n7, i8);
            case 69:
              return this.parseErrorMessage(e6, n7, i8, "error");
            case 78:
              return this.parseErrorMessage(e6, n7, i8, "notice");
            case 84:
              return this.parseRowDescriptionMessage(
                e6,
                n7,
                i8
              );
            case 116:
              return this.parseParameterDescriptionMessage(e6, n7, i8);
            case 71:
              return this.parseCopyInMessage(e6, n7, i8);
            case 72:
              return this.parseCopyOutMessage(e6, n7, i8);
            case 100:
              return this.parseCopyData(e6, n7, i8);
            default:
              sc.default.fail(`unknown message code: ${t6.toString(16)}`);
          }
        }
        parseReadyForQueryMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.string(1);
          return new M3.ReadyForQueryMessage(t6, i8);
        }
        parseCommandCompleteMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.cstring();
          return new M3.CommandCompleteMessage(
            t6,
            i8
          );
        }
        parseCopyData(e6, t6, n7) {
          let i8 = n7.slice(e6, e6 + (t6 - 4));
          return new M3.CopyDataMessage(
            t6,
            i8
          );
        }
        parseCopyInMessage(e6, t6, n7) {
          return this.parseCopyMessage(e6, t6, n7, "copyInResponse");
        }
        parseCopyOutMessage(e6, t6, n7) {
          return this.parseCopyMessage(e6, t6, n7, "copyOutResponse");
        }
        parseCopyMessage(e6, t6, n7, i8) {
          this.reader.setBuffer(e6, n7);
          let s10 = this.reader.byte() !== 0, o9 = this.reader.int16(), u7 = new M3.CopyResponse(t6, i8, s10, o9);
          for (let c6 = 0; c6 < o9; c6++) u7.columnTypes[c6] = this.reader.int16();
          return u7;
        }
        parseNotificationMessage(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int32(), s10 = this.reader.cstring(), o9 = this.reader.cstring();
          return new M3.NotificationResponseMessage(t6, i8, s10, o9);
        }
        parseRowDescriptionMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int16(), s10 = new M3.RowDescriptionMessage(t6, i8);
          for (let o9 = 0; o9 < i8; o9++) s10.fields[o9] = this.parseField();
          return s10;
        }
        parseField() {
          let e6 = this.reader.cstring(), t6 = this.reader.int32(), n7 = this.reader.int16(), i8 = this.reader.int32(), s10 = this.reader.int16(), o9 = this.reader.int32(), u7 = this.reader.int16() === 0 ? "text" : "binary";
          return new M3.Field(e6, t6, n7, i8, s10, o9, u7);
        }
        parseParameterDescriptionMessage(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int16(), s10 = new M3.ParameterDescriptionMessage(t6, i8);
          for (let o9 = 0; o9 < i8; o9++) s10.dataTypeIDs[o9] = this.reader.int32();
          return s10;
        }
        parseDataRowMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int16(), s10 = new Array(i8);
          for (let o9 = 0; o9 < i8; o9++) {
            let u7 = this.reader.int32();
            s10[o9] = u7 === -1 ? null : this.reader.string(u7);
          }
          return new M3.DataRowMessage(
            t6,
            s10
          );
        }
        parseParameterStatusMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.cstring(), s10 = this.reader.cstring();
          return new M3.ParameterStatusMessage(t6, i8, s10);
        }
        parseBackendKeyData(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int32(), s10 = this.reader.int32();
          return new M3.BackendKeyDataMessage(t6, i8, s10);
        }
        parseAuthenticationResponse(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int32(), s10 = { name: "authenticationOk", length: t6 };
          switch (i8) {
            case 0:
              break;
            case 3:
              s10.length === 8 && (s10.name = "authenticationCleartextPassword");
              break;
            case 5:
              if (s10.length === 12) {
                s10.name = "authenticationMD5Password";
                let u7 = this.reader.bytes(4);
                return new M3.AuthenticationMD5Password(t6, u7);
              }
              break;
            case 10:
              s10.name = "authenticationSASL", s10.mechanisms = [];
              let o9;
              do
                o9 = this.reader.cstring(), o9 && s10.mechanisms.push(o9);
              while (o9);
              break;
            case 11:
              s10.name = "authenticationSASLContinue", s10.data = this.reader.string(t6 - 8);
              break;
            case 12:
              s10.name = "authenticationSASLFinal", s10.data = this.reader.string(t6 - 8);
              break;
            default:
              throw new Error("Unknown authenticationOk message type " + i8);
          }
          return s10;
        }
        parseErrorMessage(e6, t6, n7, i8) {
          this.reader.setBuffer(e6, n7);
          let s10 = {}, o9 = this.reader.string(1);
          for (; o9 !== "\0"; ) s10[o9] = this.reader.cstring(), o9 = this.reader.string(1);
          let u7 = s10.M, c6 = i8 === "notice" ? new M3.NoticeMessage(
            t6,
            u7
          ) : new M3.DatabaseError(u7, t6, i8);
          return c6.severity = s10.S, c6.code = s10.C, c6.detail = s10.D, c6.hint = s10.H, c6.position = s10.P, c6.internalPosition = s10.p, c6.internalQuery = s10.q, c6.where = s10.W, c6.schema = s10.s, c6.table = s10.t, c6.column = s10.c, c6.dataType = s10.d, c6.constraint = s10.n, c6.file = s10.F, c6.line = s10.L, c6.routine = s10.R, c6;
        }
      };
      a6(sn2, "Parser");
      var nn2 = sn2;
      qe2.Parser = nn2;
    });
    on2 = I4((be3) => {
      "use strict";
      p8();
      Object.defineProperty(be3, "__esModule", { value: true });
      be3.DatabaseError = be3.serialize = be3.parse = void 0;
      var ac = zr();
      Object.defineProperty(
        be3,
        "DatabaseError",
        { enumerable: true, get: function() {
          return ac.DatabaseError;
        } }
      );
      var uc = gs();
      Object.defineProperty(be3, "serialize", { enumerable: true, get: function() {
        return uc.serialize;
      } });
      var cc = vs();
      function hc(r6, e6) {
        let t6 = new cc.Parser();
        return r6.on("data", (n7) => t6.parse(
          n7,
          e6
        )), new Promise((n7) => r6.on("end", () => n7()));
      }
      a6(hc, "parse");
      be3.parse = hc;
    });
    _s = {};
    X3(_s, { connect: () => lc });
    As = K3(() => {
      "use strict";
      p8();
      a6(lc, "connect");
    });
    cn2 = I4((ef, Ts) => {
      "use strict";
      p8();
      var Cs2 = (wt2(), k8(ds)), fc2 = ge3().EventEmitter, {
        parse: pc,
        serialize: q7
      } = on2(), Is = q7.flush(), dc = q7.sync(), yc = q7.end(), un2 = class un extends fc2 {
        constructor(e6) {
          super(), e6 = e6 || {}, this.stream = e6.stream || new Cs2.Socket(), this._keepAlive = e6.keepAlive, this._keepAliveInitialDelayMillis = e6.keepAliveInitialDelayMillis, this.lastBuffer = false, this.parsedStatements = {}, this.ssl = e6.ssl || false, this._ending = false, this._emitMessage = false;
          var t6 = this;
          this.on("newListener", function(n7) {
            n7 === "message" && (t6._emitMessage = true);
          });
        }
        connect(e6, t6) {
          var n7 = this;
          this._connecting = true, this.stream.setNoDelay(true), this.stream.connect(
            e6,
            t6
          ), this.stream.once("connect", function() {
            n7._keepAlive && n7.stream.setKeepAlive(
              true,
              n7._keepAliveInitialDelayMillis
            ), n7.emit("connect");
          });
          let i8 = a6(function(s10) {
            n7._ending && (s10.code === "ECONNRESET" || s10.code === "EPIPE") || n7.emit("error", s10);
          }, "reportStreamError");
          if (this.stream.on("error", i8), this.stream.on("close", function() {
            n7.emit("end");
          }), !this.ssl) return this.attachListeners(this.stream);
          this.stream.once("data", function(s10) {
            var o9 = s10.toString("utf8");
            switch (o9) {
              case "S":
                break;
              case "N":
                return n7.stream.end(), n7.emit("error", new Error("The server does not support SSL connections"));
              default:
                return n7.stream.end(), n7.emit("error", new Error("There was an error establishing an SSL connection"));
            }
            var u7 = (As(), k8(_s));
            let c6 = { socket: n7.stream };
            n7.ssl !== true && (Object.assign(
              c6,
              n7.ssl
            ), "key" in n7.ssl && (c6.key = n7.ssl.key)), Cs2.isIP(t6) === 0 && (c6.servername = t6);
            try {
              n7.stream = u7.connect(c6);
            } catch (h8) {
              return n7.emit("error", h8);
            }
            n7.attachListeners(n7.stream), n7.stream.on("error", i8), n7.emit("sslconnect");
          });
        }
        attachListeners(e6) {
          e6.on("end", () => {
            this.emit("end");
          }), pc(e6, (t6) => {
            var n7 = t6.name === "error" ? "errorMessage" : t6.name;
            this._emitMessage && this.emit("message", t6), this.emit(n7, t6);
          });
        }
        requestSsl() {
          this.stream.write(q7.requestSsl());
        }
        startup(e6) {
          this.stream.write(q7.startup(e6));
        }
        cancel(e6, t6) {
          this._send(q7.cancel(e6, t6));
        }
        password(e6) {
          this._send(q7.password(e6));
        }
        sendSASLInitialResponseMessage(e6, t6) {
          this._send(q7.sendSASLInitialResponseMessage(
            e6,
            t6
          ));
        }
        sendSCRAMClientFinalMessage(e6) {
          this._send(q7.sendSCRAMClientFinalMessage(e6));
        }
        _send(e6) {
          return this.stream.writable ? this.stream.write(e6) : false;
        }
        query(e6) {
          this._send(q7.query(
            e6
          ));
        }
        parse(e6) {
          this._send(q7.parse(e6));
        }
        bind(e6) {
          this._send(q7.bind(e6));
        }
        execute(e6) {
          this._send(q7.execute(e6));
        }
        flush() {
          this.stream.writable && this.stream.write(Is);
        }
        sync() {
          this._ending = true, this._send(Is), this._send(dc);
        }
        ref() {
          this.stream.ref();
        }
        unref() {
          this.stream.unref();
        }
        end() {
          if (this._ending = true, !this._connecting || !this.stream.writable) {
            this.stream.end();
            return;
          }
          return this.stream.write(yc, () => {
            this.stream.end();
          });
        }
        close(e6) {
          this._send(q7.close(e6));
        }
        describe(e6) {
          this._send(q7.describe(e6));
        }
        sendCopyFromChunk(e6) {
          this._send(q7.copyData(e6));
        }
        endCopyFrom() {
          this._send(q7.copyDone());
        }
        sendCopyFail(e6) {
          this._send(q7.copyFail(e6));
        }
      };
      a6(un2, "Connection");
      var an3 = un2;
      Ts.exports = an3;
    });
    Ls = I4((sf, Bs2) => {
      "use strict";
      p8();
      var mc = ge3().EventEmitter, nf = (Ge2(), k8(He2)), gc = tt2(), hn3 = qi(), wc = Yi(), bc = hr(), Sc = gt3(), Ps = fs7(), xc = et2(), Ec = cn2(), ln2 = class ln extends mc {
        constructor(e6) {
          super(), this.connectionParameters = new Sc(e6), this.user = this.connectionParameters.user, this.database = this.connectionParameters.database, this.port = this.connectionParameters.port, this.host = this.connectionParameters.host, Object.defineProperty(this, "password", { configurable: true, enumerable: false, writable: true, value: this.connectionParameters.password }), this.replication = this.connectionParameters.replication;
          var t6 = e6 || {};
          this._Promise = t6.Promise || b8.Promise, this._types = new bc(t6.types), this._ending = false, this._connecting = false, this._connected = false, this._connectionError = false, this._queryable = true, this.connection = t6.connection || new Ec({ stream: t6.stream, ssl: this.connectionParameters.ssl, keepAlive: t6.keepAlive || false, keepAliveInitialDelayMillis: t6.keepAliveInitialDelayMillis || 0, encoding: this.connectionParameters.client_encoding || "utf8" }), this.queryQueue = [], this.binary = t6.binary || xc.binary, this.processID = null, this.secretKey = null, this.ssl = this.connectionParameters.ssl || false, this.ssl && this.ssl.key && Object.defineProperty(this.ssl, "key", { enumerable: false }), this._connectionTimeoutMillis = t6.connectionTimeoutMillis || 0;
        }
        _errorAllQueries(e6) {
          let t6 = a6(
            (n7) => {
              m9.nextTick(() => {
                n7.handleError(e6, this.connection);
              });
            },
            "enqueueError"
          );
          this.activeQuery && (t6(this.activeQuery), this.activeQuery = null), this.queryQueue.forEach(t6), this.queryQueue.length = 0;
        }
        _connect(e6) {
          var t6 = this, n7 = this.connection;
          if (this._connectionCallback = e6, this._connecting || this._connected) {
            let i8 = new Error("Client has already been connected. You cannot reuse a client.");
            m9.nextTick(() => {
              e6(i8);
            });
            return;
          }
          this._connecting = true, this.connectionTimeoutHandle, this._connectionTimeoutMillis > 0 && (this.connectionTimeoutHandle = setTimeout(() => {
            n7._ending = true, n7.stream.destroy(new Error("timeout expired"));
          }, this._connectionTimeoutMillis)), this.host && this.host.indexOf("/") === 0 ? n7.connect(this.host + "/.s.PGSQL." + this.port) : n7.connect(this.port, this.host), n7.on("connect", function() {
            t6.ssl ? n7.requestSsl() : n7.startup(t6.getStartupConf());
          }), n7.on("sslconnect", function() {
            n7.startup(t6.getStartupConf());
          }), this._attachListeners(n7), n7.once("end", () => {
            let i8 = this._ending ? new Error("Connection terminated") : new Error("Connection terminated unexpectedly");
            clearTimeout(this.connectionTimeoutHandle), this._errorAllQueries(i8), this._ending || (this._connecting && !this._connectionError ? this._connectionCallback ? this._connectionCallback(i8) : this._handleErrorEvent(i8) : this._connectionError || this._handleErrorEvent(
              i8
            )), m9.nextTick(() => {
              this.emit("end");
            });
          });
        }
        connect(e6) {
          if (e6) {
            this._connect(e6);
            return;
          }
          return new this._Promise((t6, n7) => {
            this._connect((i8) => {
              i8 ? n7(i8) : t6();
            });
          });
        }
        _attachListeners(e6) {
          e6.on("authenticationCleartextPassword", this._handleAuthCleartextPassword.bind(this)), e6.on("authenticationMD5Password", this._handleAuthMD5Password.bind(this)), e6.on("authenticationSASL", this._handleAuthSASL.bind(this)), e6.on("authenticationSASLContinue", this._handleAuthSASLContinue.bind(this)), e6.on("authenticationSASLFinal", this._handleAuthSASLFinal.bind(this)), e6.on("backendKeyData", this._handleBackendKeyData.bind(this)), e6.on("error", this._handleErrorEvent.bind(this)), e6.on(
            "errorMessage",
            this._handleErrorMessage.bind(this)
          ), e6.on("readyForQuery", this._handleReadyForQuery.bind(this)), e6.on("notice", this._handleNotice.bind(this)), e6.on("rowDescription", this._handleRowDescription.bind(this)), e6.on("dataRow", this._handleDataRow.bind(this)), e6.on("portalSuspended", this._handlePortalSuspended.bind(this)), e6.on(
            "emptyQuery",
            this._handleEmptyQuery.bind(this)
          ), e6.on("commandComplete", this._handleCommandComplete.bind(this)), e6.on("parseComplete", this._handleParseComplete.bind(this)), e6.on("copyInResponse", this._handleCopyInResponse.bind(this)), e6.on("copyData", this._handleCopyData.bind(this)), e6.on("notification", this._handleNotification.bind(this));
        }
        _checkPgPass(e6) {
          let t6 = this.connection;
          typeof this.password == "function" ? this._Promise.resolve().then(
            () => this.password()
          ).then((n7) => {
            if (n7 !== void 0) {
              if (typeof n7 != "string") {
                t6.emit("error", new TypeError("Password must be a string"));
                return;
              }
              this.connectionParameters.password = this.password = n7;
            } else this.connectionParameters.password = this.password = null;
            e6();
          }).catch((n7) => {
            t6.emit("error", n7);
          }) : this.password !== null ? e6() : wc(
            this.connectionParameters,
            (n7) => {
              n7 !== void 0 && (this.connectionParameters.password = this.password = n7), e6();
            }
          );
        }
        _handleAuthCleartextPassword(e6) {
          this._checkPgPass(() => {
            this.connection.password(this.password);
          });
        }
        _handleAuthMD5Password(e6) {
          this._checkPgPass(() => {
            let t6 = gc.postgresMd5PasswordHash(
              this.user,
              this.password,
              e6.salt
            );
            this.connection.password(t6);
          });
        }
        _handleAuthSASL(e6) {
          this._checkPgPass(() => {
            this.saslSession = hn3.startSession(e6.mechanisms), this.connection.sendSASLInitialResponseMessage(
              this.saslSession.mechanism,
              this.saslSession.response
            );
          });
        }
        _handleAuthSASLContinue(e6) {
          hn3.continueSession(this.saslSession, this.password, e6.data), this.connection.sendSCRAMClientFinalMessage(
            this.saslSession.response
          );
        }
        _handleAuthSASLFinal(e6) {
          hn3.finalizeSession(
            this.saslSession,
            e6.data
          ), this.saslSession = null;
        }
        _handleBackendKeyData(e6) {
          this.processID = e6.processID, this.secretKey = e6.secretKey;
        }
        _handleReadyForQuery(e6) {
          this._connecting && (this._connecting = false, this._connected = true, clearTimeout(this.connectionTimeoutHandle), this._connectionCallback && (this._connectionCallback(null, this), this._connectionCallback = null), this.emit("connect"));
          let { activeQuery: t6 } = this;
          this.activeQuery = null, this.readyForQuery = true, t6 && t6.handleReadyForQuery(this.connection), this._pulseQueryQueue();
        }
        _handleErrorWhileConnecting(e6) {
          if (!this._connectionError) {
            if (this._connectionError = true, clearTimeout(this.connectionTimeoutHandle), this._connectionCallback) return this._connectionCallback(e6);
            this.emit("error", e6);
          }
        }
        _handleErrorEvent(e6) {
          if (this._connecting) return this._handleErrorWhileConnecting(e6);
          this._queryable = false, this._errorAllQueries(e6), this.emit("error", e6);
        }
        _handleErrorMessage(e6) {
          if (this._connecting)
            return this._handleErrorWhileConnecting(e6);
          let t6 = this.activeQuery;
          if (!t6) {
            this._handleErrorEvent(
              e6
            );
            return;
          }
          this.activeQuery = null, t6.handleError(e6, this.connection);
        }
        _handleRowDescription(e6) {
          this.activeQuery.handleRowDescription(e6);
        }
        _handleDataRow(e6) {
          this.activeQuery.handleDataRow(
            e6
          );
        }
        _handlePortalSuspended(e6) {
          this.activeQuery.handlePortalSuspended(this.connection);
        }
        _handleEmptyQuery(e6) {
          this.activeQuery.handleEmptyQuery(this.connection);
        }
        _handleCommandComplete(e6) {
          this.activeQuery.handleCommandComplete(e6, this.connection);
        }
        _handleParseComplete(e6) {
          this.activeQuery.name && (this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text);
        }
        _handleCopyInResponse(e6) {
          this.activeQuery.handleCopyInResponse(
            this.connection
          );
        }
        _handleCopyData(e6) {
          this.activeQuery.handleCopyData(e6, this.connection);
        }
        _handleNotification(e6) {
          this.emit("notification", e6);
        }
        _handleNotice(e6) {
          this.emit("notice", e6);
        }
        getStartupConf() {
          var e6 = this.connectionParameters, t6 = { user: e6.user, database: e6.database }, n7 = e6.application_name || e6.fallback_application_name;
          return n7 && (t6.application_name = n7), e6.replication && (t6.replication = "" + e6.replication), e6.statement_timeout && (t6.statement_timeout = String(parseInt(
            e6.statement_timeout,
            10
          ))), e6.lock_timeout && (t6.lock_timeout = String(parseInt(e6.lock_timeout, 10))), e6.idle_in_transaction_session_timeout && (t6.idle_in_transaction_session_timeout = String(parseInt(
            e6.idle_in_transaction_session_timeout,
            10
          ))), e6.options && (t6.options = e6.options), t6;
        }
        cancel(e6, t6) {
          if (e6.activeQuery === t6) {
            var n7 = this.connection;
            this.host && this.host.indexOf("/") === 0 ? n7.connect(this.host + "/.s.PGSQL." + this.port) : n7.connect(this.port, this.host), n7.on("connect", function() {
              n7.cancel(
                e6.processID,
                e6.secretKey
              );
            });
          } else e6.queryQueue.indexOf(t6) !== -1 && e6.queryQueue.splice(e6.queryQueue.indexOf(t6), 1);
        }
        setTypeParser(e6, t6, n7) {
          return this._types.setTypeParser(e6, t6, n7);
        }
        getTypeParser(e6, t6) {
          return this._types.getTypeParser(e6, t6);
        }
        escapeIdentifier(e6) {
          return '"' + e6.replace(
            /"/g,
            '""'
          ) + '"';
        }
        escapeLiteral(e6) {
          for (var t6 = false, n7 = "'", i8 = 0; i8 < e6.length; i8++) {
            var s10 = e6[i8];
            s10 === "'" ? n7 += s10 + s10 : s10 === "\\" ? (n7 += s10 + s10, t6 = true) : n7 += s10;
          }
          return n7 += "'", t6 === true && (n7 = " E" + n7), n7;
        }
        _pulseQueryQueue() {
          if (this.readyForQuery === true) if (this.activeQuery = this.queryQueue.shift(), this.activeQuery) {
            this.readyForQuery = false, this.hasExecuted = true;
            let e6 = this.activeQuery.submit(this.connection);
            e6 && m9.nextTick(() => {
              this.activeQuery.handleError(e6, this.connection), this.readyForQuery = true, this._pulseQueryQueue();
            });
          } else this.hasExecuted && (this.activeQuery = null, this.emit("drain"));
        }
        query(e6, t6, n7) {
          var i8, s10, o9, u7, c6;
          if (e6 == null) throw new TypeError("Client was passed a null or undefined query");
          return typeof e6.submit == "function" ? (o9 = e6.query_timeout || this.connectionParameters.query_timeout, s10 = i8 = e6, typeof t6 == "function" && (i8.callback = i8.callback || t6)) : (o9 = this.connectionParameters.query_timeout, i8 = new Ps(
            e6,
            t6,
            n7
          ), i8.callback || (s10 = new this._Promise((h8, l7) => {
            i8.callback = (y7, E4) => y7 ? l7(y7) : h8(E4);
          }))), o9 && (c6 = i8.callback, u7 = setTimeout(() => {
            var h8 = new Error("Query read timeout");
            m9.nextTick(
              () => {
                i8.handleError(h8, this.connection);
              }
            ), c6(h8), i8.callback = () => {
            };
            var l7 = this.queryQueue.indexOf(i8);
            l7 > -1 && this.queryQueue.splice(l7, 1), this._pulseQueryQueue();
          }, o9), i8.callback = (h8, l7) => {
            clearTimeout(u7), c6(h8, l7);
          }), this.binary && !i8.binary && (i8.binary = true), i8._result && !i8._result._types && (i8._result._types = this._types), this._queryable ? this._ending ? (m9.nextTick(() => {
            i8.handleError(
              new Error("Client was closed and is not queryable"),
              this.connection
            );
          }), s10) : (this.queryQueue.push(i8), this._pulseQueryQueue(), s10) : (m9.nextTick(
            () => {
              i8.handleError(new Error("Client has encountered a connection error and is not queryable"), this.connection);
            }
          ), s10);
        }
        ref() {
          this.connection.ref();
        }
        unref() {
          this.connection.unref();
        }
        end(e6) {
          if (this._ending = true, !this.connection._connecting) if (e6) e6();
          else return this._Promise.resolve();
          if (this.activeQuery || !this._queryable ? this.connection.stream.destroy() : this.connection.end(), e6) this.connection.once("end", e6);
          else return new this._Promise((t6) => {
            this.connection.once("end", t6);
          });
        }
      };
      a6(ln2, "Client");
      var vt2 = ln2;
      vt2.Query = Ps;
      Bs2.exports = vt2;
    });
    Ds = I4((uf, Ms2) => {
      "use strict";
      p8();
      var vc = ge3().EventEmitter, Rs2 = a6(function() {
      }, "NOOP"), Fs = a6(
        (r6, e6) => {
          let t6 = r6.findIndex(e6);
          return t6 === -1 ? void 0 : r6.splice(t6, 1)[0];
        },
        "removeWhere"
      ), dn2 = class dn {
        constructor(e6, t6, n7) {
          this.client = e6, this.idleListener = t6, this.timeoutId = n7;
        }
      };
      a6(dn2, "IdleItem");
      var fn3 = dn2, yn2 = class yn {
        constructor(e6) {
          this.callback = e6;
        }
      };
      a6(yn2, "PendingItem");
      var Ne3 = yn2;
      function _c14() {
        throw new Error("Release called on client which has already been released to the pool.");
      }
      a6(_c14, "throwOnDoubleRelease");
      function _t2(r6, e6) {
        if (e6) return { callback: e6, result: void 0 };
        let t6, n7, i8 = a6(function(o9, u7) {
          o9 ? t6(o9) : n7(u7);
        }, "cb"), s10 = new r6(function(o9, u7) {
          n7 = o9, t6 = u7;
        }).catch((o9) => {
          throw Error.captureStackTrace(
            o9
          ), o9;
        });
        return { callback: i8, result: s10 };
      }
      a6(_t2, "promisify");
      function Ac(r6, e6) {
        return a6(
          function t6(n7) {
            n7.client = e6, e6.removeListener("error", t6), e6.on("error", () => {
              r6.log("additional client error after disconnection due to error", n7);
            }), r6._remove(e6), r6.emit("error", n7, e6);
          },
          "idleListener"
        );
      }
      a6(Ac, "makeIdleListener");
      var mn2 = class mn extends vc {
        constructor(e6, t6) {
          super(), this.options = Object.assign({}, e6), e6 != null && "password" in e6 && Object.defineProperty(
            this.options,
            "password",
            { configurable: true, enumerable: false, writable: true, value: e6.password }
          ), e6 != null && e6.ssl && e6.ssl.key && Object.defineProperty(this.options.ssl, "key", { enumerable: false }), this.options.max = this.options.max || this.options.poolSize || 10, this.options.maxUses = this.options.maxUses || 1 / 0, this.options.allowExitOnIdle = this.options.allowExitOnIdle || false, this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0, this.log = this.options.log || function() {
          }, this.Client = this.options.Client || t6 || At2().Client, this.Promise = this.options.Promise || b8.Promise, typeof this.options.idleTimeoutMillis > "u" && (this.options.idleTimeoutMillis = 1e4), this._clients = [], this._idle = [], this._expired = /* @__PURE__ */ new WeakSet(), this._pendingQueue = [], this._endCallback = void 0, this.ending = false, this.ended = false;
        }
        _isFull() {
          return this._clients.length >= this.options.max;
        }
        _pulseQueue() {
          if (this.log("pulse queue"), this.ended) {
            this.log("pulse queue ended");
            return;
          }
          if (this.ending) {
            this.log(
              "pulse queue on ending"
            ), this._idle.length && this._idle.slice().map((t6) => {
              this._remove(
                t6.client
              );
            }), this._clients.length || (this.ended = true, this._endCallback());
            return;
          }
          if (!this._pendingQueue.length) {
            this.log("no queued requests");
            return;
          }
          if (!this._idle.length && this._isFull()) return;
          let e6 = this._pendingQueue.shift();
          if (this._idle.length) {
            let t6 = this._idle.pop();
            clearTimeout(t6.timeoutId);
            let n7 = t6.client;
            n7.ref && n7.ref();
            let i8 = t6.idleListener;
            return this._acquireClient(n7, e6, i8, false);
          }
          if (!this._isFull()) return this.newClient(e6);
          throw new Error("unexpected condition");
        }
        _remove(e6) {
          let t6 = Fs(this._idle, (n7) => n7.client === e6);
          t6 !== void 0 && clearTimeout(t6.timeoutId), this._clients = this._clients.filter((n7) => n7 !== e6), e6.end(), this.emit("remove", e6);
        }
        connect(e6) {
          if (this.ending) {
            let i8 = new Error("Cannot use a pool after calling end on the pool");
            return e6 ? e6(i8) : this.Promise.reject(
              i8
            );
          }
          let t6 = _t2(this.Promise, e6), n7 = t6.result;
          if (this._isFull() || this._idle.length) {
            if (this._idle.length && m9.nextTick(() => this._pulseQueue()), !this.options.connectionTimeoutMillis)
              return this._pendingQueue.push(new Ne3(t6.callback)), n7;
            let i8 = a6((u7, c6, h8) => {
              clearTimeout(
                o9
              ), t6.callback(u7, c6, h8);
            }, "queueCallback"), s10 = new Ne3(i8), o9 = setTimeout(() => {
              Fs(
                this._pendingQueue,
                (u7) => u7.callback === i8
              ), s10.timedOut = true, t6.callback(new Error("timeout exceeded when trying to connect"));
            }, this.options.connectionTimeoutMillis);
            return this._pendingQueue.push(s10), n7;
          }
          return this.newClient(new Ne3(t6.callback)), n7;
        }
        newClient(e6) {
          let t6 = new this.Client(this.options);
          this._clients.push(t6);
          let n7 = Ac(this, t6);
          this.log("checking client timeout");
          let i8, s10 = false;
          this.options.connectionTimeoutMillis && (i8 = setTimeout(() => {
            this.log("ending client due to timeout"), s10 = true, t6.connection ? t6.connection.stream.destroy() : t6.end();
          }, this.options.connectionTimeoutMillis)), this.log("connecting new client"), t6.connect((o9) => {
            if (i8 && clearTimeout(i8), t6.on("error", n7), o9) this.log("client failed to connect", o9), this._clients = this._clients.filter((u7) => u7 !== t6), s10 && (o9.message = "Connection terminated due to connection timeout"), this._pulseQueue(), e6.timedOut || e6.callback(
              o9,
              void 0,
              Rs2
            );
            else {
              if (this.log("new client connected"), this.options.maxLifetimeSeconds !== 0) {
                let u7 = setTimeout(() => {
                  this.log("ending client due to expired lifetime"), this._expired.add(t6), this._idle.findIndex((h8) => h8.client === t6) !== -1 && this._acquireClient(
                    t6,
                    new Ne3((h8, l7, y7) => y7()),
                    n7,
                    false
                  );
                }, this.options.maxLifetimeSeconds * 1e3);
                u7.unref(), t6.once(
                  "end",
                  () => clearTimeout(u7)
                );
              }
              return this._acquireClient(t6, e6, n7, true);
            }
          });
        }
        _acquireClient(e6, t6, n7, i8) {
          i8 && this.emit("connect", e6), this.emit("acquire", e6), e6.release = this._releaseOnce(e6, n7), e6.removeListener("error", n7), t6.timedOut ? i8 && this.options.verify ? this.options.verify(
            e6,
            e6.release
          ) : e6.release() : i8 && this.options.verify ? this.options.verify(e6, (s10) => {
            if (s10) return e6.release(s10), t6.callback(s10, void 0, Rs2);
            t6.callback(void 0, e6, e6.release);
          }) : t6.callback(
            void 0,
            e6,
            e6.release
          );
        }
        _releaseOnce(e6, t6) {
          let n7 = false;
          return (i8) => {
            n7 && _c14(), n7 = true, this._release(
              e6,
              t6,
              i8
            );
          };
        }
        _release(e6, t6, n7) {
          if (e6.on("error", t6), e6._poolUseCount = (e6._poolUseCount || 0) + 1, this.emit("release", n7, e6), n7 || this.ending || !e6._queryable || e6._ending || e6._poolUseCount >= this.options.maxUses) {
            e6._poolUseCount >= this.options.maxUses && this.log("remove expended client"), this._remove(e6), this._pulseQueue();
            return;
          }
          if (this._expired.has(e6)) {
            this.log("remove expired client"), this._expired.delete(e6), this._remove(e6), this._pulseQueue();
            return;
          }
          let s10;
          this.options.idleTimeoutMillis && (s10 = setTimeout(() => {
            this.log("remove idle client"), this._remove(e6);
          }, this.options.idleTimeoutMillis), this.options.allowExitOnIdle && s10.unref()), this.options.allowExitOnIdle && e6.unref(), this._idle.push(new fn3(e6, t6, s10)), this._pulseQueue();
        }
        query(e6, t6, n7) {
          if (typeof e6 == "function") {
            let s10 = _t2(this.Promise, e6);
            return S4(function() {
              return s10.callback(new Error("Passing a function as the first parameter to pool.query is not supported"));
            }), s10.result;
          }
          typeof t6 == "function" && (n7 = t6, t6 = void 0);
          let i8 = _t2(this.Promise, n7);
          return n7 = i8.callback, this.connect((s10, o9) => {
            if (s10)
              return n7(s10);
            let u7 = false, c6 = a6((h8) => {
              u7 || (u7 = true, o9.release(h8), n7(h8));
            }, "onError");
            o9.once("error", c6), this.log("dispatching query");
            try {
              o9.query(e6, t6, (h8, l7) => {
                if (this.log("query dispatched"), o9.removeListener("error", c6), !u7) return u7 = true, o9.release(h8), h8 ? n7(h8) : n7(
                  void 0,
                  l7
                );
              });
            } catch (h8) {
              return o9.release(h8), n7(h8);
            }
          }), i8.result;
        }
        end(e6) {
          if (this.log("ending"), this.ending) {
            let n7 = new Error("Called end on pool more than once");
            return e6 ? e6(n7) : this.Promise.reject(n7);
          }
          this.ending = true;
          let t6 = _t2(this.Promise, e6);
          return this._endCallback = t6.callback, this._pulseQueue(), t6.result;
        }
        get waitingCount() {
          return this._pendingQueue.length;
        }
        get idleCount() {
          return this._idle.length;
        }
        get expiredCount() {
          return this._clients.reduce((e6, t6) => e6 + (this._expired.has(t6) ? 1 : 0), 0);
        }
        get totalCount() {
          return this._clients.length;
        }
      };
      a6(mn2, "Pool");
      var pn2 = mn2;
      Ms2.exports = pn2;
    });
    Os = {};
    X3(Os, { default: () => Cc });
    ks = K3(() => {
      "use strict";
      p8();
      Cc = {};
    });
    Us = I4((ff, Ic) => {
      Ic.exports = { name: "pg", version: "8.8.0", description: "PostgreSQL client - pure javascript & libpq with the same API", keywords: [
        "database",
        "libpq",
        "pg",
        "postgre",
        "postgres",
        "postgresql",
        "rdbms"
      ], homepage: "https://github.com/brianc/node-postgres", repository: { type: "git", url: "git://github.com/brianc/node-postgres.git", directory: "packages/pg" }, author: "Brian Carlson <brian.m.carlson@gmail.com>", main: "./lib", dependencies: {
        "buffer-writer": "2.0.0",
        "packet-reader": "1.0.0",
        "pg-connection-string": "^2.5.0",
        "pg-pool": "^3.5.2",
        "pg-protocol": "^1.5.0",
        "pg-types": "^2.1.0",
        pgpass: "1.x"
      }, devDependencies: { async: "2.6.4", bluebird: "3.5.2", co: "4.6.0", "pg-copy-streams": "0.3.0" }, peerDependencies: { "pg-native": ">=3.0.1" }, peerDependenciesMeta: {
        "pg-native": { optional: true }
      }, scripts: { test: "make test-all" }, files: ["lib", "SPONSORS.md"], license: "MIT", engines: { node: ">= 8.0.0" }, gitHead: "c99fb2c127ddf8d712500db2c7b9a5491a178655" };
    });
    Qs = I4((pf, Ns2) => {
      "use strict";
      p8();
      var qs2 = ge3().EventEmitter, Tc2 = (Ge2(), k8(He2)), gn2 = tt2(), Qe3 = Ns2.exports = function(r6, e6, t6) {
        qs2.call(this), r6 = gn2.normalizeQueryConfig(r6, e6, t6), this.text = r6.text, this.values = r6.values, this.name = r6.name, this.callback = r6.callback, this.state = "new", this._arrayMode = r6.rowMode === "array", this._emitRowEvents = false, this.on("newListener", function(n7) {
          n7 === "row" && (this._emitRowEvents = true);
        }.bind(this));
      };
      Tc2.inherits(
        Qe3,
        qs2
      );
      var Pc = { sqlState: "code", statementPosition: "position", messagePrimary: "message", context: "where", schemaName: "schema", tableName: "table", columnName: "column", dataTypeName: "dataType", constraintName: "constraint", sourceFile: "file", sourceLine: "line", sourceFunction: "routine" };
      Qe3.prototype.handleError = function(r6) {
        var e6 = this.native.pq.resultErrorFields();
        if (e6) for (var t6 in e6) {
          var n7 = Pc[t6] || t6;
          r6[n7] = e6[t6];
        }
        this.callback ? this.callback(r6) : this.emit("error", r6), this.state = "error";
      };
      Qe3.prototype.then = function(r6, e6) {
        return this._getPromise().then(r6, e6);
      };
      Qe3.prototype.catch = function(r6) {
        return this._getPromise().catch(r6);
      };
      Qe3.prototype._getPromise = function() {
        return this._promise ? this._promise : (this._promise = new Promise(function(r6, e6) {
          this._once("end", r6), this._once(
            "error",
            e6
          );
        }.bind(this)), this._promise);
      };
      Qe3.prototype.submit = function(r6) {
        this.state = "running";
        var e6 = this;
        this.native = r6.native, r6.native.arrayMode = this._arrayMode;
        var t6 = a6(
          function(s10, o9, u7) {
            if (r6.native.arrayMode = false, S4(function() {
              e6.emit("_done");
            }), s10) return e6.handleError(s10);
            e6._emitRowEvents && (u7.length > 1 ? o9.forEach((c6, h8) => {
              c6.forEach((l7) => {
                e6.emit(
                  "row",
                  l7,
                  u7[h8]
                );
              });
            }) : o9.forEach(function(c6) {
              e6.emit("row", c6, u7);
            })), e6.state = "end", e6.emit(
              "end",
              u7
            ), e6.callback && e6.callback(null, u7);
          },
          "after"
        );
        if (m9.domain && (t6 = m9.domain.bind(
          t6
        )), this.name) {
          this.name.length > 63 && (console.error("Warning! Postgres only supports 63 characters for query names."), console.error(
            "You supplied %s (%s)",
            this.name,
            this.name.length
          ), console.error("This can cause conflicts and silent errors executing queries"));
          var n7 = (this.values || []).map(gn2.prepareValue);
          if (r6.namedQueries[this.name]) {
            if (this.text && r6.namedQueries[this.name] !== this.text) {
              let s10 = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
              return t6(s10);
            }
            return r6.native.execute(this.name, n7, t6);
          }
          return r6.native.prepare(
            this.name,
            this.text,
            n7.length,
            function(s10) {
              return s10 ? t6(s10) : (r6.namedQueries[e6.name] = e6.text, e6.native.execute(e6.name, n7, t6));
            }
          );
        } else if (this.values) {
          if (!Array.isArray(this.values)) {
            let s10 = new Error("Query values must be an array");
            return t6(s10);
          }
          var i8 = this.values.map(gn2.prepareValue);
          r6.native.query(this.text, i8, t6);
        } else r6.native.query(this.text, t6);
      };
    });
    Gs = I4((gf, Hs2) => {
      "use strict";
      p8();
      var Bc = (ks(), k8(Os)), Lc = hr(), mf = Us(), Ws = ge3().EventEmitter, Rc = (Ge2(), k8(He2)), Fc = gt3(), js2 = Qs(), Z4 = Hs2.exports = function(r6) {
        Ws.call(this), r6 = r6 || {}, this._Promise = r6.Promise || b8.Promise, this._types = new Lc(r6.types), this.native = new Bc({ types: this._types }), this._queryQueue = [], this._ending = false, this._connecting = false, this._connected = false, this._queryable = true;
        var e6 = this.connectionParameters = new Fc(
          r6
        );
        this.user = e6.user, Object.defineProperty(this, "password", {
          configurable: true,
          enumerable: false,
          writable: true,
          value: e6.password
        }), this.database = e6.database, this.host = e6.host, this.port = e6.port, this.namedQueries = {};
      };
      Z4.Query = js2;
      Rc.inherits(Z4, Ws);
      Z4.prototype._errorAllQueries = function(r6) {
        let e6 = a6(
          (t6) => {
            m9.nextTick(() => {
              t6.native = this.native, t6.handleError(r6);
            });
          },
          "enqueueError"
        );
        this._hasActiveQuery() && (e6(this._activeQuery), this._activeQuery = null), this._queryQueue.forEach(e6), this._queryQueue.length = 0;
      };
      Z4.prototype._connect = function(r6) {
        var e6 = this;
        if (this._connecting) {
          m9.nextTick(() => r6(new Error("Client has already been connected. You cannot reuse a client.")));
          return;
        }
        this._connecting = true, this.connectionParameters.getLibpqConnectionString(function(t6, n7) {
          if (t6) return r6(
            t6
          );
          e6.native.connect(n7, function(i8) {
            if (i8) return e6.native.end(), r6(i8);
            e6._connected = true, e6.native.on("error", function(s10) {
              e6._queryable = false, e6._errorAllQueries(s10), e6.emit("error", s10);
            }), e6.native.on("notification", function(s10) {
              e6.emit("notification", { channel: s10.relname, payload: s10.extra });
            }), e6.emit("connect"), e6._pulseQueryQueue(true), r6();
          });
        });
      };
      Z4.prototype.connect = function(r6) {
        if (r6) {
          this._connect(r6);
          return;
        }
        return new this._Promise(
          (e6, t6) => {
            this._connect((n7) => {
              n7 ? t6(n7) : e6();
            });
          }
        );
      };
      Z4.prototype.query = function(r6, e6, t6) {
        var n7, i8, s10, o9, u7;
        if (r6 == null) throw new TypeError("Client was passed a null or undefined query");
        if (typeof r6.submit == "function") s10 = r6.query_timeout || this.connectionParameters.query_timeout, i8 = n7 = r6, typeof e6 == "function" && (r6.callback = e6);
        else if (s10 = this.connectionParameters.query_timeout, n7 = new js2(r6, e6, t6), !n7.callback) {
          let c6, h8;
          i8 = new this._Promise((l7, y7) => {
            c6 = l7, h8 = y7;
          }), n7.callback = (l7, y7) => l7 ? h8(l7) : c6(y7);
        }
        return s10 && (u7 = n7.callback, o9 = setTimeout(() => {
          var c6 = new Error("Query read timeout");
          m9.nextTick(() => {
            n7.handleError(c6, this.connection);
          }), u7(c6), n7.callback = () => {
          };
          var h8 = this._queryQueue.indexOf(n7);
          h8 > -1 && this._queryQueue.splice(h8, 1), this._pulseQueryQueue();
        }, s10), n7.callback = (c6, h8) => {
          clearTimeout(o9), u7(c6, h8);
        }), this._queryable ? this._ending ? (n7.native = this.native, m9.nextTick(() => {
          n7.handleError(
            new Error("Client was closed and is not queryable")
          );
        }), i8) : (this._queryQueue.push(
          n7
        ), this._pulseQueryQueue(), i8) : (n7.native = this.native, m9.nextTick(() => {
          n7.handleError(
            new Error("Client has encountered a connection error and is not queryable")
          );
        }), i8);
      };
      Z4.prototype.end = function(r6) {
        var e6 = this;
        this._ending = true, this._connected || this.once(
          "connect",
          this.end.bind(this, r6)
        );
        var t6;
        return r6 || (t6 = new this._Promise(function(n7, i8) {
          r6 = a6((s10) => s10 ? i8(s10) : n7(), "cb");
        })), this.native.end(function() {
          e6._errorAllQueries(new Error(
            "Connection terminated"
          )), m9.nextTick(() => {
            e6.emit("end"), r6 && r6();
          });
        }), t6;
      };
      Z4.prototype._hasActiveQuery = function() {
        return this._activeQuery && this._activeQuery.state !== "error" && this._activeQuery.state !== "end";
      };
      Z4.prototype._pulseQueryQueue = function(r6) {
        if (this._connected && !this._hasActiveQuery()) {
          var e6 = this._queryQueue.shift();
          if (!e6) {
            r6 || this.emit("drain");
            return;
          }
          this._activeQuery = e6, e6.submit(this);
          var t6 = this;
          e6.once(
            "_done",
            function() {
              t6._pulseQueryQueue();
            }
          );
        }
      };
      Z4.prototype.cancel = function(r6) {
        this._activeQuery === r6 ? this.native.cancel(function() {
        }) : this._queryQueue.indexOf(r6) !== -1 && this._queryQueue.splice(this._queryQueue.indexOf(r6), 1);
      };
      Z4.prototype.ref = function() {
      };
      Z4.prototype.unref = function() {
      };
      Z4.prototype.setTypeParser = function(r6, e6, t6) {
        return this._types.setTypeParser(r6, e6, t6);
      };
      Z4.prototype.getTypeParser = function(r6, e6) {
        return this._types.getTypeParser(r6, e6);
      };
    });
    wn2 = I4((Sf, $s3) => {
      "use strict";
      p8();
      $s3.exports = Gs();
    });
    At2 = I4((Ef, nt2) => {
      "use strict";
      p8();
      var Mc = Ls(), Dc = et2(), Oc = cn2(), kc = Ds(), { DatabaseError: Uc } = on2(), qc2 = a6((r6) => {
        var e6;
        return e6 = class extends kc {
          constructor(n7) {
            super(n7, r6);
          }
        }, a6(e6, "BoundPool"), e6;
      }, "poolFactory"), bn3 = a6(function(r6) {
        this.defaults = Dc, this.Client = r6, this.Query = this.Client.Query, this.Pool = qc2(this.Client), this._pools = [], this.Connection = Oc, this.types = Xe2(), this.DatabaseError = Uc;
      }, "PG");
      typeof m9.env.NODE_PG_FORCE_NATIVE < "u" ? nt2.exports = new bn3(wn2()) : (nt2.exports = new bn3(Mc), Object.defineProperty(nt2.exports, "native", { configurable: true, enumerable: false, get() {
        var r6 = null;
        try {
          r6 = new bn3(wn2());
        } catch (e6) {
          if (e6.code !== "MODULE_NOT_FOUND") throw e6;
        }
        return Object.defineProperty(nt2.exports, "native", { value: r6 }), r6;
      } }));
    });
    p8();
    Ct2 = We2(At2());
    wt2();
    p8();
    fr();
    wt2();
    zs = We2(tt2());
    Sn2 = class Sn3 extends Error {
      constructor() {
        super(...arguments);
        T3(this, "name", "NeonDbError");
        T3(this, "code", null);
        T3(this, "sourceError");
      }
    };
    a6(Sn2, "NeonDbError");
    Ae3 = Sn2;
    Ks = "transaction() expects an array of queries, or a function returning an array of queries";
    a6(Ys, "neon");
    a6(Nc, "createNeonQueryPromise");
    a6(Vs, "processQueryResult");
    Js = We2(gt3());
    Se2 = We2(At2());
    En2 = class En3 extends Ct2.Client {
      constructor(t6) {
        super(t6);
        this.config = t6;
      }
      get neonConfig() {
        return this.connection.stream;
      }
      connect(t6) {
        let { neonConfig: n7 } = this;
        n7.forceDisablePgSSL && (this.ssl = this.connection.ssl = false), this.ssl && n7.useSecureWebSocket && console.warn("SSL is enabled for both Postgres (e.g. ?sslmode=require in the connection string + forceDisablePgSSL = false) and the WebSocket tunnel (useSecureWebSocket = true). Double encryption will increase latency and CPU usage. It may be appropriate to disable SSL in the Postgres connection parameters or set forceDisablePgSSL = true.");
        let i8 = this.config?.host !== void 0 || this.config?.connectionString !== void 0 || m9.env.PGHOST !== void 0, s10 = m9.env.USER ?? m9.env.USERNAME;
        if (!i8 && this.host === "localhost" && this.user === s10 && this.database === s10 && this.password === null) throw new Error(`No database host or connection string was set, and key parameters have default values (host: localhost, user: ${s10}, db: ${s10}, password: null). Is an environment variable missing? Alternatively, if you intended to connect with these parameters, please set the host to 'localhost' explicitly.`);
        let o9 = super.connect(t6), u7 = n7.pipelineTLS && this.ssl, c6 = n7.pipelineConnect === "password";
        if (!u7 && !n7.pipelineConnect) return o9;
        let h8 = this.connection;
        if (u7 && h8.on("connect", () => h8.stream.emit("data", "S")), c6) {
          h8.removeAllListeners(
            "authenticationCleartextPassword"
          ), h8.removeAllListeners("readyForQuery"), h8.once(
            "readyForQuery",
            () => h8.on("readyForQuery", this._handleReadyForQuery.bind(this))
          );
          let l7 = this.ssl ? "sslconnect" : "connect";
          h8.on(l7, () => {
            this._handleAuthCleartextPassword(), this._handleReadyForQuery();
          });
        }
        return o9;
      }
      async _handleAuthSASLContinue(t6) {
        let n7 = this.saslSession, i8 = this.password, s10 = t6.data;
        if (n7.message !== "SASLInitialResponse" || typeof i8 != "string" || typeof s10 != "string") throw new Error("SASL: protocol error");
        let o9 = Object.fromEntries(s10.split(",").map(($4) => {
          if (!/^.=/.test($4)) throw new Error("SASL: Invalid attribute pair entry");
          let ne3 = $4[0], Ce3 = $4.substring(2);
          return [ne3, Ce3];
        })), u7 = o9.r, c6 = o9.s, h8 = o9.i;
        if (!u7 || !/^[!-+--~]+$/.test(u7)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing/unprintable");
        if (!c6 || !/^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(c6)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing/not base64");
        if (!h8 || !/^[1-9][0-9]*$/.test(h8)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: missing/invalid iteration count");
        if (!u7.startsWith(n7.clientNonce)) throw new Error(
          "SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce"
        );
        if (u7.length === n7.clientNonce.length) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
        let l7 = parseInt(h8, 10), y7 = d6.from(c6, "base64"), E4 = new TextEncoder(), _7 = E4.encode(i8), P5 = await w9.subtle.importKey("raw", _7, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]), N5 = new Uint8Array(await w9.subtle.sign("HMAC", P5, d6.concat([y7, d6.from(
          [0, 0, 0, 1]
        )]))), J3 = N5;
        for (var pe2 = 0; pe2 < l7 - 1; pe2++) N5 = new Uint8Array(await w9.subtle.sign(
          "HMAC",
          P5,
          N5
        )), J3 = d6.from(J3.map(($4, ne3) => J3[ne3] ^ N5[ne3]));
        let A5 = J3, g10 = await w9.subtle.importKey(
          "raw",
          A5,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        ), D6 = new Uint8Array(await w9.subtle.sign("HMAC", g10, E4.encode("Client Key"))), H5 = await w9.subtle.digest(
          "SHA-256",
          D6
        ), Q3 = "n=*,r=" + n7.clientNonce, W4 = "r=" + u7 + ",s=" + c6 + ",i=" + l7, ue = "c=biws,r=" + u7, de2 = Q3 + "," + W4 + "," + ue, L6 = await w9.subtle.importKey(
          "raw",
          H5,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        );
        var G4 = new Uint8Array(await w9.subtle.sign("HMAC", L6, E4.encode(de2))), ce3 = d6.from(D6.map(($4, ne3) => D6[ne3] ^ G4[ne3])), ye3 = ce3.toString("base64");
        let xe3 = await w9.subtle.importKey("raw", A5, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]), he3 = await w9.subtle.sign("HMAC", xe3, E4.encode("Server Key")), ie4 = await w9.subtle.importKey("raw", he3, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]);
        var se2 = d6.from(await w9.subtle.sign("HMAC", ie4, E4.encode(de2)));
        n7.message = "SASLResponse", n7.serverSignature = se2.toString("base64"), n7.response = ue + ",p=" + ye3, this.connection.sendSCRAMClientFinalMessage(this.saslSession.response);
      }
    };
    a6(En2, "NeonClient");
    xn2 = En2;
    a6(Qc, "promisify");
    vn2 = class vn3 extends Ct2.Pool {
      constructor() {
        super(...arguments);
        T3(this, "Client", xn2);
        T3(this, "hasFetchUnsupportedListeners", false);
      }
      on(t6, n7) {
        return t6 !== "error" && (this.hasFetchUnsupportedListeners = true), super.on(t6, n7);
      }
      query(t6, n7, i8) {
        if (!_e6.poolQueryViaFetch || this.hasFetchUnsupportedListeners || typeof t6 == "function")
          return super.query(t6, n7, i8);
        typeof n7 == "function" && (i8 = n7, n7 = void 0);
        let s10 = Qc(
          this.Promise,
          i8
        );
        i8 = s10.callback;
        try {
          let o9 = new Js.default(this.options), u7 = encodeURIComponent, c6 = encodeURI, h8 = `postgresql://${u7(o9.user)}:${u7(o9.password)}@${u7(o9.host)}/${c6(o9.database)}`, l7 = typeof t6 == "string" ? t6 : t6.text, y7 = n7 ?? t6.values ?? [];
          Ys(h8, { fullResults: true, arrayMode: t6.rowMode === "array" })(l7, y7).then((_7) => i8(void 0, _7)).catch((_7) => i8(_7));
        } catch (o9) {
          i8(o9);
        }
        return s10.result;
      }
    };
    a6(vn2, "NeonPool");
    Zs = vn2;
    export_ClientBase = Se2.ClientBase;
    export_Connection = Se2.Connection;
    export_DatabaseError = Se2.DatabaseError;
    export_Query = Se2.Query;
    export_defaults = Se2.defaults;
    export_types = Se2.types;
  }
});

// ../node_modules/.pnpm/@vercel+postgres@0.8.0/node_modules/@vercel/postgres/dist/chunk-WDBQYBZQ.js
function postgresConnectionString(type = "pool") {
  let connectionString;
  switch (type) {
    case "pool": {
      connectionString = process.env.POSTGRES_URL;
      break;
    }
    case "direct": {
      connectionString = process.env.POSTGRES_URL_NON_POOLING;
      break;
    }
    default: {
      const _exhaustiveCheck = type;
      const str = _exhaustiveCheck;
      throw new VercelPostgresError(
        "invalid_connection_type",
        `Unhandled type: ${str}`
      );
    }
  }
  if (connectionString === "undefined")
    connectionString = void 0;
  return connectionString;
}
function isPooledConnectionString(connectionString) {
  return connectionString.includes("-pooler.");
}
function isDirectConnectionString(connectionString) {
  return !isPooledConnectionString(connectionString);
}
function isLocalhostConnectionString(connectionString) {
  try {
    const withHttpsProtocol = connectionString.replace(
      /^postgresql:\/\//,
      "https://"
    );
    return new URL(withHttpsProtocol).hostname === "localhost";
  } catch (err3) {
    if (err3 instanceof TypeError) {
      return false;
    }
    if (typeof err3 === "object" && err3 !== null && "message" in err3 && typeof err3.message === "string" && err3.message === "Invalid URL") {
      return false;
    }
    throw err3;
  }
}
function sqlTemplate(strings, ...values2) {
  var _a506, _b375;
  if (!isTemplateStringsArray(strings) || !Array.isArray(values2)) {
    throw new VercelPostgresError(
      "incorrect_tagged_template_call",
      "It looks like you tried to call `sql` as a function. Make sure to use it as a tagged template.\n	Example: sql`SELECT * FROM users`, not sql('SELECT * FROM users')"
    );
  }
  let result = (_a506 = strings[0]) != null ? _a506 : "";
  for (let i8 = 1; i8 < strings.length; i8++) {
    result += `$${i8}${(_b375 = strings[i8]) != null ? _b375 : ""}`;
  }
  return [result, values2];
}
function isTemplateStringsArray(strings) {
  return Array.isArray(strings) && "raw" in strings && Array.isArray(strings.raw);
}
function createClient(config) {
  var _a506;
  const connectionString = (_a506 = config == null ? void 0 : config.connectionString) != null ? _a506 : postgresConnectionString("direct");
  if (!connectionString)
    throw new VercelPostgresError(
      "missing_connection_string",
      "You did not supply a 'connectionString' and no 'POSTGRES_URL_NON_POOLING' env var was found."
    );
  if (!isLocalhostConnectionString(connectionString) && !isDirectConnectionString(connectionString))
    throw new VercelPostgresError(
      "invalid_connection_string",
      "This connection string is meant to be used with a pooled connection. Try `createPool()` instead."
    );
  return new VercelClient({
    ...config,
    connectionString
  });
}
function createPool(config) {
  var _a506;
  const connectionString = (_a506 = config == null ? void 0 : config.connectionString) != null ? _a506 : postgresConnectionString("pool");
  if (!connectionString)
    throw new VercelPostgresError(
      "missing_connection_string",
      "You did not supply a 'connectionString' and no 'POSTGRES_URL' env var was found."
    );
  if (!isLocalhostConnectionString(connectionString) && !isPooledConnectionString(connectionString))
    throw new VercelPostgresError(
      "invalid_connection_string",
      "This connection string is meant to be used with a direct connection. Make sure to use a pooled connection string or try `createClient()` instead."
    );
  let maxUses = config == null ? void 0 : config.maxUses;
  let max2 = config == null ? void 0 : config.max;
  if (typeof EdgeRuntime !== "undefined") {
    if (maxUses && maxUses !== 1) {
      console.warn(
        "@vercel/postgres: Overriding `maxUses` to 1 because the EdgeRuntime does not support client reuse."
      );
    }
    if (max2 && max2 !== 1e4) {
      console.warn(
        "@vercel/postgres: Overriding `max` to 10,000 because the EdgeRuntime does not support client reuse."
      );
    }
    maxUses = 1;
    max2 = 1e4;
  }
  const pool2 = new VercelPool({
    ...config,
    connectionString,
    maxUses,
    max: max2
  });
  return pool2;
}
var VercelPostgresError, VercelClient, VercelPool, pool, sql2, db;
var init_chunk_WDBQYBZQ = __esm({
  "../node_modules/.pnpm/@vercel+postgres@0.8.0/node_modules/@vercel/postgres/dist/chunk-WDBQYBZQ.js"() {
    "use strict";
    init_serverless();
    init_serverless();
    init_serverless();
    VercelPostgresError = class extends Error {
      constructor(code, message) {
        super(`VercelPostgresError - '${code}': ${message}`);
        this.code = code;
        this.name = "VercelPostgresError";
      }
    };
    VercelClient = class extends xn2 {
      /**
       * A template literal tag providing safe, easy to use SQL parameterization.
       * Parameters are substituted using the underlying Postgres database, and so must follow
       * the rules of Postgres parameterization.
       * @example
       * ```ts
       * const pool = createClient();
       * const userId = 123;
       * await client.connect();
       * const result = await pool.sql`SELECT * FROM users WHERE id = ${userId}`;
       * // Equivalent to: await pool.query('SELECT * FROM users WHERE id = $1', [id]);
       * await client.end();
       * ```
       * @returns A promise that resolves to the query result.
       */
      async sql(strings, ...values2) {
        const [query, params] = sqlTemplate(strings, ...values2);
        return this.query(query, params);
      }
    };
    VercelPool = class extends Zs {
      constructor(config) {
        var _a506;
        super(config);
        this.Client = VercelClient;
        this.connectionString = (_a506 = config.connectionString) != null ? _a506 : "";
      }
      /**
       * A template literal tag providing safe, easy to use SQL parameterization.
       * Parameters are substituted using the underlying Postgres database, and so must follow
       * the rules of Postgres parameterization.
       * @example
       * ```ts
       * const pool = createPool();
       * const userId = 123;
       * const result = await pool.sql`SELECT * FROM users WHERE id = ${userId}`;
       * // Equivalent to: await pool.query('SELECT * FROM users WHERE id = $1', [id]);
       * ```
       * @returns A promise that resolves to the query result.
       */
      async sql(strings, ...values2) {
        const [query, params] = sqlTemplate(strings, ...values2);
        const sql22 = Ys(this.connectionString, {
          fullResults: true
        });
        return sql22(query, params);
      }
      connect(callback) {
        return super.connect(
          callback
        );
      }
    };
    sql2 = new Proxy(
      // eslint-disable-next-line @typescript-eslint/no-empty-function -- [@vercel/style-guide@5 migration]
      () => {
      },
      {
        get(_7, prop) {
          if (!pool) {
            pool = createPool();
          }
          const val2 = Reflect.get(pool, prop);
          if (typeof val2 === "function") {
            return val2.bind(pool);
          }
          return val2;
        },
        apply(_7, __, argumentsList) {
          if (!pool) {
            pool = createPool();
          }
          return pool.sql(...argumentsList);
        }
      }
    );
    db = sql2;
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/stream.js
var require_stream3 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/stream.js"(exports2, module2) {
    "use strict";
    var { Duplex } = require("stream");
    function emitClose(stream) {
      stream.emit("close");
    }
    function duplexOnEnd() {
      if (!this.destroyed && this._writableState.finished) {
        this.destroy();
      }
    }
    function duplexOnError(err3) {
      this.removeListener("error", duplexOnError);
      this.destroy();
      if (this.listenerCount("error") === 0) {
        this.emit("error", err3);
      }
    }
    function createWebSocketStream3(ws4, options) {
      let terminateOnDestroy = true;
      const duplex = new Duplex({
        ...options,
        autoDestroy: false,
        emitClose: false,
        objectMode: false,
        writableObjectMode: false
      });
      ws4.on("message", function message(msg, isBinary2) {
        const data = !isBinary2 && duplex._readableState.objectMode ? msg.toString() : msg;
        if (!duplex.push(data)) ws4.pause();
      });
      ws4.once("error", function error2(err3) {
        if (duplex.destroyed) return;
        terminateOnDestroy = false;
        duplex.destroy(err3);
      });
      ws4.once("close", function close() {
        if (duplex.destroyed) return;
        duplex.push(null);
      });
      duplex._destroy = function(err3, callback) {
        if (ws4.readyState === ws4.CLOSED) {
          callback(err3);
          process.nextTick(emitClose, duplex);
          return;
        }
        let called = false;
        ws4.once("error", function error2(err4) {
          called = true;
          callback(err4);
        });
        ws4.once("close", function close() {
          if (!called) callback(err3);
          process.nextTick(emitClose, duplex);
        });
        if (terminateOnDestroy) ws4.terminate();
      };
      duplex._final = function(callback) {
        if (ws4.readyState === ws4.CONNECTING) {
          ws4.once("open", function open() {
            duplex._final(callback);
          });
          return;
        }
        if (ws4._socket === null) return;
        if (ws4._socket._writableState.finished) {
          callback();
          if (duplex._readableState.endEmitted) duplex.destroy();
        } else {
          ws4._socket.once("finish", function finish() {
            callback();
          });
          ws4.close();
        }
      };
      duplex._read = function() {
        if (ws4.isPaused) ws4.resume();
      };
      duplex._write = function(chunk, encoding, callback) {
        if (ws4.readyState === ws4.CONNECTING) {
          ws4.once("open", function open() {
            duplex._write(chunk, encoding, callback);
          });
          return;
        }
        ws4.send(chunk, callback);
      };
      duplex.on("end", duplexOnEnd);
      duplex.on("error", duplexOnError);
      return duplex;
    }
    module2.exports = createWebSocketStream3;
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/constants.js
var require_constants3 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/constants.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      BINARY_TYPES: ["nodebuffer", "arraybuffer", "fragments"],
      EMPTY_BUFFER: Buffer.alloc(0),
      GUID: "258EAFA5-E914-47DA-95CA-C5AB0DC85B11",
      kForOnEventAttribute: Symbol("kIsForOnEventAttribute"),
      kListener: Symbol("kListener"),
      kStatusCode: Symbol("status-code"),
      kWebSocket: Symbol("websocket"),
      NOOP: () => {
      }
    };
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/buffer-util.js
var require_buffer_util2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/buffer-util.js"(exports2, module2) {
    "use strict";
    var { EMPTY_BUFFER } = require_constants3();
    var FastBuffer = Buffer[Symbol.species];
    function concat(list, totalLength) {
      if (list.length === 0) return EMPTY_BUFFER;
      if (list.length === 1) return list[0];
      const target = Buffer.allocUnsafe(totalLength);
      let offset = 0;
      for (let i8 = 0; i8 < list.length; i8++) {
        const buf = list[i8];
        target.set(buf, offset);
        offset += buf.length;
      }
      if (offset < totalLength) {
        return new FastBuffer(target.buffer, target.byteOffset, offset);
      }
      return target;
    }
    function _mask(source, mask, output, offset, length) {
      for (let i8 = 0; i8 < length; i8++) {
        output[offset + i8] = source[i8] ^ mask[i8 & 3];
      }
    }
    function _unmask(buffer2, mask) {
      for (let i8 = 0; i8 < buffer2.length; i8++) {
        buffer2[i8] ^= mask[i8 & 3];
      }
    }
    function toArrayBuffer(buf) {
      if (buf.length === buf.buffer.byteLength) {
        return buf.buffer;
      }
      return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.length);
    }
    function toBuffer(data) {
      toBuffer.readOnly = true;
      if (Buffer.isBuffer(data)) return data;
      let buf;
      if (data instanceof ArrayBuffer) {
        buf = new FastBuffer(data);
      } else if (ArrayBuffer.isView(data)) {
        buf = new FastBuffer(data.buffer, data.byteOffset, data.byteLength);
      } else {
        buf = Buffer.from(data);
        toBuffer.readOnly = false;
      }
      return buf;
    }
    module2.exports = {
      concat,
      mask: _mask,
      toArrayBuffer,
      toBuffer,
      unmask: _unmask
    };
    if (!process.env.WS_NO_BUFFER_UTIL) {
      try {
        const bufferUtil = require_bufferutil();
        module2.exports.mask = function(source, mask, output, offset, length) {
          if (length < 48) _mask(source, mask, output, offset, length);
          else bufferUtil.mask(source, mask, output, offset, length);
        };
        module2.exports.unmask = function(buffer2, mask) {
          if (buffer2.length < 32) _unmask(buffer2, mask);
          else bufferUtil.unmask(buffer2, mask);
        };
      } catch (e6) {
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/limiter.js
var require_limiter2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/limiter.js"(exports2, module2) {
    "use strict";
    var kDone = Symbol("kDone");
    var kRun = Symbol("kRun");
    var Limiter = class {
      /**
       * Creates a new `Limiter`.
       *
       * @param {Number} [concurrency=Infinity] The maximum number of jobs allowed
       *     to run concurrently
       */
      constructor(concurrency) {
        this[kDone] = () => {
          this.pending--;
          this[kRun]();
        };
        this.concurrency = concurrency || Infinity;
        this.jobs = [];
        this.pending = 0;
      }
      /**
       * Adds a job to the queue.
       *
       * @param {Function} job The job to run
       * @public
       */
      add(job) {
        this.jobs.push(job);
        this[kRun]();
      }
      /**
       * Removes a job from the queue and runs it if possible.
       *
       * @private
       */
      [kRun]() {
        if (this.pending === this.concurrency) return;
        if (this.jobs.length) {
          const job = this.jobs.shift();
          this.pending++;
          job(this[kDone]);
        }
      }
    };
    module2.exports = Limiter;
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/permessage-deflate.js
var require_permessage_deflate2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/permessage-deflate.js"(exports2, module2) {
    "use strict";
    var zlib2 = require("zlib");
    var bufferUtil = require_buffer_util2();
    var Limiter = require_limiter2();
    var { kStatusCode } = require_constants3();
    var FastBuffer = Buffer[Symbol.species];
    var TRAILER = Buffer.from([0, 0, 255, 255]);
    var kPerMessageDeflate = Symbol("permessage-deflate");
    var kTotalLength = Symbol("total-length");
    var kCallback = Symbol("callback");
    var kBuffers = Symbol("buffers");
    var kError = Symbol("error");
    var zlibLimiter;
    var PerMessageDeflate = class {
      /**
       * Creates a PerMessageDeflate instance.
       *
       * @param {Object} [options] Configuration options
       * @param {(Boolean|Number)} [options.clientMaxWindowBits] Advertise support
       *     for, or request, a custom client window size
       * @param {Boolean} [options.clientNoContextTakeover=false] Advertise/
       *     acknowledge disabling of client context takeover
       * @param {Number} [options.concurrencyLimit=10] The number of concurrent
       *     calls to zlib
       * @param {(Boolean|Number)} [options.serverMaxWindowBits] Request/confirm the
       *     use of a custom server window size
       * @param {Boolean} [options.serverNoContextTakeover=false] Request/accept
       *     disabling of server context takeover
       * @param {Number} [options.threshold=1024] Size (in bytes) below which
       *     messages should not be compressed if context takeover is disabled
       * @param {Object} [options.zlibDeflateOptions] Options to pass to zlib on
       *     deflate
       * @param {Object} [options.zlibInflateOptions] Options to pass to zlib on
       *     inflate
       * @param {Boolean} [isServer=false] Create the instance in either server or
       *     client mode
       * @param {Number} [maxPayload=0] The maximum allowed message length
       */
      constructor(options, isServer, maxPayload) {
        this._maxPayload = maxPayload | 0;
        this._options = options || {};
        this._threshold = this._options.threshold !== void 0 ? this._options.threshold : 1024;
        this._isServer = !!isServer;
        this._deflate = null;
        this._inflate = null;
        this.params = null;
        if (!zlibLimiter) {
          const concurrency = this._options.concurrencyLimit !== void 0 ? this._options.concurrencyLimit : 10;
          zlibLimiter = new Limiter(concurrency);
        }
      }
      /**
       * @type {String}
       */
      static get extensionName() {
        return "permessage-deflate";
      }
      /**
       * Create an extension negotiation offer.
       *
       * @return {Object} Extension parameters
       * @public
       */
      offer() {
        const params = {};
        if (this._options.serverNoContextTakeover) {
          params.server_no_context_takeover = true;
        }
        if (this._options.clientNoContextTakeover) {
          params.client_no_context_takeover = true;
        }
        if (this._options.serverMaxWindowBits) {
          params.server_max_window_bits = this._options.serverMaxWindowBits;
        }
        if (this._options.clientMaxWindowBits) {
          params.client_max_window_bits = this._options.clientMaxWindowBits;
        } else if (this._options.clientMaxWindowBits == null) {
          params.client_max_window_bits = true;
        }
        return params;
      }
      /**
       * Accept an extension negotiation offer/response.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Object} Accepted configuration
       * @public
       */
      accept(configurations) {
        configurations = this.normalizeParams(configurations);
        this.params = this._isServer ? this.acceptAsServer(configurations) : this.acceptAsClient(configurations);
        return this.params;
      }
      /**
       * Releases all resources used by the extension.
       *
       * @public
       */
      cleanup() {
        if (this._inflate) {
          this._inflate.close();
          this._inflate = null;
        }
        if (this._deflate) {
          const callback = this._deflate[kCallback];
          this._deflate.close();
          this._deflate = null;
          if (callback) {
            callback(
              new Error(
                "The deflate stream was closed while data was being processed"
              )
            );
          }
        }
      }
      /**
       *  Accept an extension negotiation offer.
       *
       * @param {Array} offers The extension negotiation offers
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsServer(offers) {
        const opts = this._options;
        const accepted = offers.find((params) => {
          if (opts.serverNoContextTakeover === false && params.server_no_context_takeover || params.server_max_window_bits && (opts.serverMaxWindowBits === false || typeof opts.serverMaxWindowBits === "number" && opts.serverMaxWindowBits > params.server_max_window_bits) || typeof opts.clientMaxWindowBits === "number" && !params.client_max_window_bits) {
            return false;
          }
          return true;
        });
        if (!accepted) {
          throw new Error("None of the extension offers can be accepted");
        }
        if (opts.serverNoContextTakeover) {
          accepted.server_no_context_takeover = true;
        }
        if (opts.clientNoContextTakeover) {
          accepted.client_no_context_takeover = true;
        }
        if (typeof opts.serverMaxWindowBits === "number") {
          accepted.server_max_window_bits = opts.serverMaxWindowBits;
        }
        if (typeof opts.clientMaxWindowBits === "number") {
          accepted.client_max_window_bits = opts.clientMaxWindowBits;
        } else if (accepted.client_max_window_bits === true || opts.clientMaxWindowBits === false) {
          delete accepted.client_max_window_bits;
        }
        return accepted;
      }
      /**
       * Accept the extension negotiation response.
       *
       * @param {Array} response The extension negotiation response
       * @return {Object} Accepted configuration
       * @private
       */
      acceptAsClient(response) {
        const params = response[0];
        if (this._options.clientNoContextTakeover === false && params.client_no_context_takeover) {
          throw new Error('Unexpected parameter "client_no_context_takeover"');
        }
        if (!params.client_max_window_bits) {
          if (typeof this._options.clientMaxWindowBits === "number") {
            params.client_max_window_bits = this._options.clientMaxWindowBits;
          }
        } else if (this._options.clientMaxWindowBits === false || typeof this._options.clientMaxWindowBits === "number" && params.client_max_window_bits > this._options.clientMaxWindowBits) {
          throw new Error(
            'Unexpected or invalid parameter "client_max_window_bits"'
          );
        }
        return params;
      }
      /**
       * Normalize parameters.
       *
       * @param {Array} configurations The extension negotiation offers/reponse
       * @return {Array} The offers/response with normalized parameters
       * @private
       */
      normalizeParams(configurations) {
        configurations.forEach((params) => {
          Object.keys(params).forEach((key) => {
            let value = params[key];
            if (value.length > 1) {
              throw new Error(`Parameter "${key}" must have only a single value`);
            }
            value = value[0];
            if (key === "client_max_window_bits") {
              if (value !== true) {
                const num = +value;
                if (!Number.isInteger(num) || num < 8 || num > 15) {
                  throw new TypeError(
                    `Invalid value for parameter "${key}": ${value}`
                  );
                }
                value = num;
              } else if (!this._isServer) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else if (key === "server_max_window_bits") {
              const num = +value;
              if (!Number.isInteger(num) || num < 8 || num > 15) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
              value = num;
            } else if (key === "client_no_context_takeover" || key === "server_no_context_takeover") {
              if (value !== true) {
                throw new TypeError(
                  `Invalid value for parameter "${key}": ${value}`
                );
              }
            } else {
              throw new Error(`Unknown parameter "${key}"`);
            }
            params[key] = value;
          });
        });
        return configurations;
      }
      /**
       * Decompress data. Concurrency limited.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      decompress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._decompress(data, fin, (err3, result) => {
            done();
            callback(err3, result);
          });
        });
      }
      /**
       * Compress data. Concurrency limited.
       *
       * @param {(Buffer|String)} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @public
       */
      compress(data, fin, callback) {
        zlibLimiter.add((done) => {
          this._compress(data, fin, (err3, result) => {
            done();
            callback(err3, result);
          });
        });
      }
      /**
       * Decompress data.
       *
       * @param {Buffer} data Compressed data
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _decompress(data, fin, callback) {
        const endpoint = this._isServer ? "client" : "server";
        if (!this._inflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._inflate = zlib2.createInflateRaw({
            ...this._options.zlibInflateOptions,
            windowBits
          });
          this._inflate[kPerMessageDeflate] = this;
          this._inflate[kTotalLength] = 0;
          this._inflate[kBuffers] = [];
          this._inflate.on("error", inflateOnError);
          this._inflate.on("data", inflateOnData);
        }
        this._inflate[kCallback] = callback;
        this._inflate.write(data);
        if (fin) this._inflate.write(TRAILER);
        this._inflate.flush(() => {
          const err3 = this._inflate[kError];
          if (err3) {
            this._inflate.close();
            this._inflate = null;
            callback(err3);
            return;
          }
          const data2 = bufferUtil.concat(
            this._inflate[kBuffers],
            this._inflate[kTotalLength]
          );
          if (this._inflate._readableState.endEmitted) {
            this._inflate.close();
            this._inflate = null;
          } else {
            this._inflate[kTotalLength] = 0;
            this._inflate[kBuffers] = [];
            if (fin && this.params[`${endpoint}_no_context_takeover`]) {
              this._inflate.reset();
            }
          }
          callback(null, data2);
        });
      }
      /**
       * Compress data.
       *
       * @param {(Buffer|String)} data Data to compress
       * @param {Boolean} fin Specifies whether or not this is the last fragment
       * @param {Function} callback Callback
       * @private
       */
      _compress(data, fin, callback) {
        const endpoint = this._isServer ? "server" : "client";
        if (!this._deflate) {
          const key = `${endpoint}_max_window_bits`;
          const windowBits = typeof this.params[key] !== "number" ? zlib2.Z_DEFAULT_WINDOWBITS : this.params[key];
          this._deflate = zlib2.createDeflateRaw({
            ...this._options.zlibDeflateOptions,
            windowBits
          });
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          this._deflate.on("data", deflateOnData);
        }
        this._deflate[kCallback] = callback;
        this._deflate.write(data);
        this._deflate.flush(zlib2.Z_SYNC_FLUSH, () => {
          if (!this._deflate) {
            return;
          }
          let data2 = bufferUtil.concat(
            this._deflate[kBuffers],
            this._deflate[kTotalLength]
          );
          if (fin) {
            data2 = new FastBuffer(data2.buffer, data2.byteOffset, data2.length - 4);
          }
          this._deflate[kCallback] = null;
          this._deflate[kTotalLength] = 0;
          this._deflate[kBuffers] = [];
          if (fin && this.params[`${endpoint}_no_context_takeover`]) {
            this._deflate.reset();
          }
          callback(null, data2);
        });
      }
    };
    module2.exports = PerMessageDeflate;
    function deflateOnData(chunk) {
      this[kBuffers].push(chunk);
      this[kTotalLength] += chunk.length;
    }
    function inflateOnData(chunk) {
      this[kTotalLength] += chunk.length;
      if (this[kPerMessageDeflate]._maxPayload < 1 || this[kTotalLength] <= this[kPerMessageDeflate]._maxPayload) {
        this[kBuffers].push(chunk);
        return;
      }
      this[kError] = new RangeError("Max payload size exceeded");
      this[kError].code = "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH";
      this[kError][kStatusCode] = 1009;
      this.removeListener("data", inflateOnData);
      this.reset();
    }
    function inflateOnError(err3) {
      this[kPerMessageDeflate]._inflate = null;
      err3[kStatusCode] = 1007;
      this[kCallback](err3);
    }
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/validation.js
var require_validation2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/validation.js"(exports2, module2) {
    "use strict";
    var { isUtf8 } = require("buffer");
    var tokenChars = [
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 0 - 15
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      0,
      // 16 - 31
      0,
      1,
      0,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      1,
      1,
      0,
      1,
      1,
      0,
      // 32 - 47
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      0,
      0,
      0,
      // 48 - 63
      0,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 64 - 79
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      0,
      0,
      1,
      1,
      // 80 - 95
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      // 96 - 111
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      1,
      0,
      1,
      0,
      1,
      0
      // 112 - 127
    ];
    function isValidStatusCode(code) {
      return code >= 1e3 && code <= 1014 && code !== 1004 && code !== 1005 && code !== 1006 || code >= 3e3 && code <= 4999;
    }
    function _isValidUTF8(buf) {
      const len = buf.length;
      let i8 = 0;
      while (i8 < len) {
        if ((buf[i8] & 128) === 0) {
          i8++;
        } else if ((buf[i8] & 224) === 192) {
          if (i8 + 1 === len || (buf[i8 + 1] & 192) !== 128 || (buf[i8] & 254) === 192) {
            return false;
          }
          i8 += 2;
        } else if ((buf[i8] & 240) === 224) {
          if (i8 + 2 >= len || (buf[i8 + 1] & 192) !== 128 || (buf[i8 + 2] & 192) !== 128 || buf[i8] === 224 && (buf[i8 + 1] & 224) === 128 || // Overlong
          buf[i8] === 237 && (buf[i8 + 1] & 224) === 160) {
            return false;
          }
          i8 += 3;
        } else if ((buf[i8] & 248) === 240) {
          if (i8 + 3 >= len || (buf[i8 + 1] & 192) !== 128 || (buf[i8 + 2] & 192) !== 128 || (buf[i8 + 3] & 192) !== 128 || buf[i8] === 240 && (buf[i8 + 1] & 240) === 128 || // Overlong
          buf[i8] === 244 && buf[i8 + 1] > 143 || buf[i8] > 244) {
            return false;
          }
          i8 += 4;
        } else {
          return false;
        }
      }
      return true;
    }
    module2.exports = {
      isValidStatusCode,
      isValidUTF8: _isValidUTF8,
      tokenChars
    };
    if (isUtf8) {
      module2.exports.isValidUTF8 = function(buf) {
        return buf.length < 24 ? _isValidUTF8(buf) : isUtf8(buf);
      };
    } else if (!process.env.WS_NO_UTF_8_VALIDATE) {
      try {
        const isValidUTF8 = require_utf_8_validate();
        module2.exports.isValidUTF8 = function(buf) {
          return buf.length < 32 ? _isValidUTF8(buf) : isValidUTF8(buf);
        };
      } catch (e6) {
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/receiver.js
var require_receiver2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/receiver.js"(exports2, module2) {
    "use strict";
    var { Writable: Writable2 } = require("stream");
    var PerMessageDeflate = require_permessage_deflate2();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      kStatusCode,
      kWebSocket
    } = require_constants3();
    var { concat, toArrayBuffer, unmask } = require_buffer_util2();
    var { isValidStatusCode, isValidUTF8 } = require_validation2();
    var FastBuffer = Buffer[Symbol.species];
    var promise = Promise.resolve();
    var queueTask = typeof queueMicrotask === "function" ? queueMicrotask : queueMicrotaskShim;
    var GET_INFO = 0;
    var GET_PAYLOAD_LENGTH_16 = 1;
    var GET_PAYLOAD_LENGTH_64 = 2;
    var GET_MASK = 3;
    var GET_DATA = 4;
    var INFLATING = 5;
    var WAIT_MICROTASK = 6;
    var Receiver3 = class extends Writable2 {
      /**
       * Creates a Receiver instance.
       *
       * @param {Object} [options] Options object
       * @param {String} [options.binaryType=nodebuffer] The type for binary data
       * @param {Object} [options.extensions] An object containing the negotiated
       *     extensions
       * @param {Boolean} [options.isServer=false] Specifies whether to operate in
       *     client or server mode
       * @param {Number} [options.maxPayload=0] The maximum allowed message length
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       */
      constructor(options = {}) {
        super();
        this._binaryType = options.binaryType || BINARY_TYPES[0];
        this._extensions = options.extensions || {};
        this._isServer = !!options.isServer;
        this._maxPayload = options.maxPayload | 0;
        this._skipUTF8Validation = !!options.skipUTF8Validation;
        this[kWebSocket] = void 0;
        this._bufferedBytes = 0;
        this._buffers = [];
        this._compressed = false;
        this._payloadLength = 0;
        this._mask = void 0;
        this._fragmented = 0;
        this._masked = false;
        this._fin = false;
        this._opcode = 0;
        this._totalPayloadLength = 0;
        this._messageLength = 0;
        this._fragments = [];
        this._state = GET_INFO;
        this._loop = false;
      }
      /**
       * Implements `Writable.prototype._write()`.
       *
       * @param {Buffer} chunk The chunk of data to write
       * @param {String} encoding The character encoding of `chunk`
       * @param {Function} cb Callback
       * @private
       */
      _write(chunk, encoding, cb) {
        if (this._opcode === 8 && this._state == GET_INFO) return cb();
        this._bufferedBytes += chunk.length;
        this._buffers.push(chunk);
        this.startLoop(cb);
      }
      /**
       * Consumes `n` bytes from the buffered data.
       *
       * @param {Number} n The number of bytes to consume
       * @return {Buffer} The consumed bytes
       * @private
       */
      consume(n7) {
        this._bufferedBytes -= n7;
        if (n7 === this._buffers[0].length) return this._buffers.shift();
        if (n7 < this._buffers[0].length) {
          const buf = this._buffers[0];
          this._buffers[0] = new FastBuffer(
            buf.buffer,
            buf.byteOffset + n7,
            buf.length - n7
          );
          return new FastBuffer(buf.buffer, buf.byteOffset, n7);
        }
        const dst = Buffer.allocUnsafe(n7);
        do {
          const buf = this._buffers[0];
          const offset = dst.length - n7;
          if (n7 >= buf.length) {
            dst.set(this._buffers.shift(), offset);
          } else {
            dst.set(new Uint8Array(buf.buffer, buf.byteOffset, n7), offset);
            this._buffers[0] = new FastBuffer(
              buf.buffer,
              buf.byteOffset + n7,
              buf.length - n7
            );
          }
          n7 -= buf.length;
        } while (n7 > 0);
        return dst;
      }
      /**
       * Starts the parsing loop.
       *
       * @param {Function} cb Callback
       * @private
       */
      startLoop(cb) {
        let err3;
        this._loop = true;
        do {
          switch (this._state) {
            case GET_INFO:
              err3 = this.getInfo();
              break;
            case GET_PAYLOAD_LENGTH_16:
              err3 = this.getPayloadLength16();
              break;
            case GET_PAYLOAD_LENGTH_64:
              err3 = this.getPayloadLength64();
              break;
            case GET_MASK:
              this.getMask();
              break;
            case GET_DATA:
              err3 = this.getData(cb);
              break;
            case INFLATING:
              this._loop = false;
              return;
            default:
              this._loop = false;
              queueTask(() => {
                this._state = GET_INFO;
                this.startLoop(cb);
              });
              return;
          }
        } while (this._loop);
        cb(err3);
      }
      /**
       * Reads the first two bytes of a frame.
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      getInfo() {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        const buf = this.consume(2);
        if ((buf[0] & 48) !== 0) {
          this._loop = false;
          return error2(
            RangeError,
            "RSV2 and RSV3 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_2_3"
          );
        }
        const compressed = (buf[0] & 64) === 64;
        if (compressed && !this._extensions[PerMessageDeflate.extensionName]) {
          this._loop = false;
          return error2(
            RangeError,
            "RSV1 must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_RSV_1"
          );
        }
        this._fin = (buf[0] & 128) === 128;
        this._opcode = buf[0] & 15;
        this._payloadLength = buf[1] & 127;
        if (this._opcode === 0) {
          if (compressed) {
            this._loop = false;
            return error2(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (!this._fragmented) {
            this._loop = false;
            return error2(
              RangeError,
              "invalid opcode 0",
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
          }
          this._opcode = this._fragmented;
        } else if (this._opcode === 1 || this._opcode === 2) {
          if (this._fragmented) {
            this._loop = false;
            return error2(
              RangeError,
              `invalid opcode ${this._opcode}`,
              true,
              1002,
              "WS_ERR_INVALID_OPCODE"
            );
          }
          this._compressed = compressed;
        } else if (this._opcode > 7 && this._opcode < 11) {
          if (!this._fin) {
            this._loop = false;
            return error2(
              RangeError,
              "FIN must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_FIN"
            );
          }
          if (compressed) {
            this._loop = false;
            return error2(
              RangeError,
              "RSV1 must be clear",
              true,
              1002,
              "WS_ERR_UNEXPECTED_RSV_1"
            );
          }
          if (this._payloadLength > 125 || this._opcode === 8 && this._payloadLength === 1) {
            this._loop = false;
            return error2(
              RangeError,
              `invalid payload length ${this._payloadLength}`,
              true,
              1002,
              "WS_ERR_INVALID_CONTROL_PAYLOAD_LENGTH"
            );
          }
        } else {
          this._loop = false;
          return error2(
            RangeError,
            `invalid opcode ${this._opcode}`,
            true,
            1002,
            "WS_ERR_INVALID_OPCODE"
          );
        }
        if (!this._fin && !this._fragmented) this._fragmented = this._opcode;
        this._masked = (buf[1] & 128) === 128;
        if (this._isServer) {
          if (!this._masked) {
            this._loop = false;
            return error2(
              RangeError,
              "MASK must be set",
              true,
              1002,
              "WS_ERR_EXPECTED_MASK"
            );
          }
        } else if (this._masked) {
          this._loop = false;
          return error2(
            RangeError,
            "MASK must be clear",
            true,
            1002,
            "WS_ERR_UNEXPECTED_MASK"
          );
        }
        if (this._payloadLength === 126) this._state = GET_PAYLOAD_LENGTH_16;
        else if (this._payloadLength === 127) this._state = GET_PAYLOAD_LENGTH_64;
        else return this.haveLength();
      }
      /**
       * Gets extended payload length (7+16).
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      getPayloadLength16() {
        if (this._bufferedBytes < 2) {
          this._loop = false;
          return;
        }
        this._payloadLength = this.consume(2).readUInt16BE(0);
        return this.haveLength();
      }
      /**
       * Gets extended payload length (7+64).
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      getPayloadLength64() {
        if (this._bufferedBytes < 8) {
          this._loop = false;
          return;
        }
        const buf = this.consume(8);
        const num = buf.readUInt32BE(0);
        if (num > Math.pow(2, 53 - 32) - 1) {
          this._loop = false;
          return error2(
            RangeError,
            "Unsupported WebSocket frame: payload length > 2^53 - 1",
            false,
            1009,
            "WS_ERR_UNSUPPORTED_DATA_PAYLOAD_LENGTH"
          );
        }
        this._payloadLength = num * Math.pow(2, 32) + buf.readUInt32BE(4);
        return this.haveLength();
      }
      /**
       * Payload length has been read.
       *
       * @return {(RangeError|undefined)} A possible error
       * @private
       */
      haveLength() {
        if (this._payloadLength && this._opcode < 8) {
          this._totalPayloadLength += this._payloadLength;
          if (this._totalPayloadLength > this._maxPayload && this._maxPayload > 0) {
            this._loop = false;
            return error2(
              RangeError,
              "Max payload size exceeded",
              false,
              1009,
              "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
            );
          }
        }
        if (this._masked) this._state = GET_MASK;
        else this._state = GET_DATA;
      }
      /**
       * Reads mask bytes.
       *
       * @private
       */
      getMask() {
        if (this._bufferedBytes < 4) {
          this._loop = false;
          return;
        }
        this._mask = this.consume(4);
        this._state = GET_DATA;
      }
      /**
       * Reads data bytes.
       *
       * @param {Function} cb Callback
       * @return {(Error|RangeError|undefined)} A possible error
       * @private
       */
      getData(cb) {
        let data = EMPTY_BUFFER;
        if (this._payloadLength) {
          if (this._bufferedBytes < this._payloadLength) {
            this._loop = false;
            return;
          }
          data = this.consume(this._payloadLength);
          if (this._masked && (this._mask[0] | this._mask[1] | this._mask[2] | this._mask[3]) !== 0) {
            unmask(data, this._mask);
          }
        }
        if (this._opcode > 7) return this.controlMessage(data);
        if (this._compressed) {
          this._state = INFLATING;
          this.decompress(data, cb);
          return;
        }
        if (data.length) {
          this._messageLength = this._totalPayloadLength;
          this._fragments.push(data);
        }
        return this.dataMessage();
      }
      /**
       * Decompresses data.
       *
       * @param {Buffer} data Compressed data
       * @param {Function} cb Callback
       * @private
       */
      decompress(data, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        perMessageDeflate.decompress(data, this._fin, (err3, buf) => {
          if (err3) return cb(err3);
          if (buf.length) {
            this._messageLength += buf.length;
            if (this._messageLength > this._maxPayload && this._maxPayload > 0) {
              return cb(
                error2(
                  RangeError,
                  "Max payload size exceeded",
                  false,
                  1009,
                  "WS_ERR_UNSUPPORTED_MESSAGE_LENGTH"
                )
              );
            }
            this._fragments.push(buf);
          }
          const er3 = this.dataMessage();
          if (er3) return cb(er3);
          this.startLoop(cb);
        });
      }
      /**
       * Handles a data message.
       *
       * @return {(Error|undefined)} A possible error
       * @private
       */
      dataMessage() {
        if (this._fin) {
          const messageLength = this._messageLength;
          const fragments = this._fragments;
          this._totalPayloadLength = 0;
          this._messageLength = 0;
          this._fragmented = 0;
          this._fragments = [];
          if (this._opcode === 2) {
            let data;
            if (this._binaryType === "nodebuffer") {
              data = concat(fragments, messageLength);
            } else if (this._binaryType === "arraybuffer") {
              data = toArrayBuffer(concat(fragments, messageLength));
            } else {
              data = fragments;
            }
            this.emit("message", data, true);
          } else {
            const buf = concat(fragments, messageLength);
            if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
              this._loop = false;
              return error2(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
            }
            this.emit("message", buf, false);
          }
        }
        this._state = WAIT_MICROTASK;
      }
      /**
       * Handles a control message.
       *
       * @param {Buffer} data Data to handle
       * @return {(Error|RangeError|undefined)} A possible error
       * @private
       */
      controlMessage(data) {
        if (this._opcode === 8) {
          this._loop = false;
          if (data.length === 0) {
            this.emit("conclude", 1005, EMPTY_BUFFER);
            this.end();
            this._state = GET_INFO;
          } else {
            const code = data.readUInt16BE(0);
            if (!isValidStatusCode(code)) {
              return error2(
                RangeError,
                `invalid status code ${code}`,
                true,
                1002,
                "WS_ERR_INVALID_CLOSE_CODE"
              );
            }
            const buf = new FastBuffer(
              data.buffer,
              data.byteOffset + 2,
              data.length - 2
            );
            if (!this._skipUTF8Validation && !isValidUTF8(buf)) {
              return error2(
                Error,
                "invalid UTF-8 sequence",
                true,
                1007,
                "WS_ERR_INVALID_UTF8"
              );
            }
            this.emit("conclude", code, buf);
            this.end();
            this._state = GET_INFO;
          }
        } else if (this._opcode === 9) {
          this.emit("ping", data);
          this._state = WAIT_MICROTASK;
        } else {
          this.emit("pong", data);
          this._state = WAIT_MICROTASK;
        }
      }
    };
    module2.exports = Receiver3;
    function error2(ErrorCtor, message, prefix2, statusCode, errorCode) {
      const err3 = new ErrorCtor(
        prefix2 ? `Invalid WebSocket frame: ${message}` : message
      );
      Error.captureStackTrace(err3, error2);
      err3.code = errorCode;
      err3[kStatusCode] = statusCode;
      return err3;
    }
    function queueMicrotaskShim(cb) {
      promise.then(cb).catch(throwErrorNextTick);
    }
    function throwError(err3) {
      throw err3;
    }
    function throwErrorNextTick(err3) {
      process.nextTick(throwError, err3);
    }
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/sender.js
var require_sender2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/sender.js"(exports2, module2) {
    "use strict";
    var { Duplex } = require("stream");
    var { randomFillSync } = require("crypto");
    var PerMessageDeflate = require_permessage_deflate2();
    var { EMPTY_BUFFER } = require_constants3();
    var { isValidStatusCode } = require_validation2();
    var { mask: applyMask, toBuffer } = require_buffer_util2();
    var kByteLength = Symbol("kByteLength");
    var maskBuffer = Buffer.alloc(4);
    var Sender3 = class _Sender {
      /**
       * Creates a Sender instance.
       *
       * @param {Duplex} socket The connection socket
       * @param {Object} [extensions] An object containing the negotiated extensions
       * @param {Function} [generateMask] The function used to generate the masking
       *     key
       */
      constructor(socket, extensions, generateMask) {
        this._extensions = extensions || {};
        if (generateMask) {
          this._generateMask = generateMask;
          this._maskBuffer = Buffer.alloc(4);
        }
        this._socket = socket;
        this._firstFragment = true;
        this._compress = false;
        this._bufferedBytes = 0;
        this._deflating = false;
        this._queue = [];
      }
      /**
       * Frames a piece of data according to the HyBi WebSocket protocol.
       *
       * @param {(Buffer|String)} data The data to frame
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @return {(Buffer|String)[]} The framed data
       * @public
       */
      static frame(data, options) {
        let mask;
        let merge2 = false;
        let offset = 2;
        let skipMasking = false;
        if (options.mask) {
          mask = options.maskBuffer || maskBuffer;
          if (options.generateMask) {
            options.generateMask(mask);
          } else {
            randomFillSync(mask, 0, 4);
          }
          skipMasking = (mask[0] | mask[1] | mask[2] | mask[3]) === 0;
          offset = 6;
        }
        let dataLength;
        if (typeof data === "string") {
          if ((!options.mask || skipMasking) && options[kByteLength] !== void 0) {
            dataLength = options[kByteLength];
          } else {
            data = Buffer.from(data);
            dataLength = data.length;
          }
        } else {
          dataLength = data.length;
          merge2 = options.mask && options.readOnly && !skipMasking;
        }
        let payloadLength = dataLength;
        if (dataLength >= 65536) {
          offset += 8;
          payloadLength = 127;
        } else if (dataLength > 125) {
          offset += 2;
          payloadLength = 126;
        }
        const target = Buffer.allocUnsafe(merge2 ? dataLength + offset : offset);
        target[0] = options.fin ? options.opcode | 128 : options.opcode;
        if (options.rsv1) target[0] |= 64;
        target[1] = payloadLength;
        if (payloadLength === 126) {
          target.writeUInt16BE(dataLength, 2);
        } else if (payloadLength === 127) {
          target[2] = target[3] = 0;
          target.writeUIntBE(dataLength, 4, 6);
        }
        if (!options.mask) return [target, data];
        target[1] |= 128;
        target[offset - 4] = mask[0];
        target[offset - 3] = mask[1];
        target[offset - 2] = mask[2];
        target[offset - 1] = mask[3];
        if (skipMasking) return [target, data];
        if (merge2) {
          applyMask(data, mask, target, offset, dataLength);
          return [target];
        }
        applyMask(data, mask, data, 0, dataLength);
        return [target, data];
      }
      /**
       * Sends a close message to the other peer.
       *
       * @param {Number} [code] The status code component of the body
       * @param {(String|Buffer)} [data] The message component of the body
       * @param {Boolean} [mask=false] Specifies whether or not to mask the message
       * @param {Function} [cb] Callback
       * @public
       */
      close(code, data, mask, cb) {
        let buf;
        if (code === void 0) {
          buf = EMPTY_BUFFER;
        } else if (typeof code !== "number" || !isValidStatusCode(code)) {
          throw new TypeError("First argument must be a valid error code number");
        } else if (data === void 0 || !data.length) {
          buf = Buffer.allocUnsafe(2);
          buf.writeUInt16BE(code, 0);
        } else {
          const length = Buffer.byteLength(data);
          if (length > 123) {
            throw new RangeError("The message must not be greater than 123 bytes");
          }
          buf = Buffer.allocUnsafe(2 + length);
          buf.writeUInt16BE(code, 0);
          if (typeof data === "string") {
            buf.write(data, 2);
          } else {
            buf.set(data, 2);
          }
        }
        const options = {
          [kByteLength]: buf.length,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 8,
          readOnly: false,
          rsv1: false
        };
        if (this._deflating) {
          this.enqueue([this.dispatch, buf, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(buf, options), cb);
        }
      }
      /**
       * Sends a ping message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      ping(data, mask, cb) {
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (byteLength > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        const options = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 9,
          readOnly,
          rsv1: false
        };
        if (this._deflating) {
          this.enqueue([this.dispatch, data, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(data, options), cb);
        }
      }
      /**
       * Sends a pong message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Boolean} [mask=false] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback
       * @public
       */
      pong(data, mask, cb) {
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (byteLength > 125) {
          throw new RangeError("The data size must not be greater than 125 bytes");
        }
        const options = {
          [kByteLength]: byteLength,
          fin: true,
          generateMask: this._generateMask,
          mask,
          maskBuffer: this._maskBuffer,
          opcode: 10,
          readOnly,
          rsv1: false
        };
        if (this._deflating) {
          this.enqueue([this.dispatch, data, false, options, cb]);
        } else {
          this.sendFrame(_Sender.frame(data, options), cb);
        }
      }
      /**
       * Sends a data message to the other peer.
       *
       * @param {*} data The message to send
       * @param {Object} options Options object
       * @param {Boolean} [options.binary=false] Specifies whether `data` is binary
       *     or text
       * @param {Boolean} [options.compress=false] Specifies whether or not to
       *     compress `data`
       * @param {Boolean} [options.fin=false] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Function} [cb] Callback
       * @public
       */
      send(data, options, cb) {
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        let opcode = options.binary ? 2 : 1;
        let rsv1 = options.compress;
        let byteLength;
        let readOnly;
        if (typeof data === "string") {
          byteLength = Buffer.byteLength(data);
          readOnly = false;
        } else {
          data = toBuffer(data);
          byteLength = data.length;
          readOnly = toBuffer.readOnly;
        }
        if (this._firstFragment) {
          this._firstFragment = false;
          if (rsv1 && perMessageDeflate && perMessageDeflate.params[perMessageDeflate._isServer ? "server_no_context_takeover" : "client_no_context_takeover"]) {
            rsv1 = byteLength >= perMessageDeflate._threshold;
          }
          this._compress = rsv1;
        } else {
          rsv1 = false;
          opcode = 0;
        }
        if (options.fin) this._firstFragment = true;
        if (perMessageDeflate) {
          const opts = {
            [kByteLength]: byteLength,
            fin: options.fin,
            generateMask: this._generateMask,
            mask: options.mask,
            maskBuffer: this._maskBuffer,
            opcode,
            readOnly,
            rsv1
          };
          if (this._deflating) {
            this.enqueue([this.dispatch, data, this._compress, opts, cb]);
          } else {
            this.dispatch(data, this._compress, opts, cb);
          }
        } else {
          this.sendFrame(
            _Sender.frame(data, {
              [kByteLength]: byteLength,
              fin: options.fin,
              generateMask: this._generateMask,
              mask: options.mask,
              maskBuffer: this._maskBuffer,
              opcode,
              readOnly,
              rsv1: false
            }),
            cb
          );
        }
      }
      /**
       * Dispatches a message.
       *
       * @param {(Buffer|String)} data The message to send
       * @param {Boolean} [compress=false] Specifies whether or not to compress
       *     `data`
       * @param {Object} options Options object
       * @param {Boolean} [options.fin=false] Specifies whether or not to set the
       *     FIN bit
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Boolean} [options.mask=false] Specifies whether or not to mask
       *     `data`
       * @param {Buffer} [options.maskBuffer] The buffer used to store the masking
       *     key
       * @param {Number} options.opcode The opcode
       * @param {Boolean} [options.readOnly=false] Specifies whether `data` can be
       *     modified
       * @param {Boolean} [options.rsv1=false] Specifies whether or not to set the
       *     RSV1 bit
       * @param {Function} [cb] Callback
       * @private
       */
      dispatch(data, compress2, options, cb) {
        if (!compress2) {
          this.sendFrame(_Sender.frame(data, options), cb);
          return;
        }
        const perMessageDeflate = this._extensions[PerMessageDeflate.extensionName];
        this._bufferedBytes += options[kByteLength];
        this._deflating = true;
        perMessageDeflate.compress(data, options.fin, (_7, buf) => {
          if (this._socket.destroyed) {
            const err3 = new Error(
              "The socket was closed while data was being compressed"
            );
            if (typeof cb === "function") cb(err3);
            for (let i8 = 0; i8 < this._queue.length; i8++) {
              const params = this._queue[i8];
              const callback = params[params.length - 1];
              if (typeof callback === "function") callback(err3);
            }
            return;
          }
          this._bufferedBytes -= options[kByteLength];
          this._deflating = false;
          options.readOnly = false;
          this.sendFrame(_Sender.frame(buf, options), cb);
          this.dequeue();
        });
      }
      /**
       * Executes queued send operations.
       *
       * @private
       */
      dequeue() {
        while (!this._deflating && this._queue.length) {
          const params = this._queue.shift();
          this._bufferedBytes -= params[3][kByteLength];
          Reflect.apply(params[0], this, params.slice(1));
        }
      }
      /**
       * Enqueues a send operation.
       *
       * @param {Array} params Send operation parameters.
       * @private
       */
      enqueue(params) {
        this._bufferedBytes += params[3][kByteLength];
        this._queue.push(params);
      }
      /**
       * Sends a frame.
       *
       * @param {Buffer[]} list The frame to send
       * @param {Function} [cb] Callback
       * @private
       */
      sendFrame(list, cb) {
        if (list.length === 2) {
          this._socket.cork();
          this._socket.write(list[0]);
          this._socket.write(list[1], cb);
          this._socket.uncork();
        } else {
          this._socket.write(list[0], cb);
        }
      }
    };
    module2.exports = Sender3;
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/event-target.js
var require_event_target2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/event-target.js"(exports2, module2) {
    "use strict";
    var { kForOnEventAttribute, kListener } = require_constants3();
    var kCode = Symbol("kCode");
    var kData = Symbol("kData");
    var kError = Symbol("kError");
    var kMessage = Symbol("kMessage");
    var kReason = Symbol("kReason");
    var kTarget = Symbol("kTarget");
    var kType = Symbol("kType");
    var kWasClean = Symbol("kWasClean");
    var Event = class {
      /**
       * Create a new `Event`.
       *
       * @param {String} type The name of the event
       * @throws {TypeError} If the `type` argument is not specified
       */
      constructor(type) {
        this[kTarget] = null;
        this[kType] = type;
      }
      /**
       * @type {*}
       */
      get target() {
        return this[kTarget];
      }
      /**
       * @type {String}
       */
      get type() {
        return this[kType];
      }
    };
    Object.defineProperty(Event.prototype, "target", { enumerable: true });
    Object.defineProperty(Event.prototype, "type", { enumerable: true });
    var CloseEvent = class extends Event {
      /**
       * Create a new `CloseEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {Number} [options.code=0] The status code explaining why the
       *     connection was closed
       * @param {String} [options.reason=''] A human-readable string explaining why
       *     the connection was closed
       * @param {Boolean} [options.wasClean=false] Indicates whether or not the
       *     connection was cleanly closed
       */
      constructor(type, options = {}) {
        super(type);
        this[kCode] = options.code === void 0 ? 0 : options.code;
        this[kReason] = options.reason === void 0 ? "" : options.reason;
        this[kWasClean] = options.wasClean === void 0 ? false : options.wasClean;
      }
      /**
       * @type {Number}
       */
      get code() {
        return this[kCode];
      }
      /**
       * @type {String}
       */
      get reason() {
        return this[kReason];
      }
      /**
       * @type {Boolean}
       */
      get wasClean() {
        return this[kWasClean];
      }
    };
    Object.defineProperty(CloseEvent.prototype, "code", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "reason", { enumerable: true });
    Object.defineProperty(CloseEvent.prototype, "wasClean", { enumerable: true });
    var ErrorEvent = class extends Event {
      /**
       * Create a new `ErrorEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {*} [options.error=null] The error that generated this event
       * @param {String} [options.message=''] The error message
       */
      constructor(type, options = {}) {
        super(type);
        this[kError] = options.error === void 0 ? null : options.error;
        this[kMessage] = options.message === void 0 ? "" : options.message;
      }
      /**
       * @type {*}
       */
      get error() {
        return this[kError];
      }
      /**
       * @type {String}
       */
      get message() {
        return this[kMessage];
      }
    };
    Object.defineProperty(ErrorEvent.prototype, "error", { enumerable: true });
    Object.defineProperty(ErrorEvent.prototype, "message", { enumerable: true });
    var MessageEvent = class extends Event {
      /**
       * Create a new `MessageEvent`.
       *
       * @param {String} type The name of the event
       * @param {Object} [options] A dictionary object that allows for setting
       *     attributes via object members of the same name
       * @param {*} [options.data=null] The message content
       */
      constructor(type, options = {}) {
        super(type);
        this[kData] = options.data === void 0 ? null : options.data;
      }
      /**
       * @type {*}
       */
      get data() {
        return this[kData];
      }
    };
    Object.defineProperty(MessageEvent.prototype, "data", { enumerable: true });
    var EventTarget = {
      /**
       * Register an event listener.
       *
       * @param {String} type A string representing the event type to listen for
       * @param {(Function|Object)} handler The listener to add
       * @param {Object} [options] An options object specifies characteristics about
       *     the event listener
       * @param {Boolean} [options.once=false] A `Boolean` indicating that the
       *     listener should be invoked at most once after being added. If `true`,
       *     the listener would be automatically removed when invoked.
       * @public
       */
      addEventListener(type, handler, options = {}) {
        for (const listener of this.listeners(type)) {
          if (!options[kForOnEventAttribute] && listener[kListener] === handler && !listener[kForOnEventAttribute]) {
            return;
          }
        }
        let wrapper;
        if (type === "message") {
          wrapper = function onMessage(data, isBinary2) {
            const event = new MessageEvent("message", {
              data: isBinary2 ? data : data.toString()
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "close") {
          wrapper = function onClose(code, message) {
            const event = new CloseEvent("close", {
              code,
              reason: message.toString(),
              wasClean: this._closeFrameReceived && this._closeFrameSent
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "error") {
          wrapper = function onError(error2) {
            const event = new ErrorEvent("error", {
              error: error2,
              message: error2.message
            });
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else if (type === "open") {
          wrapper = function onOpen() {
            const event = new Event("open");
            event[kTarget] = this;
            callListener(handler, this, event);
          };
        } else {
          return;
        }
        wrapper[kForOnEventAttribute] = !!options[kForOnEventAttribute];
        wrapper[kListener] = handler;
        if (options.once) {
          this.once(type, wrapper);
        } else {
          this.on(type, wrapper);
        }
      },
      /**
       * Remove an event listener.
       *
       * @param {String} type A string representing the event type to remove
       * @param {(Function|Object)} handler The listener to remove
       * @public
       */
      removeEventListener(type, handler) {
        for (const listener of this.listeners(type)) {
          if (listener[kListener] === handler && !listener[kForOnEventAttribute]) {
            this.removeListener(type, listener);
            break;
          }
        }
      }
    };
    module2.exports = {
      CloseEvent,
      ErrorEvent,
      Event,
      EventTarget,
      MessageEvent
    };
    function callListener(listener, thisArg, event) {
      if (typeof listener === "object" && listener.handleEvent) {
        listener.handleEvent.call(listener, event);
      } else {
        listener.call(thisArg, event);
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/extension.js
var require_extension2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/extension.js"(exports2, module2) {
    "use strict";
    var { tokenChars } = require_validation2();
    function push(dest, name3, elem) {
      if (dest[name3] === void 0) dest[name3] = [elem];
      else dest[name3].push(elem);
    }
    function parse6(header) {
      const offers = /* @__PURE__ */ Object.create(null);
      let params = /* @__PURE__ */ Object.create(null);
      let mustUnescape = false;
      let isEscaping = false;
      let inQuotes = false;
      let extensionName;
      let paramName;
      let start2 = -1;
      let code = -1;
      let end = -1;
      let i8 = 0;
      for (; i8 < header.length; i8++) {
        code = header.charCodeAt(i8);
        if (extensionName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start2 === -1) start2 = i8;
          } else if (i8 !== 0 && (code === 32 || code === 9)) {
            if (end === -1 && start2 !== -1) end = i8;
          } else if (code === 59 || code === 44) {
            if (start2 === -1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (end === -1) end = i8;
            const name3 = header.slice(start2, end);
            if (code === 44) {
              push(offers, name3, params);
              params = /* @__PURE__ */ Object.create(null);
            } else {
              extensionName = name3;
            }
            start2 = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
        } else if (paramName === void 0) {
          if (end === -1 && tokenChars[code] === 1) {
            if (start2 === -1) start2 = i8;
          } else if (code === 32 || code === 9) {
            if (end === -1 && start2 !== -1) end = i8;
          } else if (code === 59 || code === 44) {
            if (start2 === -1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (end === -1) end = i8;
            push(params, header.slice(start2, end), true);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            start2 = end = -1;
          } else if (code === 61 && start2 !== -1 && end === -1) {
            paramName = header.slice(start2, i8);
            start2 = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
        } else {
          if (isEscaping) {
            if (tokenChars[code] !== 1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (start2 === -1) start2 = i8;
            else if (!mustUnescape) mustUnescape = true;
            isEscaping = false;
          } else if (inQuotes) {
            if (tokenChars[code] === 1) {
              if (start2 === -1) start2 = i8;
            } else if (code === 34 && start2 !== -1) {
              inQuotes = false;
              end = i8;
            } else if (code === 92) {
              isEscaping = true;
            } else {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
          } else if (code === 34 && header.charCodeAt(i8 - 1) === 61) {
            inQuotes = true;
          } else if (end === -1 && tokenChars[code] === 1) {
            if (start2 === -1) start2 = i8;
          } else if (start2 !== -1 && (code === 32 || code === 9)) {
            if (end === -1) end = i8;
          } else if (code === 59 || code === 44) {
            if (start2 === -1) {
              throw new SyntaxError(`Unexpected character at index ${i8}`);
            }
            if (end === -1) end = i8;
            let value = header.slice(start2, end);
            if (mustUnescape) {
              value = value.replace(/\\/g, "");
              mustUnescape = false;
            }
            push(params, paramName, value);
            if (code === 44) {
              push(offers, extensionName, params);
              params = /* @__PURE__ */ Object.create(null);
              extensionName = void 0;
            }
            paramName = void 0;
            start2 = end = -1;
          } else {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
        }
      }
      if (start2 === -1 || inQuotes || code === 32 || code === 9) {
        throw new SyntaxError("Unexpected end of input");
      }
      if (end === -1) end = i8;
      const token = header.slice(start2, end);
      if (extensionName === void 0) {
        push(offers, token, params);
      } else {
        if (paramName === void 0) {
          push(params, token, true);
        } else if (mustUnescape) {
          push(params, paramName, token.replace(/\\/g, ""));
        } else {
          push(params, paramName, token);
        }
        push(offers, extensionName, params);
      }
      return offers;
    }
    function format2(extensions) {
      return Object.keys(extensions).map((extension) => {
        let configurations = extensions[extension];
        if (!Array.isArray(configurations)) configurations = [configurations];
        return configurations.map((params) => {
          return [extension].concat(
            Object.keys(params).map((k9) => {
              let values2 = params[k9];
              if (!Array.isArray(values2)) values2 = [values2];
              return values2.map((v11) => v11 === true ? k9 : `${k9}=${v11}`).join("; ");
            })
          ).join("; ");
        }).join(", ");
      }).join(", ");
    }
    module2.exports = { format: format2, parse: parse6 };
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/websocket.js
var require_websocket2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/websocket.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events");
    var https3 = require("https");
    var http4 = require("http");
    var net2 = require("net");
    var tls2 = require("tls");
    var { randomBytes, createHash: createHash4 } = require("crypto");
    var { Duplex, Readable: Readable6 } = require("stream");
    var { URL: URL2 } = require("url");
    var PerMessageDeflate = require_permessage_deflate2();
    var Receiver3 = require_receiver2();
    var Sender3 = require_sender2();
    var {
      BINARY_TYPES,
      EMPTY_BUFFER,
      GUID,
      kForOnEventAttribute,
      kListener,
      kStatusCode,
      kWebSocket,
      NOOP
    } = require_constants3();
    var {
      EventTarget: { addEventListener: addEventListener2, removeEventListener }
    } = require_event_target2();
    var { format: format2, parse: parse6 } = require_extension2();
    var { toBuffer } = require_buffer_util2();
    var closeTimeout = 30 * 1e3;
    var kAborted = Symbol("kAborted");
    var protocolVersions = [8, 13];
    var readyStates = ["CONNECTING", "OPEN", "CLOSING", "CLOSED"];
    var subprotocolRegex = /^[!#$%&'*+\-.0-9A-Z^_`|a-z~]+$/;
    var WebSocket4 = class _WebSocket extends EventEmitter {
      /**
       * Create a new `WebSocket`.
       *
       * @param {(String|URL)} address The URL to which to connect
       * @param {(String|String[])} [protocols] The subprotocols
       * @param {Object} [options] Connection options
       */
      constructor(address, protocols, options) {
        super();
        this._binaryType = BINARY_TYPES[0];
        this._closeCode = 1006;
        this._closeFrameReceived = false;
        this._closeFrameSent = false;
        this._closeMessage = EMPTY_BUFFER;
        this._closeTimer = null;
        this._extensions = {};
        this._paused = false;
        this._protocol = "";
        this._readyState = _WebSocket.CONNECTING;
        this._receiver = null;
        this._sender = null;
        this._socket = null;
        if (address !== null) {
          this._bufferedAmount = 0;
          this._isServer = false;
          this._redirects = 0;
          if (protocols === void 0) {
            protocols = [];
          } else if (!Array.isArray(protocols)) {
            if (typeof protocols === "object" && protocols !== null) {
              options = protocols;
              protocols = [];
            } else {
              protocols = [protocols];
            }
          }
          initAsClient(this, address, protocols, options);
        } else {
          this._isServer = true;
        }
      }
      /**
       * This deviates from the WHATWG interface since ws doesn't support the
       * required default "blob" type (instead we define a custom "nodebuffer"
       * type).
       *
       * @type {String}
       */
      get binaryType() {
        return this._binaryType;
      }
      set binaryType(type) {
        if (!BINARY_TYPES.includes(type)) return;
        this._binaryType = type;
        if (this._receiver) this._receiver._binaryType = type;
      }
      /**
       * @type {Number}
       */
      get bufferedAmount() {
        if (!this._socket) return this._bufferedAmount;
        return this._socket._writableState.length + this._sender._bufferedBytes;
      }
      /**
       * @type {String}
       */
      get extensions() {
        return Object.keys(this._extensions).join();
      }
      /**
       * @type {Boolean}
       */
      get isPaused() {
        return this._paused;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onclose() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onerror() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onopen() {
        return null;
      }
      /**
       * @type {Function}
       */
      /* istanbul ignore next */
      get onmessage() {
        return null;
      }
      /**
       * @type {String}
       */
      get protocol() {
        return this._protocol;
      }
      /**
       * @type {Number}
       */
      get readyState() {
        return this._readyState;
      }
      /**
       * @type {String}
       */
      get url() {
        return this._url;
      }
      /**
       * Set up the socket and the internal resources.
       *
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Object} options Options object
       * @param {Function} [options.generateMask] The function used to generate the
       *     masking key
       * @param {Number} [options.maxPayload=0] The maximum allowed message size
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       * @private
       */
      setSocket(socket, head, options) {
        const receiver = new Receiver3({
          binaryType: this.binaryType,
          extensions: this._extensions,
          isServer: this._isServer,
          maxPayload: options.maxPayload,
          skipUTF8Validation: options.skipUTF8Validation
        });
        this._sender = new Sender3(socket, this._extensions, options.generateMask);
        this._receiver = receiver;
        this._socket = socket;
        receiver[kWebSocket] = this;
        socket[kWebSocket] = this;
        receiver.on("conclude", receiverOnConclude);
        receiver.on("drain", receiverOnDrain);
        receiver.on("error", receiverOnError);
        receiver.on("message", receiverOnMessage);
        receiver.on("ping", receiverOnPing);
        receiver.on("pong", receiverOnPong);
        if (socket.setTimeout) socket.setTimeout(0);
        if (socket.setNoDelay) socket.setNoDelay();
        if (head.length > 0) socket.unshift(head);
        socket.on("close", socketOnClose);
        socket.on("data", socketOnData);
        socket.on("end", socketOnEnd);
        socket.on("error", socketOnError);
        this._readyState = _WebSocket.OPEN;
        this.emit("open");
      }
      /**
       * Emit the `'close'` event.
       *
       * @private
       */
      emitClose() {
        if (!this._socket) {
          this._readyState = _WebSocket.CLOSED;
          this.emit("close", this._closeCode, this._closeMessage);
          return;
        }
        if (this._extensions[PerMessageDeflate.extensionName]) {
          this._extensions[PerMessageDeflate.extensionName].cleanup();
        }
        this._receiver.removeAllListeners();
        this._readyState = _WebSocket.CLOSED;
        this.emit("close", this._closeCode, this._closeMessage);
      }
      /**
       * Start a closing handshake.
       *
       *          +----------+   +-----------+   +----------+
       *     - - -|ws.close()|-->|close frame|-->|ws.close()|- - -
       *    |     +----------+   +-----------+   +----------+     |
       *          +----------+   +-----------+         |
       * CLOSING  |ws.close()|<--|close frame|<--+-----+       CLOSING
       *          +----------+   +-----------+   |
       *    |           |                        |   +---+        |
       *                +------------------------+-->|fin| - - - -
       *    |         +---+                      |   +---+
       *     - - - - -|fin|<---------------------+
       *              +---+
       *
       * @param {Number} [code] Status code explaining why the connection is closing
       * @param {(String|Buffer)} [data] The reason why the connection is
       *     closing
       * @public
       */
      close(code, data) {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          abortHandshake(this, this._req, msg);
          return;
        }
        if (this.readyState === _WebSocket.CLOSING) {
          if (this._closeFrameSent && (this._closeFrameReceived || this._receiver._writableState.errorEmitted)) {
            this._socket.end();
          }
          return;
        }
        this._readyState = _WebSocket.CLOSING;
        this._sender.close(code, data, !this._isServer, (err3) => {
          if (err3) return;
          this._closeFrameSent = true;
          if (this._closeFrameReceived || this._receiver._writableState.errorEmitted) {
            this._socket.end();
          }
        });
        this._closeTimer = setTimeout(
          this._socket.destroy.bind(this._socket),
          closeTimeout
        );
      }
      /**
       * Pause the socket.
       *
       * @public
       */
      pause() {
        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
          return;
        }
        this._paused = true;
        this._socket.pause();
      }
      /**
       * Send a ping.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the ping is sent
       * @public
       */
      ping(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.ping(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Send a pong.
       *
       * @param {*} [data] The data to send
       * @param {Boolean} [mask] Indicates whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when the pong is sent
       * @public
       */
      pong(data, mask, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof data === "function") {
          cb = data;
          data = mask = void 0;
        } else if (typeof mask === "function") {
          cb = mask;
          mask = void 0;
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        if (mask === void 0) mask = !this._isServer;
        this._sender.pong(data || EMPTY_BUFFER, mask, cb);
      }
      /**
       * Resume the socket.
       *
       * @public
       */
      resume() {
        if (this.readyState === _WebSocket.CONNECTING || this.readyState === _WebSocket.CLOSED) {
          return;
        }
        this._paused = false;
        if (!this._receiver._writableState.needDrain) this._socket.resume();
      }
      /**
       * Send a data message.
       *
       * @param {*} data The message to send
       * @param {Object} [options] Options object
       * @param {Boolean} [options.binary] Specifies whether `data` is binary or
       *     text
       * @param {Boolean} [options.compress] Specifies whether or not to compress
       *     `data`
       * @param {Boolean} [options.fin=true] Specifies whether the fragment is the
       *     last one
       * @param {Boolean} [options.mask] Specifies whether or not to mask `data`
       * @param {Function} [cb] Callback which is executed when data is written out
       * @public
       */
      send(data, options, cb) {
        if (this.readyState === _WebSocket.CONNECTING) {
          throw new Error("WebSocket is not open: readyState 0 (CONNECTING)");
        }
        if (typeof options === "function") {
          cb = options;
          options = {};
        }
        if (typeof data === "number") data = data.toString();
        if (this.readyState !== _WebSocket.OPEN) {
          sendAfterClose(this, data, cb);
          return;
        }
        const opts = {
          binary: typeof data !== "string",
          mask: !this._isServer,
          compress: true,
          fin: true,
          ...options
        };
        if (!this._extensions[PerMessageDeflate.extensionName]) {
          opts.compress = false;
        }
        this._sender.send(data || EMPTY_BUFFER, opts, cb);
      }
      /**
       * Forcibly close the connection.
       *
       * @public
       */
      terminate() {
        if (this.readyState === _WebSocket.CLOSED) return;
        if (this.readyState === _WebSocket.CONNECTING) {
          const msg = "WebSocket was closed before the connection was established";
          abortHandshake(this, this._req, msg);
          return;
        }
        if (this._socket) {
          this._readyState = _WebSocket.CLOSING;
          this._socket.destroy();
        }
      }
    };
    Object.defineProperty(WebSocket4, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket4.prototype, "CONNECTING", {
      enumerable: true,
      value: readyStates.indexOf("CONNECTING")
    });
    Object.defineProperty(WebSocket4, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket4.prototype, "OPEN", {
      enumerable: true,
      value: readyStates.indexOf("OPEN")
    });
    Object.defineProperty(WebSocket4, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket4.prototype, "CLOSING", {
      enumerable: true,
      value: readyStates.indexOf("CLOSING")
    });
    Object.defineProperty(WebSocket4, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    Object.defineProperty(WebSocket4.prototype, "CLOSED", {
      enumerable: true,
      value: readyStates.indexOf("CLOSED")
    });
    [
      "binaryType",
      "bufferedAmount",
      "extensions",
      "isPaused",
      "protocol",
      "readyState",
      "url"
    ].forEach((property) => {
      Object.defineProperty(WebSocket4.prototype, property, { enumerable: true });
    });
    ["open", "error", "close", "message"].forEach((method) => {
      Object.defineProperty(WebSocket4.prototype, `on${method}`, {
        enumerable: true,
        get() {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute]) return listener[kListener];
          }
          return null;
        },
        set(handler) {
          for (const listener of this.listeners(method)) {
            if (listener[kForOnEventAttribute]) {
              this.removeListener(method, listener);
              break;
            }
          }
          if (typeof handler !== "function") return;
          this.addEventListener(method, handler, {
            [kForOnEventAttribute]: true
          });
        }
      });
    });
    WebSocket4.prototype.addEventListener = addEventListener2;
    WebSocket4.prototype.removeEventListener = removeEventListener;
    module2.exports = WebSocket4;
    function initAsClient(websocket, address, protocols, options) {
      const opts = {
        protocolVersion: protocolVersions[1],
        maxPayload: 100 * 1024 * 1024,
        skipUTF8Validation: false,
        perMessageDeflate: true,
        followRedirects: false,
        maxRedirects: 10,
        ...options,
        createConnection: void 0,
        socketPath: void 0,
        hostname: void 0,
        protocol: void 0,
        timeout: void 0,
        method: "GET",
        host: void 0,
        path: void 0,
        port: void 0
      };
      if (!protocolVersions.includes(opts.protocolVersion)) {
        throw new RangeError(
          `Unsupported protocol version: ${opts.protocolVersion} (supported versions: ${protocolVersions.join(", ")})`
        );
      }
      let parsedUrl;
      if (address instanceof URL2) {
        parsedUrl = address;
      } else {
        try {
          parsedUrl = new URL2(address);
        } catch (e6) {
          throw new SyntaxError(`Invalid URL: ${address}`);
        }
      }
      if (parsedUrl.protocol === "http:") {
        parsedUrl.protocol = "ws:";
      } else if (parsedUrl.protocol === "https:") {
        parsedUrl.protocol = "wss:";
      }
      websocket._url = parsedUrl.href;
      const isSecure = parsedUrl.protocol === "wss:";
      const isIpcUrl = parsedUrl.protocol === "ws+unix:";
      let invalidUrlMessage;
      if (parsedUrl.protocol !== "ws:" && !isSecure && !isIpcUrl) {
        invalidUrlMessage = `The URL's protocol must be one of "ws:", "wss:", "http:", "https", or "ws+unix:"`;
      } else if (isIpcUrl && !parsedUrl.pathname) {
        invalidUrlMessage = "The URL's pathname is empty";
      } else if (parsedUrl.hash) {
        invalidUrlMessage = "The URL contains a fragment identifier";
      }
      if (invalidUrlMessage) {
        const err3 = new SyntaxError(invalidUrlMessage);
        if (websocket._redirects === 0) {
          throw err3;
        } else {
          emitErrorAndClose(websocket, err3);
          return;
        }
      }
      const defaultPort = isSecure ? 443 : 80;
      const key = randomBytes(16).toString("base64");
      const request2 = isSecure ? https3.request : http4.request;
      const protocolSet = /* @__PURE__ */ new Set();
      let perMessageDeflate;
      opts.createConnection = isSecure ? tlsConnect : netConnect;
      opts.defaultPort = opts.defaultPort || defaultPort;
      opts.port = parsedUrl.port || defaultPort;
      opts.host = parsedUrl.hostname.startsWith("[") ? parsedUrl.hostname.slice(1, -1) : parsedUrl.hostname;
      opts.headers = {
        ...opts.headers,
        "Sec-WebSocket-Version": opts.protocolVersion,
        "Sec-WebSocket-Key": key,
        Connection: "Upgrade",
        Upgrade: "websocket"
      };
      opts.path = parsedUrl.pathname + parsedUrl.search;
      opts.timeout = opts.handshakeTimeout;
      if (opts.perMessageDeflate) {
        perMessageDeflate = new PerMessageDeflate(
          opts.perMessageDeflate !== true ? opts.perMessageDeflate : {},
          false,
          opts.maxPayload
        );
        opts.headers["Sec-WebSocket-Extensions"] = format2({
          [PerMessageDeflate.extensionName]: perMessageDeflate.offer()
        });
      }
      if (protocols.length) {
        for (const protocol2 of protocols) {
          if (typeof protocol2 !== "string" || !subprotocolRegex.test(protocol2) || protocolSet.has(protocol2)) {
            throw new SyntaxError(
              "An invalid or duplicated subprotocol was specified"
            );
          }
          protocolSet.add(protocol2);
        }
        opts.headers["Sec-WebSocket-Protocol"] = protocols.join(",");
      }
      if (opts.origin) {
        if (opts.protocolVersion < 13) {
          opts.headers["Sec-WebSocket-Origin"] = opts.origin;
        } else {
          opts.headers.Origin = opts.origin;
        }
      }
      if (parsedUrl.username || parsedUrl.password) {
        opts.auth = `${parsedUrl.username}:${parsedUrl.password}`;
      }
      if (isIpcUrl) {
        const parts2 = opts.path.split(":");
        opts.socketPath = parts2[0];
        opts.path = parts2[1];
      }
      let req;
      if (opts.followRedirects) {
        if (websocket._redirects === 0) {
          websocket._originalIpc = isIpcUrl;
          websocket._originalSecure = isSecure;
          websocket._originalHostOrSocketPath = isIpcUrl ? opts.socketPath : parsedUrl.host;
          const headers = options && options.headers;
          options = { ...options, headers: {} };
          if (headers) {
            for (const [key2, value] of Object.entries(headers)) {
              options.headers[key2.toLowerCase()] = value;
            }
          }
        } else if (websocket.listenerCount("redirect") === 0) {
          const isSameHost = isIpcUrl ? websocket._originalIpc ? opts.socketPath === websocket._originalHostOrSocketPath : false : websocket._originalIpc ? false : parsedUrl.host === websocket._originalHostOrSocketPath;
          if (!isSameHost || websocket._originalSecure && !isSecure) {
            delete opts.headers.authorization;
            delete opts.headers.cookie;
            if (!isSameHost) delete opts.headers.host;
            opts.auth = void 0;
          }
        }
        if (opts.auth && !options.headers.authorization) {
          options.headers.authorization = "Basic " + Buffer.from(opts.auth).toString("base64");
        }
        req = websocket._req = request2(opts);
        if (websocket._redirects) {
          websocket.emit("redirect", websocket.url, req);
        }
      } else {
        req = websocket._req = request2(opts);
      }
      if (opts.timeout) {
        req.on("timeout", () => {
          abortHandshake(websocket, req, "Opening handshake has timed out");
        });
      }
      req.on("error", (err3) => {
        if (req === null || req[kAborted]) return;
        req = websocket._req = null;
        emitErrorAndClose(websocket, err3);
      });
      req.on("response", (res) => {
        const location2 = res.headers.location;
        const statusCode = res.statusCode;
        if (location2 && opts.followRedirects && statusCode >= 300 && statusCode < 400) {
          if (++websocket._redirects > opts.maxRedirects) {
            abortHandshake(websocket, req, "Maximum redirects exceeded");
            return;
          }
          req.abort();
          let addr2;
          try {
            addr2 = new URL2(location2, address);
          } catch (e6) {
            const err3 = new SyntaxError(`Invalid URL: ${location2}`);
            emitErrorAndClose(websocket, err3);
            return;
          }
          initAsClient(websocket, addr2, protocols, options);
        } else if (!websocket.emit("unexpected-response", req, res)) {
          abortHandshake(
            websocket,
            req,
            `Unexpected server response: ${res.statusCode}`
          );
        }
      });
      req.on("upgrade", (res, socket, head) => {
        websocket.emit("upgrade", res);
        if (websocket.readyState !== WebSocket4.CONNECTING) return;
        req = websocket._req = null;
        if (res.headers.upgrade.toLowerCase() !== "websocket") {
          abortHandshake(websocket, socket, "Invalid Upgrade header");
          return;
        }
        const digest = createHash4("sha1").update(key + GUID).digest("base64");
        if (res.headers["sec-websocket-accept"] !== digest) {
          abortHandshake(websocket, socket, "Invalid Sec-WebSocket-Accept header");
          return;
        }
        const serverProt = res.headers["sec-websocket-protocol"];
        let protError;
        if (serverProt !== void 0) {
          if (!protocolSet.size) {
            protError = "Server sent a subprotocol but none was requested";
          } else if (!protocolSet.has(serverProt)) {
            protError = "Server sent an invalid subprotocol";
          }
        } else if (protocolSet.size) {
          protError = "Server sent no subprotocol";
        }
        if (protError) {
          abortHandshake(websocket, socket, protError);
          return;
        }
        if (serverProt) websocket._protocol = serverProt;
        const secWebSocketExtensions = res.headers["sec-websocket-extensions"];
        if (secWebSocketExtensions !== void 0) {
          if (!perMessageDeflate) {
            const message = "Server sent a Sec-WebSocket-Extensions header but no extension was requested";
            abortHandshake(websocket, socket, message);
            return;
          }
          let extensions;
          try {
            extensions = parse6(secWebSocketExtensions);
          } catch (err3) {
            const message = "Invalid Sec-WebSocket-Extensions header";
            abortHandshake(websocket, socket, message);
            return;
          }
          const extensionNames = Object.keys(extensions);
          if (extensionNames.length !== 1 || extensionNames[0] !== PerMessageDeflate.extensionName) {
            const message = "Server indicated an extension that was not requested";
            abortHandshake(websocket, socket, message);
            return;
          }
          try {
            perMessageDeflate.accept(extensions[PerMessageDeflate.extensionName]);
          } catch (err3) {
            const message = "Invalid Sec-WebSocket-Extensions header";
            abortHandshake(websocket, socket, message);
            return;
          }
          websocket._extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
        }
        websocket.setSocket(socket, head, {
          generateMask: opts.generateMask,
          maxPayload: opts.maxPayload,
          skipUTF8Validation: opts.skipUTF8Validation
        });
      });
      if (opts.finishRequest) {
        opts.finishRequest(req, websocket);
      } else {
        req.end();
      }
    }
    function emitErrorAndClose(websocket, err3) {
      websocket._readyState = WebSocket4.CLOSING;
      websocket.emit("error", err3);
      websocket.emitClose();
    }
    function netConnect(options) {
      options.path = options.socketPath;
      return net2.connect(options);
    }
    function tlsConnect(options) {
      options.path = void 0;
      if (!options.servername && options.servername !== "") {
        options.servername = net2.isIP(options.host) ? "" : options.host;
      }
      return tls2.connect(options);
    }
    function abortHandshake(websocket, stream, message) {
      websocket._readyState = WebSocket4.CLOSING;
      const err3 = new Error(message);
      Error.captureStackTrace(err3, abortHandshake);
      if (stream.setHeader) {
        stream[kAborted] = true;
        stream.abort();
        if (stream.socket && !stream.socket.destroyed) {
          stream.socket.destroy();
        }
        process.nextTick(emitErrorAndClose, websocket, err3);
      } else {
        stream.destroy(err3);
        stream.once("error", websocket.emit.bind(websocket, "error"));
        stream.once("close", websocket.emitClose.bind(websocket));
      }
    }
    function sendAfterClose(websocket, data, cb) {
      if (data) {
        const length = toBuffer(data).length;
        if (websocket._socket) websocket._sender._bufferedBytes += length;
        else websocket._bufferedAmount += length;
      }
      if (cb) {
        const err3 = new Error(
          `WebSocket is not open: readyState ${websocket.readyState} (${readyStates[websocket.readyState]})`
        );
        process.nextTick(cb, err3);
      }
    }
    function receiverOnConclude(code, reason) {
      const websocket = this[kWebSocket];
      websocket._closeFrameReceived = true;
      websocket._closeMessage = reason;
      websocket._closeCode = code;
      if (websocket._socket[kWebSocket] === void 0) return;
      websocket._socket.removeListener("data", socketOnData);
      process.nextTick(resume, websocket._socket);
      if (code === 1005) websocket.close();
      else websocket.close(code, reason);
    }
    function receiverOnDrain() {
      const websocket = this[kWebSocket];
      if (!websocket.isPaused) websocket._socket.resume();
    }
    function receiverOnError(err3) {
      const websocket = this[kWebSocket];
      if (websocket._socket[kWebSocket] !== void 0) {
        websocket._socket.removeListener("data", socketOnData);
        process.nextTick(resume, websocket._socket);
        websocket.close(err3[kStatusCode]);
      }
      websocket.emit("error", err3);
    }
    function receiverOnFinish() {
      this[kWebSocket].emitClose();
    }
    function receiverOnMessage(data, isBinary2) {
      this[kWebSocket].emit("message", data, isBinary2);
    }
    function receiverOnPing(data) {
      const websocket = this[kWebSocket];
      websocket.pong(data, !websocket._isServer, NOOP);
      websocket.emit("ping", data);
    }
    function receiverOnPong(data) {
      this[kWebSocket].emit("pong", data);
    }
    function resume(stream) {
      stream.resume();
    }
    function socketOnClose() {
      const websocket = this[kWebSocket];
      this.removeListener("close", socketOnClose);
      this.removeListener("data", socketOnData);
      this.removeListener("end", socketOnEnd);
      websocket._readyState = WebSocket4.CLOSING;
      let chunk;
      if (!this._readableState.endEmitted && !websocket._closeFrameReceived && !websocket._receiver._writableState.errorEmitted && (chunk = websocket._socket.read()) !== null) {
        websocket._receiver.write(chunk);
      }
      websocket._receiver.end();
      this[kWebSocket] = void 0;
      clearTimeout(websocket._closeTimer);
      if (websocket._receiver._writableState.finished || websocket._receiver._writableState.errorEmitted) {
        websocket.emitClose();
      } else {
        websocket._receiver.on("error", receiverOnFinish);
        websocket._receiver.on("finish", receiverOnFinish);
      }
    }
    function socketOnData(chunk) {
      if (!this[kWebSocket]._receiver.write(chunk)) {
        this.pause();
      }
    }
    function socketOnEnd() {
      const websocket = this[kWebSocket];
      websocket._readyState = WebSocket4.CLOSING;
      websocket._receiver.end();
      this.end();
    }
    function socketOnError() {
      const websocket = this[kWebSocket];
      this.removeListener("error", socketOnError);
      this.on("error", NOOP);
      if (websocket) {
        websocket._readyState = WebSocket4.CLOSING;
        this.destroy();
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/subprotocol.js
var require_subprotocol2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/subprotocol.js"(exports2, module2) {
    "use strict";
    var { tokenChars } = require_validation2();
    function parse6(header) {
      const protocols = /* @__PURE__ */ new Set();
      let start2 = -1;
      let end = -1;
      let i8 = 0;
      for (i8; i8 < header.length; i8++) {
        const code = header.charCodeAt(i8);
        if (end === -1 && tokenChars[code] === 1) {
          if (start2 === -1) start2 = i8;
        } else if (i8 !== 0 && (code === 32 || code === 9)) {
          if (end === -1 && start2 !== -1) end = i8;
        } else if (code === 44) {
          if (start2 === -1) {
            throw new SyntaxError(`Unexpected character at index ${i8}`);
          }
          if (end === -1) end = i8;
          const protocol3 = header.slice(start2, end);
          if (protocols.has(protocol3)) {
            throw new SyntaxError(`The "${protocol3}" subprotocol is duplicated`);
          }
          protocols.add(protocol3);
          start2 = end = -1;
        } else {
          throw new SyntaxError(`Unexpected character at index ${i8}`);
        }
      }
      if (start2 === -1 || end !== -1) {
        throw new SyntaxError("Unexpected end of input");
      }
      const protocol2 = header.slice(start2, i8);
      if (protocols.has(protocol2)) {
        throw new SyntaxError(`The "${protocol2}" subprotocol is duplicated`);
      }
      protocols.add(protocol2);
      return protocols;
    }
    module2.exports = { parse: parse6 };
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/websocket-server.js
var require_websocket_server2 = __commonJS({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/lib/websocket-server.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events");
    var http4 = require("http");
    var { Duplex } = require("stream");
    var { createHash: createHash4 } = require("crypto");
    var extension = require_extension2();
    var PerMessageDeflate = require_permessage_deflate2();
    var subprotocol = require_subprotocol2();
    var WebSocket4 = require_websocket2();
    var { GUID, kWebSocket } = require_constants3();
    var keyRegex = /^[+/0-9A-Za-z]{22}==$/;
    var RUNNING = 0;
    var CLOSING = 1;
    var CLOSED = 2;
    var WebSocketServer3 = class extends EventEmitter {
      /**
       * Create a `WebSocketServer` instance.
       *
       * @param {Object} options Configuration options
       * @param {Number} [options.backlog=511] The maximum length of the queue of
       *     pending connections
       * @param {Boolean} [options.clientTracking=true] Specifies whether or not to
       *     track clients
       * @param {Function} [options.handleProtocols] A hook to handle protocols
       * @param {String} [options.host] The hostname where to bind the server
       * @param {Number} [options.maxPayload=104857600] The maximum allowed message
       *     size
       * @param {Boolean} [options.noServer=false] Enable no server mode
       * @param {String} [options.path] Accept only connections matching this path
       * @param {(Boolean|Object)} [options.perMessageDeflate=false] Enable/disable
       *     permessage-deflate
       * @param {Number} [options.port] The port where to bind the server
       * @param {(http.Server|https.Server)} [options.server] A pre-created HTTP/S
       *     server to use
       * @param {Boolean} [options.skipUTF8Validation=false] Specifies whether or
       *     not to skip UTF-8 validation for text and close messages
       * @param {Function} [options.verifyClient] A hook to reject connections
       * @param {Function} [options.WebSocket=WebSocket] Specifies the `WebSocket`
       *     class to use. It must be the `WebSocket` class or class that extends it
       * @param {Function} [callback] A listener for the `listening` event
       */
      constructor(options, callback) {
        super();
        options = {
          maxPayload: 100 * 1024 * 1024,
          skipUTF8Validation: false,
          perMessageDeflate: false,
          handleProtocols: null,
          clientTracking: true,
          verifyClient: null,
          noServer: false,
          backlog: null,
          // use default (511 as implemented in net.js)
          server: null,
          host: null,
          path: null,
          port: null,
          WebSocket: WebSocket4,
          ...options
        };
        if (options.port == null && !options.server && !options.noServer || options.port != null && (options.server || options.noServer) || options.server && options.noServer) {
          throw new TypeError(
            'One and only one of the "port", "server", or "noServer" options must be specified'
          );
        }
        if (options.port != null) {
          this._server = http4.createServer((req, res) => {
            const body2 = http4.STATUS_CODES[426];
            res.writeHead(426, {
              "Content-Length": body2.length,
              "Content-Type": "text/plain"
            });
            res.end(body2);
          });
          this._server.listen(
            options.port,
            options.host,
            options.backlog,
            callback
          );
        } else if (options.server) {
          this._server = options.server;
        }
        if (this._server) {
          const emitConnection = this.emit.bind(this, "connection");
          this._removeListeners = addListeners(this._server, {
            listening: this.emit.bind(this, "listening"),
            error: this.emit.bind(this, "error"),
            upgrade: (req, socket, head) => {
              this.handleUpgrade(req, socket, head, emitConnection);
            }
          });
        }
        if (options.perMessageDeflate === true) options.perMessageDeflate = {};
        if (options.clientTracking) {
          this.clients = /* @__PURE__ */ new Set();
          this._shouldEmitClose = false;
        }
        this.options = options;
        this._state = RUNNING;
      }
      /**
       * Returns the bound address, the address family name, and port of the server
       * as reported by the operating system if listening on an IP socket.
       * If the server is listening on a pipe or UNIX domain socket, the name is
       * returned as a string.
       *
       * @return {(Object|String|null)} The address of the server
       * @public
       */
      address() {
        if (this.options.noServer) {
          throw new Error('The server is operating in "noServer" mode');
        }
        if (!this._server) return null;
        return this._server.address();
      }
      /**
       * Stop the server from accepting new connections and emit the `'close'` event
       * when all existing connections are closed.
       *
       * @param {Function} [cb] A one-time listener for the `'close'` event
       * @public
       */
      close(cb) {
        if (this._state === CLOSED) {
          if (cb) {
            this.once("close", () => {
              cb(new Error("The server is not running"));
            });
          }
          process.nextTick(emitClose, this);
          return;
        }
        if (cb) this.once("close", cb);
        if (this._state === CLOSING) return;
        this._state = CLOSING;
        if (this.options.noServer || this.options.server) {
          if (this._server) {
            this._removeListeners();
            this._removeListeners = this._server = null;
          }
          if (this.clients) {
            if (!this.clients.size) {
              process.nextTick(emitClose, this);
            } else {
              this._shouldEmitClose = true;
            }
          } else {
            process.nextTick(emitClose, this);
          }
        } else {
          const server = this._server;
          this._removeListeners();
          this._removeListeners = this._server = null;
          server.close(() => {
            emitClose(this);
          });
        }
      }
      /**
       * See if a given request should be handled by this server instance.
       *
       * @param {http.IncomingMessage} req Request object to inspect
       * @return {Boolean} `true` if the request is valid, else `false`
       * @public
       */
      shouldHandle(req) {
        if (this.options.path) {
          const index7 = req.url.indexOf("?");
          const pathname = index7 !== -1 ? req.url.slice(0, index7) : req.url;
          if (pathname !== this.options.path) return false;
        }
        return true;
      }
      /**
       * Handle a HTTP Upgrade request.
       *
       * @param {http.IncomingMessage} req The request object
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @public
       */
      handleUpgrade(req, socket, head, cb) {
        socket.on("error", socketOnError);
        const key = req.headers["sec-websocket-key"];
        const version3 = +req.headers["sec-websocket-version"];
        if (req.method !== "GET") {
          const message = "Invalid HTTP method";
          abortHandshakeOrEmitwsClientError(this, req, socket, 405, message);
          return;
        }
        if (req.headers.upgrade.toLowerCase() !== "websocket") {
          const message = "Invalid Upgrade header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (!key || !keyRegex.test(key)) {
          const message = "Missing or invalid Sec-WebSocket-Key header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (version3 !== 8 && version3 !== 13) {
          const message = "Missing or invalid Sec-WebSocket-Version header";
          abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
          return;
        }
        if (!this.shouldHandle(req)) {
          abortHandshake(socket, 400);
          return;
        }
        const secWebSocketProtocol = req.headers["sec-websocket-protocol"];
        let protocols = /* @__PURE__ */ new Set();
        if (secWebSocketProtocol !== void 0) {
          try {
            protocols = subprotocol.parse(secWebSocketProtocol);
          } catch (err3) {
            const message = "Invalid Sec-WebSocket-Protocol header";
            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
            return;
          }
        }
        const secWebSocketExtensions = req.headers["sec-websocket-extensions"];
        const extensions = {};
        if (this.options.perMessageDeflate && secWebSocketExtensions !== void 0) {
          const perMessageDeflate = new PerMessageDeflate(
            this.options.perMessageDeflate,
            true,
            this.options.maxPayload
          );
          try {
            const offers = extension.parse(secWebSocketExtensions);
            if (offers[PerMessageDeflate.extensionName]) {
              perMessageDeflate.accept(offers[PerMessageDeflate.extensionName]);
              extensions[PerMessageDeflate.extensionName] = perMessageDeflate;
            }
          } catch (err3) {
            const message = "Invalid or unacceptable Sec-WebSocket-Extensions header";
            abortHandshakeOrEmitwsClientError(this, req, socket, 400, message);
            return;
          }
        }
        if (this.options.verifyClient) {
          const info3 = {
            origin: req.headers[`${version3 === 8 ? "sec-websocket-origin" : "origin"}`],
            secure: !!(req.socket.authorized || req.socket.encrypted),
            req
          };
          if (this.options.verifyClient.length === 2) {
            this.options.verifyClient(info3, (verified, code, message, headers) => {
              if (!verified) {
                return abortHandshake(socket, code || 401, message, headers);
              }
              this.completeUpgrade(
                extensions,
                key,
                protocols,
                req,
                socket,
                head,
                cb
              );
            });
            return;
          }
          if (!this.options.verifyClient(info3)) return abortHandshake(socket, 401);
        }
        this.completeUpgrade(extensions, key, protocols, req, socket, head, cb);
      }
      /**
       * Upgrade the connection to WebSocket.
       *
       * @param {Object} extensions The accepted extensions
       * @param {String} key The value of the `Sec-WebSocket-Key` header
       * @param {Set} protocols The subprotocols
       * @param {http.IncomingMessage} req The request object
       * @param {Duplex} socket The network socket between the server and client
       * @param {Buffer} head The first packet of the upgraded stream
       * @param {Function} cb Callback
       * @throws {Error} If called more than once with the same socket
       * @private
       */
      completeUpgrade(extensions, key, protocols, req, socket, head, cb) {
        if (!socket.readable || !socket.writable) return socket.destroy();
        if (socket[kWebSocket]) {
          throw new Error(
            "server.handleUpgrade() was called more than once with the same socket, possibly due to a misconfiguration"
          );
        }
        if (this._state > RUNNING) return abortHandshake(socket, 503);
        const digest = createHash4("sha1").update(key + GUID).digest("base64");
        const headers = [
          "HTTP/1.1 101 Switching Protocols",
          "Upgrade: websocket",
          "Connection: Upgrade",
          `Sec-WebSocket-Accept: ${digest}`
        ];
        const ws4 = new this.options.WebSocket(null);
        if (protocols.size) {
          const protocol2 = this.options.handleProtocols ? this.options.handleProtocols(protocols, req) : protocols.values().next().value;
          if (protocol2) {
            headers.push(`Sec-WebSocket-Protocol: ${protocol2}`);
            ws4._protocol = protocol2;
          }
        }
        if (extensions[PerMessageDeflate.extensionName]) {
          const params = extensions[PerMessageDeflate.extensionName].params;
          const value = extension.format({
            [PerMessageDeflate.extensionName]: [params]
          });
          headers.push(`Sec-WebSocket-Extensions: ${value}`);
          ws4._extensions = extensions;
        }
        this.emit("headers", headers, req);
        socket.write(headers.concat("\r\n").join("\r\n"));
        socket.removeListener("error", socketOnError);
        ws4.setSocket(socket, head, {
          maxPayload: this.options.maxPayload,
          skipUTF8Validation: this.options.skipUTF8Validation
        });
        if (this.clients) {
          this.clients.add(ws4);
          ws4.on("close", () => {
            this.clients.delete(ws4);
            if (this._shouldEmitClose && !this.clients.size) {
              process.nextTick(emitClose, this);
            }
          });
        }
        cb(ws4, req);
      }
    };
    module2.exports = WebSocketServer3;
    function addListeners(server, map2) {
      for (const event of Object.keys(map2)) server.on(event, map2[event]);
      return function removeListeners() {
        for (const event of Object.keys(map2)) {
          server.removeListener(event, map2[event]);
        }
      };
    }
    function emitClose(server) {
      server._state = CLOSED;
      server.emit("close");
    }
    function socketOnError() {
      this.destroy();
    }
    function abortHandshake(socket, code, message, headers) {
      message = message || http4.STATUS_CODES[code];
      headers = {
        Connection: "close",
        "Content-Type": "text/html",
        "Content-Length": Buffer.byteLength(message),
        ...headers
      };
      socket.once("finish", socket.destroy);
      socket.end(
        `HTTP/1.1 ${code} ${http4.STATUS_CODES[code]}\r
` + Object.keys(headers).map((h8) => `${h8}: ${headers[h8]}`).join("\r\n") + "\r\n\r\n" + message
      );
    }
    function abortHandshakeOrEmitwsClientError(server, req, socket, code, message) {
      if (server.listenerCount("wsClientError")) {
        const err3 = new Error(message);
        Error.captureStackTrace(err3, abortHandshakeOrEmitwsClientError);
        server.emit("wsClientError", err3, socket, req);
      } else {
        abortHandshake(socket, code, message);
      }
    }
  }
});

// ../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/wrapper.mjs
var import_stream9, import_receiver2, import_sender2, import_websocket2, import_websocket_server2, wrapper_default2;
var init_wrapper2 = __esm({
  "../node_modules/.pnpm/ws@8.14.2_bufferutil@4.0.8_utf-8-validate@6.0.3/node_modules/ws/wrapper.mjs"() {
    "use strict";
    import_stream9 = __toESM(require_stream3(), 1);
    import_receiver2 = __toESM(require_receiver2(), 1);
    import_sender2 = __toESM(require_sender2(), 1);
    import_websocket2 = __toESM(require_websocket2(), 1);
    import_websocket_server2 = __toESM(require_websocket_server2(), 1);
    wrapper_default2 = import_websocket2.default;
  }
});

// ../node_modules/.pnpm/@vercel+postgres@0.8.0/node_modules/@vercel/postgres/dist/index-node.js
var index_node_exports = {};
__export(index_node_exports, {
  VercelClient: () => VercelClient,
  VercelPool: () => VercelPool,
  createClient: () => createClient,
  createPool: () => createPool,
  db: () => db,
  postgresConnectionString: () => postgresConnectionString,
  sql: () => sql2,
  types: () => export_types
});
var init_index_node = __esm({
  "../node_modules/.pnpm/@vercel+postgres@0.8.0/node_modules/@vercel/postgres/dist/index-node.js"() {
    "use strict";
    init_chunk_WDBQYBZQ();
    init_serverless();
    init_wrapper2();
    if (_e6) {
      _e6.webSocketConstructor = wrapper_default2;
    }
  }
});

// ../drizzle-orm/dist/vercel-postgres/session.js
var _a470, _b343, VercelPgPreparedQuery, _a471, _b344, _VercelPgSession, VercelPgSession, _a472, _b345, _VercelPgTransaction, VercelPgTransaction;
var init_session9 = __esm({
  "../drizzle-orm/dist/vercel-postgres/session.js"() {
    "use strict";
    init_index_node();
    init_cache();
    init_entity();
    init_logger();
    init_pg_core();
    init_session2();
    init_sql();
    init_utils();
    VercelPgPreparedQuery = class extends (_b343 = PgPreparedQuery, _a470 = entityKind, _b343) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, name3, _isResponseInArrayMode, customResultMapper) {
        super({ sql: queryString, params }, cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQuery");
        __publicField(this, "queryConfig");
        this.client = client;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
        this.rawQuery = {
          name: name3,
          text: queryString,
          types: {
            // @ts-ignore
            getTypeParser: (typeId, format2) => {
              if (typeId === export_types.builtins.TIMESTAMPTZ) {
                return (val2) => val2;
              }
              if (typeId === export_types.builtins.TIMESTAMP) {
                return (val2) => val2;
              }
              if (typeId === export_types.builtins.DATE) {
                return (val2) => val2;
              }
              if (typeId === export_types.builtins.INTERVAL) {
                return (val2) => val2;
              }
              if (typeId === 1231) {
                return (val2) => val2;
              }
              if (typeId === 1115) {
                return (val2) => val2;
              }
              if (typeId === 1185) {
                return (val2) => val2;
              }
              if (typeId === 1187) {
                return (val2) => val2;
              }
              if (typeId === 1182) {
                return (val2) => val2;
              }
              return export_types.getTypeParser(typeId, format2);
            }
          }
        };
        this.queryConfig = {
          name: name3,
          text: queryString,
          rowMode: "array",
          types: {
            // @ts-ignore
            getTypeParser: (typeId, format2) => {
              if (typeId === export_types.builtins.TIMESTAMPTZ) {
                return (val2) => val2;
              }
              if (typeId === export_types.builtins.TIMESTAMP) {
                return (val2) => val2;
              }
              if (typeId === export_types.builtins.DATE) {
                return (val2) => val2;
              }
              if (typeId === export_types.builtins.INTERVAL) {
                return (val2) => val2;
              }
              if (typeId === 1231) {
                return (val2) => val2;
              }
              if (typeId === 1115) {
                return (val2) => val2;
              }
              if (typeId === 1185) {
                return (val2) => val2;
              }
              if (typeId === 1187) {
                return (val2) => val2;
              }
              if (typeId === 1182) {
                return (val2) => val2;
              }
              return export_types.getTypeParser(typeId, format2);
            }
          }
        };
      }
      async execute(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQuery.text, params);
        const { fields, rawQuery, client, queryConfig: query, joinsNotNullableMap, customResultMapper } = this;
        if (!fields && !customResultMapper) {
          return this.queryWithCache(rawQuery.text, params, async () => {
            return await client.query(rawQuery, params);
          });
        }
        const { rows } = await this.queryWithCache(query.text, params, async () => {
          return await client.query(query, params);
        });
        if (customResultMapper) {
          return customResultMapper(rows);
        }
        return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      all(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQuery.text, params);
        return this.queryWithCache(this.rawQuery.text, params, async () => {
          return await this.client.query(this.rawQuery, params);
        }).then((result) => result.rows);
      }
      values(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQuery.text, params);
        return this.queryWithCache(this.queryConfig.text, params, async () => {
          return await this.client.query(this.queryConfig, params);
        }).then((result) => result.rows);
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(VercelPgPreparedQuery, _a470, "VercelPgPreparedQuery");
    _VercelPgSession = class _VercelPgSession extends (_b344 = PgSession, _a471 = entityKind, _b344) {
      constructor(client, dialect6, schema6, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, name3, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return new VercelPgPreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          name3,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      async query(query, params) {
        this.logger.logQuery(query, params);
        const result = await this.client.query({
          rowMode: "array",
          text: query,
          values: params
        });
        return result;
      }
      async queryObjects(query, params) {
        return this.client.query(query, params);
      }
      async count(sql22) {
        const result = await this.execute(sql22);
        return Number(result["rows"][0]["count"]);
      }
      async transaction(transaction, config) {
        const session = this.client instanceof VercelPool ? new _VercelPgSession(await this.client.connect(), this.dialect, this.schema, this.options) : this;
        const tx = new VercelPgTransaction(this.dialect, session, this.schema);
        await tx.execute(sql`begin${config ? sql` ${tx.getTransactionConfigSQL(config)}` : void 0}`);
        try {
          const result = await transaction(tx);
          await tx.execute(sql`commit`);
          return result;
        } catch (error2) {
          await tx.execute(sql`rollback`);
          throw error2;
        } finally {
          if (this.client instanceof VercelPool) {
            session.client.release();
          }
        }
      }
    };
    __publicField(_VercelPgSession, _a471, "VercelPgSession");
    VercelPgSession = _VercelPgSession;
    _VercelPgTransaction = class _VercelPgTransaction extends (_b345 = PgTransaction, _a472 = entityKind, _b345) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _VercelPgTransaction(
          this.dialect,
          this.session,
          this.schema,
          this.nestedIndex + 1
        );
        await tx.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await tx.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_VercelPgTransaction, _a472, "VercelPgTransaction");
    VercelPgTransaction = _VercelPgTransaction;
  }
});

// ../drizzle-orm/dist/vercel-postgres/driver.js
function construct5(client, config = {}) {
  const dialect6 = new PgDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const driver2 = new VercelPgDriver(client, dialect6, { logger: logger2, cache: config.cache });
  const session = driver2.createSession(schema6);
  const db2 = new VercelPgDatabase(dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function drizzle5(...params) {
  if (isConfig(params[0])) {
    const { client, ...drizzleConfig } = params[0];
    return construct5(client ?? sql2, drizzleConfig);
  }
  return construct5(params[0] ?? sql2, params[1]);
}
var _a473, VercelPgDriver, _a474, _b346, VercelPgDatabase;
var init_driver5 = __esm({
  "../drizzle-orm/dist/vercel-postgres/driver.js"() {
    "use strict";
    init_index_node();
    init_entity();
    init_logger();
    init_db2();
    init_pg_core();
    init_relations();
    init_utils();
    init_session9();
    _a473 = entityKind;
    VercelPgDriver = class {
      constructor(client, dialect6, options = {}) {
        this.client = client;
        this.dialect = dialect6;
        this.options = options;
      }
      createSession(schema6) {
        return new VercelPgSession(this.client, this.dialect, schema6, {
          logger: this.options.logger,
          cache: this.options.cache
        });
      }
    };
    __publicField(VercelPgDriver, _a473, "VercelPgDriver");
    VercelPgDatabase = class extends (_b346 = PgDatabase, _a474 = entityKind, _b346) {
    };
    __publicField(VercelPgDatabase, _a474, "VercelPgDatabase");
    ((drizzle22) => {
      function mock(config) {
        return construct5({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle5 || (drizzle5 = {}));
  }
});

// ../drizzle-orm/dist/vercel-postgres/index.js
var vercel_postgres_exports = {};
__export(vercel_postgres_exports, {
  VercelPgDatabase: () => VercelPgDatabase,
  VercelPgDriver: () => VercelPgDriver,
  VercelPgPreparedQuery: () => VercelPgPreparedQuery,
  VercelPgSession: () => VercelPgSession,
  VercelPgTransaction: () => VercelPgTransaction,
  drizzle: () => drizzle5
});
var init_vercel_postgres = __esm({
  "../drizzle-orm/dist/vercel-postgres/index.js"() {
    "use strict";
    init_driver5();
    init_session9();
  }
});

// ../drizzle-orm/dist/vercel-postgres/migrator.js
var migrator_exports5 = {};
__export(migrator_exports5, {
  migrate: () => migrate5
});
async function migrate5(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator6 = __esm({
  "../drizzle-orm/dist/vercel-postgres/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../node_modules/.pnpm/@neondatabase+serverless@0.9.5/node_modules/@neondatabase/serverless/index.mjs
var serverless_exports = {};
__export(serverless_exports, {
  Client: () => vn4,
  ClientBase: () => export_ClientBase2,
  Connection: () => export_Connection2,
  DatabaseError: () => export_DatabaseError2,
  NeonDbError: () => Ae4,
  Pool: () => Zs2,
  Query: () => export_Query2,
  defaults: () => export_defaults2,
  neon: () => Ys2,
  neonConfig: () => _e7,
  types: () => export_types2
});
function Ge3(r6) {
  let e6 = 1779033703, t6 = 3144134277, n7 = 1013904242, i8 = 2773480762, s10 = 1359893119, o9 = 2600822924, u7 = 528734635, c6 = 1541459225, h8 = 0, l7 = 0, d7 = [
    1116352408,
    1899447441,
    3049323471,
    3921009573,
    961987163,
    1508970993,
    2453635748,
    2870763221,
    3624381080,
    310598401,
    607225278,
    1426881987,
    1925078388,
    2162078206,
    2614888103,
    3248222580,
    3835390401,
    4022224774,
    264347078,
    604807628,
    770255983,
    1249150122,
    1555081692,
    1996064986,
    2554220882,
    2821834349,
    2952996808,
    3210313671,
    3336571891,
    3584528711,
    113926993,
    338241895,
    666307205,
    773529912,
    1294757372,
    1396182291,
    1695183700,
    1986661051,
    2177026350,
    2456956037,
    2730485921,
    2820302411,
    3259730800,
    3345764771,
    3516065817,
    3600352804,
    4094571909,
    275423344,
    430227734,
    506948616,
    659060556,
    883997877,
    958139571,
    1322822218,
    1537002063,
    1747873779,
    1955562222,
    2024104815,
    2227730452,
    2361852424,
    2428436474,
    2756734187,
    3204031479,
    3329325298
  ], b9 = a7(
    (A5, w10) => A5 >>> w10 | A5 << 32 - w10,
    "rrot"
  ), C6 = new Uint32Array(64), B3 = new Uint8Array(64), W4 = a7(() => {
    for (let R5 = 0, G4 = 0; R5 < 16; R5++, G4 += 4) C6[R5] = B3[G4] << 24 | B3[G4 + 1] << 16 | B3[G4 + 2] << 8 | B3[G4 + 3];
    for (let R5 = 16; R5 < 64; R5++) {
      let G4 = b9(C6[R5 - 15], 7) ^ b9(C6[R5 - 15], 18) ^ C6[R5 - 15] >>> 3, he3 = b9(C6[R5 - 2], 17) ^ b9(C6[R5 - 2], 19) ^ C6[R5 - 2] >>> 10;
      C6[R5] = C6[R5 - 16] + G4 + C6[R5 - 7] + he3 | 0;
    }
    let A5 = e6, w10 = t6, P5 = n7, V2 = i8, k9 = s10, j7 = o9, ce3 = u7, ee3 = c6;
    for (let R5 = 0; R5 < 64; R5++) {
      let G4 = b9(
        k9,
        6
      ) ^ b9(k9, 11) ^ b9(k9, 25), he3 = k9 & j7 ^ ~k9 & ce3, ye3 = ee3 + G4 + he3 + d7[R5] + C6[R5] | 0, xe3 = b9(A5, 2) ^ b9(A5, 13) ^ b9(A5, 22), me2 = A5 & w10 ^ A5 & P5 ^ w10 & P5, se2 = xe3 + me2 | 0;
      ee3 = ce3, ce3 = j7, j7 = k9, k9 = V2 + ye3 | 0, V2 = P5, P5 = w10, w10 = A5, A5 = ye3 + se2 | 0;
    }
    e6 = e6 + A5 | 0, t6 = t6 + w10 | 0, n7 = n7 + P5 | 0, i8 = i8 + V2 | 0, s10 = s10 + k9 | 0, o9 = o9 + j7 | 0, u7 = u7 + ce3 | 0, c6 = c6 + ee3 | 0, l7 = 0;
  }, "process"), X4 = a7((A5) => {
    typeof A5 == "string" && (A5 = new TextEncoder().encode(A5));
    for (let w10 = 0; w10 < A5.length; w10++) B3[l7++] = A5[w10], l7 === 64 && W4();
    h8 += A5.length;
  }, "add"), de2 = a7(() => {
    if (B3[l7++] = 128, l7 == 64 && W4(), l7 + 8 > 64) {
      for (; l7 < 64; ) B3[l7++] = 0;
      W4();
    }
    for (; l7 < 58; ) B3[l7++] = 0;
    let A5 = h8 * 8;
    B3[l7++] = A5 / 1099511627776 & 255, B3[l7++] = A5 / 4294967296 & 255, B3[l7++] = A5 >>> 24, B3[l7++] = A5 >>> 16 & 255, B3[l7++] = A5 >>> 8 & 255, B3[l7++] = A5 & 255, W4();
    let w10 = new Uint8Array(32);
    return w10[0] = e6 >>> 24, w10[1] = e6 >>> 16 & 255, w10[2] = e6 >>> 8 & 255, w10[3] = e6 & 255, w10[4] = t6 >>> 24, w10[5] = t6 >>> 16 & 255, w10[6] = t6 >>> 8 & 255, w10[7] = t6 & 255, w10[8] = n7 >>> 24, w10[9] = n7 >>> 16 & 255, w10[10] = n7 >>> 8 & 255, w10[11] = n7 & 255, w10[12] = i8 >>> 24, w10[13] = i8 >>> 16 & 255, w10[14] = i8 >>> 8 & 255, w10[15] = i8 & 255, w10[16] = s10 >>> 24, w10[17] = s10 >>> 16 & 255, w10[18] = s10 >>> 8 & 255, w10[19] = s10 & 255, w10[20] = o9 >>> 24, w10[21] = o9 >>> 16 & 255, w10[22] = o9 >>> 8 & 255, w10[23] = o9 & 255, w10[24] = u7 >>> 24, w10[25] = u7 >>> 16 & 255, w10[26] = u7 >>> 8 & 255, w10[27] = u7 & 255, w10[28] = c6 >>> 24, w10[29] = c6 >>> 16 & 255, w10[30] = c6 >>> 8 & 255, w10[31] = c6 & 255, w10;
  }, "digest");
  return r6 === void 0 ? { add: X4, digest: de2 } : (X4(r6), de2());
}
function Vo(r6) {
  return g8.getRandomValues(y5.alloc(r6));
}
function Ko2(r6) {
  if (r6 === "sha256") return { update: a7(
    function(e6) {
      return { digest: a7(function() {
        return y5.from(Ge3(e6));
      }, "digest") };
    },
    "update"
  ) };
  if (r6 === "md5") return { update: a7(function(e6) {
    return { digest: a7(function() {
      return typeof e6 == "string" ? $e3.hashStr(e6) : $e3.hashByteArray(e6);
    }, "digest") };
  }, "update") };
  throw new Error(
    `Hash type '${r6}' not supported`
  );
}
function zo(r6, e6) {
  if (r6 !== "sha256") throw new Error(
    `Only sha256 is supported (requested: '${r6}')`
  );
  return { update: a7(function(t6) {
    return {
      digest: a7(function() {
        typeof e6 == "string" && (e6 = new TextEncoder().encode(e6)), typeof t6 == "string" && (t6 = new TextEncoder().encode(t6));
        let n7 = e6.length;
        if (n7 > 64) e6 = Ge3(e6);
        else if (n7 < 64) {
          let c6 = new Uint8Array(64);
          c6.set(e6), e6 = c6;
        }
        let i8 = new Uint8Array(64), s10 = new Uint8Array(
          64
        );
        for (let c6 = 0; c6 < 64; c6++) i8[c6] = 54 ^ e6[c6], s10[c6] = 92 ^ e6[c6];
        let o9 = new Uint8Array(t6.length + 64);
        o9.set(i8, 0), o9.set(t6, 64);
        let u7 = new Uint8Array(96);
        return u7.set(s10, 0), u7.set(
          Ge3(o9),
          64
        ), y5.from(Ge3(u7));
      }, "digest")
    };
  }, "update") };
}
function ou2(...r6) {
  return r6.join("/");
}
function au(r6, e6) {
  e6(new Error("No filesystem"));
}
function fr2(r6, e6 = false) {
  let { protocol: t6 } = new URL(r6), n7 = "http:" + r6.substring(t6.length), {
    username: i8,
    password: s10,
    host: o9,
    hostname: u7,
    port: c6,
    pathname: h8,
    search: l7,
    searchParams: d7,
    hash: b9
  } = new URL(n7);
  s10 = decodeURIComponent(s10), i8 = decodeURIComponent(
    i8
  ), h8 = decodeURIComponent(h8);
  let C6 = i8 + ":" + s10, B3 = e6 ? Object.fromEntries(d7.entries()) : l7;
  return {
    href: r6,
    protocol: t6,
    auth: C6,
    username: i8,
    password: s10,
    host: o9,
    hostname: u7,
    port: c6,
    pathname: h8,
    search: l7,
    query: B3,
    hash: b9
  };
}
function Fu(r6) {
  return 0;
}
function lc2({ socket: r6, servername: e6 }) {
  return r6.startTls(e6), r6;
}
function Ys2(r6, {
  arrayMode: e6,
  fullResults: t6,
  fetchOptions: n7,
  isolationLevel: i8,
  readOnly: s10,
  deferrable: o9,
  queryCallback: u7,
  resultCallback: c6
} = {}) {
  if (!r6) throw new Error("No database connection string was provided to `neon()`. Perhaps an environment variable has not been set?");
  let h8;
  try {
    h8 = fr2(r6);
  } catch {
    throw new Error("Database connection string provided to `neon()` is not a valid URL. Connection string: " + String(r6));
  }
  let {
    protocol: l7,
    username: d7,
    password: b9,
    hostname: C6,
    port: B3,
    pathname: W4
  } = h8;
  if (l7 !== "postgres:" && l7 !== "postgresql:" || !d7 || !b9 || !C6 || !W4) throw new Error("Database connection string format for `neon()` should be: postgresql://user:password@host.tld/dbname?option=value");
  function X4(A5, ...w10) {
    let P5, V2;
    if (typeof A5 == "string") P5 = A5, V2 = w10[1], w10 = w10[0] ?? [];
    else {
      P5 = "";
      for (let j7 = 0; j7 < A5.length; j7++)
        P5 += A5[j7], j7 < w10.length && (P5 += "$" + (j7 + 1));
    }
    w10 = w10.map((j7) => (0, Ks2.prepareValue)(j7));
    let k9 = {
      query: P5,
      params: w10
    };
    return u7 && u7(k9), Qc2(de2, k9, V2);
  }
  a7(X4, "resolve"), X4.transaction = async (A5, w10) => {
    if (typeof A5 == "function" && (A5 = A5(X4)), !Array.isArray(A5)) throw new Error($s);
    A5.forEach((k9) => {
      if (k9[Symbol.toStringTag] !== "NeonQueryPromise") throw new Error($s);
    });
    let P5 = A5.map((k9) => k9.parameterizedQuery), V2 = A5.map((k9) => k9.opts ?? {});
    return de2(P5, V2, w10);
  };
  async function de2(A5, w10, P5) {
    let {
      fetchEndpoint: V2,
      fetchFunction: k9
    } = _e7, j7 = typeof V2 == "function" ? V2(C6, B3) : V2, ce3 = Array.isArray(A5) ? { queries: A5 } : A5, ee3 = n7 ?? {}, R5 = e6 ?? false, G4 = t6 ?? false, he3 = i8, ye3 = s10, xe3 = o9;
    P5 !== void 0 && (P5.fetchOptions !== void 0 && (ee3 = { ...ee3, ...P5.fetchOptions }), P5.arrayMode !== void 0 && (R5 = P5.arrayMode), P5.fullResults !== void 0 && (G4 = P5.fullResults), P5.isolationLevel !== void 0 && (he3 = P5.isolationLevel), P5.readOnly !== void 0 && (ye3 = P5.readOnly), P5.deferrable !== void 0 && (xe3 = P5.deferrable)), w10 !== void 0 && !Array.isArray(w10) && w10.fetchOptions !== void 0 && (ee3 = { ...ee3, ...w10.fetchOptions });
    let me2 = { "Neon-Connection-String": r6, "Neon-Raw-Text-Output": "true", "Neon-Array-Mode": "true" };
    Array.isArray(A5) && (he3 !== void 0 && (me2["Neon-Batch-Isolation-Level"] = he3), ye3 !== void 0 && (me2["Neon-Batch-Read-Only"] = String(ye3)), xe3 !== void 0 && (me2["Neon-Batch-Deferrable"] = String(
      xe3
    )));
    let se2;
    try {
      se2 = await (k9 ?? fetch)(j7, {
        method: "POST",
        body: JSON.stringify(ce3),
        headers: me2,
        ...ee3
      });
    } catch (oe) {
      let U4 = new Ae4(`Error connecting to database: ${oe.message}`);
      throw U4.sourceError = oe, U4;
    }
    if (se2.ok) {
      let oe = await se2.json();
      if (Array.isArray(A5)) {
        let U4 = oe.results;
        if (!Array.isArray(U4)) throw new Ae4("Neon internal error: unexpected result format");
        return U4.map((K4, le2) => {
          let It4 = w10[le2] ?? {}, Xs3 = It4.arrayMode ?? R5, eo3 = It4.fullResults ?? G4;
          return Vs2(K4, {
            arrayMode: Xs3,
            fullResults: eo3,
            parameterizedQuery: A5[le2],
            resultCallback: c6,
            types: It4.types
          });
        });
      } else {
        let U4 = w10 ?? {}, K4 = U4.arrayMode ?? R5, le2 = U4.fullResults ?? G4;
        return Vs2(
          oe,
          { arrayMode: K4, fullResults: le2, parameterizedQuery: A5, resultCallback: c6, types: U4.types }
        );
      }
    } else {
      let { status: oe } = se2;
      if (oe === 400) {
        let U4 = await se2.json(), K4 = new Ae4(U4.message);
        for (let le2 of qc)
          K4[le2] = U4[le2] ?? void 0;
        throw K4;
      } else {
        let U4 = await se2.text();
        throw new Ae4(`Server error (HTTP status ${oe}): ${U4}`);
      }
    }
  }
  return a7(de2, "execute"), X4;
}
function Qc2(r6, e6, t6) {
  return { [Symbol.toStringTag]: "NeonQueryPromise", parameterizedQuery: e6, opts: t6, then: a7(
    (n7, i8) => r6(e6, t6).then(n7, i8),
    "then"
  ), catch: a7((n7) => r6(e6, t6).catch(n7), "catch"), finally: a7((n7) => r6(
    e6,
    t6
  ).finally(n7), "finally") };
}
function Vs2(r6, {
  arrayMode: e6,
  fullResults: t6,
  parameterizedQuery: n7,
  resultCallback: i8,
  types: s10
}) {
  let o9 = new zs2.default(
    s10
  ), u7 = r6.fields.map((l7) => l7.name), c6 = r6.fields.map((l7) => o9.getTypeParser(l7.dataTypeID)), h8 = e6 === true ? r6.rows.map((l7) => l7.map((d7, b9) => d7 === null ? null : c6[b9](d7))) : r6.rows.map((l7) => Object.fromEntries(
    l7.map((d7, b9) => [u7[b9], d7 === null ? null : c6[b9](d7)])
  ));
  return i8 && i8(n7, r6, h8, { arrayMode: e6, fullResults: t6 }), t6 ? (r6.viaNeonFetch = true, r6.rowAsArray = e6, r6.rows = h8, r6._parsers = c6, r6._types = o9, r6) : h8;
}
function Wc(r6, e6) {
  if (e6) return {
    callback: e6,
    result: void 0
  };
  let t6, n7, i8 = a7(function(o9, u7) {
    o9 ? t6(o9) : n7(u7);
  }, "cb"), s10 = new r6(function(o9, u7) {
    n7 = o9, t6 = u7;
  });
  return { callback: i8, result: s10 };
}
var to2, Ce2, ro2, no2, io2, so, oo, a7, z4, I5, ie2, An2, Te2, N3, _5, In3, Pn2, $n, S5, x9, v9, g8, y5, m10, p9, we3, je2, $o2, He3, ni2, O5, $e3, ii, qt3, Qt3, jt2, Ht2, ci, li, di, mi, Ei2, Ai, Bi, Ri, Je2, Xe3, et3, qi2, tr2, rr2, nr3, ir2, sr3, uu, or4, Qi2, ur2, ar2, Wi, $i, zi, Zi, mt2, Xi2, Tu, es2, ts, pr, ns, gt4, cs, ps2, ys2, ds2, Mu, E2, _e7, wt3, Yr2, ms, ws2, bs2, vs2, an2, Es, _s2, hn2, Bs, Ms, Ds2, Cc2, ks2, Us2, qs, Hs, bn2, Ct3, Tt2, Ks2, zs2, xn3, Ae4, $s, qc, Js2, Qe2, En4, vn4, _n3, Zs2, export_ClientBase2, export_Connection2, export_DatabaseError2, export_Query2, export_defaults2, export_types2;
var init_serverless2 = __esm({
  "../node_modules/.pnpm/@neondatabase+serverless@0.9.5/node_modules/@neondatabase/serverless/index.mjs"() {
    "use strict";
    to2 = Object.create;
    Ce2 = Object.defineProperty;
    ro2 = Object.getOwnPropertyDescriptor;
    no2 = Object.getOwnPropertyNames;
    io2 = Object.getPrototypeOf;
    so = Object.prototype.hasOwnProperty;
    oo = (r6, e6, t6) => e6 in r6 ? Ce2(r6, e6, { enumerable: true, configurable: true, writable: true, value: t6 }) : r6[e6] = t6;
    a7 = (r6, e6) => Ce2(r6, "name", { value: e6, configurable: true });
    z4 = (r6, e6) => () => (r6 && (e6 = r6(r6 = 0)), e6);
    I5 = (r6, e6) => () => (e6 || r6((e6 = { exports: {} }).exports, e6), e6.exports);
    ie2 = (r6, e6) => {
      for (var t6 in e6)
        Ce2(r6, t6, { get: e6[t6], enumerable: true });
    };
    An2 = (r6, e6, t6, n7) => {
      if (e6 && typeof e6 == "object" || typeof e6 == "function") for (let i8 of no2(e6)) !so.call(r6, i8) && i8 !== t6 && Ce2(r6, i8, { get: () => e6[i8], enumerable: !(n7 = ro2(e6, i8)) || n7.enumerable });
      return r6;
    };
    Te2 = (r6, e6, t6) => (t6 = r6 != null ? to2(io2(r6)) : {}, An2(e6 || !r6 || !r6.__esModule ? Ce2(t6, "default", {
      value: r6,
      enumerable: true
    }) : t6, r6));
    N3 = (r6) => An2(Ce2({}, "__esModule", { value: true }), r6);
    _5 = (r6, e6, t6) => oo(r6, typeof e6 != "symbol" ? e6 + "" : e6, t6);
    In3 = I5((nt2) => {
      "use strict";
      p9();
      nt2.byteLength = uo2;
      nt2.toByteArray = ho;
      nt2.fromByteArray = po;
      var ae = [], te4 = [], ao2 = typeof Uint8Array < "u" ? Uint8Array : Array, Pt3 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      for (ve2 = 0, Cn3 = Pt3.length; ve2 < Cn3; ++ve2)
        ae[ve2] = Pt3[ve2], te4[Pt3.charCodeAt(ve2)] = ve2;
      var ve2, Cn3;
      te4[45] = 62;
      te4[95] = 63;
      function Tn3(r6) {
        var e6 = r6.length;
        if (e6 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
        var t6 = r6.indexOf("=");
        t6 === -1 && (t6 = e6);
        var n7 = t6 === e6 ? 0 : 4 - t6 % 4;
        return [t6, n7];
      }
      a7(
        Tn3,
        "getLens"
      );
      function uo2(r6) {
        var e6 = Tn3(r6), t6 = e6[0], n7 = e6[1];
        return (t6 + n7) * 3 / 4 - n7;
      }
      a7(uo2, "byteLength");
      function co(r6, e6, t6) {
        return (e6 + t6) * 3 / 4 - t6;
      }
      a7(co, "_byteLength");
      function ho(r6) {
        var e6, t6 = Tn3(r6), n7 = t6[0], i8 = t6[1], s10 = new ao2(co(r6, n7, i8)), o9 = 0, u7 = i8 > 0 ? n7 - 4 : n7, c6;
        for (c6 = 0; c6 < u7; c6 += 4) e6 = te4[r6.charCodeAt(c6)] << 18 | te4[r6.charCodeAt(c6 + 1)] << 12 | te4[r6.charCodeAt(c6 + 2)] << 6 | te4[r6.charCodeAt(c6 + 3)], s10[o9++] = e6 >> 16 & 255, s10[o9++] = e6 >> 8 & 255, s10[o9++] = e6 & 255;
        return i8 === 2 && (e6 = te4[r6.charCodeAt(c6)] << 2 | te4[r6.charCodeAt(c6 + 1)] >> 4, s10[o9++] = e6 & 255), i8 === 1 && (e6 = te4[r6.charCodeAt(
          c6
        )] << 10 | te4[r6.charCodeAt(c6 + 1)] << 4 | te4[r6.charCodeAt(c6 + 2)] >> 2, s10[o9++] = e6 >> 8 & 255, s10[o9++] = e6 & 255), s10;
      }
      a7(ho, "toByteArray");
      function lo(r6) {
        return ae[r6 >> 18 & 63] + ae[r6 >> 12 & 63] + ae[r6 >> 6 & 63] + ae[r6 & 63];
      }
      a7(lo, "tripletToBase64");
      function fo(r6, e6, t6) {
        for (var n7, i8 = [], s10 = e6; s10 < t6; s10 += 3) n7 = (r6[s10] << 16 & 16711680) + (r6[s10 + 1] << 8 & 65280) + (r6[s10 + 2] & 255), i8.push(lo(n7));
        return i8.join(
          ""
        );
      }
      a7(fo, "encodeChunk");
      function po(r6) {
        for (var e6, t6 = r6.length, n7 = t6 % 3, i8 = [], s10 = 16383, o9 = 0, u7 = t6 - n7; o9 < u7; o9 += s10) i8.push(fo(r6, o9, o9 + s10 > u7 ? u7 : o9 + s10));
        return n7 === 1 ? (e6 = r6[t6 - 1], i8.push(ae[e6 >> 2] + ae[e6 << 4 & 63] + "==")) : n7 === 2 && (e6 = (r6[t6 - 2] << 8) + r6[t6 - 1], i8.push(ae[e6 >> 10] + ae[e6 >> 4 & 63] + ae[e6 << 2 & 63] + "=")), i8.join("");
      }
      a7(po, "fromByteArray");
    });
    Pn2 = I5((Bt2) => {
      p9();
      Bt2.read = function(r6, e6, t6, n7, i8) {
        var s10, o9, u7 = i8 * 8 - n7 - 1, c6 = (1 << u7) - 1, h8 = c6 >> 1, l7 = -7, d7 = t6 ? i8 - 1 : 0, b9 = t6 ? -1 : 1, C6 = r6[e6 + d7];
        for (d7 += b9, s10 = C6 & (1 << -l7) - 1, C6 >>= -l7, l7 += u7; l7 > 0; s10 = s10 * 256 + r6[e6 + d7], d7 += b9, l7 -= 8) ;
        for (o9 = s10 & (1 << -l7) - 1, s10 >>= -l7, l7 += n7; l7 > 0; o9 = o9 * 256 + r6[e6 + d7], d7 += b9, l7 -= 8) ;
        if (s10 === 0) s10 = 1 - h8;
        else {
          if (s10 === c6) return o9 ? NaN : (C6 ? -1 : 1) * (1 / 0);
          o9 = o9 + Math.pow(2, n7), s10 = s10 - h8;
        }
        return (C6 ? -1 : 1) * o9 * Math.pow(2, s10 - n7);
      };
      Bt2.write = function(r6, e6, t6, n7, i8, s10) {
        var o9, u7, c6, h8 = s10 * 8 - i8 - 1, l7 = (1 << h8) - 1, d7 = l7 >> 1, b9 = i8 === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, C6 = n7 ? 0 : s10 - 1, B3 = n7 ? 1 : -1, W4 = e6 < 0 || e6 === 0 && 1 / e6 < 0 ? 1 : 0;
        for (e6 = Math.abs(e6), isNaN(e6) || e6 === 1 / 0 ? (u7 = isNaN(e6) ? 1 : 0, o9 = l7) : (o9 = Math.floor(Math.log(e6) / Math.LN2), e6 * (c6 = Math.pow(2, -o9)) < 1 && (o9--, c6 *= 2), o9 + d7 >= 1 ? e6 += b9 / c6 : e6 += b9 * Math.pow(2, 1 - d7), e6 * c6 >= 2 && (o9++, c6 /= 2), o9 + d7 >= l7 ? (u7 = 0, o9 = l7) : o9 + d7 >= 1 ? (u7 = (e6 * c6 - 1) * Math.pow(
          2,
          i8
        ), o9 = o9 + d7) : (u7 = e6 * Math.pow(2, d7 - 1) * Math.pow(2, i8), o9 = 0)); i8 >= 8; r6[t6 + C6] = u7 & 255, C6 += B3, u7 /= 256, i8 -= 8) ;
        for (o9 = o9 << i8 | u7, h8 += i8; h8 > 0; r6[t6 + C6] = o9 & 255, C6 += B3, o9 /= 256, h8 -= 8) ;
        r6[t6 + C6 - B3] |= W4 * 128;
      };
    });
    $n = I5((Le2) => {
      "use strict";
      p9();
      var Lt2 = In3(), Pe3 = Pn2(), Bn3 = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
      Le2.Buffer = f9;
      Le2.SlowBuffer = So;
      Le2.INSPECT_MAX_BYTES = 50;
      var it2 = 2147483647;
      Le2.kMaxLength = it2;
      f9.TYPED_ARRAY_SUPPORT = yo();
      !f9.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
      function yo() {
        try {
          let r6 = new Uint8Array(1), e6 = { foo: a7(function() {
            return 42;
          }, "foo") };
          return Object.setPrototypeOf(e6, Uint8Array.prototype), Object.setPrototypeOf(
            r6,
            e6
          ), r6.foo() === 42;
        } catch {
          return false;
        }
      }
      a7(yo, "typedArraySupport");
      Object.defineProperty(
        f9.prototype,
        "parent",
        { enumerable: true, get: a7(function() {
          if (f9.isBuffer(this)) return this.buffer;
        }, "get") }
      );
      Object.defineProperty(f9.prototype, "offset", { enumerable: true, get: a7(
        function() {
          if (f9.isBuffer(this)) return this.byteOffset;
        },
        "get"
      ) });
      function fe3(r6) {
        if (r6 > it2) throw new RangeError('The value "' + r6 + '" is invalid for option "size"');
        let e6 = new Uint8Array(
          r6
        );
        return Object.setPrototypeOf(e6, f9.prototype), e6;
      }
      a7(fe3, "createBuffer");
      function f9(r6, e6, t6) {
        if (typeof r6 == "number") {
          if (typeof e6 == "string") throw new TypeError('The "string" argument must be of type string. Received type number');
          return Dt2(r6);
        }
        return Mn2(
          r6,
          e6,
          t6
        );
      }
      a7(f9, "Buffer");
      f9.poolSize = 8192;
      function Mn2(r6, e6, t6) {
        if (typeof r6 == "string") return go(
          r6,
          e6
        );
        if (ArrayBuffer.isView(r6)) return wo(r6);
        if (r6 == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof r6);
        if (ue(r6, ArrayBuffer) || r6 && ue(r6.buffer, ArrayBuffer) || typeof SharedArrayBuffer < "u" && (ue(r6, SharedArrayBuffer) || r6 && ue(r6.buffer, SharedArrayBuffer)))
          return Ft2(r6, e6, t6);
        if (typeof r6 == "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
        let n7 = r6.valueOf && r6.valueOf();
        if (n7 != null && n7 !== r6) return f9.from(n7, e6, t6);
        let i8 = bo(r6);
        if (i8) return i8;
        if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof r6[Symbol.toPrimitive] == "function") return f9.from(r6[Symbol.toPrimitive]("string"), e6, t6);
        throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof r6);
      }
      a7(Mn2, "from");
      f9.from = function(r6, e6, t6) {
        return Mn2(r6, e6, t6);
      };
      Object.setPrototypeOf(f9.prototype, Uint8Array.prototype);
      Object.setPrototypeOf(
        f9,
        Uint8Array
      );
      function Dn2(r6) {
        if (typeof r6 != "number") throw new TypeError('"size" argument must be of type number');
        if (r6 < 0) throw new RangeError('The value "' + r6 + '" is invalid for option "size"');
      }
      a7(Dn2, "assertSize");
      function mo(r6, e6, t6) {
        return Dn2(r6), r6 <= 0 ? fe3(r6) : e6 !== void 0 ? typeof t6 == "string" ? fe3(r6).fill(e6, t6) : fe3(r6).fill(e6) : fe3(r6);
      }
      a7(
        mo,
        "alloc"
      );
      f9.alloc = function(r6, e6, t6) {
        return mo(r6, e6, t6);
      };
      function Dt2(r6) {
        return Dn2(r6), fe3(
          r6 < 0 ? 0 : kt2(r6) | 0
        );
      }
      a7(Dt2, "allocUnsafe");
      f9.allocUnsafe = function(r6) {
        return Dt2(r6);
      };
      f9.allocUnsafeSlow = function(r6) {
        return Dt2(r6);
      };
      function go(r6, e6) {
        if ((typeof e6 != "string" || e6 === "") && (e6 = "utf8"), !f9.isEncoding(e6)) throw new TypeError("Unknown encoding: " + e6);
        let t6 = kn2(r6, e6) | 0, n7 = fe3(t6), i8 = n7.write(r6, e6);
        return i8 !== t6 && (n7 = n7.slice(0, i8)), n7;
      }
      a7(go, "fromString");
      function Rt2(r6) {
        let e6 = r6.length < 0 ? 0 : kt2(r6.length) | 0, t6 = fe3(e6);
        for (let n7 = 0; n7 < e6; n7 += 1) t6[n7] = r6[n7] & 255;
        return t6;
      }
      a7(Rt2, "fromArrayLike");
      function wo(r6) {
        if (ue(r6, Uint8Array)) {
          let e6 = new Uint8Array(r6);
          return Ft2(e6.buffer, e6.byteOffset, e6.byteLength);
        }
        return Rt2(r6);
      }
      a7(wo, "fromArrayView");
      function Ft2(r6, e6, t6) {
        if (e6 < 0 || r6.byteLength < e6) throw new RangeError('"offset" is outside of buffer bounds');
        if (r6.byteLength < e6 + (t6 || 0)) throw new RangeError('"length" is outside of buffer bounds');
        let n7;
        return e6 === void 0 && t6 === void 0 ? n7 = new Uint8Array(
          r6
        ) : t6 === void 0 ? n7 = new Uint8Array(r6, e6) : n7 = new Uint8Array(r6, e6, t6), Object.setPrototypeOf(
          n7,
          f9.prototype
        ), n7;
      }
      a7(Ft2, "fromArrayBuffer");
      function bo(r6) {
        if (f9.isBuffer(r6)) {
          let e6 = kt2(
            r6.length
          ) | 0, t6 = fe3(e6);
          return t6.length === 0 || r6.copy(t6, 0, 0, e6), t6;
        }
        if (r6.length !== void 0)
          return typeof r6.length != "number" || Ot2(r6.length) ? fe3(0) : Rt2(r6);
        if (r6.type === "Buffer" && Array.isArray(r6.data)) return Rt2(r6.data);
      }
      a7(bo, "fromObject");
      function kt2(r6) {
        if (r6 >= it2) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + it2.toString(16) + " bytes");
        return r6 | 0;
      }
      a7(kt2, "checked");
      function So(r6) {
        return +r6 != r6 && (r6 = 0), f9.alloc(+r6);
      }
      a7(So, "SlowBuffer");
      f9.isBuffer = a7(function(e6) {
        return e6 != null && e6._isBuffer === true && e6 !== f9.prototype;
      }, "isBuffer");
      f9.compare = a7(function(e6, t6) {
        if (ue(e6, Uint8Array) && (e6 = f9.from(e6, e6.offset, e6.byteLength)), ue(t6, Uint8Array) && (t6 = f9.from(t6, t6.offset, t6.byteLength)), !f9.isBuffer(e6) || !f9.isBuffer(t6)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
        if (e6 === t6) return 0;
        let n7 = e6.length, i8 = t6.length;
        for (let s10 = 0, o9 = Math.min(n7, i8); s10 < o9; ++s10) if (e6[s10] !== t6[s10]) {
          n7 = e6[s10], i8 = t6[s10];
          break;
        }
        return n7 < i8 ? -1 : i8 < n7 ? 1 : 0;
      }, "compare");
      f9.isEncoding = a7(function(e6) {
        switch (String(e6).toLowerCase()) {
          case "hex":
          case "utf8":
          case "utf-8":
          case "ascii":
          case "latin1":
          case "binary":
          case "base64":
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return true;
          default:
            return false;
        }
      }, "isEncoding");
      f9.concat = a7(function(e6, t6) {
        if (!Array.isArray(e6)) throw new TypeError('"list" argument must be an Array of Buffers');
        if (e6.length === 0) return f9.alloc(0);
        let n7;
        if (t6 === void 0) for (t6 = 0, n7 = 0; n7 < e6.length; ++n7) t6 += e6[n7].length;
        let i8 = f9.allocUnsafe(t6), s10 = 0;
        for (n7 = 0; n7 < e6.length; ++n7) {
          let o9 = e6[n7];
          if (ue(o9, Uint8Array)) s10 + o9.length > i8.length ? (f9.isBuffer(
            o9
          ) || (o9 = f9.from(o9)), o9.copy(i8, s10)) : Uint8Array.prototype.set.call(i8, o9, s10);
          else if (f9.isBuffer(
            o9
          )) o9.copy(i8, s10);
          else throw new TypeError('"list" argument must be an Array of Buffers');
          s10 += o9.length;
        }
        return i8;
      }, "concat");
      function kn2(r6, e6) {
        if (f9.isBuffer(r6)) return r6.length;
        if (ArrayBuffer.isView(r6) || ue(r6, ArrayBuffer)) return r6.byteLength;
        if (typeof r6 != "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof r6);
        let t6 = r6.length, n7 = arguments.length > 2 && arguments[2] === true;
        if (!n7 && t6 === 0) return 0;
        let i8 = false;
        for (; ; ) switch (e6) {
          case "ascii":
          case "latin1":
          case "binary":
            return t6;
          case "utf8":
          case "utf-8":
            return Mt2(r6).length;
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return t6 * 2;
          case "hex":
            return t6 >>> 1;
          case "base64":
            return Gn3(r6).length;
          default:
            if (i8) return n7 ? -1 : Mt2(r6).length;
            e6 = ("" + e6).toLowerCase(), i8 = true;
        }
      }
      a7(kn2, "byteLength");
      f9.byteLength = kn2;
      function xo(r6, e6, t6) {
        let n7 = false;
        if ((e6 === void 0 || e6 < 0) && (e6 = 0), e6 > this.length || ((t6 === void 0 || t6 > this.length) && (t6 = this.length), t6 <= 0) || (t6 >>>= 0, e6 >>>= 0, t6 <= e6)) return "";
        for (r6 || (r6 = "utf8"); ; ) switch (r6) {
          case "hex":
            return Lo(
              this,
              e6,
              t6
            );
          case "utf8":
          case "utf-8":
            return On2(this, e6, t6);
          case "ascii":
            return Po(
              this,
              e6,
              t6
            );
          case "latin1":
          case "binary":
            return Bo(this, e6, t6);
          case "base64":
            return To(
              this,
              e6,
              t6
            );
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return Ro(this, e6, t6);
          default:
            if (n7) throw new TypeError("Unknown encoding: " + r6);
            r6 = (r6 + "").toLowerCase(), n7 = true;
        }
      }
      a7(
        xo,
        "slowToString"
      );
      f9.prototype._isBuffer = true;
      function Ee2(r6, e6, t6) {
        let n7 = r6[e6];
        r6[e6] = r6[t6], r6[t6] = n7;
      }
      a7(Ee2, "swap");
      f9.prototype.swap16 = a7(function() {
        let e6 = this.length;
        if (e6 % 2 !== 0)
          throw new RangeError("Buffer size must be a multiple of 16-bits");
        for (let t6 = 0; t6 < e6; t6 += 2) Ee2(this, t6, t6 + 1);
        return this;
      }, "swap16");
      f9.prototype.swap32 = a7(function() {
        let e6 = this.length;
        if (e6 % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
        for (let t6 = 0; t6 < e6; t6 += 4) Ee2(this, t6, t6 + 3), Ee2(this, t6 + 1, t6 + 2);
        return this;
      }, "swap32");
      f9.prototype.swap64 = a7(function() {
        let e6 = this.length;
        if (e6 % 8 !== 0) throw new RangeError(
          "Buffer size must be a multiple of 64-bits"
        );
        for (let t6 = 0; t6 < e6; t6 += 8) Ee2(this, t6, t6 + 7), Ee2(this, t6 + 1, t6 + 6), Ee2(this, t6 + 2, t6 + 5), Ee2(this, t6 + 3, t6 + 4);
        return this;
      }, "swap64");
      f9.prototype.toString = a7(function() {
        let e6 = this.length;
        return e6 === 0 ? "" : arguments.length === 0 ? On2(
          this,
          0,
          e6
        ) : xo.apply(this, arguments);
      }, "toString");
      f9.prototype.toLocaleString = f9.prototype.toString;
      f9.prototype.equals = a7(function(e6) {
        if (!f9.isBuffer(e6)) throw new TypeError(
          "Argument must be a Buffer"
        );
        return this === e6 ? true : f9.compare(this, e6) === 0;
      }, "equals");
      f9.prototype.inspect = a7(function() {
        let e6 = "", t6 = Le2.INSPECT_MAX_BYTES;
        return e6 = this.toString(
          "hex",
          0,
          t6
        ).replace(/(.{2})/g, "$1 ").trim(), this.length > t6 && (e6 += " ... "), "<Buffer " + e6 + ">";
      }, "inspect");
      Bn3 && (f9.prototype[Bn3] = f9.prototype.inspect);
      f9.prototype.compare = a7(function(e6, t6, n7, i8, s10) {
        if (ue(e6, Uint8Array) && (e6 = f9.from(e6, e6.offset, e6.byteLength)), !f9.isBuffer(e6)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof e6);
        if (t6 === void 0 && (t6 = 0), n7 === void 0 && (n7 = e6 ? e6.length : 0), i8 === void 0 && (i8 = 0), s10 === void 0 && (s10 = this.length), t6 < 0 || n7 > e6.length || i8 < 0 || s10 > this.length) throw new RangeError("out of range index");
        if (i8 >= s10 && t6 >= n7) return 0;
        if (i8 >= s10) return -1;
        if (t6 >= n7) return 1;
        if (t6 >>>= 0, n7 >>>= 0, i8 >>>= 0, s10 >>>= 0, this === e6) return 0;
        let o9 = s10 - i8, u7 = n7 - t6, c6 = Math.min(o9, u7), h8 = this.slice(i8, s10), l7 = e6.slice(t6, n7);
        for (let d7 = 0; d7 < c6; ++d7)
          if (h8[d7] !== l7[d7]) {
            o9 = h8[d7], u7 = l7[d7];
            break;
          }
        return o9 < u7 ? -1 : u7 < o9 ? 1 : 0;
      }, "compare");
      function Un2(r6, e6, t6, n7, i8) {
        if (r6.length === 0) return -1;
        if (typeof t6 == "string" ? (n7 = t6, t6 = 0) : t6 > 2147483647 ? t6 = 2147483647 : t6 < -2147483648 && (t6 = -2147483648), t6 = +t6, Ot2(t6) && (t6 = i8 ? 0 : r6.length - 1), t6 < 0 && (t6 = r6.length + t6), t6 >= r6.length) {
          if (i8) return -1;
          t6 = r6.length - 1;
        } else if (t6 < 0) if (i8) t6 = 0;
        else return -1;
        if (typeof e6 == "string" && (e6 = f9.from(e6, n7)), f9.isBuffer(e6)) return e6.length === 0 ? -1 : Ln2(r6, e6, t6, n7, i8);
        if (typeof e6 == "number") return e6 = e6 & 255, typeof Uint8Array.prototype.indexOf == "function" ? i8 ? Uint8Array.prototype.indexOf.call(r6, e6, t6) : Uint8Array.prototype.lastIndexOf.call(r6, e6, t6) : Ln2(
          r6,
          [e6],
          t6,
          n7,
          i8
        );
        throw new TypeError("val must be string, number or Buffer");
      }
      a7(Un2, "bidirectionalIndexOf");
      function Ln2(r6, e6, t6, n7, i8) {
        let s10 = 1, o9 = r6.length, u7 = e6.length;
        if (n7 !== void 0 && (n7 = String(n7).toLowerCase(), n7 === "ucs2" || n7 === "ucs-2" || n7 === "utf16le" || n7 === "utf-16le")) {
          if (r6.length < 2 || e6.length < 2) return -1;
          s10 = 2, o9 /= 2, u7 /= 2, t6 /= 2;
        }
        function c6(l7, d7) {
          return s10 === 1 ? l7[d7] : l7.readUInt16BE(d7 * s10);
        }
        a7(c6, "read");
        let h8;
        if (i8) {
          let l7 = -1;
          for (h8 = t6; h8 < o9; h8++) if (c6(r6, h8) === c6(e6, l7 === -1 ? 0 : h8 - l7)) {
            if (l7 === -1 && (l7 = h8), h8 - l7 + 1 === u7) return l7 * s10;
          } else l7 !== -1 && (h8 -= h8 - l7), l7 = -1;
        } else for (t6 + u7 > o9 && (t6 = o9 - u7), h8 = t6; h8 >= 0; h8--) {
          let l7 = true;
          for (let d7 = 0; d7 < u7; d7++)
            if (c6(r6, h8 + d7) !== c6(e6, d7)) {
              l7 = false;
              break;
            }
          if (l7) return h8;
        }
        return -1;
      }
      a7(Ln2, "arrayIndexOf");
      f9.prototype.includes = a7(function(e6, t6, n7) {
        return this.indexOf(e6, t6, n7) !== -1;
      }, "includes");
      f9.prototype.indexOf = a7(function(e6, t6, n7) {
        return Un2(this, e6, t6, n7, true);
      }, "indexOf");
      f9.prototype.lastIndexOf = a7(function(e6, t6, n7) {
        return Un2(this, e6, t6, n7, false);
      }, "lastIndexOf");
      function vo(r6, e6, t6, n7) {
        t6 = Number(t6) || 0;
        let i8 = r6.length - t6;
        n7 ? (n7 = Number(n7), n7 > i8 && (n7 = i8)) : n7 = i8;
        let s10 = e6.length;
        n7 > s10 / 2 && (n7 = s10 / 2);
        let o9;
        for (o9 = 0; o9 < n7; ++o9) {
          let u7 = parseInt(e6.substr(o9 * 2, 2), 16);
          if (Ot2(u7))
            return o9;
          r6[t6 + o9] = u7;
        }
        return o9;
      }
      a7(vo, "hexWrite");
      function Eo(r6, e6, t6, n7) {
        return st2(Mt2(
          e6,
          r6.length - t6
        ), r6, t6, n7);
      }
      a7(Eo, "utf8Write");
      function _o(r6, e6, t6, n7) {
        return st2(ko(e6), r6, t6, n7);
      }
      a7(_o, "asciiWrite");
      function Ao(r6, e6, t6, n7) {
        return st2(Gn3(e6), r6, t6, n7);
      }
      a7(Ao, "base64Write");
      function Co(r6, e6, t6, n7) {
        return st2(Uo(e6, r6.length - t6), r6, t6, n7);
      }
      a7(Co, "ucs2Write");
      f9.prototype.write = a7(function(e6, t6, n7, i8) {
        if (t6 === void 0) i8 = "utf8", n7 = this.length, t6 = 0;
        else if (n7 === void 0 && typeof t6 == "string") i8 = t6, n7 = this.length, t6 = 0;
        else if (isFinite(t6)) t6 = t6 >>> 0, isFinite(n7) ? (n7 = n7 >>> 0, i8 === void 0 && (i8 = "utf8")) : (i8 = n7, n7 = void 0);
        else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
        let s10 = this.length - t6;
        if ((n7 === void 0 || n7 > s10) && (n7 = s10), e6.length > 0 && (n7 < 0 || t6 < 0) || t6 > this.length) throw new RangeError(
          "Attempt to write outside buffer bounds"
        );
        i8 || (i8 = "utf8");
        let o9 = false;
        for (; ; ) switch (i8) {
          case "hex":
            return vo(this, e6, t6, n7);
          case "utf8":
          case "utf-8":
            return Eo(this, e6, t6, n7);
          case "ascii":
          case "latin1":
          case "binary":
            return _o(this, e6, t6, n7);
          case "base64":
            return Ao(
              this,
              e6,
              t6,
              n7
            );
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return Co(this, e6, t6, n7);
          default:
            if (o9) throw new TypeError("Unknown encoding: " + i8);
            i8 = ("" + i8).toLowerCase(), o9 = true;
        }
      }, "write");
      f9.prototype.toJSON = a7(function() {
        return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
      }, "toJSON");
      function To(r6, e6, t6) {
        return e6 === 0 && t6 === r6.length ? Lt2.fromByteArray(r6) : Lt2.fromByteArray(r6.slice(e6, t6));
      }
      a7(To, "base64Slice");
      function On2(r6, e6, t6) {
        t6 = Math.min(r6.length, t6);
        let n7 = [], i8 = e6;
        for (; i8 < t6; ) {
          let s10 = r6[i8], o9 = null, u7 = s10 > 239 ? 4 : s10 > 223 ? 3 : s10 > 191 ? 2 : 1;
          if (i8 + u7 <= t6) {
            let c6, h8, l7, d7;
            switch (u7) {
              case 1:
                s10 < 128 && (o9 = s10);
                break;
              case 2:
                c6 = r6[i8 + 1], (c6 & 192) === 128 && (d7 = (s10 & 31) << 6 | c6 & 63, d7 > 127 && (o9 = d7));
                break;
              case 3:
                c6 = r6[i8 + 1], h8 = r6[i8 + 2], (c6 & 192) === 128 && (h8 & 192) === 128 && (d7 = (s10 & 15) << 12 | (c6 & 63) << 6 | h8 & 63, d7 > 2047 && (d7 < 55296 || d7 > 57343) && (o9 = d7));
                break;
              case 4:
                c6 = r6[i8 + 1], h8 = r6[i8 + 2], l7 = r6[i8 + 3], (c6 & 192) === 128 && (h8 & 192) === 128 && (l7 & 192) === 128 && (d7 = (s10 & 15) << 18 | (c6 & 63) << 12 | (h8 & 63) << 6 | l7 & 63, d7 > 65535 && d7 < 1114112 && (o9 = d7));
            }
          }
          o9 === null ? (o9 = 65533, u7 = 1) : o9 > 65535 && (o9 -= 65536, n7.push(o9 >>> 10 & 1023 | 55296), o9 = 56320 | o9 & 1023), n7.push(o9), i8 += u7;
        }
        return Io(n7);
      }
      a7(On2, "utf8Slice");
      var Rn2 = 4096;
      function Io(r6) {
        let e6 = r6.length;
        if (e6 <= Rn2) return String.fromCharCode.apply(String, r6);
        let t6 = "", n7 = 0;
        for (; n7 < e6; ) t6 += String.fromCharCode.apply(String, r6.slice(n7, n7 += Rn2));
        return t6;
      }
      a7(Io, "decodeCodePointsArray");
      function Po(r6, e6, t6) {
        let n7 = "";
        t6 = Math.min(r6.length, t6);
        for (let i8 = e6; i8 < t6; ++i8) n7 += String.fromCharCode(r6[i8] & 127);
        return n7;
      }
      a7(Po, "asciiSlice");
      function Bo(r6, e6, t6) {
        let n7 = "";
        t6 = Math.min(r6.length, t6);
        for (let i8 = e6; i8 < t6; ++i8) n7 += String.fromCharCode(r6[i8]);
        return n7;
      }
      a7(Bo, "latin1Slice");
      function Lo(r6, e6, t6) {
        let n7 = r6.length;
        (!e6 || e6 < 0) && (e6 = 0), (!t6 || t6 < 0 || t6 > n7) && (t6 = n7);
        let i8 = "";
        for (let s10 = e6; s10 < t6; ++s10) i8 += Oo[r6[s10]];
        return i8;
      }
      a7(Lo, "hexSlice");
      function Ro(r6, e6, t6) {
        let n7 = r6.slice(e6, t6), i8 = "";
        for (let s10 = 0; s10 < n7.length - 1; s10 += 2) i8 += String.fromCharCode(n7[s10] + n7[s10 + 1] * 256);
        return i8;
      }
      a7(Ro, "utf16leSlice");
      f9.prototype.slice = a7(function(e6, t6) {
        let n7 = this.length;
        e6 = ~~e6, t6 = t6 === void 0 ? n7 : ~~t6, e6 < 0 ? (e6 += n7, e6 < 0 && (e6 = 0)) : e6 > n7 && (e6 = n7), t6 < 0 ? (t6 += n7, t6 < 0 && (t6 = 0)) : t6 > n7 && (t6 = n7), t6 < e6 && (t6 = e6);
        let i8 = this.subarray(
          e6,
          t6
        );
        return Object.setPrototypeOf(i8, f9.prototype), i8;
      }, "slice");
      function q7(r6, e6, t6) {
        if (r6 % 1 !== 0 || r6 < 0) throw new RangeError("offset is not uint");
        if (r6 + e6 > t6) throw new RangeError(
          "Trying to access beyond buffer length"
        );
      }
      a7(q7, "checkOffset");
      f9.prototype.readUintLE = f9.prototype.readUIntLE = a7(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = this[e6], s10 = 1, o9 = 0;
        for (; ++o9 < t6 && (s10 *= 256); ) i8 += this[e6 + o9] * s10;
        return i8;
      }, "readUIntLE");
      f9.prototype.readUintBE = f9.prototype.readUIntBE = a7(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = this[e6 + --t6], s10 = 1;
        for (; t6 > 0 && (s10 *= 256); ) i8 += this[e6 + --t6] * s10;
        return i8;
      }, "readUIntBE");
      f9.prototype.readUint8 = f9.prototype.readUInt8 = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 1, this.length), this[e6];
      }, "readUInt8");
      f9.prototype.readUint16LE = f9.prototype.readUInt16LE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 2, this.length), this[e6] | this[e6 + 1] << 8;
      }, "readUInt16LE");
      f9.prototype.readUint16BE = f9.prototype.readUInt16BE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 2, this.length), this[e6] << 8 | this[e6 + 1];
      }, "readUInt16BE");
      f9.prototype.readUint32LE = f9.prototype.readUInt32LE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), (this[e6] | this[e6 + 1] << 8 | this[e6 + 2] << 16) + this[e6 + 3] * 16777216;
      }, "readUInt32LE");
      f9.prototype.readUint32BE = f9.prototype.readUInt32BE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), this[e6] * 16777216 + (this[e6 + 1] << 16 | this[e6 + 2] << 8 | this[e6 + 3]);
      }, "readUInt32BE");
      f9.prototype.readBigUInt64LE = ge4(a7(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(e6, this.length - 8);
        let i8 = t6 + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 24, s10 = this[++e6] + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + n7 * 2 ** 24;
        return BigInt(i8) + (BigInt(s10) << BigInt(32));
      }, "readBigUInt64LE"));
      f9.prototype.readBigUInt64BE = ge4(a7(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(e6, this.length - 8);
        let i8 = t6 * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + this[++e6], s10 = this[++e6] * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + n7;
        return (BigInt(
          i8
        ) << BigInt(32)) + BigInt(s10);
      }, "readBigUInt64BE"));
      f9.prototype.readIntLE = a7(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = this[e6], s10 = 1, o9 = 0;
        for (; ++o9 < t6 && (s10 *= 256); )
          i8 += this[e6 + o9] * s10;
        return s10 *= 128, i8 >= s10 && (i8 -= Math.pow(2, 8 * t6)), i8;
      }, "readIntLE");
      f9.prototype.readIntBE = a7(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = t6, s10 = 1, o9 = this[e6 + --i8];
        for (; i8 > 0 && (s10 *= 256); ) o9 += this[e6 + --i8] * s10;
        return s10 *= 128, o9 >= s10 && (o9 -= Math.pow(2, 8 * t6)), o9;
      }, "readIntBE");
      f9.prototype.readInt8 = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 1, this.length), this[e6] & 128 ? (255 - this[e6] + 1) * -1 : this[e6];
      }, "readInt8");
      f9.prototype.readInt16LE = a7(function(e6, t6) {
        e6 = e6 >>> 0, t6 || q7(e6, 2, this.length);
        let n7 = this[e6] | this[e6 + 1] << 8;
        return n7 & 32768 ? n7 | 4294901760 : n7;
      }, "readInt16LE");
      f9.prototype.readInt16BE = a7(
        function(e6, t6) {
          e6 = e6 >>> 0, t6 || q7(e6, 2, this.length);
          let n7 = this[e6 + 1] | this[e6] << 8;
          return n7 & 32768 ? n7 | 4294901760 : n7;
        },
        "readInt16BE"
      );
      f9.prototype.readInt32LE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), this[e6] | this[e6 + 1] << 8 | this[e6 + 2] << 16 | this[e6 + 3] << 24;
      }, "readInt32LE");
      f9.prototype.readInt32BE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), this[e6] << 24 | this[e6 + 1] << 16 | this[e6 + 2] << 8 | this[e6 + 3];
      }, "readInt32BE");
      f9.prototype.readBigInt64LE = ge4(a7(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(
          e6,
          this.length - 8
        );
        let i8 = this[e6 + 4] + this[e6 + 5] * 2 ** 8 + this[e6 + 6] * 2 ** 16 + (n7 << 24);
        return (BigInt(
          i8
        ) << BigInt(32)) + BigInt(t6 + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 24);
      }, "readBigInt64LE"));
      f9.prototype.readBigInt64BE = ge4(a7(function(e6) {
        e6 = e6 >>> 0, Be2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(e6, this.length - 8);
        let i8 = (t6 << 24) + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + this[++e6];
        return (BigInt(i8) << BigInt(32)) + BigInt(
          this[++e6] * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + n7
        );
      }, "readBigInt64BE"));
      f9.prototype.readFloatLE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), Pe3.read(
          this,
          e6,
          true,
          23,
          4
        );
      }, "readFloatLE");
      f9.prototype.readFloatBE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), Pe3.read(this, e6, false, 23, 4);
      }, "readFloatBE");
      f9.prototype.readDoubleLE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 8, this.length), Pe3.read(this, e6, true, 52, 8);
      }, "readDoubleLE");
      f9.prototype.readDoubleBE = a7(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 8, this.length), Pe3.read(this, e6, false, 52, 8);
      }, "readDoubleBE");
      function Y3(r6, e6, t6, n7, i8, s10) {
        if (!f9.isBuffer(
          r6
        )) throw new TypeError('"buffer" argument must be a Buffer instance');
        if (e6 > i8 || e6 < s10) throw new RangeError('"value" argument is out of bounds');
        if (t6 + n7 > r6.length) throw new RangeError(
          "Index out of range"
        );
      }
      a7(Y3, "checkInt");
      f9.prototype.writeUintLE = f9.prototype.writeUIntLE = a7(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, n7 = n7 >>> 0, !i8) {
          let u7 = Math.pow(2, 8 * n7) - 1;
          Y3(
            this,
            e6,
            t6,
            n7,
            u7,
            0
          );
        }
        let s10 = 1, o9 = 0;
        for (this[t6] = e6 & 255; ++o9 < n7 && (s10 *= 256); ) this[t6 + o9] = e6 / s10 & 255;
        return t6 + n7;
      }, "writeUIntLE");
      f9.prototype.writeUintBE = f9.prototype.writeUIntBE = a7(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, n7 = n7 >>> 0, !i8) {
          let u7 = Math.pow(2, 8 * n7) - 1;
          Y3(this, e6, t6, n7, u7, 0);
        }
        let s10 = n7 - 1, o9 = 1;
        for (this[t6 + s10] = e6 & 255; --s10 >= 0 && (o9 *= 256); ) this[t6 + s10] = e6 / o9 & 255;
        return t6 + n7;
      }, "writeUIntBE");
      f9.prototype.writeUint8 = f9.prototype.writeUInt8 = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 1, 255, 0), this[t6] = e6 & 255, t6 + 1;
      }, "writeUInt8");
      f9.prototype.writeUint16LE = f9.prototype.writeUInt16LE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          2,
          65535,
          0
        ), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, t6 + 2;
      }, "writeUInt16LE");
      f9.prototype.writeUint16BE = f9.prototype.writeUInt16BE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          2,
          65535,
          0
        ), this[t6] = e6 >>> 8, this[t6 + 1] = e6 & 255, t6 + 2;
      }, "writeUInt16BE");
      f9.prototype.writeUint32LE = f9.prototype.writeUInt32LE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          4,
          4294967295,
          0
        ), this[t6 + 3] = e6 >>> 24, this[t6 + 2] = e6 >>> 16, this[t6 + 1] = e6 >>> 8, this[t6] = e6 & 255, t6 + 4;
      }, "writeUInt32LE");
      f9.prototype.writeUint32BE = f9.prototype.writeUInt32BE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 4, 4294967295, 0), this[t6] = e6 >>> 24, this[t6 + 1] = e6 >>> 16, this[t6 + 2] = e6 >>> 8, this[t6 + 3] = e6 & 255, t6 + 4;
      }, "writeUInt32BE");
      function Nn2(r6, e6, t6, n7, i8) {
        Hn2(
          e6,
          n7,
          i8,
          r6,
          t6,
          7
        );
        let s10 = Number(e6 & BigInt(4294967295));
        r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10;
        let o9 = Number(e6 >> BigInt(32) & BigInt(4294967295));
        return r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, t6;
      }
      a7(Nn2, "wrtBigUInt64LE");
      function qn2(r6, e6, t6, n7, i8) {
        Hn2(e6, n7, i8, r6, t6, 7);
        let s10 = Number(e6 & BigInt(4294967295));
        r6[t6 + 7] = s10, s10 = s10 >> 8, r6[t6 + 6] = s10, s10 = s10 >> 8, r6[t6 + 5] = s10, s10 = s10 >> 8, r6[t6 + 4] = s10;
        let o9 = Number(e6 >> BigInt(32) & BigInt(4294967295));
        return r6[t6 + 3] = o9, o9 = o9 >> 8, r6[t6 + 2] = o9, o9 = o9 >> 8, r6[t6 + 1] = o9, o9 = o9 >> 8, r6[t6] = o9, t6 + 8;
      }
      a7(qn2, "wrtBigUInt64BE");
      f9.prototype.writeBigUInt64LE = ge4(a7(function(e6, t6 = 0) {
        return Nn2(this, e6, t6, BigInt(0), BigInt(
          "0xffffffffffffffff"
        ));
      }, "writeBigUInt64LE"));
      f9.prototype.writeBigUInt64BE = ge4(a7(function(e6, t6 = 0) {
        return qn2(this, e6, t6, BigInt(0), BigInt("0xffffffffffffffff"));
      }, "writeBigUInt64BE"));
      f9.prototype.writeIntLE = a7(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, !i8) {
          let c6 = Math.pow(
            2,
            8 * n7 - 1
          );
          Y3(this, e6, t6, n7, c6 - 1, -c6);
        }
        let s10 = 0, o9 = 1, u7 = 0;
        for (this[t6] = e6 & 255; ++s10 < n7 && (o9 *= 256); ) e6 < 0 && u7 === 0 && this[t6 + s10 - 1] !== 0 && (u7 = 1), this[t6 + s10] = (e6 / o9 >> 0) - u7 & 255;
        return t6 + n7;
      }, "writeIntLE");
      f9.prototype.writeIntBE = a7(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, !i8) {
          let c6 = Math.pow(
            2,
            8 * n7 - 1
          );
          Y3(this, e6, t6, n7, c6 - 1, -c6);
        }
        let s10 = n7 - 1, o9 = 1, u7 = 0;
        for (this[t6 + s10] = e6 & 255; --s10 >= 0 && (o9 *= 256); ) e6 < 0 && u7 === 0 && this[t6 + s10 + 1] !== 0 && (u7 = 1), this[t6 + s10] = (e6 / o9 >> 0) - u7 & 255;
        return t6 + n7;
      }, "writeIntBE");
      f9.prototype.writeInt8 = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          1,
          127,
          -128
        ), e6 < 0 && (e6 = 255 + e6 + 1), this[t6] = e6 & 255, t6 + 1;
      }, "writeInt8");
      f9.prototype.writeInt16LE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 2, 32767, -32768), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, t6 + 2;
      }, "writeInt16LE");
      f9.prototype.writeInt16BE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 2, 32767, -32768), this[t6] = e6 >>> 8, this[t6 + 1] = e6 & 255, t6 + 2;
      }, "writeInt16BE");
      f9.prototype.writeInt32LE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 4, 2147483647, -2147483648), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, this[t6 + 2] = e6 >>> 16, this[t6 + 3] = e6 >>> 24, t6 + 4;
      }, "writeInt32LE");
      f9.prototype.writeInt32BE = a7(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 4, 2147483647, -2147483648), e6 < 0 && (e6 = 4294967295 + e6 + 1), this[t6] = e6 >>> 24, this[t6 + 1] = e6 >>> 16, this[t6 + 2] = e6 >>> 8, this[t6 + 3] = e6 & 255, t6 + 4;
      }, "writeInt32BE");
      f9.prototype.writeBigInt64LE = ge4(a7(function(e6, t6 = 0) {
        return Nn2(this, e6, t6, -BigInt(
          "0x8000000000000000"
        ), BigInt("0x7fffffffffffffff"));
      }, "writeBigInt64LE"));
      f9.prototype.writeBigInt64BE = ge4(a7(function(e6, t6 = 0) {
        return qn2(this, e6, t6, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
      }, "writeBigInt64BE"));
      function Qn2(r6, e6, t6, n7, i8, s10) {
        if (t6 + n7 > r6.length) throw new RangeError("Index out of range");
        if (t6 < 0) throw new RangeError(
          "Index out of range"
        );
      }
      a7(Qn2, "checkIEEE754");
      function Wn2(r6, e6, t6, n7, i8) {
        return e6 = +e6, t6 = t6 >>> 0, i8 || Qn2(r6, e6, t6, 4, 34028234663852886e22, -34028234663852886e22), Pe3.write(
          r6,
          e6,
          t6,
          n7,
          23,
          4
        ), t6 + 4;
      }
      a7(Wn2, "writeFloat");
      f9.prototype.writeFloatLE = a7(function(e6, t6, n7) {
        return Wn2(
          this,
          e6,
          t6,
          true,
          n7
        );
      }, "writeFloatLE");
      f9.prototype.writeFloatBE = a7(function(e6, t6, n7) {
        return Wn2(
          this,
          e6,
          t6,
          false,
          n7
        );
      }, "writeFloatBE");
      function jn2(r6, e6, t6, n7, i8) {
        return e6 = +e6, t6 = t6 >>> 0, i8 || Qn2(
          r6,
          e6,
          t6,
          8,
          17976931348623157e292,
          -17976931348623157e292
        ), Pe3.write(r6, e6, t6, n7, 52, 8), t6 + 8;
      }
      a7(jn2, "writeDouble");
      f9.prototype.writeDoubleLE = a7(function(e6, t6, n7) {
        return jn2(
          this,
          e6,
          t6,
          true,
          n7
        );
      }, "writeDoubleLE");
      f9.prototype.writeDoubleBE = a7(function(e6, t6, n7) {
        return jn2(
          this,
          e6,
          t6,
          false,
          n7
        );
      }, "writeDoubleBE");
      f9.prototype.copy = a7(function(e6, t6, n7, i8) {
        if (!f9.isBuffer(
          e6
        )) throw new TypeError("argument should be a Buffer");
        if (n7 || (n7 = 0), !i8 && i8 !== 0 && (i8 = this.length), t6 >= e6.length && (t6 = e6.length), t6 || (t6 = 0), i8 > 0 && i8 < n7 && (i8 = n7), i8 === n7 || e6.length === 0 || this.length === 0) return 0;
        if (t6 < 0) throw new RangeError("targetStart out of bounds");
        if (n7 < 0 || n7 >= this.length) throw new RangeError("Index out of range");
        if (i8 < 0) throw new RangeError(
          "sourceEnd out of bounds"
        );
        i8 > this.length && (i8 = this.length), e6.length - t6 < i8 - n7 && (i8 = e6.length - t6 + n7);
        let s10 = i8 - n7;
        return this === e6 && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(t6, n7, i8) : Uint8Array.prototype.set.call(e6, this.subarray(n7, i8), t6), s10;
      }, "copy");
      f9.prototype.fill = a7(function(e6, t6, n7, i8) {
        if (typeof e6 == "string") {
          if (typeof t6 == "string" ? (i8 = t6, t6 = 0, n7 = this.length) : typeof n7 == "string" && (i8 = n7, n7 = this.length), i8 !== void 0 && typeof i8 != "string") throw new TypeError("encoding must be a string");
          if (typeof i8 == "string" && !f9.isEncoding(i8)) throw new TypeError("Unknown encoding: " + i8);
          if (e6.length === 1) {
            let o9 = e6.charCodeAt(0);
            (i8 === "utf8" && o9 < 128 || i8 === "latin1") && (e6 = o9);
          }
        } else typeof e6 == "number" ? e6 = e6 & 255 : typeof e6 == "boolean" && (e6 = Number(e6));
        if (t6 < 0 || this.length < t6 || this.length < n7) throw new RangeError("Out of range index");
        if (n7 <= t6) return this;
        t6 = t6 >>> 0, n7 = n7 === void 0 ? this.length : n7 >>> 0, e6 || (e6 = 0);
        let s10;
        if (typeof e6 == "number") for (s10 = t6; s10 < n7; ++s10)
          this[s10] = e6;
        else {
          let o9 = f9.isBuffer(e6) ? e6 : f9.from(e6, i8), u7 = o9.length;
          if (u7 === 0) throw new TypeError(
            'The value "' + e6 + '" is invalid for argument "value"'
          );
          for (s10 = 0; s10 < n7 - t6; ++s10) this[s10 + t6] = o9[s10 % u7];
        }
        return this;
      }, "fill");
      var Ie5 = {};
      function Ut3(r6, e6, t6) {
        var n7;
        Ie5[r6] = (n7 = class extends t6 {
          constructor() {
            super(), Object.defineProperty(this, "message", {
              value: e6.apply(this, arguments),
              writable: true,
              configurable: true
            }), this.name = `${this.name} [${r6}]`, this.stack, delete this.name;
          }
          get code() {
            return r6;
          }
          set code(s10) {
            Object.defineProperty(this, "code", {
              configurable: true,
              enumerable: true,
              value: s10,
              writable: true
            });
          }
          toString() {
            return `${this.name} [${r6}]: ${this.message}`;
          }
        }, a7(n7, "NodeError"), n7);
      }
      a7(Ut3, "E");
      Ut3("ERR_BUFFER_OUT_OF_BOUNDS", function(r6) {
        return r6 ? `${r6} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
      }, RangeError);
      Ut3("ERR_INVALID_ARG_TYPE", function(r6, e6) {
        return `The "${r6}" argument must be of type number. Received type ${typeof e6}`;
      }, TypeError);
      Ut3("ERR_OUT_OF_RANGE", function(r6, e6, t6) {
        let n7 = `The value of "${r6}" is out of range.`, i8 = t6;
        return Number.isInteger(t6) && Math.abs(t6) > 2 ** 32 ? i8 = Fn2(String(t6)) : typeof t6 == "bigint" && (i8 = String(t6), (t6 > BigInt(2) ** BigInt(32) || t6 < -(BigInt(2) ** BigInt(32))) && (i8 = Fn2(i8)), i8 += "n"), n7 += ` It must be ${e6}. Received ${i8}`, n7;
      }, RangeError);
      function Fn2(r6) {
        let e6 = "", t6 = r6.length, n7 = r6[0] === "-" ? 1 : 0;
        for (; t6 >= n7 + 4; t6 -= 3) e6 = `_${r6.slice(t6 - 3, t6)}${e6}`;
        return `${r6.slice(
          0,
          t6
        )}${e6}`;
      }
      a7(Fn2, "addNumericalSeparator");
      function Fo(r6, e6, t6) {
        Be2(e6, "offset"), (r6[e6] === void 0 || r6[e6 + t6] === void 0) && We3(e6, r6.length - (t6 + 1));
      }
      a7(Fo, "checkBounds");
      function Hn2(r6, e6, t6, n7, i8, s10) {
        if (r6 > t6 || r6 < e6) {
          let o9 = typeof e6 == "bigint" ? "n" : "", u7;
          throw s10 > 3 ? e6 === 0 || e6 === BigInt(0) ? u7 = `>= 0${o9} and < 2${o9} ** ${(s10 + 1) * 8}${o9}` : u7 = `>= -(2${o9} ** ${(s10 + 1) * 8 - 1}${o9}) and < 2 ** ${(s10 + 1) * 8 - 1}${o9}` : u7 = `>= ${e6}${o9} and <= ${t6}${o9}`, new Ie5.ERR_OUT_OF_RANGE(
            "value",
            u7,
            r6
          );
        }
        Fo(n7, i8, s10);
      }
      a7(Hn2, "checkIntBI");
      function Be2(r6, e6) {
        if (typeof r6 != "number")
          throw new Ie5.ERR_INVALID_ARG_TYPE(e6, "number", r6);
      }
      a7(Be2, "validateNumber");
      function We3(r6, e6, t6) {
        throw Math.floor(r6) !== r6 ? (Be2(r6, t6), new Ie5.ERR_OUT_OF_RANGE(
          t6 || "offset",
          "an integer",
          r6
        )) : e6 < 0 ? new Ie5.ERR_BUFFER_OUT_OF_BOUNDS() : new Ie5.ERR_OUT_OF_RANGE(t6 || "offset", `>= ${t6 ? 1 : 0} and <= ${e6}`, r6);
      }
      a7(We3, "boundsError");
      var Mo = /[^+/0-9A-Za-z-_]/g;
      function Do(r6) {
        if (r6 = r6.split("=")[0], r6 = r6.trim().replace(Mo, ""), r6.length < 2) return "";
        for (; r6.length % 4 !== 0; ) r6 = r6 + "=";
        return r6;
      }
      a7(Do, "base64clean");
      function Mt2(r6, e6) {
        e6 = e6 || 1 / 0;
        let t6, n7 = r6.length, i8 = null, s10 = [];
        for (let o9 = 0; o9 < n7; ++o9) {
          if (t6 = r6.charCodeAt(o9), t6 > 55295 && t6 < 57344) {
            if (!i8) {
              if (t6 > 56319) {
                (e6 -= 3) > -1 && s10.push(239, 191, 189);
                continue;
              } else if (o9 + 1 === n7) {
                (e6 -= 3) > -1 && s10.push(239, 191, 189);
                continue;
              }
              i8 = t6;
              continue;
            }
            if (t6 < 56320) {
              (e6 -= 3) > -1 && s10.push(
                239,
                191,
                189
              ), i8 = t6;
              continue;
            }
            t6 = (i8 - 55296 << 10 | t6 - 56320) + 65536;
          } else i8 && (e6 -= 3) > -1 && s10.push(
            239,
            191,
            189
          );
          if (i8 = null, t6 < 128) {
            if ((e6 -= 1) < 0) break;
            s10.push(t6);
          } else if (t6 < 2048) {
            if ((e6 -= 2) < 0) break;
            s10.push(t6 >> 6 | 192, t6 & 63 | 128);
          } else if (t6 < 65536) {
            if ((e6 -= 3) < 0) break;
            s10.push(t6 >> 12 | 224, t6 >> 6 & 63 | 128, t6 & 63 | 128);
          } else if (t6 < 1114112) {
            if ((e6 -= 4) < 0) break;
            s10.push(t6 >> 18 | 240, t6 >> 12 & 63 | 128, t6 >> 6 & 63 | 128, t6 & 63 | 128);
          } else throw new Error("Invalid code point");
        }
        return s10;
      }
      a7(
        Mt2,
        "utf8ToBytes"
      );
      function ko(r6) {
        let e6 = [];
        for (let t6 = 0; t6 < r6.length; ++t6) e6.push(r6.charCodeAt(
          t6
        ) & 255);
        return e6;
      }
      a7(ko, "asciiToBytes");
      function Uo(r6, e6) {
        let t6, n7, i8, s10 = [];
        for (let o9 = 0; o9 < r6.length && !((e6 -= 2) < 0); ++o9) t6 = r6.charCodeAt(o9), n7 = t6 >> 8, i8 = t6 % 256, s10.push(i8), s10.push(n7);
        return s10;
      }
      a7(Uo, "utf16leToBytes");
      function Gn3(r6) {
        return Lt2.toByteArray(Do(r6));
      }
      a7(Gn3, "base64ToBytes");
      function st2(r6, e6, t6, n7) {
        let i8;
        for (i8 = 0; i8 < n7 && !(i8 + t6 >= e6.length || i8 >= r6.length); ++i8)
          e6[i8 + t6] = r6[i8];
        return i8;
      }
      a7(st2, "blitBuffer");
      function ue(r6, e6) {
        return r6 instanceof e6 || r6 != null && r6.constructor != null && r6.constructor.name != null && r6.constructor.name === e6.name;
      }
      a7(ue, "isInstance");
      function Ot2(r6) {
        return r6 !== r6;
      }
      a7(Ot2, "numberIsNaN");
      var Oo = function() {
        let r6 = "0123456789abcdef", e6 = new Array(256);
        for (let t6 = 0; t6 < 16; ++t6) {
          let n7 = t6 * 16;
          for (let i8 = 0; i8 < 16; ++i8) e6[n7 + i8] = r6[t6] + r6[i8];
        }
        return e6;
      }();
      function ge4(r6) {
        return typeof BigInt > "u" ? No : r6;
      }
      a7(ge4, "defineBigIntMethod");
      function No() {
        throw new Error("BigInt not supported");
      }
      a7(No, "BufferBigIntNotDefined");
    });
    p9 = z4(() => {
      "use strict";
      S5 = globalThis, x9 = globalThis.setImmediate ?? ((r6) => setTimeout(
        r6,
        0
      )), v9 = globalThis.clearImmediate ?? ((r6) => clearTimeout(r6)), g8 = globalThis.crypto ?? {};
      g8.subtle ?? (g8.subtle = {});
      y5 = typeof globalThis.Buffer == "function" && typeof globalThis.Buffer.allocUnsafe == "function" ? globalThis.Buffer : $n().Buffer, m10 = globalThis.process ?? {};
      m10.env ?? (m10.env = {});
      try {
        m10.nextTick(() => {
        });
      } catch {
        let e6 = Promise.resolve();
        m10.nextTick = e6.then.bind(e6);
      }
    });
    we3 = I5((Xc, Nt2) => {
      "use strict";
      p9();
      var Re3 = typeof Reflect == "object" ? Reflect : null, Vn3 = Re3 && typeof Re3.apply == "function" ? Re3.apply : a7(function(e6, t6, n7) {
        return Function.prototype.apply.call(e6, t6, n7);
      }, "ReflectApply"), ot2;
      Re3 && typeof Re3.ownKeys == "function" ? ot2 = Re3.ownKeys : Object.getOwnPropertySymbols ? ot2 = a7(function(e6) {
        return Object.getOwnPropertyNames(
          e6
        ).concat(Object.getOwnPropertySymbols(e6));
      }, "ReflectOwnKeys") : ot2 = a7(function(e6) {
        return Object.getOwnPropertyNames(e6);
      }, "ReflectOwnKeys");
      function qo(r6) {
        console && console.warn && console.warn(r6);
      }
      a7(qo, "ProcessEmitWarning");
      var zn2 = Number.isNaN || a7(function(e6) {
        return e6 !== e6;
      }, "NumberIsNaN");
      function L6() {
        L6.init.call(this);
      }
      a7(L6, "EventEmitter");
      Nt2.exports = L6;
      Nt2.exports.once = Ho2;
      L6.EventEmitter = L6;
      L6.prototype._events = void 0;
      L6.prototype._eventsCount = 0;
      L6.prototype._maxListeners = void 0;
      var Kn = 10;
      function at2(r6) {
        if (typeof r6 != "function") throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof r6);
      }
      a7(at2, "checkListener");
      Object.defineProperty(L6, "defaultMaxListeners", { enumerable: true, get: a7(function() {
        return Kn;
      }, "get"), set: a7(function(r6) {
        if (typeof r6 != "number" || r6 < 0 || zn2(r6)) throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + r6 + ".");
        Kn = r6;
      }, "set") });
      L6.init = function() {
        (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
      };
      L6.prototype.setMaxListeners = a7(
        function(e6) {
          if (typeof e6 != "number" || e6 < 0 || zn2(e6)) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + e6 + ".");
          return this._maxListeners = e6, this;
        },
        "setMaxListeners"
      );
      function Yn(r6) {
        return r6._maxListeners === void 0 ? L6.defaultMaxListeners : r6._maxListeners;
      }
      a7(Yn, "_getMaxListeners");
      L6.prototype.getMaxListeners = a7(function() {
        return Yn(this);
      }, "getMaxListeners");
      L6.prototype.emit = a7(function(e6) {
        for (var t6 = [], n7 = 1; n7 < arguments.length; n7++) t6.push(arguments[n7]);
        var i8 = e6 === "error", s10 = this._events;
        if (s10 !== void 0) i8 = i8 && s10.error === void 0;
        else if (!i8) return false;
        if (i8) {
          var o9;
          if (t6.length > 0 && (o9 = t6[0]), o9 instanceof Error) throw o9;
          var u7 = new Error("Unhandled error." + (o9 ? " (" + o9.message + ")" : ""));
          throw u7.context = o9, u7;
        }
        var c6 = s10[e6];
        if (c6 === void 0) return false;
        if (typeof c6 == "function") Vn3(c6, this, t6);
        else for (var h8 = c6.length, l7 = ti(c6, h8), n7 = 0; n7 < h8; ++n7) Vn3(
          l7[n7],
          this,
          t6
        );
        return true;
      }, "emit");
      function Zn(r6, e6, t6, n7) {
        var i8, s10, o9;
        if (at2(t6), s10 = r6._events, s10 === void 0 ? (s10 = r6._events = /* @__PURE__ */ Object.create(null), r6._eventsCount = 0) : (s10.newListener !== void 0 && (r6.emit(
          "newListener",
          e6,
          t6.listener ? t6.listener : t6
        ), s10 = r6._events), o9 = s10[e6]), o9 === void 0) o9 = s10[e6] = t6, ++r6._eventsCount;
        else if (typeof o9 == "function" ? o9 = s10[e6] = n7 ? [t6, o9] : [o9, t6] : n7 ? o9.unshift(
          t6
        ) : o9.push(t6), i8 = Yn(r6), i8 > 0 && o9.length > i8 && !o9.warned) {
          o9.warned = true;
          var u7 = new Error("Possible EventEmitter memory leak detected. " + o9.length + " " + String(e6) + " listeners added. Use emitter.setMaxListeners() to increase limit");
          u7.name = "MaxListenersExceededWarning", u7.emitter = r6, u7.type = e6, u7.count = o9.length, qo(u7);
        }
        return r6;
      }
      a7(Zn, "_addListener");
      L6.prototype.addListener = a7(function(e6, t6) {
        return Zn(this, e6, t6, false);
      }, "addListener");
      L6.prototype.on = L6.prototype.addListener;
      L6.prototype.prependListener = a7(function(e6, t6) {
        return Zn(this, e6, t6, true);
      }, "prependListener");
      function Qo() {
        if (!this.fired) return this.target.removeListener(this.type, this.wrapFn), this.fired = true, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
      }
      a7(
        Qo,
        "onceWrapper"
      );
      function Jn(r6, e6, t6) {
        var n7 = {
          fired: false,
          wrapFn: void 0,
          target: r6,
          type: e6,
          listener: t6
        }, i8 = Qo.bind(n7);
        return i8.listener = t6, n7.wrapFn = i8, i8;
      }
      a7(Jn, "_onceWrap");
      L6.prototype.once = a7(function(e6, t6) {
        return at2(t6), this.on(e6, Jn(this, e6, t6)), this;
      }, "once");
      L6.prototype.prependOnceListener = a7(function(e6, t6) {
        return at2(t6), this.prependListener(e6, Jn(
          this,
          e6,
          t6
        )), this;
      }, "prependOnceListener");
      L6.prototype.removeListener = a7(
        function(e6, t6) {
          var n7, i8, s10, o9, u7;
          if (at2(t6), i8 = this._events, i8 === void 0) return this;
          if (n7 = i8[e6], n7 === void 0) return this;
          if (n7 === t6 || n7.listener === t6) --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i8[e6], i8.removeListener && this.emit("removeListener", e6, n7.listener || t6));
          else if (typeof n7 != "function") {
            for (s10 = -1, o9 = n7.length - 1; o9 >= 0; o9--) if (n7[o9] === t6 || n7[o9].listener === t6) {
              u7 = n7[o9].listener, s10 = o9;
              break;
            }
            if (s10 < 0) return this;
            s10 === 0 ? n7.shift() : Wo(n7, s10), n7.length === 1 && (i8[e6] = n7[0]), i8.removeListener !== void 0 && this.emit("removeListener", e6, u7 || t6);
          }
          return this;
        },
        "removeListener"
      );
      L6.prototype.off = L6.prototype.removeListener;
      L6.prototype.removeAllListeners = a7(function(e6) {
        var t6, n7, i8;
        if (n7 = this._events, n7 === void 0) return this;
        if (n7.removeListener === void 0) return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : n7[e6] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete n7[e6]), this;
        if (arguments.length === 0) {
          var s10 = Object.keys(n7), o9;
          for (i8 = 0; i8 < s10.length; ++i8) o9 = s10[i8], o9 !== "removeListener" && this.removeAllListeners(o9);
          return this.removeAllListeners(
            "removeListener"
          ), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
        }
        if (t6 = n7[e6], typeof t6 == "function") this.removeListener(e6, t6);
        else if (t6 !== void 0) for (i8 = t6.length - 1; i8 >= 0; i8--) this.removeListener(e6, t6[i8]);
        return this;
      }, "removeAllListeners");
      function Xn(r6, e6, t6) {
        var n7 = r6._events;
        if (n7 === void 0) return [];
        var i8 = n7[e6];
        return i8 === void 0 ? [] : typeof i8 == "function" ? t6 ? [i8.listener || i8] : [i8] : t6 ? jo(i8) : ti(i8, i8.length);
      }
      a7(Xn, "_listeners");
      L6.prototype.listeners = a7(function(e6) {
        return Xn(this, e6, true);
      }, "listeners");
      L6.prototype.rawListeners = a7(function(e6) {
        return Xn(this, e6, false);
      }, "rawListeners");
      L6.listenerCount = function(r6, e6) {
        return typeof r6.listenerCount == "function" ? r6.listenerCount(e6) : ei.call(r6, e6);
      };
      L6.prototype.listenerCount = ei;
      function ei(r6) {
        var e6 = this._events;
        if (e6 !== void 0) {
          var t6 = e6[r6];
          if (typeof t6 == "function") return 1;
          if (t6 !== void 0) return t6.length;
        }
        return 0;
      }
      a7(ei, "listenerCount");
      L6.prototype.eventNames = a7(function() {
        return this._eventsCount > 0 ? ot2(this._events) : [];
      }, "eventNames");
      function ti(r6, e6) {
        for (var t6 = new Array(e6), n7 = 0; n7 < e6; ++n7) t6[n7] = r6[n7];
        return t6;
      }
      a7(ti, "arrayClone");
      function Wo(r6, e6) {
        for (; e6 + 1 < r6.length; e6++) r6[e6] = r6[e6 + 1];
        r6.pop();
      }
      a7(Wo, "spliceOne");
      function jo(r6) {
        for (var e6 = new Array(r6.length), t6 = 0; t6 < e6.length; ++t6)
          e6[t6] = r6[t6].listener || r6[t6];
        return e6;
      }
      a7(jo, "unwrapListeners");
      function Ho2(r6, e6) {
        return new Promise(
          function(t6, n7) {
            function i8(o9) {
              r6.removeListener(e6, s10), n7(o9);
            }
            a7(i8, "errorListener");
            function s10() {
              typeof r6.removeListener == "function" && r6.removeListener("error", i8), t6([].slice.call(
                arguments
              ));
            }
            a7(s10, "resolver"), ri2(r6, e6, s10, { once: true }), e6 !== "error" && Go2(r6, i8, { once: true });
          }
        );
      }
      a7(Ho2, "once");
      function Go2(r6, e6, t6) {
        typeof r6.on == "function" && ri2(r6, "error", e6, t6);
      }
      a7(
        Go2,
        "addErrorHandlerIfEventEmitter"
      );
      function ri2(r6, e6, t6, n7) {
        if (typeof r6.on == "function")
          n7.once ? r6.once(e6, t6) : r6.on(e6, t6);
        else if (typeof r6.addEventListener == "function") r6.addEventListener(
          e6,
          a7(function i8(s10) {
            n7.once && r6.removeEventListener(e6, i8), t6(s10);
          }, "wrapListener")
        );
        else
          throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof r6);
      }
      a7(ri2, "eventTargetAgnosticAddListener");
    });
    je2 = {};
    ie2(je2, { default: () => $o2 });
    He3 = z4(() => {
      "use strict";
      p9();
      $o2 = {};
    });
    ni2 = z4(
      () => {
        "use strict";
        p9();
        a7(Ge3, "sha256");
      }
    );
    ii = z4(() => {
      "use strict";
      p9();
      O5 = class O6 {
        constructor() {
          _5(
            this,
            "_dataLength",
            0
          );
          _5(this, "_bufferLength", 0);
          _5(this, "_state", new Int32Array(4));
          _5(
            this,
            "_buffer",
            new ArrayBuffer(68)
          );
          _5(this, "_buffer8");
          _5(this, "_buffer32");
          this._buffer8 = new Uint8Array(
            this._buffer,
            0,
            68
          ), this._buffer32 = new Uint32Array(this._buffer, 0, 17), this.start();
        }
        static hashByteArray(e6, t6 = false) {
          return this.onePassHasher.start().appendByteArray(e6).end(t6);
        }
        static hashStr(e6, t6 = false) {
          return this.onePassHasher.start().appendStr(e6).end(t6);
        }
        static hashAsciiStr(e6, t6 = false) {
          return this.onePassHasher.start().appendAsciiStr(e6).end(t6);
        }
        static _hex(e6) {
          let t6 = O6.hexChars, n7 = O6.hexOut, i8, s10, o9, u7;
          for (u7 = 0; u7 < 4; u7 += 1) for (s10 = u7 * 8, i8 = e6[u7], o9 = 0; o9 < 8; o9 += 2) n7[s10 + 1 + o9] = t6.charAt(i8 & 15), i8 >>>= 4, n7[s10 + 0 + o9] = t6.charAt(i8 & 15), i8 >>>= 4;
          return n7.join("");
        }
        static _md5cycle(e6, t6) {
          let n7 = e6[0], i8 = e6[1], s10 = e6[2], o9 = e6[3];
          n7 += (i8 & s10 | ~i8 & o9) + t6[0] - 680876936 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[1] - 389564586 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[2] + 606105819 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[3] - 1044525330 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[4] - 176418897 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[5] + 1200080426 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[6] - 1473231341 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[7] - 45705983 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[8] + 1770035416 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[9] - 1958414417 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[10] - 42063 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[11] - 1990404162 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[12] + 1804603682 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[13] - 40341101 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[14] - 1502002290 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[15] + 1236535329 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[1] - 165796510 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[6] - 1069501632 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[11] + 643717713 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[0] - 373897302 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[5] - 701558691 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[10] + 38016083 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[15] - 660478335 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[4] - 405537848 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[9] + 568446438 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[14] - 1019803690 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[3] - 187363961 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[8] + 1163531501 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[13] - 1444681467 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[2] - 51403784 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[7] + 1735328473 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[12] - 1926607734 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[5] - 378558 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[8] - 2022574463 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[11] + 1839030562 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[14] - 35309556 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[1] - 1530992060 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[4] + 1272893353 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[7] - 155497632 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[10] - 1094730640 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[13] + 681279174 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[0] - 358537222 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[3] - 722521979 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[6] + 76029189 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[9] - 640364487 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[12] - 421815835 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[15] + 530742520 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[2] - 995338651 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[0] - 198630844 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[7] + 1126891415 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[14] - 1416354905 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[5] - 57434055 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[12] + 1700485571 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[3] - 1894986606 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[10] - 1051523 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[1] - 2054922799 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[8] + 1873313359 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[15] - 30611744 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[6] - 1560198380 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[13] + 1309151649 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[4] - 145523070 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[11] - 1120210379 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[2] + 718787259 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[9] - 343485551 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, e6[0] = n7 + e6[0] | 0, e6[1] = i8 + e6[1] | 0, e6[2] = s10 + e6[2] | 0, e6[3] = o9 + e6[3] | 0;
        }
        start() {
          return this._dataLength = 0, this._bufferLength = 0, this._state.set(O6.stateIdentity), this;
        }
        appendStr(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9;
          for (o9 = 0; o9 < e6.length; o9 += 1) {
            if (s10 = e6.charCodeAt(o9), s10 < 128) t6[i8++] = s10;
            else if (s10 < 2048) t6[i8++] = (s10 >>> 6) + 192, t6[i8++] = s10 & 63 | 128;
            else if (s10 < 55296 || s10 > 56319) t6[i8++] = (s10 >>> 12) + 224, t6[i8++] = s10 >>> 6 & 63 | 128, t6[i8++] = s10 & 63 | 128;
            else {
              if (s10 = (s10 - 55296) * 1024 + (e6.charCodeAt(++o9) - 56320) + 65536, s10 > 1114111) throw new Error("Unicode standard supports code points up to U+10FFFF");
              t6[i8++] = (s10 >>> 18) + 240, t6[i8++] = s10 >>> 12 & 63 | 128, t6[i8++] = s10 >>> 6 & 63 | 128, t6[i8++] = s10 & 63 | 128;
            }
            i8 >= 64 && (this._dataLength += 64, O6._md5cycle(this._state, n7), i8 -= 64, n7[0] = n7[16]);
          }
          return this._bufferLength = i8, this;
        }
        appendAsciiStr(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9 = 0;
          for (; ; ) {
            for (s10 = Math.min(e6.length - o9, 64 - i8); s10--; ) t6[i8++] = e6.charCodeAt(o9++);
            if (i8 < 64) break;
            this._dataLength += 64, O6._md5cycle(
              this._state,
              n7
            ), i8 = 0;
          }
          return this._bufferLength = i8, this;
        }
        appendByteArray(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9 = 0;
          for (; ; ) {
            for (s10 = Math.min(e6.length - o9, 64 - i8); s10--; ) t6[i8++] = e6[o9++];
            if (i8 < 64) break;
            this._dataLength += 64, O6._md5cycle(
              this._state,
              n7
            ), i8 = 0;
          }
          return this._bufferLength = i8, this;
        }
        getState() {
          let e6 = this._state;
          return { buffer: String.fromCharCode.apply(null, Array.from(this._buffer8)), buflen: this._bufferLength, length: this._dataLength, state: [e6[0], e6[1], e6[2], e6[3]] };
        }
        setState(e6) {
          let t6 = e6.buffer, n7 = e6.state, i8 = this._state, s10;
          for (this._dataLength = e6.length, this._bufferLength = e6.buflen, i8[0] = n7[0], i8[1] = n7[1], i8[2] = n7[2], i8[3] = n7[3], s10 = 0; s10 < t6.length; s10 += 1) this._buffer8[s10] = t6.charCodeAt(s10);
        }
        end(e6 = false) {
          let t6 = this._bufferLength, n7 = this._buffer8, i8 = this._buffer32, s10 = (t6 >> 2) + 1;
          this._dataLength += t6;
          let o9 = this._dataLength * 8;
          if (n7[t6] = 128, n7[t6 + 1] = n7[t6 + 2] = n7[t6 + 3] = 0, i8.set(O6.buffer32Identity.subarray(s10), s10), t6 > 55 && (O6._md5cycle(this._state, i8), i8.set(O6.buffer32Identity)), o9 <= 4294967295)
            i8[14] = o9;
          else {
            let u7 = o9.toString(16).match(/(.*?)(.{0,8})$/);
            if (u7 === null) return;
            let c6 = parseInt(
              u7[2],
              16
            ), h8 = parseInt(u7[1], 16) || 0;
            i8[14] = c6, i8[15] = h8;
          }
          return O6._md5cycle(this._state, i8), e6 ? this._state : O6._hex(this._state);
        }
      };
      a7(O5, "Md5"), _5(O5, "stateIdentity", new Int32Array(
        [1732584193, -271733879, -1732584194, 271733878]
      )), _5(O5, "buffer32Identity", new Int32Array(
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      )), _5(O5, "hexChars", "0123456789abcdef"), _5(O5, "hexOut", []), _5(O5, "onePassHasher", new O5());
      $e3 = O5;
    });
    qt3 = {};
    ie2(qt3, { createHash: () => Ko2, createHmac: () => zo, randomBytes: () => Vo });
    Qt3 = z4(() => {
      "use strict";
      p9();
      ni2();
      ii();
      a7(Vo, "randomBytes");
      a7(Ko2, "createHash");
      a7(zo, "createHmac");
    });
    jt2 = I5((si2) => {
      "use strict";
      p9();
      si2.parse = function(r6, e6) {
        return new Wt4(r6, e6).parse();
      };
      var ut2 = class ut3 {
        constructor(e6, t6) {
          this.source = e6, this.transform = t6 || Yo2, this.position = 0, this.entries = [], this.recorded = [], this.dimension = 0;
        }
        isEof() {
          return this.position >= this.source.length;
        }
        nextCharacter() {
          var e6 = this.source[this.position++];
          return e6 === "\\" ? { value: this.source[this.position++], escaped: true } : { value: e6, escaped: false };
        }
        record(e6) {
          this.recorded.push(e6);
        }
        newEntry(e6) {
          var t6;
          (this.recorded.length > 0 || e6) && (t6 = this.recorded.join(""), t6 === "NULL" && !e6 && (t6 = null), t6 !== null && (t6 = this.transform(t6)), this.entries.push(
            t6
          ), this.recorded = []);
        }
        consumeDimensions() {
          if (this.source[0] === "[") for (; !this.isEof(); ) {
            var e6 = this.nextCharacter();
            if (e6.value === "=") break;
          }
        }
        parse(e6) {
          var t6, n7, i8;
          for (this.consumeDimensions(); !this.isEof(); ) if (t6 = this.nextCharacter(), t6.value === "{" && !i8) this.dimension++, this.dimension > 1 && (n7 = new ut3(this.source.substr(this.position - 1), this.transform), this.entries.push(
            n7.parse(true)
          ), this.position += n7.position - 2);
          else if (t6.value === "}" && !i8) {
            if (this.dimension--, !this.dimension && (this.newEntry(), e6)) return this.entries;
          } else t6.value === '"' && !t6.escaped ? (i8 && this.newEntry(true), i8 = !i8) : t6.value === "," && !i8 ? this.newEntry() : this.record(
            t6.value
          );
          if (this.dimension !== 0) throw new Error("array dimension not balanced");
          return this.entries;
        }
      };
      a7(ut2, "ArrayParser");
      var Wt4 = ut2;
      function Yo2(r6) {
        return r6;
      }
      a7(Yo2, "identity");
    });
    Ht2 = I5((mh, oi) => {
      p9();
      var Zo2 = jt2();
      oi.exports = { create: a7(function(r6, e6) {
        return { parse: a7(
          function() {
            return Zo2.parse(r6, e6);
          },
          "parse"
        ) };
      }, "create") };
    });
    ci = I5((bh, ui2) => {
      "use strict";
      p9();
      var Jo = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/, Xo = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/, ea = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/, ta = /^-?infinity$/;
      ui2.exports = a7(function(e6) {
        if (ta.test(e6)) return Number(e6.replace("i", "I"));
        var t6 = Jo.exec(e6);
        if (!t6) return ra(e6) || null;
        var n7 = !!t6[8], i8 = parseInt(t6[1], 10);
        n7 && (i8 = ai(i8));
        var s10 = parseInt(
          t6[2],
          10
        ) - 1, o9 = t6[3], u7 = parseInt(t6[4], 10), c6 = parseInt(t6[5], 10), h8 = parseInt(t6[6], 10), l7 = t6[7];
        l7 = l7 ? 1e3 * parseFloat(l7) : 0;
        var d7, b9 = na(e6);
        return b9 != null ? (d7 = new Date(Date.UTC(
          i8,
          s10,
          o9,
          u7,
          c6,
          h8,
          l7
        )), Gt3(i8) && d7.setUTCFullYear(i8), b9 !== 0 && d7.setTime(d7.getTime() - b9)) : (d7 = new Date(
          i8,
          s10,
          o9,
          u7,
          c6,
          h8,
          l7
        ), Gt3(i8) && d7.setFullYear(i8)), d7;
      }, "parseDate");
      function ra(r6) {
        var e6 = Xo.exec(r6);
        if (e6) {
          var t6 = parseInt(e6[1], 10), n7 = !!e6[4];
          n7 && (t6 = ai(t6));
          var i8 = parseInt(
            e6[2],
            10
          ) - 1, s10 = e6[3], o9 = new Date(t6, i8, s10);
          return Gt3(t6) && o9.setFullYear(t6), o9;
        }
      }
      a7(ra, "getDate");
      function na(r6) {
        if (r6.endsWith("+00")) return 0;
        var e6 = ea.exec(r6.split(" ")[1]);
        if (e6) {
          var t6 = e6[1];
          if (t6 === "Z") return 0;
          var n7 = t6 === "-" ? -1 : 1, i8 = parseInt(e6[2], 10) * 3600 + parseInt(
            e6[3] || 0,
            10
          ) * 60 + parseInt(e6[4] || 0, 10);
          return i8 * n7 * 1e3;
        }
      }
      a7(na, "timeZoneOffset");
      function ai(r6) {
        return -(r6 - 1);
      }
      a7(ai, "bcYearToNegativeYear");
      function Gt3(r6) {
        return r6 >= 0 && r6 < 100;
      }
      a7(
        Gt3,
        "is0To99"
      );
    });
    li = I5((vh, hi3) => {
      p9();
      hi3.exports = sa;
      var ia = Object.prototype.hasOwnProperty;
      function sa(r6) {
        for (var e6 = 1; e6 < arguments.length; e6++) {
          var t6 = arguments[e6];
          for (var n7 in t6) ia.call(
            t6,
            n7
          ) && (r6[n7] = t6[n7]);
        }
        return r6;
      }
      a7(sa, "extend");
    });
    di = I5((Ah, pi2) => {
      "use strict";
      p9();
      var oa = li();
      pi2.exports = Fe2;
      function Fe2(r6) {
        if (!(this instanceof Fe2)) return new Fe2(r6);
        oa(this, wa(r6));
      }
      a7(Fe2, "PostgresInterval");
      var aa = ["seconds", "minutes", "hours", "days", "months", "years"];
      Fe2.prototype.toPostgres = function() {
        var r6 = aa.filter(this.hasOwnProperty, this);
        return this.milliseconds && r6.indexOf("seconds") < 0 && r6.push("seconds"), r6.length === 0 ? "0" : r6.map(function(e6) {
          var t6 = this[e6] || 0;
          return e6 === "seconds" && this.milliseconds && (t6 = (t6 + this.milliseconds / 1e3).toFixed(6).replace(
            /\.?0+$/,
            ""
          )), t6 + " " + e6;
        }, this).join(" ");
      };
      var ua = { years: "Y", months: "M", days: "D", hours: "H", minutes: "M", seconds: "S" }, ca = ["years", "months", "days"], ha = ["hours", "minutes", "seconds"];
      Fe2.prototype.toISOString = Fe2.prototype.toISO = function() {
        var r6 = ca.map(t6, this).join(""), e6 = ha.map(t6, this).join("");
        return "P" + r6 + "T" + e6;
        function t6(n7) {
          var i8 = this[n7] || 0;
          return n7 === "seconds" && this.milliseconds && (i8 = (i8 + this.milliseconds / 1e3).toFixed(6).replace(
            /0+$/,
            ""
          )), i8 + ua[n7];
        }
      };
      var $t3 = "([+-]?\\d+)", la = $t3 + "\\s+years?", fa = $t3 + "\\s+mons?", pa = $t3 + "\\s+days?", da = "([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?", ya = new RegExp([
        la,
        fa,
        pa,
        da
      ].map(function(r6) {
        return "(" + r6 + ")?";
      }).join("\\s*")), fi2 = {
        years: 2,
        months: 4,
        days: 6,
        hours: 9,
        minutes: 10,
        seconds: 11,
        milliseconds: 12
      }, ma = ["hours", "minutes", "seconds", "milliseconds"];
      function ga(r6) {
        var e6 = r6 + "000000".slice(r6.length);
        return parseInt(
          e6,
          10
        ) / 1e3;
      }
      a7(ga, "parseMilliseconds");
      function wa(r6) {
        if (!r6) return {};
        var e6 = ya.exec(
          r6
        ), t6 = e6[8] === "-";
        return Object.keys(fi2).reduce(function(n7, i8) {
          var s10 = fi2[i8], o9 = e6[s10];
          return !o9 || (o9 = i8 === "milliseconds" ? ga(o9) : parseInt(o9, 10), !o9) || (t6 && ~ma.indexOf(i8) && (o9 *= -1), n7[i8] = o9), n7;
        }, {});
      }
      a7(wa, "parse");
    });
    mi = I5((Ih, yi3) => {
      "use strict";
      p9();
      yi3.exports = a7(function(e6) {
        if (/^\\x/.test(e6)) return new y5(
          e6.substr(2),
          "hex"
        );
        for (var t6 = "", n7 = 0; n7 < e6.length; ) if (e6[n7] !== "\\") t6 += e6[n7], ++n7;
        else if (/[0-7]{3}/.test(e6.substr(n7 + 1, 3))) t6 += String.fromCharCode(parseInt(e6.substr(n7 + 1, 3), 8)), n7 += 4;
        else {
          for (var i8 = 1; n7 + i8 < e6.length && e6[n7 + i8] === "\\"; ) i8++;
          for (var s10 = 0; s10 < Math.floor(i8 / 2); ++s10) t6 += "\\";
          n7 += Math.floor(i8 / 2) * 2;
        }
        return new y5(t6, "binary");
      }, "parseBytea");
    });
    Ei2 = I5((Lh, vi) => {
      p9();
      var Ve3 = jt2(), Ke3 = Ht2(), ct2 = ci(), wi = di(), bi = mi();
      function ht2(r6) {
        return a7(function(t6) {
          return t6 === null ? t6 : r6(t6);
        }, "nullAllowed");
      }
      a7(ht2, "allowNull");
      function Si(r6) {
        return r6 === null ? r6 : r6 === "TRUE" || r6 === "t" || r6 === "true" || r6 === "y" || r6 === "yes" || r6 === "on" || r6 === "1";
      }
      a7(Si, "parseBool");
      function ba(r6) {
        return r6 ? Ve3.parse(r6, Si) : null;
      }
      a7(ba, "parseBoolArray");
      function Sa(r6) {
        return parseInt(r6, 10);
      }
      a7(Sa, "parseBaseTenInt");
      function Vt2(r6) {
        return r6 ? Ve3.parse(r6, ht2(Sa)) : null;
      }
      a7(Vt2, "parseIntegerArray");
      function xa(r6) {
        return r6 ? Ve3.parse(r6, ht2(function(e6) {
          return xi(e6).trim();
        })) : null;
      }
      a7(xa, "parseBigIntegerArray");
      var va = a7(function(r6) {
        if (!r6) return null;
        var e6 = Ke3.create(r6, function(t6) {
          return t6 !== null && (t6 = Zt2(t6)), t6;
        });
        return e6.parse();
      }, "parsePointArray"), Kt2 = a7(function(r6) {
        if (!r6)
          return null;
        var e6 = Ke3.create(r6, function(t6) {
          return t6 !== null && (t6 = parseFloat(t6)), t6;
        });
        return e6.parse();
      }, "parseFloatArray"), re3 = a7(function(r6) {
        if (!r6) return null;
        var e6 = Ke3.create(r6);
        return e6.parse();
      }, "parseStringArray"), zt2 = a7(function(r6) {
        if (!r6) return null;
        var e6 = Ke3.create(r6, function(t6) {
          return t6 !== null && (t6 = ct2(t6)), t6;
        });
        return e6.parse();
      }, "parseDateArray"), Ea = a7(function(r6) {
        if (!r6) return null;
        var e6 = Ke3.create(r6, function(t6) {
          return t6 !== null && (t6 = wi(t6)), t6;
        });
        return e6.parse();
      }, "parseIntervalArray"), _a506 = a7(function(r6) {
        return r6 ? Ve3.parse(r6, ht2(bi)) : null;
      }, "parseByteAArray"), Yt2 = a7(function(r6) {
        return parseInt(
          r6,
          10
        );
      }, "parseInteger"), xi = a7(function(r6) {
        var e6 = String(r6);
        return /^\d+$/.test(e6) ? e6 : r6;
      }, "parseBigInteger"), gi2 = a7(
        function(r6) {
          return r6 ? Ve3.parse(r6, ht2(JSON.parse)) : null;
        },
        "parseJsonArray"
      ), Zt2 = a7(function(r6) {
        return r6[0] !== "(" ? null : (r6 = r6.substring(1, r6.length - 1).split(","), { x: parseFloat(r6[0]), y: parseFloat(r6[1]) });
      }, "parsePoint"), Aa = a7(function(r6) {
        if (r6[0] !== "<" && r6[1] !== "(") return null;
        for (var e6 = "(", t6 = "", n7 = false, i8 = 2; i8 < r6.length - 1; i8++) {
          if (n7 || (e6 += r6[i8]), r6[i8] === ")") {
            n7 = true;
            continue;
          } else if (!n7) continue;
          r6[i8] !== "," && (t6 += r6[i8]);
        }
        var s10 = Zt2(e6);
        return s10.radius = parseFloat(t6), s10;
      }, "parseCircle"), Ca = a7(function(r6) {
        r6(
          20,
          xi
        ), r6(21, Yt2), r6(23, Yt2), r6(26, Yt2), r6(700, parseFloat), r6(701, parseFloat), r6(16, Si), r6(
          1082,
          ct2
        ), r6(1114, ct2), r6(1184, ct2), r6(600, Zt2), r6(651, re3), r6(718, Aa), r6(1e3, ba), r6(1001, _a506), r6(
          1005,
          Vt2
        ), r6(1007, Vt2), r6(1028, Vt2), r6(1016, xa), r6(1017, va), r6(1021, Kt2), r6(1022, Kt2), r6(1231, Kt2), r6(1014, re3), r6(1015, re3), r6(1008, re3), r6(1009, re3), r6(1040, re3), r6(1041, re3), r6(1115, zt2), r6(
          1182,
          zt2
        ), r6(1185, zt2), r6(1186, wi), r6(1187, Ea), r6(17, bi), r6(114, JSON.parse.bind(JSON)), r6(
          3802,
          JSON.parse.bind(JSON)
        ), r6(199, gi2), r6(3807, gi2), r6(3907, re3), r6(2951, re3), r6(791, re3), r6(
          1183,
          re3
        ), r6(1270, re3);
      }, "init");
      vi.exports = { init: Ca };
    });
    Ai = I5((Mh, _i4) => {
      "use strict";
      p9();
      var Z4 = 1e6;
      function Ta(r6) {
        var e6 = r6.readInt32BE(
          0
        ), t6 = r6.readUInt32BE(4), n7 = "";
        e6 < 0 && (e6 = ~e6 + (t6 === 0), t6 = ~t6 + 1 >>> 0, n7 = "-");
        var i8 = "", s10, o9, u7, c6, h8, l7;
        {
          if (s10 = e6 % Z4, e6 = e6 / Z4 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Z4 >>> 0, u7 = "" + (o9 - Z4 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        {
          if (s10 = e6 % Z4, e6 = e6 / Z4 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Z4 >>> 0, u7 = "" + (o9 - Z4 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        {
          if (s10 = e6 % Z4, e6 = e6 / Z4 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Z4 >>> 0, u7 = "" + (o9 - Z4 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        return s10 = e6 % Z4, o9 = 4294967296 * s10 + t6, u7 = "" + o9 % Z4, n7 + u7 + i8;
      }
      a7(Ta, "readInt8");
      _i4.exports = Ta;
    });
    Bi = I5((Uh, Pi2) => {
      p9();
      var Ia = Ai(), F6 = a7(function(r6, e6, t6, n7, i8) {
        t6 = t6 || 0, n7 = n7 || false, i8 = i8 || function(C6, B3, W4) {
          return C6 * Math.pow(2, W4) + B3;
        };
        var s10 = t6 >> 3, o9 = a7(function(C6) {
          return n7 ? ~C6 & 255 : C6;
        }, "inv"), u7 = 255, c6 = 8 - t6 % 8;
        e6 < c6 && (u7 = 255 << 8 - e6 & 255, c6 = e6), t6 && (u7 = u7 >> t6 % 8);
        var h8 = 0;
        t6 % 8 + e6 >= 8 && (h8 = i8(0, o9(r6[s10]) & u7, c6));
        for (var l7 = e6 + t6 >> 3, d7 = s10 + 1; d7 < l7; d7++) h8 = i8(h8, o9(r6[d7]), 8);
        var b9 = (e6 + t6) % 8;
        return b9 > 0 && (h8 = i8(h8, o9(r6[l7]) >> 8 - b9, b9)), h8;
      }, "parseBits"), Ii = a7(function(r6, e6, t6) {
        var n7 = Math.pow(2, t6 - 1) - 1, i8 = F6(r6, 1), s10 = F6(r6, t6, 1);
        if (s10 === 0) return 0;
        var o9 = 1, u7 = a7(function(h8, l7, d7) {
          h8 === 0 && (h8 = 1);
          for (var b9 = 1; b9 <= d7; b9++) o9 /= 2, (l7 & 1 << d7 - b9) > 0 && (h8 += o9);
          return h8;
        }, "parsePrecisionBits"), c6 = F6(r6, e6, t6 + 1, false, u7);
        return s10 == Math.pow(2, t6 + 1) - 1 ? c6 === 0 ? i8 === 0 ? 1 / 0 : -1 / 0 : NaN : (i8 === 0 ? 1 : -1) * Math.pow(2, s10 - n7) * c6;
      }, "parseFloatFromBits"), Pa = a7(function(r6) {
        return F6(r6, 1) == 1 ? -1 * (F6(r6, 15, 1, true) + 1) : F6(r6, 15, 1);
      }, "parseInt16"), Ci2 = a7(function(r6) {
        return F6(r6, 1) == 1 ? -1 * (F6(
          r6,
          31,
          1,
          true
        ) + 1) : F6(r6, 31, 1);
      }, "parseInt32"), Ba = a7(function(r6) {
        return Ii(r6, 23, 8);
      }, "parseFloat32"), La = a7(function(r6) {
        return Ii(r6, 52, 11);
      }, "parseFloat64"), Ra = a7(function(r6) {
        var e6 = F6(r6, 16, 32);
        if (e6 == 49152) return NaN;
        for (var t6 = Math.pow(1e4, F6(r6, 16, 16)), n7 = 0, i8 = [], s10 = F6(r6, 16), o9 = 0; o9 < s10; o9++) n7 += F6(r6, 16, 64 + 16 * o9) * t6, t6 /= 1e4;
        var u7 = Math.pow(10, F6(r6, 16, 48));
        return (e6 === 0 ? 1 : -1) * Math.round(n7 * u7) / u7;
      }, "parseNumeric"), Ti = a7(function(r6, e6) {
        var t6 = F6(
          e6,
          1
        ), n7 = F6(e6, 63, 1), i8 = new Date((t6 === 0 ? 1 : -1) * n7 / 1e3 + 9466848e5);
        return r6 || i8.setTime(i8.getTime() + i8.getTimezoneOffset() * 6e4), i8.usec = n7 % 1e3, i8.getMicroSeconds = function() {
          return this.usec;
        }, i8.setMicroSeconds = function(s10) {
          this.usec = s10;
        }, i8.getUTCMicroSeconds = function() {
          return this.usec;
        }, i8;
      }, "parseDate"), ze2 = a7(function(r6) {
        for (var e6 = F6(r6, 32), t6 = F6(r6, 32, 32), n7 = F6(r6, 32, 64), i8 = 96, s10 = [], o9 = 0; o9 < e6; o9++) s10[o9] = F6(r6, 32, i8), i8 += 32, i8 += 32;
        var u7 = a7(function(h8) {
          var l7 = F6(r6, 32, i8);
          if (i8 += 32, l7 == 4294967295) return null;
          var d7;
          if (h8 == 23 || h8 == 20) return d7 = F6(r6, l7 * 8, i8), i8 += l7 * 8, d7;
          if (h8 == 25) return d7 = r6.toString(this.encoding, i8 >> 3, (i8 += l7 << 3) >> 3), d7;
          console.log("ERROR: ElementType not implemented: " + h8);
        }, "parseElement"), c6 = a7(function(h8, l7) {
          var d7 = [], b9;
          if (h8.length > 1) {
            var C6 = h8.shift();
            for (b9 = 0; b9 < C6; b9++) d7[b9] = c6(h8, l7);
            h8.unshift(
              C6
            );
          } else for (b9 = 0; b9 < h8[0]; b9++) d7[b9] = u7(l7);
          return d7;
        }, "parse");
        return c6(s10, n7);
      }, "parseArray"), Fa = a7(function(r6) {
        return r6.toString("utf8");
      }, "parseText"), Ma = a7(function(r6) {
        return r6 === null ? null : F6(r6, 8) > 0;
      }, "parseBool"), Da = a7(function(r6) {
        r6(20, Ia), r6(21, Pa), r6(23, Ci2), r6(
          26,
          Ci2
        ), r6(1700, Ra), r6(700, Ba), r6(701, La), r6(16, Ma), r6(1114, Ti.bind(null, false)), r6(1184, Ti.bind(
          null,
          true
        )), r6(1e3, ze2), r6(1007, ze2), r6(1016, ze2), r6(1008, ze2), r6(1009, ze2), r6(25, Fa);
      }, "init");
      Pi2.exports = { init: Da };
    });
    Ri = I5((qh, Li3) => {
      p9();
      Li3.exports = {
        BOOL: 16,
        BYTEA: 17,
        CHAR: 18,
        INT8: 20,
        INT2: 21,
        INT4: 23,
        REGPROC: 24,
        TEXT: 25,
        OID: 26,
        TID: 27,
        XID: 28,
        CID: 29,
        JSON: 114,
        XML: 142,
        PG_NODE_TREE: 194,
        SMGR: 210,
        PATH: 602,
        POLYGON: 604,
        CIDR: 650,
        FLOAT4: 700,
        FLOAT8: 701,
        ABSTIME: 702,
        RELTIME: 703,
        TINTERVAL: 704,
        CIRCLE: 718,
        MACADDR8: 774,
        MONEY: 790,
        MACADDR: 829,
        INET: 869,
        ACLITEM: 1033,
        BPCHAR: 1042,
        VARCHAR: 1043,
        DATE: 1082,
        TIME: 1083,
        TIMESTAMP: 1114,
        TIMESTAMPTZ: 1184,
        INTERVAL: 1186,
        TIMETZ: 1266,
        BIT: 1560,
        VARBIT: 1562,
        NUMERIC: 1700,
        REFCURSOR: 1790,
        REGPROCEDURE: 2202,
        REGOPER: 2203,
        REGOPERATOR: 2204,
        REGCLASS: 2205,
        REGTYPE: 2206,
        UUID: 2950,
        TXID_SNAPSHOT: 2970,
        PG_LSN: 3220,
        PG_NDISTINCT: 3361,
        PG_DEPENDENCIES: 3402,
        TSVECTOR: 3614,
        TSQUERY: 3615,
        GTSVECTOR: 3642,
        REGCONFIG: 3734,
        REGDICTIONARY: 3769,
        JSONB: 3802,
        REGNAMESPACE: 4089,
        REGROLE: 4096
      };
    });
    Je2 = I5((Ze2) => {
      p9();
      var ka = Ei2(), Ua = Bi(), Oa = Ht2(), Na = Ri();
      Ze2.getTypeParser = qa;
      Ze2.setTypeParser = Qa;
      Ze2.arrayParser = Oa;
      Ze2.builtins = Na;
      var Ye2 = { text: {}, binary: {} };
      function Fi2(r6) {
        return String(
          r6
        );
      }
      a7(Fi2, "noParse");
      function qa(r6, e6) {
        return e6 = e6 || "text", Ye2[e6] && Ye2[e6][r6] || Fi2;
      }
      a7(
        qa,
        "getTypeParser"
      );
      function Qa(r6, e6, t6) {
        typeof e6 == "function" && (t6 = e6, e6 = "text"), Ye2[e6][r6] = t6;
      }
      a7(Qa, "setTypeParser");
      ka.init(function(r6, e6) {
        Ye2.text[r6] = e6;
      });
      Ua.init(function(r6, e6) {
        Ye2.binary[r6] = e6;
      });
    });
    Xe3 = I5((Gh, Jt2) => {
      "use strict";
      p9();
      Jt2.exports = {
        host: "localhost",
        user: m10.platform === "win32" ? m10.env.USERNAME : m10.env.USER,
        database: void 0,
        password: null,
        connectionString: void 0,
        port: 5432,
        rows: 0,
        binary: false,
        max: 10,
        idleTimeoutMillis: 3e4,
        client_encoding: "",
        ssl: false,
        application_name: void 0,
        fallback_application_name: void 0,
        options: void 0,
        parseInputDatesAsUTC: false,
        statement_timeout: false,
        lock_timeout: false,
        idle_in_transaction_session_timeout: false,
        query_timeout: false,
        connect_timeout: 0,
        keepalives: 1,
        keepalives_idle: 0
      };
      var Me2 = Je2(), Wa = Me2.getTypeParser(
        20,
        "text"
      ), ja = Me2.getTypeParser(1016, "text");
      Jt2.exports.__defineSetter__("parseInt8", function(r6) {
        Me2.setTypeParser(20, "text", r6 ? Me2.getTypeParser(23, "text") : Wa), Me2.setTypeParser(1016, "text", r6 ? Me2.getTypeParser(1007, "text") : ja);
      });
    });
    et3 = I5((Vh, Di) => {
      "use strict";
      p9();
      var Ha = (Qt3(), N3(qt3)), Ga = Xe3();
      function $a(r6) {
        var e6 = r6.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
        return '"' + e6 + '"';
      }
      a7($a, "escapeElement");
      function Mi(r6) {
        for (var e6 = "{", t6 = 0; t6 < r6.length; t6++) t6 > 0 && (e6 = e6 + ","), r6[t6] === null || typeof r6[t6] > "u" ? e6 = e6 + "NULL" : Array.isArray(r6[t6]) ? e6 = e6 + Mi(r6[t6]) : r6[t6] instanceof y5 ? e6 += "\\\\x" + r6[t6].toString("hex") : e6 += $a(lt3(r6[t6]));
        return e6 = e6 + "}", e6;
      }
      a7(Mi, "arrayString");
      var lt3 = a7(function(r6, e6) {
        if (r6 == null) return null;
        if (r6 instanceof y5) return r6;
        if (ArrayBuffer.isView(r6)) {
          var t6 = y5.from(r6.buffer, r6.byteOffset, r6.byteLength);
          return t6.length === r6.byteLength ? t6 : t6.slice(
            r6.byteOffset,
            r6.byteOffset + r6.byteLength
          );
        }
        return r6 instanceof Date ? Ga.parseInputDatesAsUTC ? za(r6) : Ka(r6) : Array.isArray(r6) ? Mi(r6) : typeof r6 == "object" ? Va(r6, e6) : r6.toString();
      }, "prepareValue");
      function Va(r6, e6) {
        if (r6 && typeof r6.toPostgres == "function") {
          if (e6 = e6 || [], e6.indexOf(r6) !== -1) throw new Error('circular reference detected while preparing "' + r6 + '" for query');
          return e6.push(r6), lt3(r6.toPostgres(lt3), e6);
        }
        return JSON.stringify(r6);
      }
      a7(Va, "prepareObject");
      function H5(r6, e6) {
        for (r6 = "" + r6; r6.length < e6; ) r6 = "0" + r6;
        return r6;
      }
      a7(
        H5,
        "pad"
      );
      function Ka(r6) {
        var e6 = -r6.getTimezoneOffset(), t6 = r6.getFullYear(), n7 = t6 < 1;
        n7 && (t6 = Math.abs(t6) + 1);
        var i8 = H5(t6, 4) + "-" + H5(r6.getMonth() + 1, 2) + "-" + H5(r6.getDate(), 2) + "T" + H5(r6.getHours(), 2) + ":" + H5(r6.getMinutes(), 2) + ":" + H5(r6.getSeconds(), 2) + "." + H5(
          r6.getMilliseconds(),
          3
        );
        return e6 < 0 ? (i8 += "-", e6 *= -1) : i8 += "+", i8 += H5(Math.floor(e6 / 60), 2) + ":" + H5(e6 % 60, 2), n7 && (i8 += " BC"), i8;
      }
      a7(Ka, "dateToString");
      function za(r6) {
        var e6 = r6.getUTCFullYear(), t6 = e6 < 1;
        t6 && (e6 = Math.abs(e6) + 1);
        var n7 = H5(e6, 4) + "-" + H5(r6.getUTCMonth() + 1, 2) + "-" + H5(r6.getUTCDate(), 2) + "T" + H5(r6.getUTCHours(), 2) + ":" + H5(r6.getUTCMinutes(), 2) + ":" + H5(r6.getUTCSeconds(), 2) + "." + H5(r6.getUTCMilliseconds(), 3);
        return n7 += "+00:00", t6 && (n7 += " BC"), n7;
      }
      a7(za, "dateToStringUTC");
      function Ya(r6, e6, t6) {
        return r6 = typeof r6 == "string" ? { text: r6 } : r6, e6 && (typeof e6 == "function" ? r6.callback = e6 : r6.values = e6), t6 && (r6.callback = t6), r6;
      }
      a7(Ya, "normalizeQueryConfig");
      var Xt3 = a7(function(r6) {
        return Ha.createHash("md5").update(r6, "utf-8").digest("hex");
      }, "md5"), Za = a7(function(r6, e6, t6) {
        var n7 = Xt3(e6 + r6), i8 = Xt3(y5.concat([y5.from(n7), t6]));
        return "md5" + i8;
      }, "postgresMd5PasswordHash");
      Di.exports = { prepareValue: a7(function(e6) {
        return lt3(
          e6
        );
      }, "prepareValueWrapper"), normalizeQueryConfig: Ya, postgresMd5PasswordHash: Za, md5: Xt3 };
    });
    qi2 = I5((Yh, Ni2) => {
      "use strict";
      p9();
      var er3 = (Qt3(), N3(qt3));
      function Ja(r6) {
        if (r6.indexOf(
          "SCRAM-SHA-256"
        ) === -1) throw new Error("SASL: Only mechanism SCRAM-SHA-256 is currently supported");
        let e6 = er3.randomBytes(18).toString("base64");
        return { mechanism: "SCRAM-SHA-256", clientNonce: e6, response: "n,,n=*,r=" + e6, message: "SASLInitialResponse" };
      }
      a7(Ja, "startSession");
      function Xa(r6, e6, t6) {
        if (r6.message !== "SASLInitialResponse") throw new Error(
          "SASL: Last message was not SASLInitialResponse"
        );
        if (typeof e6 != "string") throw new Error(
          "SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a string"
        );
        if (typeof t6 != "string") throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: serverData must be a string");
        let n7 = ru(t6);
        if (n7.nonce.startsWith(r6.clientNonce)) {
          if (n7.nonce.length === r6.clientNonce.length) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce");
        var i8 = y5.from(n7.salt, "base64"), s10 = su2(
          e6,
          i8,
          n7.iteration
        ), o9 = De3(s10, "Client Key"), u7 = iu2(o9), c6 = "n=*,r=" + r6.clientNonce, h8 = "r=" + n7.nonce + ",s=" + n7.salt + ",i=" + n7.iteration, l7 = "c=biws,r=" + n7.nonce, d7 = c6 + "," + h8 + "," + l7, b9 = De3(u7, d7), C6 = Oi(
          o9,
          b9
        ), B3 = C6.toString("base64"), W4 = De3(s10, "Server Key"), X4 = De3(W4, d7);
        r6.message = "SASLResponse", r6.serverSignature = X4.toString("base64"), r6.response = l7 + ",p=" + B3;
      }
      a7(Xa, "continueSession");
      function eu(r6, e6) {
        if (r6.message !== "SASLResponse") throw new Error("SASL: Last message was not SASLResponse");
        if (typeof e6 != "string") throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: serverData must be a string");
        let { serverSignature: t6 } = nu(
          e6
        );
        if (t6 !== r6.serverSignature) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature does not match");
      }
      a7(eu, "finalizeSession");
      function tu(r6) {
        if (typeof r6 != "string") throw new TypeError("SASL: text must be a string");
        return r6.split("").map(
          (e6, t6) => r6.charCodeAt(t6)
        ).every((e6) => e6 >= 33 && e6 <= 43 || e6 >= 45 && e6 <= 126);
      }
      a7(tu, "isPrintableChars");
      function ki(r6) {
        return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(r6);
      }
      a7(ki, "isBase64");
      function Ui(r6) {
        if (typeof r6 != "string") throw new TypeError(
          "SASL: attribute pairs text must be a string"
        );
        return new Map(r6.split(",").map((e6) => {
          if (!/^.=/.test(e6)) throw new Error("SASL: Invalid attribute pair entry");
          let t6 = e6[0], n7 = e6.substring(2);
          return [t6, n7];
        }));
      }
      a7(Ui, "parseAttributePairs");
      function ru(r6) {
        let e6 = Ui(
          r6
        ), t6 = e6.get("r");
        if (t6) {
          if (!tu(t6)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing");
        let n7 = e6.get("s");
        if (n7) {
          if (!ki(n7)) throw new Error(
            "SASL: SCRAM-SERVER-FIRST-MESSAGE: salt must be base64"
          );
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing");
        let i8 = e6.get("i");
        if (i8) {
          if (!/^[1-9][0-9]*$/.test(i8)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: invalid iteration count");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing");
        let s10 = parseInt(i8, 10);
        return { nonce: t6, salt: n7, iteration: s10 };
      }
      a7(ru, "parseServerFirstMessage");
      function nu(r6) {
        let t6 = Ui(r6).get("v");
        if (t6) {
          if (!ki(t6)) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64");
        } else throw new Error(
          "SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing"
        );
        return { serverSignature: t6 };
      }
      a7(nu, "parseServerFinalMessage");
      function Oi(r6, e6) {
        if (!y5.isBuffer(r6)) throw new TypeError(
          "first argument must be a Buffer"
        );
        if (!y5.isBuffer(e6)) throw new TypeError("second argument must be a Buffer");
        if (r6.length !== e6.length) throw new Error("Buffer lengths must match");
        if (r6.length === 0) throw new Error("Buffers cannot be empty");
        return y5.from(r6.map((t6, n7) => r6[n7] ^ e6[n7]));
      }
      a7(Oi, "xorBuffers");
      function iu2(r6) {
        return er3.createHash(
          "sha256"
        ).update(r6).digest();
      }
      a7(iu2, "sha256");
      function De3(r6, e6) {
        return er3.createHmac(
          "sha256",
          r6
        ).update(e6).digest();
      }
      a7(De3, "hmacSha256");
      function su2(r6, e6, t6) {
        for (var n7 = De3(
          r6,
          y5.concat([e6, y5.from([0, 0, 0, 1])])
        ), i8 = n7, s10 = 0; s10 < t6 - 1; s10++) n7 = De3(r6, n7), i8 = Oi(i8, n7);
        return i8;
      }
      a7(su2, "Hi");
      Ni2.exports = { startSession: Ja, continueSession: Xa, finalizeSession: eu };
    });
    tr2 = {};
    ie2(tr2, { join: () => ou2 });
    rr2 = z4(() => {
      "use strict";
      p9();
      a7(ou2, "join");
    });
    nr3 = {};
    ie2(nr3, { stat: () => au });
    ir2 = z4(
      () => {
        "use strict";
        p9();
        a7(au, "stat");
      }
    );
    sr3 = {};
    ie2(sr3, { default: () => uu });
    or4 = z4(() => {
      "use strict";
      p9();
      uu = {};
    });
    Qi2 = {};
    ie2(Qi2, { StringDecoder: () => ar2 });
    Wi = z4(() => {
      "use strict";
      p9();
      ur2 = class ur {
        constructor(e6) {
          _5(this, "td");
          this.td = new TextDecoder(e6);
        }
        write(e6) {
          return this.td.decode(e6, { stream: true });
        }
        end(e6) {
          return this.td.decode(e6);
        }
      };
      a7(ur2, "StringDecoder");
      ar2 = ur2;
    });
    $i = I5((ol, Gi2) => {
      "use strict";
      p9();
      var { Transform: cu2 } = (or4(), N3(sr3)), { StringDecoder: hu2 } = (Wi(), N3(Qi2)), be3 = Symbol("last"), ft2 = Symbol("decoder");
      function lu(r6, e6, t6) {
        let n7;
        if (this.overflow) {
          if (n7 = this[ft2].write(r6).split(this.matcher), n7.length === 1) return t6();
          n7.shift(), this.overflow = false;
        } else this[be3] += this[ft2].write(r6), n7 = this[be3].split(this.matcher);
        this[be3] = n7.pop();
        for (let i8 = 0; i8 < n7.length; i8++) try {
          Hi(this, this.mapper(n7[i8]));
        } catch (s10) {
          return t6(
            s10
          );
        }
        if (this.overflow = this[be3].length > this.maxLength, this.overflow && !this.skipOverflow) {
          t6(new Error("maximum buffer reached"));
          return;
        }
        t6();
      }
      a7(lu, "transform");
      function fu(r6) {
        if (this[be3] += this[ft2].end(), this[be3]) try {
          Hi(this, this.mapper(this[be3]));
        } catch (e6) {
          return r6(e6);
        }
        r6();
      }
      a7(fu, "flush");
      function Hi(r6, e6) {
        e6 !== void 0 && r6.push(e6);
      }
      a7(Hi, "push");
      function ji2(r6) {
        return r6;
      }
      a7(ji2, "noop");
      function pu(r6, e6, t6) {
        switch (r6 = r6 || /\r?\n/, e6 = e6 || ji2, t6 = t6 || {}, arguments.length) {
          case 1:
            typeof r6 == "function" ? (e6 = r6, r6 = /\r?\n/) : typeof r6 == "object" && !(r6 instanceof RegExp) && !r6[Symbol.split] && (t6 = r6, r6 = /\r?\n/);
            break;
          case 2:
            typeof r6 == "function" ? (t6 = e6, e6 = r6, r6 = /\r?\n/) : typeof e6 == "object" && (t6 = e6, e6 = ji2);
        }
        t6 = Object.assign({}, t6), t6.autoDestroy = true, t6.transform = lu, t6.flush = fu, t6.readableObjectMode = true;
        let n7 = new cu2(t6);
        return n7[be3] = "", n7[ft2] = new hu2("utf8"), n7.matcher = r6, n7.mapper = e6, n7.maxLength = t6.maxLength, n7.skipOverflow = t6.skipOverflow || false, n7.overflow = false, n7._destroy = function(i8, s10) {
          this._writableState.errorEmitted = false, s10(i8);
        }, n7;
      }
      a7(pu, "split");
      Gi2.exports = pu;
    });
    zi = I5((cl, pe2) => {
      "use strict";
      p9();
      var Vi3 = (rr2(), N3(tr2)), du = (or4(), N3(sr3)).Stream, yu = $i(), Ki = (He3(), N3(je2)), mu = 5432, pt2 = m10.platform === "win32", tt4 = m10.stderr, gu = 56, wu = 7, bu = 61440, Su = 32768;
      function xu(r6) {
        return (r6 & bu) == Su;
      }
      a7(xu, "isRegFile");
      var ke3 = [
        "host",
        "port",
        "database",
        "user",
        "password"
      ], cr3 = ke3.length, vu = ke3[cr3 - 1];
      function hr3() {
        var r6 = tt4 instanceof du && tt4.writable === true;
        if (r6) {
          var e6 = Array.prototype.slice.call(arguments).concat(`
`);
          tt4.write(Ki.format.apply(Ki, e6));
        }
      }
      a7(hr3, "warn");
      Object.defineProperty(
        pe2.exports,
        "isWin",
        { get: a7(function() {
          return pt2;
        }, "get"), set: a7(function(r6) {
          pt2 = r6;
        }, "set") }
      );
      pe2.exports.warnTo = function(r6) {
        var e6 = tt4;
        return tt4 = r6, e6;
      };
      pe2.exports.getFileName = function(r6) {
        var e6 = r6 || m10.env, t6 = e6.PGPASSFILE || (pt2 ? Vi3.join(e6.APPDATA || "./", "postgresql", "pgpass.conf") : Vi3.join(e6.HOME || "./", ".pgpass"));
        return t6;
      };
      pe2.exports.usePgPass = function(r6, e6) {
        return Object.prototype.hasOwnProperty.call(m10.env, "PGPASSWORD") ? false : pt2 ? true : (e6 = e6 || "<unkn>", xu(r6.mode) ? r6.mode & (gu | wu) ? (hr3('WARNING: password file "%s" has group or world access; permissions should be u=rw (0600) or less', e6), false) : true : (hr3('WARNING: password file "%s" is not a plain file', e6), false));
      };
      var Eu = pe2.exports.match = function(r6, e6) {
        return ke3.slice(0, -1).reduce(function(t6, n7, i8) {
          return i8 == 1 && Number(r6[n7] || mu) === Number(
            e6[n7]
          ) ? t6 && true : t6 && (e6[n7] === "*" || e6[n7] === r6[n7]);
        }, true);
      };
      pe2.exports.getPassword = function(r6, e6, t6) {
        var n7, i8 = e6.pipe(yu());
        function s10(c6) {
          var h8 = _u(c6);
          h8 && Au2(h8) && Eu(r6, h8) && (n7 = h8[vu], i8.end());
        }
        a7(s10, "onLine");
        var o9 = a7(function() {
          e6.destroy(), t6(n7);
        }, "onEnd"), u7 = a7(function(c6) {
          e6.destroy(), hr3("WARNING: error on reading file: %s", c6), t6(void 0);
        }, "onErr");
        e6.on("error", u7), i8.on("data", s10).on("end", o9).on("error", u7);
      };
      var _u = pe2.exports.parseLine = function(r6) {
        if (r6.length < 11 || r6.match(/^\s+#/)) return null;
        for (var e6 = "", t6 = "", n7 = 0, i8 = 0, s10 = 0, o9 = {}, u7 = false, c6 = a7(function(l7, d7, b9) {
          var C6 = r6.substring(d7, b9);
          Object.hasOwnProperty.call(
            m10.env,
            "PGPASS_NO_DEESCAPE"
          ) || (C6 = C6.replace(/\\([:\\])/g, "$1")), o9[ke3[l7]] = C6;
        }, "addToObj"), h8 = 0; h8 < r6.length - 1; h8 += 1) {
          if (e6 = r6.charAt(h8 + 1), t6 = r6.charAt(h8), u7 = n7 == cr3 - 1, u7) {
            c6(n7, i8);
            break;
          }
          h8 >= 0 && e6 == ":" && t6 !== "\\" && (c6(n7, i8, h8 + 1), i8 = h8 + 2, n7 += 1);
        }
        return o9 = Object.keys(o9).length === cr3 ? o9 : null, o9;
      }, Au2 = pe2.exports.isValidEntry = function(r6) {
        for (var e6 = { 0: function(o9) {
          return o9.length > 0;
        }, 1: function(o9) {
          return o9 === "*" ? true : (o9 = Number(o9), isFinite(o9) && o9 > 0 && o9 < 9007199254740992 && Math.floor(o9) === o9);
        }, 2: function(o9) {
          return o9.length > 0;
        }, 3: function(o9) {
          return o9.length > 0;
        }, 4: function(o9) {
          return o9.length > 0;
        } }, t6 = 0; t6 < ke3.length; t6 += 1) {
          var n7 = e6[t6], i8 = r6[ke3[t6]] || "", s10 = n7(i8);
          if (!s10) return false;
        }
        return true;
      };
    });
    Zi = I5((pl, lr2) => {
      "use strict";
      p9();
      var fl = (rr2(), N3(tr2)), Yi3 = (ir2(), N3(nr3)), dt2 = zi();
      lr2.exports = function(r6, e6) {
        var t6 = dt2.getFileName();
        Yi3.stat(t6, function(n7, i8) {
          if (n7 || !dt2.usePgPass(i8, t6)) return e6(void 0);
          var s10 = Yi3.createReadStream(t6);
          dt2.getPassword(
            r6,
            s10,
            e6
          );
        });
      };
      lr2.exports.warnTo = dt2.warnTo;
    });
    mt2 = I5((yl, Ji3) => {
      "use strict";
      p9();
      var Cu = Je2();
      function yt2(r6) {
        this._types = r6 || Cu, this.text = {}, this.binary = {};
      }
      a7(yt2, "TypeOverrides");
      yt2.prototype.getOverrides = function(r6) {
        switch (r6) {
          case "text":
            return this.text;
          case "binary":
            return this.binary;
          default:
            return {};
        }
      };
      yt2.prototype.setTypeParser = function(r6, e6, t6) {
        typeof e6 == "function" && (t6 = e6, e6 = "text"), this.getOverrides(e6)[r6] = t6;
      };
      yt2.prototype.getTypeParser = function(r6, e6) {
        return e6 = e6 || "text", this.getOverrides(e6)[r6] || this._types.getTypeParser(r6, e6);
      };
      Ji3.exports = yt2;
    });
    Xi2 = {};
    ie2(Xi2, { default: () => Tu });
    es2 = z4(() => {
      "use strict";
      p9();
      Tu = {};
    });
    ts = {};
    ie2(ts, { parse: () => fr2 });
    pr = z4(() => {
      "use strict";
      p9();
      a7(fr2, "parse");
    });
    ns = I5((xl, rs3) => {
      "use strict";
      p9();
      var Iu = (pr(), N3(ts)), dr2 = (ir2(), N3(nr3));
      function yr2(r6) {
        if (r6.charAt(0) === "/") {
          var t6 = r6.split(" ");
          return { host: t6[0], database: t6[1] };
        }
        var e6 = Iu.parse(/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(r6) ? encodeURI(r6).replace(
          /\%25(\d\d)/g,
          "%$1"
        ) : r6, true), t6 = e6.query;
        for (var n7 in t6) Array.isArray(t6[n7]) && (t6[n7] = t6[n7][t6[n7].length - 1]);
        var i8 = (e6.auth || ":").split(":");
        if (t6.user = i8[0], t6.password = i8.splice(1).join(":"), t6.port = e6.port, e6.protocol == "socket:") return t6.host = decodeURI(e6.pathname), t6.database = e6.query.db, t6.client_encoding = e6.query.encoding, t6;
        t6.host || (t6.host = e6.hostname);
        var s10 = e6.pathname;
        if (!t6.host && s10 && /^%2f/i.test(s10)) {
          var o9 = s10.split("/");
          t6.host = decodeURIComponent(
            o9[0]
          ), s10 = o9.splice(1).join("/");
        }
        switch (s10 && s10.charAt(0) === "/" && (s10 = s10.slice(1) || null), t6.database = s10 && decodeURI(s10), (t6.ssl === "true" || t6.ssl === "1") && (t6.ssl = true), t6.ssl === "0" && (t6.ssl = false), (t6.sslcert || t6.sslkey || t6.sslrootcert || t6.sslmode) && (t6.ssl = {}), t6.sslcert && (t6.ssl.cert = dr2.readFileSync(t6.sslcert).toString()), t6.sslkey && (t6.ssl.key = dr2.readFileSync(
          t6.sslkey
        ).toString()), t6.sslrootcert && (t6.ssl.ca = dr2.readFileSync(t6.sslrootcert).toString()), t6.sslmode) {
          case "disable": {
            t6.ssl = false;
            break;
          }
          case "prefer":
          case "require":
          case "verify-ca":
          case "verify-full":
            break;
          case "no-verify": {
            t6.ssl.rejectUnauthorized = false;
            break;
          }
        }
        return t6;
      }
      a7(yr2, "parse");
      rs3.exports = yr2;
      yr2.parse = yr2;
    });
    gt4 = I5((_l, os4) => {
      "use strict";
      p9();
      var Pu2 = (es2(), N3(Xi2)), ss = Xe3(), is3 = ns().parse, $4 = a7(
        function(r6, e6, t6) {
          return t6 === void 0 ? t6 = m10.env["PG" + r6.toUpperCase()] : t6 === false || (t6 = m10.env[t6]), e6[r6] || t6 || ss[r6];
        },
        "val"
      ), Bu = a7(function() {
        switch (m10.env.PGSSLMODE) {
          case "disable":
            return false;
          case "prefer":
          case "require":
          case "verify-ca":
          case "verify-full":
            return true;
          case "no-verify":
            return { rejectUnauthorized: false };
        }
        return ss.ssl;
      }, "readSSLConfigFromEnvironment"), Ue3 = a7(
        function(r6) {
          return "'" + ("" + r6).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
        },
        "quoteParamValue"
      ), ne3 = a7(function(r6, e6, t6) {
        var n7 = e6[t6];
        n7 != null && r6.push(t6 + "=" + Ue3(n7));
      }, "add"), gr = class gr {
        constructor(e6) {
          e6 = typeof e6 == "string" ? is3(e6) : e6 || {}, e6.connectionString && (e6 = Object.assign({}, e6, is3(e6.connectionString))), this.user = $4("user", e6), this.database = $4("database", e6), this.database === void 0 && (this.database = this.user), this.port = parseInt(
            $4("port", e6),
            10
          ), this.host = $4("host", e6), Object.defineProperty(this, "password", {
            configurable: true,
            enumerable: false,
            writable: true,
            value: $4("password", e6)
          }), this.binary = $4("binary", e6), this.options = $4("options", e6), this.ssl = typeof e6.ssl > "u" ? Bu() : e6.ssl, typeof this.ssl == "string" && this.ssl === "true" && (this.ssl = true), this.ssl === "no-verify" && (this.ssl = { rejectUnauthorized: false }), this.ssl && this.ssl.key && Object.defineProperty(this.ssl, "key", { enumerable: false }), this.client_encoding = $4("client_encoding", e6), this.replication = $4("replication", e6), this.isDomainSocket = !(this.host || "").indexOf("/"), this.application_name = $4("application_name", e6, "PGAPPNAME"), this.fallback_application_name = $4("fallback_application_name", e6, false), this.statement_timeout = $4("statement_timeout", e6, false), this.lock_timeout = $4(
            "lock_timeout",
            e6,
            false
          ), this.idle_in_transaction_session_timeout = $4("idle_in_transaction_session_timeout", e6, false), this.query_timeout = $4("query_timeout", e6, false), e6.connectionTimeoutMillis === void 0 ? this.connect_timeout = m10.env.PGCONNECT_TIMEOUT || 0 : this.connect_timeout = Math.floor(e6.connectionTimeoutMillis / 1e3), e6.keepAlive === false ? this.keepalives = 0 : e6.keepAlive === true && (this.keepalives = 1), typeof e6.keepAliveInitialDelayMillis == "number" && (this.keepalives_idle = Math.floor(e6.keepAliveInitialDelayMillis / 1e3));
        }
        getLibpqConnectionString(e6) {
          var t6 = [];
          ne3(t6, this, "user"), ne3(t6, this, "password"), ne3(t6, this, "port"), ne3(t6, this, "application_name"), ne3(t6, this, "fallback_application_name"), ne3(t6, this, "connect_timeout"), ne3(
            t6,
            this,
            "options"
          );
          var n7 = typeof this.ssl == "object" ? this.ssl : this.ssl ? { sslmode: this.ssl } : {};
          if (ne3(t6, n7, "sslmode"), ne3(t6, n7, "sslca"), ne3(t6, n7, "sslkey"), ne3(t6, n7, "sslcert"), ne3(t6, n7, "sslrootcert"), this.database && t6.push("dbname=" + Ue3(this.database)), this.replication && t6.push("replication=" + Ue3(this.replication)), this.host && t6.push("host=" + Ue3(this.host)), this.isDomainSocket) return e6(null, t6.join(" "));
          this.client_encoding && t6.push("client_encoding=" + Ue3(this.client_encoding)), Pu2.lookup(this.host, function(i8, s10) {
            return i8 ? e6(i8, null) : (t6.push("hostaddr=" + Ue3(s10)), e6(null, t6.join(" ")));
          });
        }
      };
      a7(gr, "ConnectionParameters");
      var mr = gr;
      os4.exports = mr;
    });
    cs = I5((Tl, us2) => {
      "use strict";
      p9();
      var Lu2 = Je2(), as = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/, br = class br {
        constructor(e6, t6) {
          this.command = null, this.rowCount = null, this.oid = null, this.rows = [], this.fields = [], this._parsers = void 0, this._types = t6, this.RowCtor = null, this.rowAsArray = e6 === "array", this.rowAsArray && (this.parseRow = this._parseRowAsArray);
        }
        addCommandComplete(e6) {
          var t6;
          e6.text ? t6 = as.exec(e6.text) : t6 = as.exec(e6.command), t6 && (this.command = t6[1], t6[3] ? (this.oid = parseInt(t6[2], 10), this.rowCount = parseInt(t6[3], 10)) : t6[2] && (this.rowCount = parseInt(
            t6[2],
            10
          )));
        }
        _parseRowAsArray(e6) {
          for (var t6 = new Array(e6.length), n7 = 0, i8 = e6.length; n7 < i8; n7++) {
            var s10 = e6[n7];
            s10 !== null ? t6[n7] = this._parsers[n7](s10) : t6[n7] = null;
          }
          return t6;
        }
        parseRow(e6) {
          for (var t6 = {}, n7 = 0, i8 = e6.length; n7 < i8; n7++) {
            var s10 = e6[n7], o9 = this.fields[n7].name;
            s10 !== null ? t6[o9] = this._parsers[n7](
              s10
            ) : t6[o9] = null;
          }
          return t6;
        }
        addRow(e6) {
          this.rows.push(e6);
        }
        addFields(e6) {
          this.fields = e6, this.fields.length && (this._parsers = new Array(e6.length));
          for (var t6 = 0; t6 < e6.length; t6++) {
            var n7 = e6[t6];
            this._types ? this._parsers[t6] = this._types.getTypeParser(n7.dataTypeID, n7.format || "text") : this._parsers[t6] = Lu2.getTypeParser(n7.dataTypeID, n7.format || "text");
          }
        }
      };
      a7(br, "Result");
      var wr = br;
      us2.exports = wr;
    });
    ps2 = I5((Bl, fs9) => {
      "use strict";
      p9();
      var { EventEmitter: Ru } = we3(), hs2 = cs(), ls = et3(), xr = class xr extends Ru {
        constructor(e6, t6, n7) {
          super(), e6 = ls.normalizeQueryConfig(e6, t6, n7), this.text = e6.text, this.values = e6.values, this.rows = e6.rows, this.types = e6.types, this.name = e6.name, this.binary = e6.binary, this.portal = e6.portal || "", this.callback = e6.callback, this._rowMode = e6.rowMode, m10.domain && e6.callback && (this.callback = m10.domain.bind(e6.callback)), this._result = new hs2(this._rowMode, this.types), this._results = this._result, this.isPreparedStatement = false, this._canceledDueToError = false, this._promise = null;
        }
        requiresPreparation() {
          return this.name || this.rows ? true : !this.text || !this.values ? false : this.values.length > 0;
        }
        _checkForMultirow() {
          this._result.command && (Array.isArray(this._results) || (this._results = [this._result]), this._result = new hs2(
            this._rowMode,
            this.types
          ), this._results.push(this._result));
        }
        handleRowDescription(e6) {
          this._checkForMultirow(), this._result.addFields(e6.fields), this._accumulateRows = this.callback || !this.listeners("row").length;
        }
        handleDataRow(e6) {
          let t6;
          if (!this._canceledDueToError) {
            try {
              t6 = this._result.parseRow(e6.fields);
            } catch (n7) {
              this._canceledDueToError = n7;
              return;
            }
            this.emit("row", t6, this._result), this._accumulateRows && this._result.addRow(t6);
          }
        }
        handleCommandComplete(e6, t6) {
          this._checkForMultirow(), this._result.addCommandComplete(e6), this.rows && t6.sync();
        }
        handleEmptyQuery(e6) {
          this.rows && e6.sync();
        }
        handleError(e6, t6) {
          if (this._canceledDueToError && (e6 = this._canceledDueToError, this._canceledDueToError = false), this.callback) return this.callback(e6);
          this.emit("error", e6);
        }
        handleReadyForQuery(e6) {
          if (this._canceledDueToError) return this.handleError(
            this._canceledDueToError,
            e6
          );
          if (this.callback) try {
            this.callback(null, this._results);
          } catch (t6) {
            m10.nextTick(() => {
              throw t6;
            });
          }
          this.emit("end", this._results);
        }
        submit(e6) {
          if (typeof this.text != "string" && typeof this.name != "string") return new Error("A query must have either text or a name. Supplying neither is unsupported.");
          let t6 = e6.parsedStatements[this.name];
          return this.text && t6 && this.text !== t6 ? new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`) : this.values && !Array.isArray(this.values) ? new Error("Query values must be an array") : (this.requiresPreparation() ? this.prepare(e6) : e6.query(this.text), null);
        }
        hasBeenParsed(e6) {
          return this.name && e6.parsedStatements[this.name];
        }
        handlePortalSuspended(e6) {
          this._getRows(e6, this.rows);
        }
        _getRows(e6, t6) {
          e6.execute(
            { portal: this.portal, rows: t6 }
          ), t6 ? e6.flush() : e6.sync();
        }
        prepare(e6) {
          this.isPreparedStatement = true, this.hasBeenParsed(e6) || e6.parse({ text: this.text, name: this.name, types: this.types });
          try {
            e6.bind({ portal: this.portal, statement: this.name, values: this.values, binary: this.binary, valueMapper: ls.prepareValue });
          } catch (t6) {
            this.handleError(t6, e6);
            return;
          }
          e6.describe(
            { type: "P", name: this.portal || "" }
          ), this._getRows(e6, this.rows);
        }
        handleCopyInResponse(e6) {
          e6.sendCopyFail("No source stream defined");
        }
        handleCopyData(e6, t6) {
        }
      };
      a7(xr, "Query");
      var Sr = xr;
      fs9.exports = Sr;
    });
    ys2 = {};
    ie2(ys2, { Socket: () => _e7, isIP: () => Fu });
    wt3 = z4(() => {
      "use strict";
      p9();
      ds2 = Te2(we3(), 1);
      a7(Fu, "isIP");
      Mu = a7((r6) => r6.replace(
        /^[^.]+\./,
        "api."
      ), "transformHost"), E2 = class E4 extends ds2.EventEmitter {
        constructor() {
          super(...arguments);
          _5(this, "opts", {});
          _5(this, "connecting", false);
          _5(this, "pending", true);
          _5(
            this,
            "writable",
            true
          );
          _5(this, "encrypted", false);
          _5(this, "authorized", false);
          _5(this, "destroyed", false);
          _5(
            this,
            "ws",
            null
          );
          _5(this, "writeBuffer");
          _5(this, "tlsState", 0);
          _5(this, "tlsRead");
          _5(this, "tlsWrite");
        }
        static get poolQueryViaFetch() {
          return E4.opts.poolQueryViaFetch ?? E4.defaults.poolQueryViaFetch;
        }
        static set poolQueryViaFetch(t6) {
          E4.opts.poolQueryViaFetch = t6;
        }
        static get fetchEndpoint() {
          return E4.opts.fetchEndpoint ?? E4.defaults.fetchEndpoint;
        }
        static set fetchEndpoint(t6) {
          E4.opts.fetchEndpoint = t6;
        }
        static get fetchConnectionCache() {
          return true;
        }
        static set fetchConnectionCache(t6) {
          console.warn("The `fetchConnectionCache` option is deprecated (now always `true`)");
        }
        static get fetchFunction() {
          return E4.opts.fetchFunction ?? E4.defaults.fetchFunction;
        }
        static set fetchFunction(t6) {
          E4.opts.fetchFunction = t6;
        }
        static get webSocketConstructor() {
          return E4.opts.webSocketConstructor ?? E4.defaults.webSocketConstructor;
        }
        static set webSocketConstructor(t6) {
          E4.opts.webSocketConstructor = t6;
        }
        get webSocketConstructor() {
          return this.opts.webSocketConstructor ?? E4.webSocketConstructor;
        }
        set webSocketConstructor(t6) {
          this.opts.webSocketConstructor = t6;
        }
        static get wsProxy() {
          return E4.opts.wsProxy ?? E4.defaults.wsProxy;
        }
        static set wsProxy(t6) {
          E4.opts.wsProxy = t6;
        }
        get wsProxy() {
          return this.opts.wsProxy ?? E4.wsProxy;
        }
        set wsProxy(t6) {
          this.opts.wsProxy = t6;
        }
        static get coalesceWrites() {
          return E4.opts.coalesceWrites ?? E4.defaults.coalesceWrites;
        }
        static set coalesceWrites(t6) {
          E4.opts.coalesceWrites = t6;
        }
        get coalesceWrites() {
          return this.opts.coalesceWrites ?? E4.coalesceWrites;
        }
        set coalesceWrites(t6) {
          this.opts.coalesceWrites = t6;
        }
        static get useSecureWebSocket() {
          return E4.opts.useSecureWebSocket ?? E4.defaults.useSecureWebSocket;
        }
        static set useSecureWebSocket(t6) {
          E4.opts.useSecureWebSocket = t6;
        }
        get useSecureWebSocket() {
          return this.opts.useSecureWebSocket ?? E4.useSecureWebSocket;
        }
        set useSecureWebSocket(t6) {
          this.opts.useSecureWebSocket = t6;
        }
        static get forceDisablePgSSL() {
          return E4.opts.forceDisablePgSSL ?? E4.defaults.forceDisablePgSSL;
        }
        static set forceDisablePgSSL(t6) {
          E4.opts.forceDisablePgSSL = t6;
        }
        get forceDisablePgSSL() {
          return this.opts.forceDisablePgSSL ?? E4.forceDisablePgSSL;
        }
        set forceDisablePgSSL(t6) {
          this.opts.forceDisablePgSSL = t6;
        }
        static get disableSNI() {
          return E4.opts.disableSNI ?? E4.defaults.disableSNI;
        }
        static set disableSNI(t6) {
          E4.opts.disableSNI = t6;
        }
        get disableSNI() {
          return this.opts.disableSNI ?? E4.disableSNI;
        }
        set disableSNI(t6) {
          this.opts.disableSNI = t6;
        }
        static get pipelineConnect() {
          return E4.opts.pipelineConnect ?? E4.defaults.pipelineConnect;
        }
        static set pipelineConnect(t6) {
          E4.opts.pipelineConnect = t6;
        }
        get pipelineConnect() {
          return this.opts.pipelineConnect ?? E4.pipelineConnect;
        }
        set pipelineConnect(t6) {
          this.opts.pipelineConnect = t6;
        }
        static get subtls() {
          return E4.opts.subtls ?? E4.defaults.subtls;
        }
        static set subtls(t6) {
          E4.opts.subtls = t6;
        }
        get subtls() {
          return this.opts.subtls ?? E4.subtls;
        }
        set subtls(t6) {
          this.opts.subtls = t6;
        }
        static get pipelineTLS() {
          return E4.opts.pipelineTLS ?? E4.defaults.pipelineTLS;
        }
        static set pipelineTLS(t6) {
          E4.opts.pipelineTLS = t6;
        }
        get pipelineTLS() {
          return this.opts.pipelineTLS ?? E4.pipelineTLS;
        }
        set pipelineTLS(t6) {
          this.opts.pipelineTLS = t6;
        }
        static get rootCerts() {
          return E4.opts.rootCerts ?? E4.defaults.rootCerts;
        }
        static set rootCerts(t6) {
          E4.opts.rootCerts = t6;
        }
        get rootCerts() {
          return this.opts.rootCerts ?? E4.rootCerts;
        }
        set rootCerts(t6) {
          this.opts.rootCerts = t6;
        }
        wsProxyAddrForHost(t6, n7) {
          let i8 = this.wsProxy;
          if (i8 === void 0) throw new Error("No WebSocket proxy is configured. Please see https://github.com/neondatabase/serverless/blob/main/CONFIG.md#wsproxy-string--host-string-port-number--string--string");
          return typeof i8 == "function" ? i8(t6, n7) : `${i8}?address=${t6}:${n7}`;
        }
        setNoDelay() {
          return this;
        }
        setKeepAlive() {
          return this;
        }
        ref() {
          return this;
        }
        unref() {
          return this;
        }
        connect(t6, n7, i8) {
          this.connecting = true, i8 && this.once("connect", i8);
          let s10 = a7(() => {
            this.connecting = false, this.pending = false, this.emit("connect"), this.emit("ready");
          }, "handleWebSocketOpen"), o9 = a7((c6, h8 = false) => {
            c6.binaryType = "arraybuffer", c6.addEventListener("error", (l7) => {
              this.emit("error", l7), this.emit("close");
            }), c6.addEventListener("message", (l7) => {
              if (this.tlsState === 0) {
                let d7 = y5.from(l7.data);
                this.emit(
                  "data",
                  d7
                );
              }
            }), c6.addEventListener("close", () => {
              this.emit("close");
            }), h8 ? s10() : c6.addEventListener(
              "open",
              s10
            );
          }, "configureWebSocket"), u7;
          try {
            u7 = this.wsProxyAddrForHost(n7, typeof t6 == "string" ? parseInt(t6, 10) : t6);
          } catch (c6) {
            this.emit("error", c6), this.emit("close");
            return;
          }
          try {
            let h8 = (this.useSecureWebSocket ? "wss:" : "ws:") + "//" + u7;
            if (this.webSocketConstructor !== void 0) this.ws = new this.webSocketConstructor(h8), o9(this.ws);
            else try {
              this.ws = new WebSocket(
                h8
              ), o9(this.ws);
            } catch {
              this.ws = new __unstable_WebSocket(h8), o9(this.ws);
            }
          } catch (c6) {
            let l7 = (this.useSecureWebSocket ? "https:" : "http:") + "//" + u7;
            fetch(l7, { headers: { Upgrade: "websocket" } }).then((d7) => {
              if (this.ws = d7.webSocket, this.ws == null) throw c6;
              this.ws.accept(), o9(
                this.ws,
                true
              );
            }).catch((d7) => {
              this.emit("error", new Error(`All attempts to open a WebSocket to connect to the database failed. Please refer to https://github.com/neondatabase/serverless/blob/main/CONFIG.md#websocketconstructor-typeof-websocket--undefined. Details: ${d7.message}`)), this.emit("close");
            });
          }
        }
        async startTls(t6) {
          if (this.subtls === void 0) throw new Error("For Postgres SSL connections, you must set `neonConfig.subtls` to the subtls library. See https://github.com/neondatabase/serverless/blob/main/CONFIG.md for more information.");
          this.tlsState = 1;
          let n7 = this.subtls.TrustedCert.fromPEM(this.rootCerts), i8 = new this.subtls.WebSocketReadQueue(this.ws), s10 = i8.read.bind(
            i8
          ), o9 = this.rawWrite.bind(this), [u7, c6] = await this.subtls.startTls(t6, n7, s10, o9, { useSNI: !this.disableSNI, expectPreData: this.pipelineTLS ? new Uint8Array([83]) : void 0 });
          this.tlsRead = u7, this.tlsWrite = c6, this.tlsState = 2, this.encrypted = true, this.authorized = true, this.emit(
            "secureConnection",
            this
          ), this.tlsReadLoop();
        }
        async tlsReadLoop() {
          for (; ; ) {
            let t6 = await this.tlsRead();
            if (t6 === void 0) break;
            {
              let n7 = y5.from(t6);
              this.emit("data", n7);
            }
          }
        }
        rawWrite(t6) {
          if (!this.coalesceWrites) {
            this.ws.send(t6);
            return;
          }
          if (this.writeBuffer === void 0) this.writeBuffer = t6, setTimeout(
            () => {
              this.ws.send(this.writeBuffer), this.writeBuffer = void 0;
            },
            0
          );
          else {
            let n7 = new Uint8Array(this.writeBuffer.length + t6.length);
            n7.set(this.writeBuffer), n7.set(t6, this.writeBuffer.length), this.writeBuffer = n7;
          }
        }
        write(t6, n7 = "utf8", i8 = (s10) => {
        }) {
          return t6.length === 0 ? (i8(), true) : (typeof t6 == "string" && (t6 = y5.from(t6, n7)), this.tlsState === 0 ? (this.rawWrite(t6), i8()) : this.tlsState === 1 ? this.once("secureConnection", () => {
            this.write(
              t6,
              n7,
              i8
            );
          }) : (this.tlsWrite(t6), i8()), true);
        }
        end(t6 = y5.alloc(0), n7 = "utf8", i8 = () => {
        }) {
          return this.write(t6, n7, () => {
            this.ws.close(), i8();
          }), this;
        }
        destroy() {
          return this.destroyed = true, this.end();
        }
      };
      a7(E2, "Socket"), _5(E2, "defaults", {
        poolQueryViaFetch: false,
        fetchEndpoint: a7((t6) => "https://" + Mu(t6) + "/sql", "fetchEndpoint"),
        fetchConnectionCache: true,
        fetchFunction: void 0,
        webSocketConstructor: void 0,
        wsProxy: a7((t6) => t6 + "/v2", "wsProxy"),
        useSecureWebSocket: true,
        forceDisablePgSSL: true,
        coalesceWrites: true,
        pipelineConnect: "password",
        subtls: void 0,
        rootCerts: "",
        pipelineTLS: false,
        disableSNI: false
      }), _5(E2, "opts", {});
      _e7 = E2;
    });
    Yr2 = I5((T4) => {
      "use strict";
      p9();
      Object.defineProperty(T4, "__esModule", { value: true });
      T4.NoticeMessage = T4.DataRowMessage = T4.CommandCompleteMessage = T4.ReadyForQueryMessage = T4.NotificationResponseMessage = T4.BackendKeyDataMessage = T4.AuthenticationMD5Password = T4.ParameterStatusMessage = T4.ParameterDescriptionMessage = T4.RowDescriptionMessage = T4.Field = T4.CopyResponse = T4.CopyDataMessage = T4.DatabaseError = T4.copyDone = T4.emptyQuery = T4.replicationStart = T4.portalSuspended = T4.noData = T4.closeComplete = T4.bindComplete = T4.parseComplete = void 0;
      T4.parseComplete = { name: "parseComplete", length: 5 };
      T4.bindComplete = { name: "bindComplete", length: 5 };
      T4.closeComplete = { name: "closeComplete", length: 5 };
      T4.noData = { name: "noData", length: 5 };
      T4.portalSuspended = { name: "portalSuspended", length: 5 };
      T4.replicationStart = { name: "replicationStart", length: 4 };
      T4.emptyQuery = { name: "emptyQuery", length: 4 };
      T4.copyDone = { name: "copyDone", length: 4 };
      var kr = class kr extends Error {
        constructor(e6, t6, n7) {
          super(
            e6
          ), this.length = t6, this.name = n7;
        }
      };
      a7(kr, "DatabaseError");
      var vr = kr;
      T4.DatabaseError = vr;
      var Ur2 = class Ur {
        constructor(e6, t6) {
          this.length = e6, this.chunk = t6, this.name = "copyData";
        }
      };
      a7(Ur2, "CopyDataMessage");
      var Er2 = Ur2;
      T4.CopyDataMessage = Er2;
      var Or = class Or {
        constructor(e6, t6, n7, i8) {
          this.length = e6, this.name = t6, this.binary = n7, this.columnTypes = new Array(i8);
        }
      };
      a7(Or, "CopyResponse");
      var _r = Or;
      T4.CopyResponse = _r;
      var Nr2 = class Nr {
        constructor(e6, t6, n7, i8, s10, o9, u7) {
          this.name = e6, this.tableID = t6, this.columnID = n7, this.dataTypeID = i8, this.dataTypeSize = s10, this.dataTypeModifier = o9, this.format = u7;
        }
      };
      a7(Nr2, "Field");
      var Ar = Nr2;
      T4.Field = Ar;
      var qr2 = class qr {
        constructor(e6, t6) {
          this.length = e6, this.fieldCount = t6, this.name = "rowDescription", this.fields = new Array(
            this.fieldCount
          );
        }
      };
      a7(qr2, "RowDescriptionMessage");
      var Cr2 = qr2;
      T4.RowDescriptionMessage = Cr2;
      var Qr = class Qr {
        constructor(e6, t6) {
          this.length = e6, this.parameterCount = t6, this.name = "parameterDescription", this.dataTypeIDs = new Array(this.parameterCount);
        }
      };
      a7(Qr, "ParameterDescriptionMessage");
      var Tr = Qr;
      T4.ParameterDescriptionMessage = Tr;
      var Wr2 = class Wr {
        constructor(e6, t6, n7) {
          this.length = e6, this.parameterName = t6, this.parameterValue = n7, this.name = "parameterStatus";
        }
      };
      a7(Wr2, "ParameterStatusMessage");
      var Ir = Wr2;
      T4.ParameterStatusMessage = Ir;
      var jr2 = class jr {
        constructor(e6, t6) {
          this.length = e6, this.salt = t6, this.name = "authenticationMD5Password";
        }
      };
      a7(jr2, "AuthenticationMD5Password");
      var Pr2 = jr2;
      T4.AuthenticationMD5Password = Pr2;
      var Hr2 = class Hr {
        constructor(e6, t6, n7) {
          this.length = e6, this.processID = t6, this.secretKey = n7, this.name = "backendKeyData";
        }
      };
      a7(
        Hr2,
        "BackendKeyDataMessage"
      );
      var Br2 = Hr2;
      T4.BackendKeyDataMessage = Br2;
      var Gr2 = class Gr {
        constructor(e6, t6, n7, i8) {
          this.length = e6, this.processId = t6, this.channel = n7, this.payload = i8, this.name = "notification";
        }
      };
      a7(Gr2, "NotificationResponseMessage");
      var Lr = Gr2;
      T4.NotificationResponseMessage = Lr;
      var $r = class $r {
        constructor(e6, t6) {
          this.length = e6, this.status = t6, this.name = "readyForQuery";
        }
      };
      a7($r, "ReadyForQueryMessage");
      var Rr = $r;
      T4.ReadyForQueryMessage = Rr;
      var Vr2 = class Vr {
        constructor(e6, t6) {
          this.length = e6, this.text = t6, this.name = "commandComplete";
        }
      };
      a7(Vr2, "CommandCompleteMessage");
      var Fr = Vr2;
      T4.CommandCompleteMessage = Fr;
      var Kr2 = class Kr {
        constructor(e6, t6) {
          this.length = e6, this.fields = t6, this.name = "dataRow", this.fieldCount = t6.length;
        }
      };
      a7(Kr2, "DataRowMessage");
      var Mr = Kr2;
      T4.DataRowMessage = Mr;
      var zr2 = class zr {
        constructor(e6, t6) {
          this.length = e6, this.message = t6, this.name = "notice";
        }
      };
      a7(zr2, "NoticeMessage");
      var Dr = zr2;
      T4.NoticeMessage = Dr;
    });
    ms = I5((bt2) => {
      "use strict";
      p9();
      Object.defineProperty(bt2, "__esModule", { value: true });
      bt2.Writer = void 0;
      var Jr2 = class Jr {
        constructor(e6 = 256) {
          this.size = e6, this.offset = 5, this.headerPosition = 0, this.buffer = y5.allocUnsafe(e6);
        }
        ensure(e6) {
          var t6 = this.buffer.length - this.offset;
          if (t6 < e6) {
            var n7 = this.buffer, i8 = n7.length + (n7.length >> 1) + e6;
            this.buffer = y5.allocUnsafe(
              i8
            ), n7.copy(this.buffer);
          }
        }
        addInt32(e6) {
          return this.ensure(4), this.buffer[this.offset++] = e6 >>> 24 & 255, this.buffer[this.offset++] = e6 >>> 16 & 255, this.buffer[this.offset++] = e6 >>> 8 & 255, this.buffer[this.offset++] = e6 >>> 0 & 255, this;
        }
        addInt16(e6) {
          return this.ensure(2), this.buffer[this.offset++] = e6 >>> 8 & 255, this.buffer[this.offset++] = e6 >>> 0 & 255, this;
        }
        addCString(e6) {
          if (!e6) this.ensure(1);
          else {
            var t6 = y5.byteLength(e6);
            this.ensure(t6 + 1), this.buffer.write(
              e6,
              this.offset,
              "utf-8"
            ), this.offset += t6;
          }
          return this.buffer[this.offset++] = 0, this;
        }
        addString(e6 = "") {
          var t6 = y5.byteLength(e6);
          return this.ensure(t6), this.buffer.write(e6, this.offset), this.offset += t6, this;
        }
        add(e6) {
          return this.ensure(e6.length), e6.copy(this.buffer, this.offset), this.offset += e6.length, this;
        }
        join(e6) {
          if (e6) {
            this.buffer[this.headerPosition] = e6;
            let t6 = this.offset - (this.headerPosition + 1);
            this.buffer.writeInt32BE(t6, this.headerPosition + 1);
          }
          return this.buffer.slice(e6 ? 0 : 5, this.offset);
        }
        flush(e6) {
          var t6 = this.join(e6);
          return this.offset = 5, this.headerPosition = 0, this.buffer = y5.allocUnsafe(this.size), t6;
        }
      };
      a7(Jr2, "Writer");
      var Zr2 = Jr2;
      bt2.Writer = Zr2;
    });
    ws2 = I5((xt2) => {
      "use strict";
      p9();
      Object.defineProperty(xt2, "__esModule", { value: true });
      xt2.serialize = void 0;
      var Xr2 = ms(), M3 = new Xr2.Writer(), Du2 = a7((r6) => {
        M3.addInt16(3).addInt16(
          0
        );
        for (let n7 of Object.keys(r6)) M3.addCString(n7).addCString(r6[n7]);
        M3.addCString("client_encoding").addCString("UTF8");
        var e6 = M3.addCString("").flush(), t6 = e6.length + 4;
        return new Xr2.Writer().addInt32(t6).add(e6).flush();
      }, "startup"), ku = a7(() => {
        let r6 = y5.allocUnsafe(8);
        return r6.writeInt32BE(8, 0), r6.writeInt32BE(80877103, 4), r6;
      }, "requestSsl"), Uu = a7((r6) => M3.addCString(r6).flush(112), "password"), Ou = a7(function(r6, e6) {
        return M3.addCString(r6).addInt32(
          y5.byteLength(e6)
        ).addString(e6), M3.flush(112);
      }, "sendSASLInitialResponseMessage"), Nu = a7(
        function(r6) {
          return M3.addString(r6).flush(112);
        },
        "sendSCRAMClientFinalMessage"
      ), qu = a7(
        (r6) => M3.addCString(r6).flush(81),
        "query"
      ), gs3 = [], Qu = a7((r6) => {
        let e6 = r6.name || "";
        e6.length > 63 && (console.error("Warning! Postgres only supports 63 characters for query names."), console.error("You supplied %s (%s)", e6, e6.length), console.error("This can cause conflicts and silent errors executing queries"));
        let t6 = r6.types || gs3;
        for (var n7 = t6.length, i8 = M3.addCString(e6).addCString(r6.text).addInt16(n7), s10 = 0; s10 < n7; s10++) i8.addInt32(t6[s10]);
        return M3.flush(80);
      }, "parse"), Oe2 = new Xr2.Writer(), Wu = a7(function(r6, e6) {
        for (let t6 = 0; t6 < r6.length; t6++) {
          let n7 = e6 ? e6(r6[t6], t6) : r6[t6];
          n7 == null ? (M3.addInt16(0), Oe2.addInt32(-1)) : n7 instanceof y5 ? (M3.addInt16(1), Oe2.addInt32(n7.length), Oe2.add(n7)) : (M3.addInt16(0), Oe2.addInt32(y5.byteLength(
            n7
          )), Oe2.addString(n7));
        }
      }, "writeValues"), ju = a7((r6 = {}) => {
        let e6 = r6.portal || "", t6 = r6.statement || "", n7 = r6.binary || false, i8 = r6.values || gs3, s10 = i8.length;
        return M3.addCString(e6).addCString(t6), M3.addInt16(s10), Wu(i8, r6.valueMapper), M3.addInt16(s10), M3.add(Oe2.flush()), M3.addInt16(n7 ? 1 : 0), M3.flush(66);
      }, "bind"), Hu = y5.from([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]), Gu = a7((r6) => {
        if (!r6 || !r6.portal && !r6.rows) return Hu;
        let e6 = r6.portal || "", t6 = r6.rows || 0, n7 = y5.byteLength(e6), i8 = 4 + n7 + 1 + 4, s10 = y5.allocUnsafe(1 + i8);
        return s10[0] = 69, s10.writeInt32BE(i8, 1), s10.write(e6, 5, "utf-8"), s10[n7 + 5] = 0, s10.writeUInt32BE(t6, s10.length - 4), s10;
      }, "execute"), $u = a7((r6, e6) => {
        let t6 = y5.allocUnsafe(16);
        return t6.writeInt32BE(16, 0), t6.writeInt16BE(1234, 4), t6.writeInt16BE(5678, 6), t6.writeInt32BE(
          r6,
          8
        ), t6.writeInt32BE(e6, 12), t6;
      }, "cancel"), en2 = a7(
        (r6, e6) => {
          let n7 = 4 + y5.byteLength(e6) + 1, i8 = y5.allocUnsafe(1 + n7);
          return i8[0] = r6, i8.writeInt32BE(n7, 1), i8.write(e6, 5, "utf-8"), i8[n7] = 0, i8;
        },
        "cstringMessage"
      ), Vu = M3.addCString("P").flush(68), Ku = M3.addCString("S").flush(68), zu = a7((r6) => r6.name ? en2(68, `${r6.type}${r6.name || ""}`) : r6.type === "P" ? Vu : Ku, "describe"), Yu = a7(
        (r6) => {
          let e6 = `${r6.type}${r6.name || ""}`;
          return en2(67, e6);
        },
        "close"
      ), Zu = a7((r6) => M3.add(r6).flush(
        100
      ), "copyData"), Ju = a7((r6) => en2(102, r6), "copyFail"), St2 = a7((r6) => y5.from([r6, 0, 0, 0, 4]), "codeOnlyBuffer"), Xu = St2(72), ec = St2(83), tc = St2(88), rc2 = St2(99), nc = {
        startup: Du2,
        password: Uu,
        requestSsl: ku,
        sendSASLInitialResponseMessage: Ou,
        sendSCRAMClientFinalMessage: Nu,
        query: qu,
        parse: Qu,
        bind: ju,
        execute: Gu,
        describe: zu,
        close: Yu,
        flush: a7(() => Xu, "flush"),
        sync: a7(
          () => ec,
          "sync"
        ),
        end: a7(() => tc, "end"),
        copyData: Zu,
        copyDone: a7(() => rc2, "copyDone"),
        copyFail: Ju,
        cancel: $u
      };
      xt2.serialize = nc;
    });
    bs2 = I5((vt2) => {
      "use strict";
      p9();
      Object.defineProperty(vt2, "__esModule", { value: true });
      vt2.BufferReader = void 0;
      var ic = y5.allocUnsafe(0), rn2 = class rn {
        constructor(e6 = 0) {
          this.offset = e6, this.buffer = ic, this.encoding = "utf-8";
        }
        setBuffer(e6, t6) {
          this.offset = e6, this.buffer = t6;
        }
        int16() {
          let e6 = this.buffer.readInt16BE(this.offset);
          return this.offset += 2, e6;
        }
        byte() {
          let e6 = this.buffer[this.offset];
          return this.offset++, e6;
        }
        int32() {
          let e6 = this.buffer.readInt32BE(this.offset);
          return this.offset += 4, e6;
        }
        string(e6) {
          let t6 = this.buffer.toString(this.encoding, this.offset, this.offset + e6);
          return this.offset += e6, t6;
        }
        cstring() {
          let e6 = this.offset, t6 = e6;
          for (; this.buffer[t6++] !== 0; ) ;
          return this.offset = t6, this.buffer.toString(this.encoding, e6, t6 - 1);
        }
        bytes(e6) {
          let t6 = this.buffer.slice(this.offset, this.offset + e6);
          return this.offset += e6, t6;
        }
      };
      a7(rn2, "BufferReader");
      var tn2 = rn2;
      vt2.BufferReader = tn2;
    });
    vs2 = I5((Et2) => {
      "use strict";
      p9();
      Object.defineProperty(Et2, "__esModule", { value: true });
      Et2.Parser = void 0;
      var D6 = Yr2(), sc = bs2(), nn2 = 1, oc = 4, Ss3 = nn2 + oc, xs = y5.allocUnsafe(0), on3 = class on {
        constructor(e6) {
          if (this.buffer = xs, this.bufferLength = 0, this.bufferOffset = 0, this.reader = new sc.BufferReader(), e6?.mode === "binary") throw new Error("Binary mode not supported yet");
          this.mode = e6?.mode || "text";
        }
        parse(e6, t6) {
          this.mergeBuffer(e6);
          let n7 = this.bufferOffset + this.bufferLength, i8 = this.bufferOffset;
          for (; i8 + Ss3 <= n7; ) {
            let s10 = this.buffer[i8], o9 = this.buffer.readUInt32BE(
              i8 + nn2
            ), u7 = nn2 + o9;
            if (u7 + i8 <= n7) {
              let c6 = this.handlePacket(i8 + Ss3, s10, o9, this.buffer);
              t6(c6), i8 += u7;
            } else
              break;
          }
          i8 === n7 ? (this.buffer = xs, this.bufferLength = 0, this.bufferOffset = 0) : (this.bufferLength = n7 - i8, this.bufferOffset = i8);
        }
        mergeBuffer(e6) {
          if (this.bufferLength > 0) {
            let t6 = this.bufferLength + e6.byteLength;
            if (t6 + this.bufferOffset > this.buffer.byteLength) {
              let i8;
              if (t6 <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) i8 = this.buffer;
              else {
                let s10 = this.buffer.byteLength * 2;
                for (; t6 >= s10; ) s10 *= 2;
                i8 = y5.allocUnsafe(s10);
              }
              this.buffer.copy(
                i8,
                0,
                this.bufferOffset,
                this.bufferOffset + this.bufferLength
              ), this.buffer = i8, this.bufferOffset = 0;
            }
            e6.copy(this.buffer, this.bufferOffset + this.bufferLength), this.bufferLength = t6;
          } else this.buffer = e6, this.bufferOffset = 0, this.bufferLength = e6.byteLength;
        }
        handlePacket(e6, t6, n7, i8) {
          switch (t6) {
            case 50:
              return D6.bindComplete;
            case 49:
              return D6.parseComplete;
            case 51:
              return D6.closeComplete;
            case 110:
              return D6.noData;
            case 115:
              return D6.portalSuspended;
            case 99:
              return D6.copyDone;
            case 87:
              return D6.replicationStart;
            case 73:
              return D6.emptyQuery;
            case 68:
              return this.parseDataRowMessage(
                e6,
                n7,
                i8
              );
            case 67:
              return this.parseCommandCompleteMessage(e6, n7, i8);
            case 90:
              return this.parseReadyForQueryMessage(e6, n7, i8);
            case 65:
              return this.parseNotificationMessage(
                e6,
                n7,
                i8
              );
            case 82:
              return this.parseAuthenticationResponse(e6, n7, i8);
            case 83:
              return this.parseParameterStatusMessage(e6, n7, i8);
            case 75:
              return this.parseBackendKeyData(e6, n7, i8);
            case 69:
              return this.parseErrorMessage(e6, n7, i8, "error");
            case 78:
              return this.parseErrorMessage(
                e6,
                n7,
                i8,
                "notice"
              );
            case 84:
              return this.parseRowDescriptionMessage(e6, n7, i8);
            case 116:
              return this.parseParameterDescriptionMessage(e6, n7, i8);
            case 71:
              return this.parseCopyInMessage(
                e6,
                n7,
                i8
              );
            case 72:
              return this.parseCopyOutMessage(e6, n7, i8);
            case 100:
              return this.parseCopyData(
                e6,
                n7,
                i8
              );
            default:
              return new D6.DatabaseError("received invalid response: " + t6.toString(
                16
              ), n7, "error");
          }
        }
        parseReadyForQueryMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.string(1);
          return new D6.ReadyForQueryMessage(t6, i8);
        }
        parseCommandCompleteMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.cstring();
          return new D6.CommandCompleteMessage(
            t6,
            i8
          );
        }
        parseCopyData(e6, t6, n7) {
          let i8 = n7.slice(e6, e6 + (t6 - 4));
          return new D6.CopyDataMessage(
            t6,
            i8
          );
        }
        parseCopyInMessage(e6, t6, n7) {
          return this.parseCopyMessage(e6, t6, n7, "copyInResponse");
        }
        parseCopyOutMessage(e6, t6, n7) {
          return this.parseCopyMessage(e6, t6, n7, "copyOutResponse");
        }
        parseCopyMessage(e6, t6, n7, i8) {
          this.reader.setBuffer(e6, n7);
          let s10 = this.reader.byte() !== 0, o9 = this.reader.int16(), u7 = new D6.CopyResponse(t6, i8, s10, o9);
          for (let c6 = 0; c6 < o9; c6++) u7.columnTypes[c6] = this.reader.int16();
          return u7;
        }
        parseNotificationMessage(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int32(), s10 = this.reader.cstring(), o9 = this.reader.cstring();
          return new D6.NotificationResponseMessage(t6, i8, s10, o9);
        }
        parseRowDescriptionMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int16(), s10 = new D6.RowDescriptionMessage(t6, i8);
          for (let o9 = 0; o9 < i8; o9++) s10.fields[o9] = this.parseField();
          return s10;
        }
        parseField() {
          let e6 = this.reader.cstring(), t6 = this.reader.int32(), n7 = this.reader.int16(), i8 = this.reader.int32(), s10 = this.reader.int16(), o9 = this.reader.int32(), u7 = this.reader.int16() === 0 ? "text" : "binary";
          return new D6.Field(e6, t6, n7, i8, s10, o9, u7);
        }
        parseParameterDescriptionMessage(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int16(), s10 = new D6.ParameterDescriptionMessage(t6, i8);
          for (let o9 = 0; o9 < i8; o9++) s10.dataTypeIDs[o9] = this.reader.int32();
          return s10;
        }
        parseDataRowMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int16(), s10 = new Array(i8);
          for (let o9 = 0; o9 < i8; o9++) {
            let u7 = this.reader.int32();
            s10[o9] = u7 === -1 ? null : this.reader.string(u7);
          }
          return new D6.DataRowMessage(
            t6,
            s10
          );
        }
        parseParameterStatusMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.cstring(), s10 = this.reader.cstring();
          return new D6.ParameterStatusMessage(t6, i8, s10);
        }
        parseBackendKeyData(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int32(), s10 = this.reader.int32();
          return new D6.BackendKeyDataMessage(t6, i8, s10);
        }
        parseAuthenticationResponse(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int32(), s10 = { name: "authenticationOk", length: t6 };
          switch (i8) {
            case 0:
              break;
            case 3:
              s10.length === 8 && (s10.name = "authenticationCleartextPassword");
              break;
            case 5:
              if (s10.length === 12) {
                s10.name = "authenticationMD5Password";
                let u7 = this.reader.bytes(4);
                return new D6.AuthenticationMD5Password(t6, u7);
              }
              break;
            case 10:
              s10.name = "authenticationSASL", s10.mechanisms = [];
              let o9;
              do
                o9 = this.reader.cstring(), o9 && s10.mechanisms.push(o9);
              while (o9);
              break;
            case 11:
              s10.name = "authenticationSASLContinue", s10.data = this.reader.string(t6 - 8);
              break;
            case 12:
              s10.name = "authenticationSASLFinal", s10.data = this.reader.string(t6 - 8);
              break;
            default:
              throw new Error("Unknown authenticationOk message type " + i8);
          }
          return s10;
        }
        parseErrorMessage(e6, t6, n7, i8) {
          this.reader.setBuffer(e6, n7);
          let s10 = {}, o9 = this.reader.string(1);
          for (; o9 !== "\0"; ) s10[o9] = this.reader.cstring(), o9 = this.reader.string(1);
          let u7 = s10.M, c6 = i8 === "notice" ? new D6.NoticeMessage(
            t6,
            u7
          ) : new D6.DatabaseError(u7, t6, i8);
          return c6.severity = s10.S, c6.code = s10.C, c6.detail = s10.D, c6.hint = s10.H, c6.position = s10.P, c6.internalPosition = s10.p, c6.internalQuery = s10.q, c6.where = s10.W, c6.schema = s10.s, c6.table = s10.t, c6.column = s10.c, c6.dataType = s10.d, c6.constraint = s10.n, c6.file = s10.F, c6.line = s10.L, c6.routine = s10.R, c6;
        }
      };
      a7(on3, "Parser");
      var sn2 = on3;
      Et2.Parser = sn2;
    });
    an2 = I5((Se3) => {
      "use strict";
      p9();
      Object.defineProperty(Se3, "__esModule", { value: true });
      Se3.DatabaseError = Se3.serialize = Se3.parse = void 0;
      var ac = Yr2();
      Object.defineProperty(
        Se3,
        "DatabaseError",
        { enumerable: true, get: a7(function() {
          return ac.DatabaseError;
        }, "get") }
      );
      var uc = ws2();
      Object.defineProperty(Se3, "serialize", { enumerable: true, get: a7(function() {
        return uc.serialize;
      }, "get") });
      var cc = vs2();
      function hc(r6, e6) {
        let t6 = new cc.Parser();
        return r6.on("data", (n7) => t6.parse(n7, e6)), new Promise((n7) => r6.on("end", () => n7()));
      }
      a7(hc, "parse");
      Se3.parse = hc;
    });
    Es = {};
    ie2(Es, { connect: () => lc2 });
    _s2 = z4(() => {
      "use strict";
      p9();
      a7(lc2, "connect");
    });
    hn2 = I5((tf, Ts) => {
      "use strict";
      p9();
      var As3 = (wt3(), N3(ys2)), fc2 = we3().EventEmitter, {
        parse: pc,
        serialize: Q3
      } = an2(), Cs2 = Q3.flush(), dc = Q3.sync(), yc = Q3.end(), cn4 = class cn extends fc2 {
        constructor(e6) {
          super(), e6 = e6 || {}, this.stream = e6.stream || new As3.Socket(), this._keepAlive = e6.keepAlive, this._keepAliveInitialDelayMillis = e6.keepAliveInitialDelayMillis, this.lastBuffer = false, this.parsedStatements = {}, this.ssl = e6.ssl || false, this._ending = false, this._emitMessage = false;
          var t6 = this;
          this.on("newListener", function(n7) {
            n7 === "message" && (t6._emitMessage = true);
          });
        }
        connect(e6, t6) {
          var n7 = this;
          this._connecting = true, this.stream.setNoDelay(true), this.stream.connect(
            e6,
            t6
          ), this.stream.once("connect", function() {
            n7._keepAlive && n7.stream.setKeepAlive(
              true,
              n7._keepAliveInitialDelayMillis
            ), n7.emit("connect");
          });
          let i8 = a7(function(s10) {
            n7._ending && (s10.code === "ECONNRESET" || s10.code === "EPIPE") || n7.emit("error", s10);
          }, "reportStreamError");
          if (this.stream.on("error", i8), this.stream.on("close", function() {
            n7.emit("end");
          }), !this.ssl) return this.attachListeners(this.stream);
          this.stream.once("data", function(s10) {
            var o9 = s10.toString("utf8");
            switch (o9) {
              case "S":
                break;
              case "N":
                return n7.stream.end(), n7.emit("error", new Error("The server does not support SSL connections"));
              default:
                return n7.stream.end(), n7.emit("error", new Error("There was an error establishing an SSL connection"));
            }
            var u7 = (_s2(), N3(Es));
            let c6 = { socket: n7.stream };
            n7.ssl !== true && (Object.assign(
              c6,
              n7.ssl
            ), "key" in n7.ssl && (c6.key = n7.ssl.key)), As3.isIP(t6) === 0 && (c6.servername = t6);
            try {
              n7.stream = u7.connect(c6);
            } catch (h8) {
              return n7.emit("error", h8);
            }
            n7.attachListeners(n7.stream), n7.stream.on("error", i8), n7.emit("sslconnect");
          });
        }
        attachListeners(e6) {
          e6.on("end", () => {
            this.emit("end");
          }), pc(e6, (t6) => {
            var n7 = t6.name === "error" ? "errorMessage" : t6.name;
            this._emitMessage && this.emit("message", t6), this.emit(n7, t6);
          });
        }
        requestSsl() {
          this.stream.write(Q3.requestSsl());
        }
        startup(e6) {
          this.stream.write(Q3.startup(e6));
        }
        cancel(e6, t6) {
          this._send(Q3.cancel(e6, t6));
        }
        password(e6) {
          this._send(Q3.password(e6));
        }
        sendSASLInitialResponseMessage(e6, t6) {
          this._send(Q3.sendSASLInitialResponseMessage(
            e6,
            t6
          ));
        }
        sendSCRAMClientFinalMessage(e6) {
          this._send(Q3.sendSCRAMClientFinalMessage(e6));
        }
        _send(e6) {
          return this.stream.writable ? this.stream.write(e6) : false;
        }
        query(e6) {
          this._send(Q3.query(
            e6
          ));
        }
        parse(e6) {
          this._send(Q3.parse(e6));
        }
        bind(e6) {
          this._send(Q3.bind(e6));
        }
        execute(e6) {
          this._send(Q3.execute(e6));
        }
        flush() {
          this.stream.writable && this.stream.write(Cs2);
        }
        sync() {
          this._ending = true, this._send(Cs2), this._send(dc);
        }
        ref() {
          this.stream.ref();
        }
        unref() {
          this.stream.unref();
        }
        end() {
          if (this._ending = true, !this._connecting || !this.stream.writable) {
            this.stream.end();
            return;
          }
          return this.stream.write(yc, () => {
            this.stream.end();
          });
        }
        close(e6) {
          this._send(Q3.close(e6));
        }
        describe(e6) {
          this._send(Q3.describe(e6));
        }
        sendCopyFromChunk(e6) {
          this._send(Q3.copyData(e6));
        }
        endCopyFrom() {
          this._send(Q3.copyDone());
        }
        sendCopyFail(e6) {
          this._send(Q3.copyFail(e6));
        }
      };
      a7(cn4, "Connection");
      var un2 = cn4;
      Ts.exports = un2;
    });
    Bs = I5((of, Ps) => {
      "use strict";
      p9();
      var mc = we3().EventEmitter, sf = (He3(), N3(je2)), gc = et3(), ln2 = qi2(), wc = Zi(), bc = mt2(), Sc = gt4(), Is = ps2(), xc = Xe3(), vc = hn2(), fn3 = class fn extends mc {
        constructor(e6) {
          super(), this.connectionParameters = new Sc(e6), this.user = this.connectionParameters.user, this.database = this.connectionParameters.database, this.port = this.connectionParameters.port, this.host = this.connectionParameters.host, Object.defineProperty(this, "password", { configurable: true, enumerable: false, writable: true, value: this.connectionParameters.password }), this.replication = this.connectionParameters.replication;
          var t6 = e6 || {};
          this._Promise = t6.Promise || S5.Promise, this._types = new bc(t6.types), this._ending = false, this._connecting = false, this._connected = false, this._connectionError = false, this._queryable = true, this.connection = t6.connection || new vc({ stream: t6.stream, ssl: this.connectionParameters.ssl, keepAlive: t6.keepAlive || false, keepAliveInitialDelayMillis: t6.keepAliveInitialDelayMillis || 0, encoding: this.connectionParameters.client_encoding || "utf8" }), this.queryQueue = [], this.binary = t6.binary || xc.binary, this.processID = null, this.secretKey = null, this.ssl = this.connectionParameters.ssl || false, this.ssl && this.ssl.key && Object.defineProperty(this.ssl, "key", { enumerable: false }), this._connectionTimeoutMillis = t6.connectionTimeoutMillis || 0;
        }
        _errorAllQueries(e6) {
          let t6 = a7(
            (n7) => {
              m10.nextTick(() => {
                n7.handleError(e6, this.connection);
              });
            },
            "enqueueError"
          );
          this.activeQuery && (t6(this.activeQuery), this.activeQuery = null), this.queryQueue.forEach(t6), this.queryQueue.length = 0;
        }
        _connect(e6) {
          var t6 = this, n7 = this.connection;
          if (this._connectionCallback = e6, this._connecting || this._connected) {
            let i8 = new Error("Client has already been connected. You cannot reuse a client.");
            m10.nextTick(() => {
              e6(i8);
            });
            return;
          }
          this._connecting = true, this.connectionTimeoutHandle, this._connectionTimeoutMillis > 0 && (this.connectionTimeoutHandle = setTimeout(() => {
            n7._ending = true, n7.stream.destroy(new Error("timeout expired"));
          }, this._connectionTimeoutMillis)), this.host && this.host.indexOf("/") === 0 ? n7.connect(this.host + "/.s.PGSQL." + this.port) : n7.connect(this.port, this.host), n7.on("connect", function() {
            t6.ssl ? n7.requestSsl() : n7.startup(t6.getStartupConf());
          }), n7.on("sslconnect", function() {
            n7.startup(t6.getStartupConf());
          }), this._attachListeners(n7), n7.once("end", () => {
            let i8 = this._ending ? new Error("Connection terminated") : new Error("Connection terminated unexpectedly");
            clearTimeout(this.connectionTimeoutHandle), this._errorAllQueries(i8), this._ending || (this._connecting && !this._connectionError ? this._connectionCallback ? this._connectionCallback(i8) : this._handleErrorEvent(i8) : this._connectionError || this._handleErrorEvent(
              i8
            )), m10.nextTick(() => {
              this.emit("end");
            });
          });
        }
        connect(e6) {
          if (e6) {
            this._connect(e6);
            return;
          }
          return new this._Promise((t6, n7) => {
            this._connect((i8) => {
              i8 ? n7(i8) : t6();
            });
          });
        }
        _attachListeners(e6) {
          e6.on("authenticationCleartextPassword", this._handleAuthCleartextPassword.bind(this)), e6.on("authenticationMD5Password", this._handleAuthMD5Password.bind(this)), e6.on("authenticationSASL", this._handleAuthSASL.bind(this)), e6.on("authenticationSASLContinue", this._handleAuthSASLContinue.bind(this)), e6.on("authenticationSASLFinal", this._handleAuthSASLFinal.bind(this)), e6.on("backendKeyData", this._handleBackendKeyData.bind(this)), e6.on("error", this._handleErrorEvent.bind(this)), e6.on(
            "errorMessage",
            this._handleErrorMessage.bind(this)
          ), e6.on("readyForQuery", this._handleReadyForQuery.bind(this)), e6.on("notice", this._handleNotice.bind(this)), e6.on("rowDescription", this._handleRowDescription.bind(this)), e6.on("dataRow", this._handleDataRow.bind(this)), e6.on("portalSuspended", this._handlePortalSuspended.bind(this)), e6.on(
            "emptyQuery",
            this._handleEmptyQuery.bind(this)
          ), e6.on("commandComplete", this._handleCommandComplete.bind(this)), e6.on("parseComplete", this._handleParseComplete.bind(this)), e6.on("copyInResponse", this._handleCopyInResponse.bind(this)), e6.on("copyData", this._handleCopyData.bind(this)), e6.on("notification", this._handleNotification.bind(this));
        }
        _checkPgPass(e6) {
          let t6 = this.connection;
          typeof this.password == "function" ? this._Promise.resolve().then(
            () => this.password()
          ).then((n7) => {
            if (n7 !== void 0) {
              if (typeof n7 != "string") {
                t6.emit("error", new TypeError("Password must be a string"));
                return;
              }
              this.connectionParameters.password = this.password = n7;
            } else this.connectionParameters.password = this.password = null;
            e6();
          }).catch((n7) => {
            t6.emit("error", n7);
          }) : this.password !== null ? e6() : wc(
            this.connectionParameters,
            (n7) => {
              n7 !== void 0 && (this.connectionParameters.password = this.password = n7), e6();
            }
          );
        }
        _handleAuthCleartextPassword(e6) {
          this._checkPgPass(() => {
            this.connection.password(this.password);
          });
        }
        _handleAuthMD5Password(e6) {
          this._checkPgPass(() => {
            let t6 = gc.postgresMd5PasswordHash(
              this.user,
              this.password,
              e6.salt
            );
            this.connection.password(t6);
          });
        }
        _handleAuthSASL(e6) {
          this._checkPgPass(() => {
            this.saslSession = ln2.startSession(e6.mechanisms), this.connection.sendSASLInitialResponseMessage(
              this.saslSession.mechanism,
              this.saslSession.response
            );
          });
        }
        _handleAuthSASLContinue(e6) {
          ln2.continueSession(this.saslSession, this.password, e6.data), this.connection.sendSCRAMClientFinalMessage(
            this.saslSession.response
          );
        }
        _handleAuthSASLFinal(e6) {
          ln2.finalizeSession(
            this.saslSession,
            e6.data
          ), this.saslSession = null;
        }
        _handleBackendKeyData(e6) {
          this.processID = e6.processID, this.secretKey = e6.secretKey;
        }
        _handleReadyForQuery(e6) {
          this._connecting && (this._connecting = false, this._connected = true, clearTimeout(this.connectionTimeoutHandle), this._connectionCallback && (this._connectionCallback(null, this), this._connectionCallback = null), this.emit("connect"));
          let { activeQuery: t6 } = this;
          this.activeQuery = null, this.readyForQuery = true, t6 && t6.handleReadyForQuery(this.connection), this._pulseQueryQueue();
        }
        _handleErrorWhileConnecting(e6) {
          if (!this._connectionError) {
            if (this._connectionError = true, clearTimeout(this.connectionTimeoutHandle), this._connectionCallback) return this._connectionCallback(e6);
            this.emit("error", e6);
          }
        }
        _handleErrorEvent(e6) {
          if (this._connecting) return this._handleErrorWhileConnecting(e6);
          this._queryable = false, this._errorAllQueries(e6), this.emit("error", e6);
        }
        _handleErrorMessage(e6) {
          if (this._connecting)
            return this._handleErrorWhileConnecting(e6);
          let t6 = this.activeQuery;
          if (!t6) {
            this._handleErrorEvent(
              e6
            );
            return;
          }
          this.activeQuery = null, t6.handleError(e6, this.connection);
        }
        _handleRowDescription(e6) {
          this.activeQuery.handleRowDescription(e6);
        }
        _handleDataRow(e6) {
          this.activeQuery.handleDataRow(
            e6
          );
        }
        _handlePortalSuspended(e6) {
          this.activeQuery.handlePortalSuspended(this.connection);
        }
        _handleEmptyQuery(e6) {
          this.activeQuery.handleEmptyQuery(this.connection);
        }
        _handleCommandComplete(e6) {
          this.activeQuery.handleCommandComplete(e6, this.connection);
        }
        _handleParseComplete(e6) {
          this.activeQuery.name && (this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text);
        }
        _handleCopyInResponse(e6) {
          this.activeQuery.handleCopyInResponse(
            this.connection
          );
        }
        _handleCopyData(e6) {
          this.activeQuery.handleCopyData(e6, this.connection);
        }
        _handleNotification(e6) {
          this.emit("notification", e6);
        }
        _handleNotice(e6) {
          this.emit("notice", e6);
        }
        getStartupConf() {
          var e6 = this.connectionParameters, t6 = { user: e6.user, database: e6.database }, n7 = e6.application_name || e6.fallback_application_name;
          return n7 && (t6.application_name = n7), e6.replication && (t6.replication = "" + e6.replication), e6.statement_timeout && (t6.statement_timeout = String(parseInt(
            e6.statement_timeout,
            10
          ))), e6.lock_timeout && (t6.lock_timeout = String(parseInt(e6.lock_timeout, 10))), e6.idle_in_transaction_session_timeout && (t6.idle_in_transaction_session_timeout = String(parseInt(
            e6.idle_in_transaction_session_timeout,
            10
          ))), e6.options && (t6.options = e6.options), t6;
        }
        cancel(e6, t6) {
          if (e6.activeQuery === t6) {
            var n7 = this.connection;
            this.host && this.host.indexOf("/") === 0 ? n7.connect(this.host + "/.s.PGSQL." + this.port) : n7.connect(this.port, this.host), n7.on("connect", function() {
              n7.cancel(
                e6.processID,
                e6.secretKey
              );
            });
          } else e6.queryQueue.indexOf(t6) !== -1 && e6.queryQueue.splice(e6.queryQueue.indexOf(t6), 1);
        }
        setTypeParser(e6, t6, n7) {
          return this._types.setTypeParser(e6, t6, n7);
        }
        getTypeParser(e6, t6) {
          return this._types.getTypeParser(e6, t6);
        }
        escapeIdentifier(e6) {
          return '"' + e6.replace(
            /"/g,
            '""'
          ) + '"';
        }
        escapeLiteral(e6) {
          for (var t6 = false, n7 = "'", i8 = 0; i8 < e6.length; i8++) {
            var s10 = e6[i8];
            s10 === "'" ? n7 += s10 + s10 : s10 === "\\" ? (n7 += s10 + s10, t6 = true) : n7 += s10;
          }
          return n7 += "'", t6 === true && (n7 = " E" + n7), n7;
        }
        _pulseQueryQueue() {
          if (this.readyForQuery === true) if (this.activeQuery = this.queryQueue.shift(), this.activeQuery) {
            this.readyForQuery = false, this.hasExecuted = true;
            let e6 = this.activeQuery.submit(this.connection);
            e6 && m10.nextTick(() => {
              this.activeQuery.handleError(e6, this.connection), this.readyForQuery = true, this._pulseQueryQueue();
            });
          } else this.hasExecuted && (this.activeQuery = null, this.emit("drain"));
        }
        query(e6, t6, n7) {
          var i8, s10, o9, u7, c6;
          if (e6 == null) throw new TypeError("Client was passed a null or undefined query");
          return typeof e6.submit == "function" ? (o9 = e6.query_timeout || this.connectionParameters.query_timeout, s10 = i8 = e6, typeof t6 == "function" && (i8.callback = i8.callback || t6)) : (o9 = this.connectionParameters.query_timeout, i8 = new Is(
            e6,
            t6,
            n7
          ), i8.callback || (s10 = new this._Promise((h8, l7) => {
            i8.callback = (d7, b9) => d7 ? l7(d7) : h8(b9);
          }))), o9 && (c6 = i8.callback, u7 = setTimeout(() => {
            var h8 = new Error("Query read timeout");
            m10.nextTick(
              () => {
                i8.handleError(h8, this.connection);
              }
            ), c6(h8), i8.callback = () => {
            };
            var l7 = this.queryQueue.indexOf(i8);
            l7 > -1 && this.queryQueue.splice(l7, 1), this._pulseQueryQueue();
          }, o9), i8.callback = (h8, l7) => {
            clearTimeout(u7), c6(h8, l7);
          }), this.binary && !i8.binary && (i8.binary = true), i8._result && !i8._result._types && (i8._result._types = this._types), this._queryable ? this._ending ? (m10.nextTick(() => {
            i8.handleError(
              new Error("Client was closed and is not queryable"),
              this.connection
            );
          }), s10) : (this.queryQueue.push(i8), this._pulseQueryQueue(), s10) : (m10.nextTick(
            () => {
              i8.handleError(new Error("Client has encountered a connection error and is not queryable"), this.connection);
            }
          ), s10);
        }
        ref() {
          this.connection.ref();
        }
        unref() {
          this.connection.unref();
        }
        end(e6) {
          if (this._ending = true, !this.connection._connecting) if (e6) e6();
          else return this._Promise.resolve();
          if (this.activeQuery || !this._queryable ? this.connection.stream.destroy() : this.connection.end(), e6) this.connection.once("end", e6);
          else return new this._Promise((t6) => {
            this.connection.once("end", t6);
          });
        }
      };
      a7(fn3, "Client");
      var _t2 = fn3;
      _t2.Query = Is;
      Ps.exports = _t2;
    });
    Ms = I5((cf, Fs) => {
      "use strict";
      p9();
      var Ec = we3().EventEmitter, Ls2 = a7(function() {
      }, "NOOP"), Rs2 = a7(
        (r6, e6) => {
          let t6 = r6.findIndex(e6);
          return t6 === -1 ? void 0 : r6.splice(t6, 1)[0];
        },
        "removeWhere"
      ), yn2 = class yn {
        constructor(e6, t6, n7) {
          this.client = e6, this.idleListener = t6, this.timeoutId = n7;
        }
      };
      a7(yn2, "IdleItem");
      var pn2 = yn2, mn2 = class mn {
        constructor(e6) {
          this.callback = e6;
        }
      };
      a7(mn2, "PendingItem");
      var Ne3 = mn2;
      function _c14() {
        throw new Error("Release called on client which has already been released to the pool.");
      }
      a7(_c14, "throwOnDoubleRelease");
      function At3(r6, e6) {
        if (e6) return { callback: e6, result: void 0 };
        let t6, n7, i8 = a7(function(o9, u7) {
          o9 ? t6(o9) : n7(u7);
        }, "cb"), s10 = new r6(function(o9, u7) {
          n7 = o9, t6 = u7;
        }).catch((o9) => {
          throw Error.captureStackTrace(
            o9
          ), o9;
        });
        return { callback: i8, result: s10 };
      }
      a7(At3, "promisify");
      function Ac(r6, e6) {
        return a7(
          function t6(n7) {
            n7.client = e6, e6.removeListener("error", t6), e6.on("error", () => {
              r6.log("additional client error after disconnection due to error", n7);
            }), r6._remove(e6), r6.emit("error", n7, e6);
          },
          "idleListener"
        );
      }
      a7(Ac, "makeIdleListener");
      var gn2 = class gn extends Ec {
        constructor(e6, t6) {
          super(), this.options = Object.assign({}, e6), e6 != null && "password" in e6 && Object.defineProperty(
            this.options,
            "password",
            { configurable: true, enumerable: false, writable: true, value: e6.password }
          ), e6 != null && e6.ssl && e6.ssl.key && Object.defineProperty(this.options.ssl, "key", { enumerable: false }), this.options.max = this.options.max || this.options.poolSize || 10, this.options.maxUses = this.options.maxUses || 1 / 0, this.options.allowExitOnIdle = this.options.allowExitOnIdle || false, this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0, this.log = this.options.log || function() {
          }, this.Client = this.options.Client || t6 || Ct3().Client, this.Promise = this.options.Promise || S5.Promise, typeof this.options.idleTimeoutMillis > "u" && (this.options.idleTimeoutMillis = 1e4), this._clients = [], this._idle = [], this._expired = /* @__PURE__ */ new WeakSet(), this._pendingQueue = [], this._endCallback = void 0, this.ending = false, this.ended = false;
        }
        _isFull() {
          return this._clients.length >= this.options.max;
        }
        _pulseQueue() {
          if (this.log("pulse queue"), this.ended) {
            this.log("pulse queue ended");
            return;
          }
          if (this.ending) {
            this.log(
              "pulse queue on ending"
            ), this._idle.length && this._idle.slice().map((t6) => {
              this._remove(
                t6.client
              );
            }), this._clients.length || (this.ended = true, this._endCallback());
            return;
          }
          if (!this._pendingQueue.length) {
            this.log("no queued requests");
            return;
          }
          if (!this._idle.length && this._isFull()) return;
          let e6 = this._pendingQueue.shift();
          if (this._idle.length) {
            let t6 = this._idle.pop();
            clearTimeout(t6.timeoutId);
            let n7 = t6.client;
            n7.ref && n7.ref();
            let i8 = t6.idleListener;
            return this._acquireClient(n7, e6, i8, false);
          }
          if (!this._isFull()) return this.newClient(e6);
          throw new Error("unexpected condition");
        }
        _remove(e6) {
          let t6 = Rs2(this._idle, (n7) => n7.client === e6);
          t6 !== void 0 && clearTimeout(t6.timeoutId), this._clients = this._clients.filter((n7) => n7 !== e6), e6.end(), this.emit("remove", e6);
        }
        connect(e6) {
          if (this.ending) {
            let i8 = new Error("Cannot use a pool after calling end on the pool");
            return e6 ? e6(i8) : this.Promise.reject(
              i8
            );
          }
          let t6 = At3(this.Promise, e6), n7 = t6.result;
          if (this._isFull() || this._idle.length) {
            if (this._idle.length && m10.nextTick(() => this._pulseQueue()), !this.options.connectionTimeoutMillis)
              return this._pendingQueue.push(new Ne3(t6.callback)), n7;
            let i8 = a7((u7, c6, h8) => {
              clearTimeout(
                o9
              ), t6.callback(u7, c6, h8);
            }, "queueCallback"), s10 = new Ne3(i8), o9 = setTimeout(() => {
              Rs2(
                this._pendingQueue,
                (u7) => u7.callback === i8
              ), s10.timedOut = true, t6.callback(new Error("timeout exceeded when trying to connect"));
            }, this.options.connectionTimeoutMillis);
            return this._pendingQueue.push(s10), n7;
          }
          return this.newClient(new Ne3(t6.callback)), n7;
        }
        newClient(e6) {
          let t6 = new this.Client(this.options);
          this._clients.push(t6);
          let n7 = Ac(this, t6);
          this.log("checking client timeout");
          let i8, s10 = false;
          this.options.connectionTimeoutMillis && (i8 = setTimeout(() => {
            this.log("ending client due to timeout"), s10 = true, t6.connection ? t6.connection.stream.destroy() : t6.end();
          }, this.options.connectionTimeoutMillis)), this.log("connecting new client"), t6.connect((o9) => {
            if (i8 && clearTimeout(i8), t6.on("error", n7), o9) this.log("client failed to connect", o9), this._clients = this._clients.filter((u7) => u7 !== t6), s10 && (o9.message = "Connection terminated due to connection timeout"), this._pulseQueue(), e6.timedOut || e6.callback(
              o9,
              void 0,
              Ls2
            );
            else {
              if (this.log("new client connected"), this.options.maxLifetimeSeconds !== 0) {
                let u7 = setTimeout(() => {
                  this.log("ending client due to expired lifetime"), this._expired.add(t6), this._idle.findIndex((h8) => h8.client === t6) !== -1 && this._acquireClient(
                    t6,
                    new Ne3((h8, l7, d7) => d7()),
                    n7,
                    false
                  );
                }, this.options.maxLifetimeSeconds * 1e3);
                u7.unref(), t6.once(
                  "end",
                  () => clearTimeout(u7)
                );
              }
              return this._acquireClient(t6, e6, n7, true);
            }
          });
        }
        _acquireClient(e6, t6, n7, i8) {
          i8 && this.emit("connect", e6), this.emit("acquire", e6), e6.release = this._releaseOnce(e6, n7), e6.removeListener("error", n7), t6.timedOut ? i8 && this.options.verify ? this.options.verify(
            e6,
            e6.release
          ) : e6.release() : i8 && this.options.verify ? this.options.verify(e6, (s10) => {
            if (s10) return e6.release(s10), t6.callback(s10, void 0, Ls2);
            t6.callback(void 0, e6, e6.release);
          }) : t6.callback(
            void 0,
            e6,
            e6.release
          );
        }
        _releaseOnce(e6, t6) {
          let n7 = false;
          return (i8) => {
            n7 && _c14(), n7 = true, this._release(
              e6,
              t6,
              i8
            );
          };
        }
        _release(e6, t6, n7) {
          if (e6.on("error", t6), e6._poolUseCount = (e6._poolUseCount || 0) + 1, this.emit("release", n7, e6), n7 || this.ending || !e6._queryable || e6._ending || e6._poolUseCount >= this.options.maxUses) {
            e6._poolUseCount >= this.options.maxUses && this.log("remove expended client"), this._remove(e6), this._pulseQueue();
            return;
          }
          if (this._expired.has(e6)) {
            this.log("remove expired client"), this._expired.delete(e6), this._remove(e6), this._pulseQueue();
            return;
          }
          let s10;
          this.options.idleTimeoutMillis && (s10 = setTimeout(() => {
            this.log("remove idle client"), this._remove(e6);
          }, this.options.idleTimeoutMillis), this.options.allowExitOnIdle && s10.unref()), this.options.allowExitOnIdle && e6.unref(), this._idle.push(new pn2(e6, t6, s10)), this._pulseQueue();
        }
        query(e6, t6, n7) {
          if (typeof e6 == "function") {
            let s10 = At3(this.Promise, e6);
            return x9(function() {
              return s10.callback(new Error("Passing a function as the first parameter to pool.query is not supported"));
            }), s10.result;
          }
          typeof t6 == "function" && (n7 = t6, t6 = void 0);
          let i8 = At3(this.Promise, n7);
          return n7 = i8.callback, this.connect((s10, o9) => {
            if (s10)
              return n7(s10);
            let u7 = false, c6 = a7((h8) => {
              u7 || (u7 = true, o9.release(h8), n7(h8));
            }, "onError");
            o9.once("error", c6), this.log("dispatching query");
            try {
              o9.query(e6, t6, (h8, l7) => {
                if (this.log("query dispatched"), o9.removeListener("error", c6), !u7) return u7 = true, o9.release(h8), h8 ? n7(h8) : n7(
                  void 0,
                  l7
                );
              });
            } catch (h8) {
              return o9.release(h8), n7(h8);
            }
          }), i8.result;
        }
        end(e6) {
          if (this.log("ending"), this.ending) {
            let n7 = new Error("Called end on pool more than once");
            return e6 ? e6(n7) : this.Promise.reject(n7);
          }
          this.ending = true;
          let t6 = At3(this.Promise, e6);
          return this._endCallback = t6.callback, this._pulseQueue(), t6.result;
        }
        get waitingCount() {
          return this._pendingQueue.length;
        }
        get idleCount() {
          return this._idle.length;
        }
        get expiredCount() {
          return this._clients.reduce((e6, t6) => e6 + (this._expired.has(t6) ? 1 : 0), 0);
        }
        get totalCount() {
          return this._clients.length;
        }
      };
      a7(gn2, "Pool");
      var dn2 = gn2;
      Fs.exports = dn2;
    });
    Ds2 = {};
    ie2(Ds2, { default: () => Cc2 });
    ks2 = z4(() => {
      "use strict";
      p9();
      Cc2 = {};
    });
    Us2 = I5((pf, Tc2) => {
      Tc2.exports = { name: "pg", version: "8.8.0", description: "PostgreSQL client - pure javascript & libpq with the same API", keywords: [
        "database",
        "libpq",
        "pg",
        "postgre",
        "postgres",
        "postgresql",
        "rdbms"
      ], homepage: "https://github.com/brianc/node-postgres", repository: { type: "git", url: "git://github.com/brianc/node-postgres.git", directory: "packages/pg" }, author: "Brian Carlson <brian.m.carlson@gmail.com>", main: "./lib", dependencies: {
        "buffer-writer": "2.0.0",
        "packet-reader": "1.0.0",
        "pg-connection-string": "^2.5.0",
        "pg-pool": "^3.5.2",
        "pg-protocol": "^1.5.0",
        "pg-types": "^2.1.0",
        pgpass: "1.x"
      }, devDependencies: { async: "2.6.4", bluebird: "3.5.2", co: "4.6.0", "pg-copy-streams": "0.3.0" }, peerDependencies: { "pg-native": ">=3.0.1" }, peerDependenciesMeta: {
        "pg-native": { optional: true }
      }, scripts: { test: "make test-all" }, files: ["lib", "SPONSORS.md"], license: "MIT", engines: { node: ">= 8.0.0" }, gitHead: "c99fb2c127ddf8d712500db2c7b9a5491a178655" };
    });
    qs = I5((df, Ns2) => {
      "use strict";
      p9();
      var Os3 = we3().EventEmitter, Ic = (He3(), N3(je2)), wn3 = et3(), qe2 = Ns2.exports = function(r6, e6, t6) {
        Os3.call(this), r6 = wn3.normalizeQueryConfig(r6, e6, t6), this.text = r6.text, this.values = r6.values, this.name = r6.name, this.callback = r6.callback, this.state = "new", this._arrayMode = r6.rowMode === "array", this._emitRowEvents = false, this.on("newListener", function(n7) {
          n7 === "row" && (this._emitRowEvents = true);
        }.bind(this));
      };
      Ic.inherits(
        qe2,
        Os3
      );
      var Pc = { sqlState: "code", statementPosition: "position", messagePrimary: "message", context: "where", schemaName: "schema", tableName: "table", columnName: "column", dataTypeName: "dataType", constraintName: "constraint", sourceFile: "file", sourceLine: "line", sourceFunction: "routine" };
      qe2.prototype.handleError = function(r6) {
        var e6 = this.native.pq.resultErrorFields();
        if (e6) for (var t6 in e6) {
          var n7 = Pc[t6] || t6;
          r6[n7] = e6[t6];
        }
        this.callback ? this.callback(r6) : this.emit("error", r6), this.state = "error";
      };
      qe2.prototype.then = function(r6, e6) {
        return this._getPromise().then(r6, e6);
      };
      qe2.prototype.catch = function(r6) {
        return this._getPromise().catch(r6);
      };
      qe2.prototype._getPromise = function() {
        return this._promise ? this._promise : (this._promise = new Promise(function(r6, e6) {
          this._once("end", r6), this._once(
            "error",
            e6
          );
        }.bind(this)), this._promise);
      };
      qe2.prototype.submit = function(r6) {
        this.state = "running";
        var e6 = this;
        this.native = r6.native, r6.native.arrayMode = this._arrayMode;
        var t6 = a7(
          function(s10, o9, u7) {
            if (r6.native.arrayMode = false, x9(function() {
              e6.emit("_done");
            }), s10) return e6.handleError(s10);
            e6._emitRowEvents && (u7.length > 1 ? o9.forEach((c6, h8) => {
              c6.forEach((l7) => {
                e6.emit(
                  "row",
                  l7,
                  u7[h8]
                );
              });
            }) : o9.forEach(function(c6) {
              e6.emit("row", c6, u7);
            })), e6.state = "end", e6.emit(
              "end",
              u7
            ), e6.callback && e6.callback(null, u7);
          },
          "after"
        );
        if (m10.domain && (t6 = m10.domain.bind(
          t6
        )), this.name) {
          this.name.length > 63 && (console.error("Warning! Postgres only supports 63 characters for query names."), console.error(
            "You supplied %s (%s)",
            this.name,
            this.name.length
          ), console.error("This can cause conflicts and silent errors executing queries"));
          var n7 = (this.values || []).map(wn3.prepareValue);
          if (r6.namedQueries[this.name]) {
            if (this.text && r6.namedQueries[this.name] !== this.text) {
              let s10 = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
              return t6(s10);
            }
            return r6.native.execute(this.name, n7, t6);
          }
          return r6.native.prepare(
            this.name,
            this.text,
            n7.length,
            function(s10) {
              return s10 ? t6(s10) : (r6.namedQueries[e6.name] = e6.text, e6.native.execute(e6.name, n7, t6));
            }
          );
        } else if (this.values) {
          if (!Array.isArray(this.values)) {
            let s10 = new Error("Query values must be an array");
            return t6(s10);
          }
          var i8 = this.values.map(wn3.prepareValue);
          r6.native.query(this.text, i8, t6);
        } else r6.native.query(this.text, t6);
      };
    });
    Hs = I5((wf, js2) => {
      "use strict";
      p9();
      var Bc = (ks2(), N3(Ds2)), Lc = mt2(), gf = Us2(), Qs2 = we3().EventEmitter, Rc = (He3(), N3(je2)), Fc = gt4(), Ws = qs(), J3 = js2.exports = function(r6) {
        Qs2.call(this), r6 = r6 || {}, this._Promise = r6.Promise || S5.Promise, this._types = new Lc(r6.types), this.native = new Bc({ types: this._types }), this._queryQueue = [], this._ending = false, this._connecting = false, this._connected = false, this._queryable = true;
        var e6 = this.connectionParameters = new Fc(
          r6
        );
        this.user = e6.user, Object.defineProperty(this, "password", {
          configurable: true,
          enumerable: false,
          writable: true,
          value: e6.password
        }), this.database = e6.database, this.host = e6.host, this.port = e6.port, this.namedQueries = {};
      };
      J3.Query = Ws;
      Rc.inherits(J3, Qs2);
      J3.prototype._errorAllQueries = function(r6) {
        let e6 = a7(
          (t6) => {
            m10.nextTick(() => {
              t6.native = this.native, t6.handleError(r6);
            });
          },
          "enqueueError"
        );
        this._hasActiveQuery() && (e6(this._activeQuery), this._activeQuery = null), this._queryQueue.forEach(e6), this._queryQueue.length = 0;
      };
      J3.prototype._connect = function(r6) {
        var e6 = this;
        if (this._connecting) {
          m10.nextTick(() => r6(new Error("Client has already been connected. You cannot reuse a client.")));
          return;
        }
        this._connecting = true, this.connectionParameters.getLibpqConnectionString(function(t6, n7) {
          if (t6) return r6(
            t6
          );
          e6.native.connect(n7, function(i8) {
            if (i8) return e6.native.end(), r6(i8);
            e6._connected = true, e6.native.on("error", function(s10) {
              e6._queryable = false, e6._errorAllQueries(s10), e6.emit("error", s10);
            }), e6.native.on("notification", function(s10) {
              e6.emit("notification", { channel: s10.relname, payload: s10.extra });
            }), e6.emit("connect"), e6._pulseQueryQueue(true), r6();
          });
        });
      };
      J3.prototype.connect = function(r6) {
        if (r6) {
          this._connect(r6);
          return;
        }
        return new this._Promise(
          (e6, t6) => {
            this._connect((n7) => {
              n7 ? t6(n7) : e6();
            });
          }
        );
      };
      J3.prototype.query = function(r6, e6, t6) {
        var n7, i8, s10, o9, u7;
        if (r6 == null) throw new TypeError("Client was passed a null or undefined query");
        if (typeof r6.submit == "function") s10 = r6.query_timeout || this.connectionParameters.query_timeout, i8 = n7 = r6, typeof e6 == "function" && (r6.callback = e6);
        else if (s10 = this.connectionParameters.query_timeout, n7 = new Ws(r6, e6, t6), !n7.callback) {
          let c6, h8;
          i8 = new this._Promise((l7, d7) => {
            c6 = l7, h8 = d7;
          }), n7.callback = (l7, d7) => l7 ? h8(l7) : c6(d7);
        }
        return s10 && (u7 = n7.callback, o9 = setTimeout(() => {
          var c6 = new Error("Query read timeout");
          m10.nextTick(() => {
            n7.handleError(c6, this.connection);
          }), u7(c6), n7.callback = () => {
          };
          var h8 = this._queryQueue.indexOf(n7);
          h8 > -1 && this._queryQueue.splice(h8, 1), this._pulseQueryQueue();
        }, s10), n7.callback = (c6, h8) => {
          clearTimeout(o9), u7(c6, h8);
        }), this._queryable ? this._ending ? (n7.native = this.native, m10.nextTick(() => {
          n7.handleError(
            new Error("Client was closed and is not queryable")
          );
        }), i8) : (this._queryQueue.push(
          n7
        ), this._pulseQueryQueue(), i8) : (n7.native = this.native, m10.nextTick(() => {
          n7.handleError(
            new Error("Client has encountered a connection error and is not queryable")
          );
        }), i8);
      };
      J3.prototype.end = function(r6) {
        var e6 = this;
        this._ending = true, this._connected || this.once(
          "connect",
          this.end.bind(this, r6)
        );
        var t6;
        return r6 || (t6 = new this._Promise(function(n7, i8) {
          r6 = a7((s10) => s10 ? i8(s10) : n7(), "cb");
        })), this.native.end(function() {
          e6._errorAllQueries(new Error(
            "Connection terminated"
          )), m10.nextTick(() => {
            e6.emit("end"), r6 && r6();
          });
        }), t6;
      };
      J3.prototype._hasActiveQuery = function() {
        return this._activeQuery && this._activeQuery.state !== "error" && this._activeQuery.state !== "end";
      };
      J3.prototype._pulseQueryQueue = function(r6) {
        if (this._connected && !this._hasActiveQuery()) {
          var e6 = this._queryQueue.shift();
          if (!e6) {
            r6 || this.emit("drain");
            return;
          }
          this._activeQuery = e6, e6.submit(this);
          var t6 = this;
          e6.once(
            "_done",
            function() {
              t6._pulseQueryQueue();
            }
          );
        }
      };
      J3.prototype.cancel = function(r6) {
        this._activeQuery === r6 ? this.native.cancel(function() {
        }) : this._queryQueue.indexOf(r6) !== -1 && this._queryQueue.splice(this._queryQueue.indexOf(r6), 1);
      };
      J3.prototype.ref = function() {
      };
      J3.prototype.unref = function() {
      };
      J3.prototype.setTypeParser = function(r6, e6, t6) {
        return this._types.setTypeParser(r6, e6, t6);
      };
      J3.prototype.getTypeParser = function(r6, e6) {
        return this._types.getTypeParser(r6, e6);
      };
    });
    bn2 = I5((xf, Gs2) => {
      "use strict";
      p9();
      Gs2.exports = Hs();
    });
    Ct3 = I5((Ef, rt2) => {
      "use strict";
      p9();
      var Mc = Bs(), Dc = Xe3(), kc = hn2(), Uc = Ms(), { DatabaseError: Oc } = an2(), Nc2 = a7((r6) => {
        var e6;
        return e6 = class extends Uc {
          constructor(n7) {
            super(n7, r6);
          }
        }, a7(e6, "BoundPool"), e6;
      }, "poolFactory"), Sn4 = a7(function(r6) {
        this.defaults = Dc, this.Client = r6, this.Query = this.Client.Query, this.Pool = Nc2(this.Client), this._pools = [], this.Connection = kc, this.types = Je2(), this.DatabaseError = Oc;
      }, "PG");
      typeof m10.env.NODE_PG_FORCE_NATIVE < "u" ? rt2.exports = new Sn4(bn2()) : (rt2.exports = new Sn4(Mc), Object.defineProperty(rt2.exports, "native", { configurable: true, enumerable: false, get() {
        var r6 = null;
        try {
          r6 = new Sn4(bn2());
        } catch (e6) {
          if (e6.code !== "MODULE_NOT_FOUND") throw e6;
        }
        return Object.defineProperty(rt2.exports, "native", { value: r6 }), r6;
      } }));
    });
    p9();
    Tt2 = Te2(Ct3());
    wt3();
    p9();
    pr();
    wt3();
    Ks2 = Te2(et3());
    zs2 = Te2(mt2());
    xn3 = class xn4 extends Error {
      constructor() {
        super(...arguments);
        _5(this, "name", "NeonDbError");
        _5(this, "severity");
        _5(this, "code");
        _5(this, "detail");
        _5(this, "hint");
        _5(
          this,
          "position"
        );
        _5(this, "internalPosition");
        _5(this, "internalQuery");
        _5(this, "where");
        _5(this, "schema");
        _5(this, "table");
        _5(this, "column");
        _5(this, "dataType");
        _5(
          this,
          "constraint"
        );
        _5(this, "file");
        _5(this, "line");
        _5(this, "routine");
        _5(this, "sourceError");
      }
    };
    a7(xn3, "NeonDbError");
    Ae4 = xn3;
    $s = "transaction() expects an array of queries, or a function returning an array of queries";
    qc = ["severity", "code", "detail", "hint", "position", "internalPosition", "internalQuery", "where", "schema", "table", "column", "dataType", "constraint", "file", "line", "routine"];
    a7(Ys2, "neon");
    a7(Qc2, "createNeonQueryPromise");
    a7(Vs2, "processQueryResult");
    Js2 = Te2(gt4());
    Qe2 = Te2(Ct3());
    En4 = class En5 extends Tt2.Client {
      constructor(t6) {
        super(t6);
        this.config = t6;
      }
      get neonConfig() {
        return this.connection.stream;
      }
      connect(t6) {
        let { neonConfig: n7 } = this;
        n7.forceDisablePgSSL && (this.ssl = this.connection.ssl = false), this.ssl && n7.useSecureWebSocket && console.warn("SSL is enabled for both Postgres (e.g. ?sslmode=require in the connection string + forceDisablePgSSL = false) and the WebSocket tunnel (useSecureWebSocket = true). Double encryption will increase latency and CPU usage. It may be appropriate to disable SSL in the Postgres connection parameters or set forceDisablePgSSL = true.");
        let i8 = this.config?.host !== void 0 || this.config?.connectionString !== void 0 || m10.env.PGHOST !== void 0, s10 = m10.env.USER ?? m10.env.USERNAME;
        if (!i8 && this.host === "localhost" && this.user === s10 && this.database === s10 && this.password === null) throw new Error(`No database host or connection string was set, and key parameters have default values (host: localhost, user: ${s10}, db: ${s10}, password: null). Is an environment variable missing? Alternatively, if you intended to connect with these parameters, please set the host to 'localhost' explicitly.`);
        let o9 = super.connect(t6), u7 = n7.pipelineTLS && this.ssl, c6 = n7.pipelineConnect === "password";
        if (!u7 && !n7.pipelineConnect) return o9;
        let h8 = this.connection;
        if (u7 && h8.on("connect", () => h8.stream.emit("data", "S")), c6) {
          h8.removeAllListeners(
            "authenticationCleartextPassword"
          ), h8.removeAllListeners("readyForQuery"), h8.once(
            "readyForQuery",
            () => h8.on("readyForQuery", this._handleReadyForQuery.bind(this))
          );
          let l7 = this.ssl ? "sslconnect" : "connect";
          h8.on(l7, () => {
            this._handleAuthCleartextPassword(), this._handleReadyForQuery();
          });
        }
        return o9;
      }
      async _handleAuthSASLContinue(t6) {
        let n7 = this.saslSession, i8 = this.password, s10 = t6.data;
        if (n7.message !== "SASLInitialResponse" || typeof i8 != "string" || typeof s10 != "string") throw new Error("SASL: protocol error");
        let o9 = Object.fromEntries(s10.split(",").map((U4) => {
          if (!/^.=/.test(U4)) throw new Error("SASL: Invalid attribute pair entry");
          let K4 = U4[0], le2 = U4.substring(2);
          return [K4, le2];
        })), u7 = o9.r, c6 = o9.s, h8 = o9.i;
        if (!u7 || !/^[!-+--~]+$/.test(u7)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing/unprintable");
        if (!c6 || !/^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(c6)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing/not base64");
        if (!h8 || !/^[1-9][0-9]*$/.test(h8)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: missing/invalid iteration count");
        if (!u7.startsWith(n7.clientNonce)) throw new Error(
          "SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce"
        );
        if (u7.length === n7.clientNonce.length) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
        let l7 = parseInt(h8, 10), d7 = y5.from(c6, "base64"), b9 = new TextEncoder(), C6 = b9.encode(i8), B3 = await g8.subtle.importKey("raw", C6, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]), W4 = new Uint8Array(await g8.subtle.sign("HMAC", B3, y5.concat([d7, y5.from(
          [0, 0, 0, 1]
        )]))), X4 = W4;
        for (var de2 = 0; de2 < l7 - 1; de2++) W4 = new Uint8Array(await g8.subtle.sign(
          "HMAC",
          B3,
          W4
        )), X4 = y5.from(X4.map((U4, K4) => X4[K4] ^ W4[K4]));
        let A5 = X4, w10 = await g8.subtle.importKey(
          "raw",
          A5,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        ), P5 = new Uint8Array(await g8.subtle.sign("HMAC", w10, b9.encode("Client Key"))), V2 = await g8.subtle.digest(
          "SHA-256",
          P5
        ), k9 = "n=*,r=" + n7.clientNonce, j7 = "r=" + u7 + ",s=" + c6 + ",i=" + l7, ce3 = "c=biws,r=" + u7, ee3 = k9 + "," + j7 + "," + ce3, R5 = await g8.subtle.importKey(
          "raw",
          V2,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        );
        var G4 = new Uint8Array(await g8.subtle.sign("HMAC", R5, b9.encode(ee3))), he3 = y5.from(P5.map((U4, K4) => P5[K4] ^ G4[K4])), ye3 = he3.toString("base64");
        let xe3 = await g8.subtle.importKey(
          "raw",
          A5,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        ), me2 = await g8.subtle.sign(
          "HMAC",
          xe3,
          b9.encode("Server Key")
        ), se2 = await g8.subtle.importKey("raw", me2, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]);
        var oe = y5.from(await g8.subtle.sign(
          "HMAC",
          se2,
          b9.encode(ee3)
        ));
        n7.message = "SASLResponse", n7.serverSignature = oe.toString("base64"), n7.response = ce3 + ",p=" + ye3, this.connection.sendSCRAMClientFinalMessage(this.saslSession.response);
      }
    };
    a7(En4, "NeonClient");
    vn4 = En4;
    a7(Wc, "promisify");
    _n3 = class _n4 extends Tt2.Pool {
      constructor() {
        super(...arguments);
        _5(this, "Client", vn4);
        _5(this, "hasFetchUnsupportedListeners", false);
      }
      on(t6, n7) {
        return t6 !== "error" && (this.hasFetchUnsupportedListeners = true), super.on(t6, n7);
      }
      query(t6, n7, i8) {
        if (!_e7.poolQueryViaFetch || this.hasFetchUnsupportedListeners || typeof t6 == "function")
          return super.query(t6, n7, i8);
        typeof n7 == "function" && (i8 = n7, n7 = void 0);
        let s10 = Wc(
          this.Promise,
          i8
        );
        i8 = s10.callback;
        try {
          let o9 = new Js2.default(this.options), u7 = encodeURIComponent, c6 = encodeURI, h8 = `postgresql://${u7(o9.user)}:${u7(o9.password)}@${u7(o9.host)}/${c6(o9.database)}`, l7 = typeof t6 == "string" ? t6 : t6.text, d7 = n7 ?? t6.values ?? [];
          Ys2(h8, { fullResults: true, arrayMode: t6.rowMode === "array" })(l7, d7, { types: t6.types ?? this.options?.types }).then((C6) => i8(void 0, C6)).catch((C6) => i8(
            C6
          ));
        } catch (o9) {
          i8(o9);
        }
        return s10.result;
      }
    };
    a7(_n3, "NeonPool");
    Zs2 = _n3;
    export_ClientBase2 = Qe2.ClientBase;
    export_Connection2 = Qe2.Connection;
    export_DatabaseError2 = Qe2.DatabaseError;
    export_Query2 = Qe2.Query;
    export_defaults2 = Qe2.defaults;
    export_types2 = Qe2.types;
  }
});

// ../node_modules/.pnpm/@neondatabase+serverless@0.10.0/node_modules/@neondatabase/serverless/index.mjs
function $e4(r6) {
  let e6 = 1779033703, t6 = 3144134277, n7 = 1013904242, i8 = 2773480762, s10 = 1359893119, o9 = 2600822924, u7 = 528734635, c6 = 1541459225, h8 = 0, l7 = 0, d7 = [
    1116352408,
    1899447441,
    3049323471,
    3921009573,
    961987163,
    1508970993,
    2453635748,
    2870763221,
    3624381080,
    310598401,
    607225278,
    1426881987,
    1925078388,
    2162078206,
    2614888103,
    3248222580,
    3835390401,
    4022224774,
    264347078,
    604807628,
    770255983,
    1249150122,
    1555081692,
    1996064986,
    2554220882,
    2821834349,
    2952996808,
    3210313671,
    3336571891,
    3584528711,
    113926993,
    338241895,
    666307205,
    773529912,
    1294757372,
    1396182291,
    1695183700,
    1986661051,
    2177026350,
    2456956037,
    2730485921,
    2820302411,
    3259730800,
    3345764771,
    3516065817,
    3600352804,
    4094571909,
    275423344,
    430227734,
    506948616,
    659060556,
    883997877,
    958139571,
    1322822218,
    1537002063,
    1747873779,
    1955562222,
    2024104815,
    2227730452,
    2361852424,
    2428436474,
    2756734187,
    3204031479,
    3329325298
  ], b9 = a8(
    (A5, w10) => A5 >>> w10 | A5 << 32 - w10,
    "rrot"
  ), C6 = new Uint32Array(64), B3 = new Uint8Array(64), j7 = a8(() => {
    for (let R5 = 0, G4 = 0; R5 < 16; R5++, G4 += 4) C6[R5] = B3[G4] << 24 | B3[G4 + 1] << 16 | B3[G4 + 2] << 8 | B3[G4 + 3];
    for (let R5 = 16; R5 < 64; R5++) {
      let G4 = b9(C6[R5 - 15], 7) ^ b9(C6[R5 - 15], 18) ^ C6[R5 - 15] >>> 3, ue = b9(C6[R5 - 2], 17) ^ b9(C6[R5 - 2], 19) ^ C6[R5 - 2] >>> 10;
      C6[R5] = C6[R5 - 16] + G4 + C6[R5 - 7] + ue | 0;
    }
    let A5 = e6, w10 = t6, P5 = n7, V2 = i8, O6 = s10, W4 = o9, ae = u7, ee3 = c6;
    for (let R5 = 0; R5 < 64; R5++) {
      let G4 = b9(
        O6,
        6
      ) ^ b9(O6, 11) ^ b9(O6, 25), ue = O6 & W4 ^ ~O6 & ae, de2 = ee3 + G4 + ue + d7[R5] + C6[R5] | 0, Ee2 = b9(A5, 2) ^ b9(A5, 13) ^ b9(A5, 22), ce3 = A5 & w10 ^ A5 & P5 ^ w10 & P5, Ce3 = Ee2 + ce3 | 0;
      ee3 = ae, ae = W4, W4 = O6, O6 = V2 + de2 | 0, V2 = P5, P5 = w10, w10 = A5, A5 = de2 + Ce3 | 0;
    }
    e6 = e6 + A5 | 0, t6 = t6 + w10 | 0, n7 = n7 + P5 | 0, i8 = i8 + V2 | 0, s10 = s10 + O6 | 0, o9 = o9 + W4 | 0, u7 = u7 + ae | 0, c6 = c6 + ee3 | 0, l7 = 0;
  }, "process"), X4 = a8((A5) => {
    typeof A5 == "string" && (A5 = new TextEncoder().encode(A5));
    for (let w10 = 0; w10 < A5.length; w10++) B3[l7++] = A5[w10], l7 === 64 && j7();
    h8 += A5.length;
  }, "add"), pe2 = a8(() => {
    if (B3[l7++] = 128, l7 == 64 && j7(), l7 + 8 > 64) {
      for (; l7 < 64; ) B3[l7++] = 0;
      j7();
    }
    for (; l7 < 58; ) B3[l7++] = 0;
    let A5 = h8 * 8;
    B3[l7++] = A5 / 1099511627776 & 255, B3[l7++] = A5 / 4294967296 & 255, B3[l7++] = A5 >>> 24, B3[l7++] = A5 >>> 16 & 255, B3[l7++] = A5 >>> 8 & 255, B3[l7++] = A5 & 255, j7();
    let w10 = new Uint8Array(32);
    return w10[0] = e6 >>> 24, w10[1] = e6 >>> 16 & 255, w10[2] = e6 >>> 8 & 255, w10[3] = e6 & 255, w10[4] = t6 >>> 24, w10[5] = t6 >>> 16 & 255, w10[6] = t6 >>> 8 & 255, w10[7] = t6 & 255, w10[8] = n7 >>> 24, w10[9] = n7 >>> 16 & 255, w10[10] = n7 >>> 8 & 255, w10[11] = n7 & 255, w10[12] = i8 >>> 24, w10[13] = i8 >>> 16 & 255, w10[14] = i8 >>> 8 & 255, w10[15] = i8 & 255, w10[16] = s10 >>> 24, w10[17] = s10 >>> 16 & 255, w10[18] = s10 >>> 8 & 255, w10[19] = s10 & 255, w10[20] = o9 >>> 24, w10[21] = o9 >>> 16 & 255, w10[22] = o9 >>> 8 & 255, w10[23] = o9 & 255, w10[24] = u7 >>> 24, w10[25] = u7 >>> 16 & 255, w10[26] = u7 >>> 8 & 255, w10[27] = u7 & 255, w10[28] = c6 >>> 24, w10[29] = c6 >>> 16 & 255, w10[30] = c6 >>> 8 & 255, w10[31] = c6 & 255, w10;
  }, "digest");
  return r6 === void 0 ? { add: X4, digest: pe2 } : (X4(r6), pe2());
}
function zo2(r6) {
  return g9.getRandomValues(y6.alloc(r6));
}
function Yo(r6) {
  if (r6 === "sha256") return { update: a8(
    function(e6) {
      return { digest: a8(function() {
        return y6.from($e4(e6));
      }, "digest") };
    },
    "update"
  ) };
  if (r6 === "md5") return { update: a8(function(e6) {
    return { digest: a8(function() {
      return typeof e6 == "string" ? Ve2.hashStr(e6) : Ve2.hashByteArray(e6);
    }, "digest") };
  }, "update") };
  throw new Error(
    `Hash type '${r6}' not supported`
  );
}
function Zo(r6, e6) {
  if (r6 !== "sha256") throw new Error(
    `Only sha256 is supported (requested: '${r6}')`
  );
  return { update: a8(function(t6) {
    return {
      digest: a8(function() {
        typeof e6 == "string" && (e6 = new TextEncoder().encode(e6)), typeof t6 == "string" && (t6 = new TextEncoder().encode(t6));
        let n7 = e6.length;
        if (n7 > 64) e6 = $e4(e6);
        else if (n7 < 64) {
          let c6 = new Uint8Array(64);
          c6.set(e6), e6 = c6;
        }
        let i8 = new Uint8Array(64), s10 = new Uint8Array(
          64
        );
        for (let c6 = 0; c6 < 64; c6++) i8[c6] = 54 ^ e6[c6], s10[c6] = 92 ^ e6[c6];
        let o9 = new Uint8Array(t6.length + 64);
        o9.set(i8, 0), o9.set(t6, 64);
        let u7 = new Uint8Array(96);
        return u7.set(s10, 0), u7.set(
          $e4(o9),
          64
        ), y6.from($e4(u7));
      }, "digest")
    };
  }, "update") };
}
function uu2(...r6) {
  return r6.join("/");
}
function cu(r6, e6) {
  e6(new Error("No filesystem"));
}
function dr(r6, e6 = false) {
  let { protocol: t6 } = new URL(r6), n7 = "http:" + r6.substring(t6.length), {
    username: i8,
    password: s10,
    host: o9,
    hostname: u7,
    port: c6,
    pathname: h8,
    search: l7,
    searchParams: d7,
    hash: b9
  } = new URL(n7);
  s10 = decodeURIComponent(s10), i8 = decodeURIComponent(
    i8
  ), h8 = decodeURIComponent(h8);
  let C6 = i8 + ":" + s10, B3 = e6 ? Object.fromEntries(d7.entries()) : l7;
  return {
    href: r6,
    protocol: t6,
    auth: C6,
    username: i8,
    password: s10,
    host: o9,
    hostname: u7,
    port: c6,
    pathname: h8,
    search: l7,
    query: B3,
    hash: b9
  };
}
function Du(r6) {
  return 0;
}
function fc({ socket: r6, servername: e6 }) {
  return r6.startTls(e6), r6;
}
function Js3(r6, {
  arrayMode: e6,
  fullResults: t6,
  fetchOptions: n7,
  isolationLevel: i8,
  readOnly: s10,
  deferrable: o9,
  queryCallback: u7,
  resultCallback: c6,
  authToken: h8
} = {}) {
  if (!r6) throw new Error("No database connection string was provided to `neon()`. Perhaps an environment variable has not been set?");
  let l7;
  try {
    l7 = dr(r6);
  } catch {
    throw new Error("Database connection string provided to `neon()` is not a valid URL. Connection string: " + String(r6));
  }
  let {
    protocol: d7,
    username: b9,
    hostname: C6,
    port: B3,
    pathname: j7
  } = l7;
  if (d7 !== "postgres:" && d7 !== "postgresql:" || !b9 || !C6 || !j7) throw new Error("Database connection string format for `neon()` should be: postgresql://user:password@host.tld/dbname?option=value");
  function X4(A5, ...w10) {
    let P5, V2;
    if (typeof A5 == "string") P5 = A5, V2 = w10[1], w10 = w10[0] ?? [];
    else {
      P5 = "";
      for (let W4 = 0; W4 < A5.length; W4++)
        P5 += A5[W4], W4 < w10.length && (P5 += "$" + (W4 + 1));
    }
    w10 = w10.map((W4) => (0, Ys3.prepareValue)(W4));
    let O6 = {
      query: P5,
      params: w10
    };
    return u7 && u7(O6), jc(pe2, O6, V2);
  }
  a8(X4, "resolve"), X4.transaction = async (A5, w10) => {
    if (typeof A5 == "function" && (A5 = A5(X4)), !Array.isArray(A5)) throw new Error(Ks3);
    A5.forEach((O6) => {
      if (O6[Symbol.toStringTag] !== "NeonQueryPromise") throw new Error(Ks3);
    });
    let P5 = A5.map((O6) => O6.parameterizedQuery), V2 = A5.map((O6) => O6.opts ?? {});
    return pe2(P5, V2, w10);
  };
  async function pe2(A5, w10, P5) {
    let {
      fetchEndpoint: V2,
      fetchFunction: O6
    } = Ae5, W4 = typeof V2 == "function" ? V2(C6, B3, { jwtAuth: h8 !== void 0 }) : V2, ae = Array.isArray(A5) ? { queries: A5 } : A5, ee3 = n7 ?? {}, R5 = e6 ?? false, G4 = t6 ?? false, ue = i8, de2 = s10, Ee2 = o9;
    P5 !== void 0 && (P5.fetchOptions !== void 0 && (ee3 = { ...ee3, ...P5.fetchOptions }), P5.arrayMode !== void 0 && (R5 = P5.arrayMode), P5.fullResults !== void 0 && (G4 = P5.fullResults), P5.isolationLevel !== void 0 && (ue = P5.isolationLevel), P5.readOnly !== void 0 && (de2 = P5.readOnly), P5.deferrable !== void 0 && (Ee2 = P5.deferrable)), w10 !== void 0 && !Array.isArray(w10) && w10.fetchOptions !== void 0 && (ee3 = {
      ...ee3,
      ...w10.fetchOptions
    });
    let ce3 = { "Neon-Connection-String": r6, "Neon-Raw-Text-Output": "true", "Neon-Array-Mode": "true" }, Ce3 = await Wc2(h8);
    Ce3 && (ce3.Authorization = `Bearer ${Ce3}`), Array.isArray(A5) && (ue !== void 0 && (ce3["Neon-Batch-Isolation-Level"] = ue), de2 !== void 0 && (ce3["Neon-Batch-Read-Only"] = String(de2)), Ee2 !== void 0 && (ce3["Neon-Batch-Deferrable"] = String(Ee2)));
    let ye3;
    try {
      ye3 = await (O6 ?? fetch)(W4, { method: "POST", body: JSON.stringify(ae), headers: ce3, ...ee3 });
    } catch (K4) {
      let k9 = new fe2(`Error connecting to database: ${K4.message}`);
      throw k9.sourceError = K4, k9;
    }
    if (ye3.ok) {
      let K4 = await ye3.json();
      if (Array.isArray(A5)) {
        let k9 = K4.results;
        if (!Array.isArray(k9)) throw new fe2("Neon internal error: unexpected result format");
        return k9.map((me2, xe3) => {
          let Bt2 = w10[xe3] ?? {}, to3 = Bt2.arrayMode ?? R5, ro3 = Bt2.fullResults ?? G4;
          return zs3(me2, {
            arrayMode: to3,
            fullResults: ro3,
            parameterizedQuery: A5[xe3],
            resultCallback: c6,
            types: Bt2.types
          });
        });
      } else {
        let k9 = w10 ?? {}, me2 = k9.arrayMode ?? R5, xe3 = k9.fullResults ?? G4;
        return zs3(K4, {
          arrayMode: me2,
          fullResults: xe3,
          parameterizedQuery: A5,
          resultCallback: c6,
          types: k9.types
        });
      }
    } else {
      let { status: K4 } = ye3;
      if (K4 === 400) {
        let k9 = await ye3.json(), me2 = new fe2(
          k9.message
        );
        for (let xe3 of Qc3) me2[xe3] = k9[xe3] ?? void 0;
        throw me2;
      } else {
        let k9 = await ye3.text();
        throw new fe2(`Server error (HTTP status ${K4}): ${k9}`);
      }
    }
  }
  return a8(pe2, "execute"), X4;
}
function jc(r6, e6, t6) {
  return {
    [Symbol.toStringTag]: "NeonQueryPromise",
    parameterizedQuery: e6,
    opts: t6,
    then: a8((n7, i8) => r6(e6, t6).then(n7, i8), "then"),
    catch: a8((n7) => r6(e6, t6).catch(n7), "catch"),
    finally: a8((n7) => r6(e6, t6).finally(n7), "finally")
  };
}
function zs3(r6, {
  arrayMode: e6,
  fullResults: t6,
  parameterizedQuery: n7,
  resultCallback: i8,
  types: s10
}) {
  let o9 = new Zs3.default(
    s10
  ), u7 = r6.fields.map((l7) => l7.name), c6 = r6.fields.map((l7) => o9.getTypeParser(l7.dataTypeID)), h8 = e6 === true ? r6.rows.map((l7) => l7.map((d7, b9) => d7 === null ? null : c6[b9](d7))) : r6.rows.map((l7) => Object.fromEntries(
    l7.map((d7, b9) => [u7[b9], d7 === null ? null : c6[b9](d7)])
  ));
  return i8 && i8(n7, r6, h8, { arrayMode: e6, fullResults: t6 }), t6 ? (r6.viaNeonFetch = true, r6.rowAsArray = e6, r6.rows = h8, r6._parsers = c6, r6._types = o9, r6) : h8;
}
async function Wc2(r6) {
  if (typeof r6 == "string") return r6;
  if (typeof r6 == "function") try {
    return await Promise.resolve(r6());
  } catch (e6) {
    let t6 = new fe2("Error getting auth token.");
    throw e6 instanceof Error && (t6 = new fe2(`Error getting auth token: ${e6.message}`)), t6;
  }
}
function Hc(r6, e6) {
  if (e6) return {
    callback: e6,
    result: void 0
  };
  let t6, n7, i8 = a8(function(o9, u7) {
    o9 ? t6(o9) : n7(u7);
  }, "cb"), s10 = new r6(function(o9, u7) {
    n7 = o9, t6 = u7;
  });
  return { callback: i8, result: s10 };
}
var no3, Te3, io3, so2, oo2, ao, uo, a8, z5, I6, ie3, Cn2, Ie4, N4, _6, Pn3, Bn2, Vn2, S6, E3, x10, g9, y6, m11, p10, we4, He4, Ko3, Ge4, ii2, U3, Ve2, si, jt3, Wt3, Gt2, $t2, hi2, fi, yi2, gi, _i3, Ci, Li2, Fi, Xe4, et4, tt3, Qi3, nr4, ir3, sr4, or5, ar3, hu, ur3, ji, hr2, cr2, Wi2, Vi2, Yi2, Ji2, gt5, es3, Pu, ts2, rs2, yr, is2, wt4, hs, ds3, gs2, ms2, ys3, v10, Ae5, bt, Jr, ws3, Ss2, Es2, _s3, cn3, As2, Cs, fn2, Rs, ks3, Os2, Tc, Us3, Ns, js, $s2, En6, Tt3, Pt2, Ys3, Zs3, It2, fe2, Ks3, Qc3, eo2, je3, _n5, vn5, An3, Xs2, export_ClientBase3, export_Connection3, export_DatabaseError3, export_Query3, export_defaults3, export_types3;
var init_serverless3 = __esm({
  "../node_modules/.pnpm/@neondatabase+serverless@0.10.0/node_modules/@neondatabase/serverless/index.mjs"() {
    "use strict";
    no3 = Object.create;
    Te3 = Object.defineProperty;
    io3 = Object.getOwnPropertyDescriptor;
    so2 = Object.getOwnPropertyNames;
    oo2 = Object.getPrototypeOf;
    ao = Object.prototype.hasOwnProperty;
    uo = (r6, e6, t6) => e6 in r6 ? Te3(r6, e6, { enumerable: true, configurable: true, writable: true, value: t6 }) : r6[e6] = t6;
    a8 = (r6, e6) => Te3(r6, "name", { value: e6, configurable: true });
    z5 = (r6, e6) => () => (r6 && (e6 = r6(r6 = 0)), e6);
    I6 = (r6, e6) => () => (e6 || r6((e6 = { exports: {} }).exports, e6), e6.exports);
    ie3 = (r6, e6) => {
      for (var t6 in e6)
        Te3(r6, t6, { get: e6[t6], enumerable: true });
    };
    Cn2 = (r6, e6, t6, n7) => {
      if (e6 && typeof e6 == "object" || typeof e6 == "function") for (let i8 of so2(e6)) !ao.call(r6, i8) && i8 !== t6 && Te3(r6, i8, { get: () => e6[i8], enumerable: !(n7 = io3(e6, i8)) || n7.enumerable });
      return r6;
    };
    Ie4 = (r6, e6, t6) => (t6 = r6 != null ? no3(oo2(r6)) : {}, Cn2(e6 || !r6 || !r6.__esModule ? Te3(t6, "default", {
      value: r6,
      enumerable: true
    }) : t6, r6));
    N4 = (r6) => Cn2(Te3({}, "__esModule", { value: true }), r6);
    _6 = (r6, e6, t6) => uo(r6, typeof e6 != "symbol" ? e6 + "" : e6, t6);
    Pn3 = I6((it2) => {
      "use strict";
      p10();
      it2.byteLength = ho;
      it2.toByteArray = fo;
      it2.fromByteArray = mo;
      var se2 = [], te4 = [], co = typeof Uint8Array < "u" ? Uint8Array : Array, Lt2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      for (ve2 = 0, Tn3 = Lt2.length; ve2 < Tn3; ++ve2)
        se2[ve2] = Lt2[ve2], te4[Lt2.charCodeAt(ve2)] = ve2;
      var ve2, Tn3;
      te4[45] = 62;
      te4[95] = 63;
      function In4(r6) {
        var e6 = r6.length;
        if (e6 % 4 > 0) throw new Error("Invalid string. Length must be a multiple of 4");
        var t6 = r6.indexOf("=");
        t6 === -1 && (t6 = e6);
        var n7 = t6 === e6 ? 0 : 4 - t6 % 4;
        return [t6, n7];
      }
      a8(
        In4,
        "getLens"
      );
      function ho(r6) {
        var e6 = In4(r6), t6 = e6[0], n7 = e6[1];
        return (t6 + n7) * 3 / 4 - n7;
      }
      a8(ho, "byteLength");
      function lo(r6, e6, t6) {
        return (e6 + t6) * 3 / 4 - t6;
      }
      a8(lo, "_byteLength");
      function fo(r6) {
        var e6, t6 = In4(r6), n7 = t6[0], i8 = t6[1], s10 = new co(lo(r6, n7, i8)), o9 = 0, u7 = i8 > 0 ? n7 - 4 : n7, c6;
        for (c6 = 0; c6 < u7; c6 += 4) e6 = te4[r6.charCodeAt(c6)] << 18 | te4[r6.charCodeAt(c6 + 1)] << 12 | te4[r6.charCodeAt(c6 + 2)] << 6 | te4[r6.charCodeAt(c6 + 3)], s10[o9++] = e6 >> 16 & 255, s10[o9++] = e6 >> 8 & 255, s10[o9++] = e6 & 255;
        return i8 === 2 && (e6 = te4[r6.charCodeAt(c6)] << 2 | te4[r6.charCodeAt(c6 + 1)] >> 4, s10[o9++] = e6 & 255), i8 === 1 && (e6 = te4[r6.charCodeAt(
          c6
        )] << 10 | te4[r6.charCodeAt(c6 + 1)] << 4 | te4[r6.charCodeAt(c6 + 2)] >> 2, s10[o9++] = e6 >> 8 & 255, s10[o9++] = e6 & 255), s10;
      }
      a8(fo, "toByteArray");
      function po(r6) {
        return se2[r6 >> 18 & 63] + se2[r6 >> 12 & 63] + se2[r6 >> 6 & 63] + se2[r6 & 63];
      }
      a8(po, "tripletToBase64");
      function yo(r6, e6, t6) {
        for (var n7, i8 = [], s10 = e6; s10 < t6; s10 += 3) n7 = (r6[s10] << 16 & 16711680) + (r6[s10 + 1] << 8 & 65280) + (r6[s10 + 2] & 255), i8.push(po(n7));
        return i8.join(
          ""
        );
      }
      a8(yo, "encodeChunk");
      function mo(r6) {
        for (var e6, t6 = r6.length, n7 = t6 % 3, i8 = [], s10 = 16383, o9 = 0, u7 = t6 - n7; o9 < u7; o9 += s10) i8.push(yo(r6, o9, o9 + s10 > u7 ? u7 : o9 + s10));
        return n7 === 1 ? (e6 = r6[t6 - 1], i8.push(se2[e6 >> 2] + se2[e6 << 4 & 63] + "==")) : n7 === 2 && (e6 = (r6[t6 - 2] << 8) + r6[t6 - 1], i8.push(se2[e6 >> 10] + se2[e6 >> 4 & 63] + se2[e6 << 2 & 63] + "=")), i8.join("");
      }
      a8(mo, "fromByteArray");
    });
    Bn2 = I6((Rt2) => {
      p10();
      Rt2.read = function(r6, e6, t6, n7, i8) {
        var s10, o9, u7 = i8 * 8 - n7 - 1, c6 = (1 << u7) - 1, h8 = c6 >> 1, l7 = -7, d7 = t6 ? i8 - 1 : 0, b9 = t6 ? -1 : 1, C6 = r6[e6 + d7];
        for (d7 += b9, s10 = C6 & (1 << -l7) - 1, C6 >>= -l7, l7 += u7; l7 > 0; s10 = s10 * 256 + r6[e6 + d7], d7 += b9, l7 -= 8) ;
        for (o9 = s10 & (1 << -l7) - 1, s10 >>= -l7, l7 += n7; l7 > 0; o9 = o9 * 256 + r6[e6 + d7], d7 += b9, l7 -= 8) ;
        if (s10 === 0) s10 = 1 - h8;
        else {
          if (s10 === c6) return o9 ? NaN : (C6 ? -1 : 1) * (1 / 0);
          o9 = o9 + Math.pow(2, n7), s10 = s10 - h8;
        }
        return (C6 ? -1 : 1) * o9 * Math.pow(2, s10 - n7);
      };
      Rt2.write = function(r6, e6, t6, n7, i8, s10) {
        var o9, u7, c6, h8 = s10 * 8 - i8 - 1, l7 = (1 << h8) - 1, d7 = l7 >> 1, b9 = i8 === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0, C6 = n7 ? 0 : s10 - 1, B3 = n7 ? 1 : -1, j7 = e6 < 0 || e6 === 0 && 1 / e6 < 0 ? 1 : 0;
        for (e6 = Math.abs(e6), isNaN(e6) || e6 === 1 / 0 ? (u7 = isNaN(e6) ? 1 : 0, o9 = l7) : (o9 = Math.floor(Math.log(e6) / Math.LN2), e6 * (c6 = Math.pow(2, -o9)) < 1 && (o9--, c6 *= 2), o9 + d7 >= 1 ? e6 += b9 / c6 : e6 += b9 * Math.pow(2, 1 - d7), e6 * c6 >= 2 && (o9++, c6 /= 2), o9 + d7 >= l7 ? (u7 = 0, o9 = l7) : o9 + d7 >= 1 ? (u7 = (e6 * c6 - 1) * Math.pow(
          2,
          i8
        ), o9 = o9 + d7) : (u7 = e6 * Math.pow(2, d7 - 1) * Math.pow(2, i8), o9 = 0)); i8 >= 8; r6[t6 + C6] = u7 & 255, C6 += B3, u7 /= 256, i8 -= 8) ;
        for (o9 = o9 << i8 | u7, h8 += i8; h8 > 0; r6[t6 + C6] = o9 & 255, C6 += B3, o9 /= 256, h8 -= 8) ;
        r6[t6 + C6 - B3] |= j7 * 128;
      };
    });
    Vn2 = I6((Re3) => {
      "use strict";
      p10();
      var Ft2 = Pn3(), Be2 = Bn2(), Ln2 = typeof Symbol == "function" && typeof Symbol.for == "function" ? Symbol.for("nodejs.util.inspect.custom") : null;
      Re3.Buffer = f9;
      Re3.SlowBuffer = xo;
      Re3.INSPECT_MAX_BYTES = 50;
      var st2 = 2147483647;
      Re3.kMaxLength = st2;
      f9.TYPED_ARRAY_SUPPORT = go();
      !f9.TYPED_ARRAY_SUPPORT && typeof console < "u" && typeof console.error == "function" && console.error("This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.");
      function go() {
        try {
          let r6 = new Uint8Array(1), e6 = { foo: a8(function() {
            return 42;
          }, "foo") };
          return Object.setPrototypeOf(e6, Uint8Array.prototype), Object.setPrototypeOf(
            r6,
            e6
          ), r6.foo() === 42;
        } catch {
          return false;
        }
      }
      a8(go, "typedArraySupport");
      Object.defineProperty(
        f9.prototype,
        "parent",
        { enumerable: true, get: a8(function() {
          if (f9.isBuffer(this)) return this.buffer;
        }, "get") }
      );
      Object.defineProperty(f9.prototype, "offset", { enumerable: true, get: a8(
        function() {
          if (f9.isBuffer(this)) return this.byteOffset;
        },
        "get"
      ) });
      function he3(r6) {
        if (r6 > st2) throw new RangeError('The value "' + r6 + '" is invalid for option "size"');
        let e6 = new Uint8Array(
          r6
        );
        return Object.setPrototypeOf(e6, f9.prototype), e6;
      }
      a8(he3, "createBuffer");
      function f9(r6, e6, t6) {
        if (typeof r6 == "number") {
          if (typeof e6 == "string") throw new TypeError('The "string" argument must be of type string. Received type number');
          return Ot2(r6);
        }
        return Dn2(
          r6,
          e6,
          t6
        );
      }
      a8(f9, "Buffer");
      f9.poolSize = 8192;
      function Dn2(r6, e6, t6) {
        if (typeof r6 == "string") return bo(
          r6,
          e6
        );
        if (ArrayBuffer.isView(r6)) return So(r6);
        if (r6 == null) throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof r6);
        if (oe(r6, ArrayBuffer) || r6 && oe(r6.buffer, ArrayBuffer) || typeof SharedArrayBuffer < "u" && (oe(r6, SharedArrayBuffer) || r6 && oe(r6.buffer, SharedArrayBuffer)))
          return Dt2(r6, e6, t6);
        if (typeof r6 == "number") throw new TypeError('The "value" argument must not be of type number. Received type number');
        let n7 = r6.valueOf && r6.valueOf();
        if (n7 != null && n7 !== r6) return f9.from(n7, e6, t6);
        let i8 = Eo(r6);
        if (i8) return i8;
        if (typeof Symbol < "u" && Symbol.toPrimitive != null && typeof r6[Symbol.toPrimitive] == "function") return f9.from(r6[Symbol.toPrimitive]("string"), e6, t6);
        throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof r6);
      }
      a8(Dn2, "from");
      f9.from = function(r6, e6, t6) {
        return Dn2(r6, e6, t6);
      };
      Object.setPrototypeOf(f9.prototype, Uint8Array.prototype);
      Object.setPrototypeOf(
        f9,
        Uint8Array
      );
      function kn2(r6) {
        if (typeof r6 != "number") throw new TypeError('"size" argument must be of type number');
        if (r6 < 0) throw new RangeError('The value "' + r6 + '" is invalid for option "size"');
      }
      a8(kn2, "assertSize");
      function wo(r6, e6, t6) {
        return kn2(r6), r6 <= 0 ? he3(r6) : e6 !== void 0 ? typeof t6 == "string" ? he3(r6).fill(e6, t6) : he3(r6).fill(e6) : he3(r6);
      }
      a8(
        wo,
        "alloc"
      );
      f9.alloc = function(r6, e6, t6) {
        return wo(r6, e6, t6);
      };
      function Ot2(r6) {
        return kn2(r6), he3(
          r6 < 0 ? 0 : Ut3(r6) | 0
        );
      }
      a8(Ot2, "allocUnsafe");
      f9.allocUnsafe = function(r6) {
        return Ot2(r6);
      };
      f9.allocUnsafeSlow = function(r6) {
        return Ot2(r6);
      };
      function bo(r6, e6) {
        if ((typeof e6 != "string" || e6 === "") && (e6 = "utf8"), !f9.isEncoding(e6)) throw new TypeError("Unknown encoding: " + e6);
        let t6 = On2(r6, e6) | 0, n7 = he3(t6), i8 = n7.write(r6, e6);
        return i8 !== t6 && (n7 = n7.slice(0, i8)), n7;
      }
      a8(bo, "fromString");
      function Mt2(r6) {
        let e6 = r6.length < 0 ? 0 : Ut3(r6.length) | 0, t6 = he3(e6);
        for (let n7 = 0; n7 < e6; n7 += 1) t6[n7] = r6[n7] & 255;
        return t6;
      }
      a8(Mt2, "fromArrayLike");
      function So(r6) {
        if (oe(r6, Uint8Array)) {
          let e6 = new Uint8Array(r6);
          return Dt2(e6.buffer, e6.byteOffset, e6.byteLength);
        }
        return Mt2(r6);
      }
      a8(So, "fromArrayView");
      function Dt2(r6, e6, t6) {
        if (e6 < 0 || r6.byteLength < e6) throw new RangeError('"offset" is outside of buffer bounds');
        if (r6.byteLength < e6 + (t6 || 0)) throw new RangeError('"length" is outside of buffer bounds');
        let n7;
        return e6 === void 0 && t6 === void 0 ? n7 = new Uint8Array(
          r6
        ) : t6 === void 0 ? n7 = new Uint8Array(r6, e6) : n7 = new Uint8Array(r6, e6, t6), Object.setPrototypeOf(
          n7,
          f9.prototype
        ), n7;
      }
      a8(Dt2, "fromArrayBuffer");
      function Eo(r6) {
        if (f9.isBuffer(r6)) {
          let e6 = Ut3(
            r6.length
          ) | 0, t6 = he3(e6);
          return t6.length === 0 || r6.copy(t6, 0, 0, e6), t6;
        }
        if (r6.length !== void 0)
          return typeof r6.length != "number" || qt4(r6.length) ? he3(0) : Mt2(r6);
        if (r6.type === "Buffer" && Array.isArray(r6.data)) return Mt2(r6.data);
      }
      a8(Eo, "fromObject");
      function Ut3(r6) {
        if (r6 >= st2) throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + st2.toString(16) + " bytes");
        return r6 | 0;
      }
      a8(Ut3, "checked");
      function xo(r6) {
        return +r6 != r6 && (r6 = 0), f9.alloc(+r6);
      }
      a8(xo, "SlowBuffer");
      f9.isBuffer = a8(function(e6) {
        return e6 != null && e6._isBuffer === true && e6 !== f9.prototype;
      }, "isBuffer");
      f9.compare = a8(function(e6, t6) {
        if (oe(e6, Uint8Array) && (e6 = f9.from(e6, e6.offset, e6.byteLength)), oe(t6, Uint8Array) && (t6 = f9.from(t6, t6.offset, t6.byteLength)), !f9.isBuffer(e6) || !f9.isBuffer(t6)) throw new TypeError('The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array');
        if (e6 === t6) return 0;
        let n7 = e6.length, i8 = t6.length;
        for (let s10 = 0, o9 = Math.min(n7, i8); s10 < o9; ++s10) if (e6[s10] !== t6[s10]) {
          n7 = e6[s10], i8 = t6[s10];
          break;
        }
        return n7 < i8 ? -1 : i8 < n7 ? 1 : 0;
      }, "compare");
      f9.isEncoding = a8(function(e6) {
        switch (String(e6).toLowerCase()) {
          case "hex":
          case "utf8":
          case "utf-8":
          case "ascii":
          case "latin1":
          case "binary":
          case "base64":
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return true;
          default:
            return false;
        }
      }, "isEncoding");
      f9.concat = a8(function(e6, t6) {
        if (!Array.isArray(e6)) throw new TypeError('"list" argument must be an Array of Buffers');
        if (e6.length === 0) return f9.alloc(0);
        let n7;
        if (t6 === void 0) for (t6 = 0, n7 = 0; n7 < e6.length; ++n7) t6 += e6[n7].length;
        let i8 = f9.allocUnsafe(t6), s10 = 0;
        for (n7 = 0; n7 < e6.length; ++n7) {
          let o9 = e6[n7];
          if (oe(o9, Uint8Array)) s10 + o9.length > i8.length ? (f9.isBuffer(
            o9
          ) || (o9 = f9.from(o9)), o9.copy(i8, s10)) : Uint8Array.prototype.set.call(i8, o9, s10);
          else if (f9.isBuffer(
            o9
          )) o9.copy(i8, s10);
          else throw new TypeError('"list" argument must be an Array of Buffers');
          s10 += o9.length;
        }
        return i8;
      }, "concat");
      function On2(r6, e6) {
        if (f9.isBuffer(r6)) return r6.length;
        if (ArrayBuffer.isView(r6) || oe(r6, ArrayBuffer)) return r6.byteLength;
        if (typeof r6 != "string") throw new TypeError('The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof r6);
        let t6 = r6.length, n7 = arguments.length > 2 && arguments[2] === true;
        if (!n7 && t6 === 0) return 0;
        let i8 = false;
        for (; ; ) switch (e6) {
          case "ascii":
          case "latin1":
          case "binary":
            return t6;
          case "utf8":
          case "utf-8":
            return kt2(r6).length;
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return t6 * 2;
          case "hex":
            return t6 >>> 1;
          case "base64":
            return $n2(r6).length;
          default:
            if (i8) return n7 ? -1 : kt2(r6).length;
            e6 = ("" + e6).toLowerCase(), i8 = true;
        }
      }
      a8(On2, "byteLength");
      f9.byteLength = On2;
      function vo(r6, e6, t6) {
        let n7 = false;
        if ((e6 === void 0 || e6 < 0) && (e6 = 0), e6 > this.length || ((t6 === void 0 || t6 > this.length) && (t6 = this.length), t6 <= 0) || (t6 >>>= 0, e6 >>>= 0, t6 <= e6)) return "";
        for (r6 || (r6 = "utf8"); ; ) switch (r6) {
          case "hex":
            return Fo(
              this,
              e6,
              t6
            );
          case "utf8":
          case "utf-8":
            return Nn2(this, e6, t6);
          case "ascii":
            return Lo(
              this,
              e6,
              t6
            );
          case "latin1":
          case "binary":
            return Ro(this, e6, t6);
          case "base64":
            return Po(
              this,
              e6,
              t6
            );
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return Mo(this, e6, t6);
          default:
            if (n7) throw new TypeError("Unknown encoding: " + r6);
            r6 = (r6 + "").toLowerCase(), n7 = true;
        }
      }
      a8(
        vo,
        "slowToString"
      );
      f9.prototype._isBuffer = true;
      function _e8(r6, e6, t6) {
        let n7 = r6[e6];
        r6[e6] = r6[t6], r6[t6] = n7;
      }
      a8(_e8, "swap");
      f9.prototype.swap16 = a8(function() {
        let e6 = this.length;
        if (e6 % 2 !== 0)
          throw new RangeError("Buffer size must be a multiple of 16-bits");
        for (let t6 = 0; t6 < e6; t6 += 2) _e8(this, t6, t6 + 1);
        return this;
      }, "swap16");
      f9.prototype.swap32 = a8(function() {
        let e6 = this.length;
        if (e6 % 4 !== 0) throw new RangeError("Buffer size must be a multiple of 32-bits");
        for (let t6 = 0; t6 < e6; t6 += 4) _e8(this, t6, t6 + 3), _e8(this, t6 + 1, t6 + 2);
        return this;
      }, "swap32");
      f9.prototype.swap64 = a8(function() {
        let e6 = this.length;
        if (e6 % 8 !== 0) throw new RangeError(
          "Buffer size must be a multiple of 64-bits"
        );
        for (let t6 = 0; t6 < e6; t6 += 8) _e8(this, t6, t6 + 7), _e8(this, t6 + 1, t6 + 6), _e8(this, t6 + 2, t6 + 5), _e8(this, t6 + 3, t6 + 4);
        return this;
      }, "swap64");
      f9.prototype.toString = a8(function() {
        let e6 = this.length;
        return e6 === 0 ? "" : arguments.length === 0 ? Nn2(
          this,
          0,
          e6
        ) : vo.apply(this, arguments);
      }, "toString");
      f9.prototype.toLocaleString = f9.prototype.toString;
      f9.prototype.equals = a8(function(e6) {
        if (!f9.isBuffer(e6)) throw new TypeError(
          "Argument must be a Buffer"
        );
        return this === e6 ? true : f9.compare(this, e6) === 0;
      }, "equals");
      f9.prototype.inspect = a8(function() {
        let e6 = "", t6 = Re3.INSPECT_MAX_BYTES;
        return e6 = this.toString(
          "hex",
          0,
          t6
        ).replace(/(.{2})/g, "$1 ").trim(), this.length > t6 && (e6 += " ... "), "<Buffer " + e6 + ">";
      }, "inspect");
      Ln2 && (f9.prototype[Ln2] = f9.prototype.inspect);
      f9.prototype.compare = a8(function(e6, t6, n7, i8, s10) {
        if (oe(e6, Uint8Array) && (e6 = f9.from(e6, e6.offset, e6.byteLength)), !f9.isBuffer(e6)) throw new TypeError('The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof e6);
        if (t6 === void 0 && (t6 = 0), n7 === void 0 && (n7 = e6 ? e6.length : 0), i8 === void 0 && (i8 = 0), s10 === void 0 && (s10 = this.length), t6 < 0 || n7 > e6.length || i8 < 0 || s10 > this.length) throw new RangeError("out of range index");
        if (i8 >= s10 && t6 >= n7) return 0;
        if (i8 >= s10) return -1;
        if (t6 >= n7) return 1;
        if (t6 >>>= 0, n7 >>>= 0, i8 >>>= 0, s10 >>>= 0, this === e6) return 0;
        let o9 = s10 - i8, u7 = n7 - t6, c6 = Math.min(o9, u7), h8 = this.slice(i8, s10), l7 = e6.slice(t6, n7);
        for (let d7 = 0; d7 < c6; ++d7)
          if (h8[d7] !== l7[d7]) {
            o9 = h8[d7], u7 = l7[d7];
            break;
          }
        return o9 < u7 ? -1 : u7 < o9 ? 1 : 0;
      }, "compare");
      function Un2(r6, e6, t6, n7, i8) {
        if (r6.length === 0) return -1;
        if (typeof t6 == "string" ? (n7 = t6, t6 = 0) : t6 > 2147483647 ? t6 = 2147483647 : t6 < -2147483648 && (t6 = -2147483648), t6 = +t6, qt4(t6) && (t6 = i8 ? 0 : r6.length - 1), t6 < 0 && (t6 = r6.length + t6), t6 >= r6.length) {
          if (i8) return -1;
          t6 = r6.length - 1;
        } else if (t6 < 0) if (i8) t6 = 0;
        else return -1;
        if (typeof e6 == "string" && (e6 = f9.from(e6, n7)), f9.isBuffer(e6)) return e6.length === 0 ? -1 : Rn2(r6, e6, t6, n7, i8);
        if (typeof e6 == "number") return e6 = e6 & 255, typeof Uint8Array.prototype.indexOf == "function" ? i8 ? Uint8Array.prototype.indexOf.call(r6, e6, t6) : Uint8Array.prototype.lastIndexOf.call(r6, e6, t6) : Rn2(
          r6,
          [e6],
          t6,
          n7,
          i8
        );
        throw new TypeError("val must be string, number or Buffer");
      }
      a8(Un2, "bidirectionalIndexOf");
      function Rn2(r6, e6, t6, n7, i8) {
        let s10 = 1, o9 = r6.length, u7 = e6.length;
        if (n7 !== void 0 && (n7 = String(n7).toLowerCase(), n7 === "ucs2" || n7 === "ucs-2" || n7 === "utf16le" || n7 === "utf-16le")) {
          if (r6.length < 2 || e6.length < 2) return -1;
          s10 = 2, o9 /= 2, u7 /= 2, t6 /= 2;
        }
        function c6(l7, d7) {
          return s10 === 1 ? l7[d7] : l7.readUInt16BE(d7 * s10);
        }
        a8(c6, "read");
        let h8;
        if (i8) {
          let l7 = -1;
          for (h8 = t6; h8 < o9; h8++) if (c6(r6, h8) === c6(e6, l7 === -1 ? 0 : h8 - l7)) {
            if (l7 === -1 && (l7 = h8), h8 - l7 + 1 === u7) return l7 * s10;
          } else l7 !== -1 && (h8 -= h8 - l7), l7 = -1;
        } else for (t6 + u7 > o9 && (t6 = o9 - u7), h8 = t6; h8 >= 0; h8--) {
          let l7 = true;
          for (let d7 = 0; d7 < u7; d7++)
            if (c6(r6, h8 + d7) !== c6(e6, d7)) {
              l7 = false;
              break;
            }
          if (l7) return h8;
        }
        return -1;
      }
      a8(Rn2, "arrayIndexOf");
      f9.prototype.includes = a8(function(e6, t6, n7) {
        return this.indexOf(e6, t6, n7) !== -1;
      }, "includes");
      f9.prototype.indexOf = a8(function(e6, t6, n7) {
        return Un2(this, e6, t6, n7, true);
      }, "indexOf");
      f9.prototype.lastIndexOf = a8(function(e6, t6, n7) {
        return Un2(this, e6, t6, n7, false);
      }, "lastIndexOf");
      function _o(r6, e6, t6, n7) {
        t6 = Number(t6) || 0;
        let i8 = r6.length - t6;
        n7 ? (n7 = Number(n7), n7 > i8 && (n7 = i8)) : n7 = i8;
        let s10 = e6.length;
        n7 > s10 / 2 && (n7 = s10 / 2);
        let o9;
        for (o9 = 0; o9 < n7; ++o9) {
          let u7 = parseInt(e6.substr(o9 * 2, 2), 16);
          if (qt4(u7))
            return o9;
          r6[t6 + o9] = u7;
        }
        return o9;
      }
      a8(_o, "hexWrite");
      function Ao(r6, e6, t6, n7) {
        return ot2(kt2(
          e6,
          r6.length - t6
        ), r6, t6, n7);
      }
      a8(Ao, "utf8Write");
      function Co(r6, e6, t6, n7) {
        return ot2(Uo(e6), r6, t6, n7);
      }
      a8(Co, "asciiWrite");
      function To(r6, e6, t6, n7) {
        return ot2($n2(e6), r6, t6, n7);
      }
      a8(To, "base64Write");
      function Io(r6, e6, t6, n7) {
        return ot2(No(e6, r6.length - t6), r6, t6, n7);
      }
      a8(Io, "ucs2Write");
      f9.prototype.write = a8(function(e6, t6, n7, i8) {
        if (t6 === void 0) i8 = "utf8", n7 = this.length, t6 = 0;
        else if (n7 === void 0 && typeof t6 == "string") i8 = t6, n7 = this.length, t6 = 0;
        else if (isFinite(t6)) t6 = t6 >>> 0, isFinite(n7) ? (n7 = n7 >>> 0, i8 === void 0 && (i8 = "utf8")) : (i8 = n7, n7 = void 0);
        else throw new Error("Buffer.write(string, encoding, offset[, length]) is no longer supported");
        let s10 = this.length - t6;
        if ((n7 === void 0 || n7 > s10) && (n7 = s10), e6.length > 0 && (n7 < 0 || t6 < 0) || t6 > this.length) throw new RangeError(
          "Attempt to write outside buffer bounds"
        );
        i8 || (i8 = "utf8");
        let o9 = false;
        for (; ; ) switch (i8) {
          case "hex":
            return _o(this, e6, t6, n7);
          case "utf8":
          case "utf-8":
            return Ao(this, e6, t6, n7);
          case "ascii":
          case "latin1":
          case "binary":
            return Co(this, e6, t6, n7);
          case "base64":
            return To(
              this,
              e6,
              t6,
              n7
            );
          case "ucs2":
          case "ucs-2":
          case "utf16le":
          case "utf-16le":
            return Io(this, e6, t6, n7);
          default:
            if (o9) throw new TypeError("Unknown encoding: " + i8);
            i8 = ("" + i8).toLowerCase(), o9 = true;
        }
      }, "write");
      f9.prototype.toJSON = a8(function() {
        return { type: "Buffer", data: Array.prototype.slice.call(this._arr || this, 0) };
      }, "toJSON");
      function Po(r6, e6, t6) {
        return e6 === 0 && t6 === r6.length ? Ft2.fromByteArray(r6) : Ft2.fromByteArray(r6.slice(e6, t6));
      }
      a8(Po, "base64Slice");
      function Nn2(r6, e6, t6) {
        t6 = Math.min(r6.length, t6);
        let n7 = [], i8 = e6;
        for (; i8 < t6; ) {
          let s10 = r6[i8], o9 = null, u7 = s10 > 239 ? 4 : s10 > 223 ? 3 : s10 > 191 ? 2 : 1;
          if (i8 + u7 <= t6) {
            let c6, h8, l7, d7;
            switch (u7) {
              case 1:
                s10 < 128 && (o9 = s10);
                break;
              case 2:
                c6 = r6[i8 + 1], (c6 & 192) === 128 && (d7 = (s10 & 31) << 6 | c6 & 63, d7 > 127 && (o9 = d7));
                break;
              case 3:
                c6 = r6[i8 + 1], h8 = r6[i8 + 2], (c6 & 192) === 128 && (h8 & 192) === 128 && (d7 = (s10 & 15) << 12 | (c6 & 63) << 6 | h8 & 63, d7 > 2047 && (d7 < 55296 || d7 > 57343) && (o9 = d7));
                break;
              case 4:
                c6 = r6[i8 + 1], h8 = r6[i8 + 2], l7 = r6[i8 + 3], (c6 & 192) === 128 && (h8 & 192) === 128 && (l7 & 192) === 128 && (d7 = (s10 & 15) << 18 | (c6 & 63) << 12 | (h8 & 63) << 6 | l7 & 63, d7 > 65535 && d7 < 1114112 && (o9 = d7));
            }
          }
          o9 === null ? (o9 = 65533, u7 = 1) : o9 > 65535 && (o9 -= 65536, n7.push(o9 >>> 10 & 1023 | 55296), o9 = 56320 | o9 & 1023), n7.push(o9), i8 += u7;
        }
        return Bo(n7);
      }
      a8(Nn2, "utf8Slice");
      var Fn2 = 4096;
      function Bo(r6) {
        let e6 = r6.length;
        if (e6 <= Fn2) return String.fromCharCode.apply(String, r6);
        let t6 = "", n7 = 0;
        for (; n7 < e6; ) t6 += String.fromCharCode.apply(String, r6.slice(n7, n7 += Fn2));
        return t6;
      }
      a8(Bo, "decodeCodePointsArray");
      function Lo(r6, e6, t6) {
        let n7 = "";
        t6 = Math.min(r6.length, t6);
        for (let i8 = e6; i8 < t6; ++i8) n7 += String.fromCharCode(r6[i8] & 127);
        return n7;
      }
      a8(Lo, "asciiSlice");
      function Ro(r6, e6, t6) {
        let n7 = "";
        t6 = Math.min(r6.length, t6);
        for (let i8 = e6; i8 < t6; ++i8) n7 += String.fromCharCode(r6[i8]);
        return n7;
      }
      a8(Ro, "latin1Slice");
      function Fo(r6, e6, t6) {
        let n7 = r6.length;
        (!e6 || e6 < 0) && (e6 = 0), (!t6 || t6 < 0 || t6 > n7) && (t6 = n7);
        let i8 = "";
        for (let s10 = e6; s10 < t6; ++s10) i8 += qo[r6[s10]];
        return i8;
      }
      a8(Fo, "hexSlice");
      function Mo(r6, e6, t6) {
        let n7 = r6.slice(e6, t6), i8 = "";
        for (let s10 = 0; s10 < n7.length - 1; s10 += 2) i8 += String.fromCharCode(n7[s10] + n7[s10 + 1] * 256);
        return i8;
      }
      a8(Mo, "utf16leSlice");
      f9.prototype.slice = a8(function(e6, t6) {
        let n7 = this.length;
        e6 = ~~e6, t6 = t6 === void 0 ? n7 : ~~t6, e6 < 0 ? (e6 += n7, e6 < 0 && (e6 = 0)) : e6 > n7 && (e6 = n7), t6 < 0 ? (t6 += n7, t6 < 0 && (t6 = 0)) : t6 > n7 && (t6 = n7), t6 < e6 && (t6 = e6);
        let i8 = this.subarray(
          e6,
          t6
        );
        return Object.setPrototypeOf(i8, f9.prototype), i8;
      }, "slice");
      function q7(r6, e6, t6) {
        if (r6 % 1 !== 0 || r6 < 0) throw new RangeError("offset is not uint");
        if (r6 + e6 > t6) throw new RangeError(
          "Trying to access beyond buffer length"
        );
      }
      a8(q7, "checkOffset");
      f9.prototype.readUintLE = f9.prototype.readUIntLE = a8(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = this[e6], s10 = 1, o9 = 0;
        for (; ++o9 < t6 && (s10 *= 256); ) i8 += this[e6 + o9] * s10;
        return i8;
      }, "readUIntLE");
      f9.prototype.readUintBE = f9.prototype.readUIntBE = a8(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = this[e6 + --t6], s10 = 1;
        for (; t6 > 0 && (s10 *= 256); ) i8 += this[e6 + --t6] * s10;
        return i8;
      }, "readUIntBE");
      f9.prototype.readUint8 = f9.prototype.readUInt8 = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 1, this.length), this[e6];
      }, "readUInt8");
      f9.prototype.readUint16LE = f9.prototype.readUInt16LE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 2, this.length), this[e6] | this[e6 + 1] << 8;
      }, "readUInt16LE");
      f9.prototype.readUint16BE = f9.prototype.readUInt16BE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 2, this.length), this[e6] << 8 | this[e6 + 1];
      }, "readUInt16BE");
      f9.prototype.readUint32LE = f9.prototype.readUInt32LE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), (this[e6] | this[e6 + 1] << 8 | this[e6 + 2] << 16) + this[e6 + 3] * 16777216;
      }, "readUInt32LE");
      f9.prototype.readUint32BE = f9.prototype.readUInt32BE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), this[e6] * 16777216 + (this[e6 + 1] << 16 | this[e6 + 2] << 8 | this[e6 + 3]);
      }, "readUInt32BE");
      f9.prototype.readBigUInt64LE = ge4(a8(function(e6) {
        e6 = e6 >>> 0, Le2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(e6, this.length - 8);
        let i8 = t6 + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 24, s10 = this[++e6] + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + n7 * 2 ** 24;
        return BigInt(i8) + (BigInt(s10) << BigInt(32));
      }, "readBigUInt64LE"));
      f9.prototype.readBigUInt64BE = ge4(a8(function(e6) {
        e6 = e6 >>> 0, Le2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(e6, this.length - 8);
        let i8 = t6 * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + this[++e6], s10 = this[++e6] * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + n7;
        return (BigInt(
          i8
        ) << BigInt(32)) + BigInt(s10);
      }, "readBigUInt64BE"));
      f9.prototype.readIntLE = a8(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = this[e6], s10 = 1, o9 = 0;
        for (; ++o9 < t6 && (s10 *= 256); )
          i8 += this[e6 + o9] * s10;
        return s10 *= 128, i8 >= s10 && (i8 -= Math.pow(2, 8 * t6)), i8;
      }, "readIntLE");
      f9.prototype.readIntBE = a8(function(e6, t6, n7) {
        e6 = e6 >>> 0, t6 = t6 >>> 0, n7 || q7(e6, t6, this.length);
        let i8 = t6, s10 = 1, o9 = this[e6 + --i8];
        for (; i8 > 0 && (s10 *= 256); ) o9 += this[e6 + --i8] * s10;
        return s10 *= 128, o9 >= s10 && (o9 -= Math.pow(2, 8 * t6)), o9;
      }, "readIntBE");
      f9.prototype.readInt8 = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 1, this.length), this[e6] & 128 ? (255 - this[e6] + 1) * -1 : this[e6];
      }, "readInt8");
      f9.prototype.readInt16LE = a8(function(e6, t6) {
        e6 = e6 >>> 0, t6 || q7(e6, 2, this.length);
        let n7 = this[e6] | this[e6 + 1] << 8;
        return n7 & 32768 ? n7 | 4294901760 : n7;
      }, "readInt16LE");
      f9.prototype.readInt16BE = a8(
        function(e6, t6) {
          e6 = e6 >>> 0, t6 || q7(e6, 2, this.length);
          let n7 = this[e6 + 1] | this[e6] << 8;
          return n7 & 32768 ? n7 | 4294901760 : n7;
        },
        "readInt16BE"
      );
      f9.prototype.readInt32LE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), this[e6] | this[e6 + 1] << 8 | this[e6 + 2] << 16 | this[e6 + 3] << 24;
      }, "readInt32LE");
      f9.prototype.readInt32BE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), this[e6] << 24 | this[e6 + 1] << 16 | this[e6 + 2] << 8 | this[e6 + 3];
      }, "readInt32BE");
      f9.prototype.readBigInt64LE = ge4(a8(function(e6) {
        e6 = e6 >>> 0, Le2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(
          e6,
          this.length - 8
        );
        let i8 = this[e6 + 4] + this[e6 + 5] * 2 ** 8 + this[e6 + 6] * 2 ** 16 + (n7 << 24);
        return (BigInt(
          i8
        ) << BigInt(32)) + BigInt(t6 + this[++e6] * 2 ** 8 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 24);
      }, "readBigInt64LE"));
      f9.prototype.readBigInt64BE = ge4(a8(function(e6) {
        e6 = e6 >>> 0, Le2(e6, "offset");
        let t6 = this[e6], n7 = this[e6 + 7];
        (t6 === void 0 || n7 === void 0) && We3(e6, this.length - 8);
        let i8 = (t6 << 24) + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + this[++e6];
        return (BigInt(i8) << BigInt(32)) + BigInt(
          this[++e6] * 2 ** 24 + this[++e6] * 2 ** 16 + this[++e6] * 2 ** 8 + n7
        );
      }, "readBigInt64BE"));
      f9.prototype.readFloatLE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), Be2.read(
          this,
          e6,
          true,
          23,
          4
        );
      }, "readFloatLE");
      f9.prototype.readFloatBE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 4, this.length), Be2.read(this, e6, false, 23, 4);
      }, "readFloatBE");
      f9.prototype.readDoubleLE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 8, this.length), Be2.read(this, e6, true, 52, 8);
      }, "readDoubleLE");
      f9.prototype.readDoubleBE = a8(function(e6, t6) {
        return e6 = e6 >>> 0, t6 || q7(e6, 8, this.length), Be2.read(this, e6, false, 52, 8);
      }, "readDoubleBE");
      function Y3(r6, e6, t6, n7, i8, s10) {
        if (!f9.isBuffer(
          r6
        )) throw new TypeError('"buffer" argument must be a Buffer instance');
        if (e6 > i8 || e6 < s10) throw new RangeError('"value" argument is out of bounds');
        if (t6 + n7 > r6.length) throw new RangeError(
          "Index out of range"
        );
      }
      a8(Y3, "checkInt");
      f9.prototype.writeUintLE = f9.prototype.writeUIntLE = a8(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, n7 = n7 >>> 0, !i8) {
          let u7 = Math.pow(2, 8 * n7) - 1;
          Y3(
            this,
            e6,
            t6,
            n7,
            u7,
            0
          );
        }
        let s10 = 1, o9 = 0;
        for (this[t6] = e6 & 255; ++o9 < n7 && (s10 *= 256); ) this[t6 + o9] = e6 / s10 & 255;
        return t6 + n7;
      }, "writeUIntLE");
      f9.prototype.writeUintBE = f9.prototype.writeUIntBE = a8(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, n7 = n7 >>> 0, !i8) {
          let u7 = Math.pow(2, 8 * n7) - 1;
          Y3(this, e6, t6, n7, u7, 0);
        }
        let s10 = n7 - 1, o9 = 1;
        for (this[t6 + s10] = e6 & 255; --s10 >= 0 && (o9 *= 256); ) this[t6 + s10] = e6 / o9 & 255;
        return t6 + n7;
      }, "writeUIntBE");
      f9.prototype.writeUint8 = f9.prototype.writeUInt8 = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 1, 255, 0), this[t6] = e6 & 255, t6 + 1;
      }, "writeUInt8");
      f9.prototype.writeUint16LE = f9.prototype.writeUInt16LE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          2,
          65535,
          0
        ), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, t6 + 2;
      }, "writeUInt16LE");
      f9.prototype.writeUint16BE = f9.prototype.writeUInt16BE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          2,
          65535,
          0
        ), this[t6] = e6 >>> 8, this[t6 + 1] = e6 & 255, t6 + 2;
      }, "writeUInt16BE");
      f9.prototype.writeUint32LE = f9.prototype.writeUInt32LE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          4,
          4294967295,
          0
        ), this[t6 + 3] = e6 >>> 24, this[t6 + 2] = e6 >>> 16, this[t6 + 1] = e6 >>> 8, this[t6] = e6 & 255, t6 + 4;
      }, "writeUInt32LE");
      f9.prototype.writeUint32BE = f9.prototype.writeUInt32BE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 4, 4294967295, 0), this[t6] = e6 >>> 24, this[t6 + 1] = e6 >>> 16, this[t6 + 2] = e6 >>> 8, this[t6 + 3] = e6 & 255, t6 + 4;
      }, "writeUInt32BE");
      function qn2(r6, e6, t6, n7, i8) {
        Gn3(
          e6,
          n7,
          i8,
          r6,
          t6,
          7
        );
        let s10 = Number(e6 & BigInt(4294967295));
        r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10, s10 = s10 >> 8, r6[t6++] = s10;
        let o9 = Number(e6 >> BigInt(32) & BigInt(4294967295));
        return r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, o9 = o9 >> 8, r6[t6++] = o9, t6;
      }
      a8(qn2, "wrtBigUInt64LE");
      function Qn2(r6, e6, t6, n7, i8) {
        Gn3(e6, n7, i8, r6, t6, 7);
        let s10 = Number(e6 & BigInt(4294967295));
        r6[t6 + 7] = s10, s10 = s10 >> 8, r6[t6 + 6] = s10, s10 = s10 >> 8, r6[t6 + 5] = s10, s10 = s10 >> 8, r6[t6 + 4] = s10;
        let o9 = Number(e6 >> BigInt(32) & BigInt(4294967295));
        return r6[t6 + 3] = o9, o9 = o9 >> 8, r6[t6 + 2] = o9, o9 = o9 >> 8, r6[t6 + 1] = o9, o9 = o9 >> 8, r6[t6] = o9, t6 + 8;
      }
      a8(Qn2, "wrtBigUInt64BE");
      f9.prototype.writeBigUInt64LE = ge4(a8(function(e6, t6 = 0) {
        return qn2(this, e6, t6, BigInt(0), BigInt(
          "0xffffffffffffffff"
        ));
      }, "writeBigUInt64LE"));
      f9.prototype.writeBigUInt64BE = ge4(a8(function(e6, t6 = 0) {
        return Qn2(this, e6, t6, BigInt(0), BigInt("0xffffffffffffffff"));
      }, "writeBigUInt64BE"));
      f9.prototype.writeIntLE = a8(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, !i8) {
          let c6 = Math.pow(
            2,
            8 * n7 - 1
          );
          Y3(this, e6, t6, n7, c6 - 1, -c6);
        }
        let s10 = 0, o9 = 1, u7 = 0;
        for (this[t6] = e6 & 255; ++s10 < n7 && (o9 *= 256); ) e6 < 0 && u7 === 0 && this[t6 + s10 - 1] !== 0 && (u7 = 1), this[t6 + s10] = (e6 / o9 >> 0) - u7 & 255;
        return t6 + n7;
      }, "writeIntLE");
      f9.prototype.writeIntBE = a8(function(e6, t6, n7, i8) {
        if (e6 = +e6, t6 = t6 >>> 0, !i8) {
          let c6 = Math.pow(
            2,
            8 * n7 - 1
          );
          Y3(this, e6, t6, n7, c6 - 1, -c6);
        }
        let s10 = n7 - 1, o9 = 1, u7 = 0;
        for (this[t6 + s10] = e6 & 255; --s10 >= 0 && (o9 *= 256); ) e6 < 0 && u7 === 0 && this[t6 + s10 + 1] !== 0 && (u7 = 1), this[t6 + s10] = (e6 / o9 >> 0) - u7 & 255;
        return t6 + n7;
      }, "writeIntBE");
      f9.prototype.writeInt8 = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(
          this,
          e6,
          t6,
          1,
          127,
          -128
        ), e6 < 0 && (e6 = 255 + e6 + 1), this[t6] = e6 & 255, t6 + 1;
      }, "writeInt8");
      f9.prototype.writeInt16LE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 2, 32767, -32768), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, t6 + 2;
      }, "writeInt16LE");
      f9.prototype.writeInt16BE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 2, 32767, -32768), this[t6] = e6 >>> 8, this[t6 + 1] = e6 & 255, t6 + 2;
      }, "writeInt16BE");
      f9.prototype.writeInt32LE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 4, 2147483647, -2147483648), this[t6] = e6 & 255, this[t6 + 1] = e6 >>> 8, this[t6 + 2] = e6 >>> 16, this[t6 + 3] = e6 >>> 24, t6 + 4;
      }, "writeInt32LE");
      f9.prototype.writeInt32BE = a8(function(e6, t6, n7) {
        return e6 = +e6, t6 = t6 >>> 0, n7 || Y3(this, e6, t6, 4, 2147483647, -2147483648), e6 < 0 && (e6 = 4294967295 + e6 + 1), this[t6] = e6 >>> 24, this[t6 + 1] = e6 >>> 16, this[t6 + 2] = e6 >>> 8, this[t6 + 3] = e6 & 255, t6 + 4;
      }, "writeInt32BE");
      f9.prototype.writeBigInt64LE = ge4(a8(function(e6, t6 = 0) {
        return qn2(this, e6, t6, -BigInt(
          "0x8000000000000000"
        ), BigInt("0x7fffffffffffffff"));
      }, "writeBigInt64LE"));
      f9.prototype.writeBigInt64BE = ge4(a8(function(e6, t6 = 0) {
        return Qn2(this, e6, t6, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
      }, "writeBigInt64BE"));
      function jn2(r6, e6, t6, n7, i8, s10) {
        if (t6 + n7 > r6.length) throw new RangeError("Index out of range");
        if (t6 < 0) throw new RangeError(
          "Index out of range"
        );
      }
      a8(jn2, "checkIEEE754");
      function Wn2(r6, e6, t6, n7, i8) {
        return e6 = +e6, t6 = t6 >>> 0, i8 || jn2(r6, e6, t6, 4, 34028234663852886e22, -34028234663852886e22), Be2.write(
          r6,
          e6,
          t6,
          n7,
          23,
          4
        ), t6 + 4;
      }
      a8(Wn2, "writeFloat");
      f9.prototype.writeFloatLE = a8(function(e6, t6, n7) {
        return Wn2(
          this,
          e6,
          t6,
          true,
          n7
        );
      }, "writeFloatLE");
      f9.prototype.writeFloatBE = a8(function(e6, t6, n7) {
        return Wn2(
          this,
          e6,
          t6,
          false,
          n7
        );
      }, "writeFloatBE");
      function Hn2(r6, e6, t6, n7, i8) {
        return e6 = +e6, t6 = t6 >>> 0, i8 || jn2(
          r6,
          e6,
          t6,
          8,
          17976931348623157e292,
          -17976931348623157e292
        ), Be2.write(r6, e6, t6, n7, 52, 8), t6 + 8;
      }
      a8(Hn2, "writeDouble");
      f9.prototype.writeDoubleLE = a8(function(e6, t6, n7) {
        return Hn2(
          this,
          e6,
          t6,
          true,
          n7
        );
      }, "writeDoubleLE");
      f9.prototype.writeDoubleBE = a8(function(e6, t6, n7) {
        return Hn2(
          this,
          e6,
          t6,
          false,
          n7
        );
      }, "writeDoubleBE");
      f9.prototype.copy = a8(function(e6, t6, n7, i8) {
        if (!f9.isBuffer(
          e6
        )) throw new TypeError("argument should be a Buffer");
        if (n7 || (n7 = 0), !i8 && i8 !== 0 && (i8 = this.length), t6 >= e6.length && (t6 = e6.length), t6 || (t6 = 0), i8 > 0 && i8 < n7 && (i8 = n7), i8 === n7 || e6.length === 0 || this.length === 0) return 0;
        if (t6 < 0) throw new RangeError("targetStart out of bounds");
        if (n7 < 0 || n7 >= this.length) throw new RangeError("Index out of range");
        if (i8 < 0) throw new RangeError(
          "sourceEnd out of bounds"
        );
        i8 > this.length && (i8 = this.length), e6.length - t6 < i8 - n7 && (i8 = e6.length - t6 + n7);
        let s10 = i8 - n7;
        return this === e6 && typeof Uint8Array.prototype.copyWithin == "function" ? this.copyWithin(t6, n7, i8) : Uint8Array.prototype.set.call(e6, this.subarray(n7, i8), t6), s10;
      }, "copy");
      f9.prototype.fill = a8(function(e6, t6, n7, i8) {
        if (typeof e6 == "string") {
          if (typeof t6 == "string" ? (i8 = t6, t6 = 0, n7 = this.length) : typeof n7 == "string" && (i8 = n7, n7 = this.length), i8 !== void 0 && typeof i8 != "string") throw new TypeError("encoding must be a string");
          if (typeof i8 == "string" && !f9.isEncoding(i8)) throw new TypeError("Unknown encoding: " + i8);
          if (e6.length === 1) {
            let o9 = e6.charCodeAt(0);
            (i8 === "utf8" && o9 < 128 || i8 === "latin1") && (e6 = o9);
          }
        } else typeof e6 == "number" ? e6 = e6 & 255 : typeof e6 == "boolean" && (e6 = Number(e6));
        if (t6 < 0 || this.length < t6 || this.length < n7) throw new RangeError("Out of range index");
        if (n7 <= t6) return this;
        t6 = t6 >>> 0, n7 = n7 === void 0 ? this.length : n7 >>> 0, e6 || (e6 = 0);
        let s10;
        if (typeof e6 == "number") for (s10 = t6; s10 < n7; ++s10)
          this[s10] = e6;
        else {
          let o9 = f9.isBuffer(e6) ? e6 : f9.from(e6, i8), u7 = o9.length;
          if (u7 === 0) throw new TypeError(
            'The value "' + e6 + '" is invalid for argument "value"'
          );
          for (s10 = 0; s10 < n7 - t6; ++s10) this[s10 + t6] = o9[s10 % u7];
        }
        return this;
      }, "fill");
      var Pe3 = {};
      function Nt2(r6, e6, t6) {
        var n7;
        Pe3[r6] = (n7 = class extends t6 {
          constructor() {
            super(), Object.defineProperty(this, "message", {
              value: e6.apply(this, arguments),
              writable: true,
              configurable: true
            }), this.name = `${this.name} [${r6}]`, this.stack, delete this.name;
          }
          get code() {
            return r6;
          }
          set code(s10) {
            Object.defineProperty(this, "code", {
              configurable: true,
              enumerable: true,
              value: s10,
              writable: true
            });
          }
          toString() {
            return `${this.name} [${r6}]: ${this.message}`;
          }
        }, a8(n7, "NodeError"), n7);
      }
      a8(Nt2, "E");
      Nt2("ERR_BUFFER_OUT_OF_BOUNDS", function(r6) {
        return r6 ? `${r6} is outside of buffer bounds` : "Attempt to access memory outside buffer bounds";
      }, RangeError);
      Nt2("ERR_INVALID_ARG_TYPE", function(r6, e6) {
        return `The "${r6}" argument must be of type number. Received type ${typeof e6}`;
      }, TypeError);
      Nt2("ERR_OUT_OF_RANGE", function(r6, e6, t6) {
        let n7 = `The value of "${r6}" is out of range.`, i8 = t6;
        return Number.isInteger(t6) && Math.abs(t6) > 2 ** 32 ? i8 = Mn2(String(t6)) : typeof t6 == "bigint" && (i8 = String(t6), (t6 > BigInt(2) ** BigInt(32) || t6 < -(BigInt(2) ** BigInt(32))) && (i8 = Mn2(i8)), i8 += "n"), n7 += ` It must be ${e6}. Received ${i8}`, n7;
      }, RangeError);
      function Mn2(r6) {
        let e6 = "", t6 = r6.length, n7 = r6[0] === "-" ? 1 : 0;
        for (; t6 >= n7 + 4; t6 -= 3) e6 = `_${r6.slice(t6 - 3, t6)}${e6}`;
        return `${r6.slice(
          0,
          t6
        )}${e6}`;
      }
      a8(Mn2, "addNumericalSeparator");
      function Do(r6, e6, t6) {
        Le2(e6, "offset"), (r6[e6] === void 0 || r6[e6 + t6] === void 0) && We3(e6, r6.length - (t6 + 1));
      }
      a8(Do, "checkBounds");
      function Gn3(r6, e6, t6, n7, i8, s10) {
        if (r6 > t6 || r6 < e6) {
          let o9 = typeof e6 == "bigint" ? "n" : "", u7;
          throw s10 > 3 ? e6 === 0 || e6 === BigInt(0) ? u7 = `>= 0${o9} and < 2${o9} ** ${(s10 + 1) * 8}${o9}` : u7 = `>= -(2${o9} ** ${(s10 + 1) * 8 - 1}${o9}) and < 2 ** ${(s10 + 1) * 8 - 1}${o9}` : u7 = `>= ${e6}${o9} and <= ${t6}${o9}`, new Pe3.ERR_OUT_OF_RANGE(
            "value",
            u7,
            r6
          );
        }
        Do(n7, i8, s10);
      }
      a8(Gn3, "checkIntBI");
      function Le2(r6, e6) {
        if (typeof r6 != "number")
          throw new Pe3.ERR_INVALID_ARG_TYPE(e6, "number", r6);
      }
      a8(Le2, "validateNumber");
      function We3(r6, e6, t6) {
        throw Math.floor(r6) !== r6 ? (Le2(r6, t6), new Pe3.ERR_OUT_OF_RANGE(
          t6 || "offset",
          "an integer",
          r6
        )) : e6 < 0 ? new Pe3.ERR_BUFFER_OUT_OF_BOUNDS() : new Pe3.ERR_OUT_OF_RANGE(t6 || "offset", `>= ${t6 ? 1 : 0} and <= ${e6}`, r6);
      }
      a8(We3, "boundsError");
      var ko = /[^+/0-9A-Za-z-_]/g;
      function Oo(r6) {
        if (r6 = r6.split("=")[0], r6 = r6.trim().replace(ko, ""), r6.length < 2) return "";
        for (; r6.length % 4 !== 0; ) r6 = r6 + "=";
        return r6;
      }
      a8(Oo, "base64clean");
      function kt2(r6, e6) {
        e6 = e6 || 1 / 0;
        let t6, n7 = r6.length, i8 = null, s10 = [];
        for (let o9 = 0; o9 < n7; ++o9) {
          if (t6 = r6.charCodeAt(o9), t6 > 55295 && t6 < 57344) {
            if (!i8) {
              if (t6 > 56319) {
                (e6 -= 3) > -1 && s10.push(239, 191, 189);
                continue;
              } else if (o9 + 1 === n7) {
                (e6 -= 3) > -1 && s10.push(239, 191, 189);
                continue;
              }
              i8 = t6;
              continue;
            }
            if (t6 < 56320) {
              (e6 -= 3) > -1 && s10.push(
                239,
                191,
                189
              ), i8 = t6;
              continue;
            }
            t6 = (i8 - 55296 << 10 | t6 - 56320) + 65536;
          } else i8 && (e6 -= 3) > -1 && s10.push(
            239,
            191,
            189
          );
          if (i8 = null, t6 < 128) {
            if ((e6 -= 1) < 0) break;
            s10.push(t6);
          } else if (t6 < 2048) {
            if ((e6 -= 2) < 0) break;
            s10.push(t6 >> 6 | 192, t6 & 63 | 128);
          } else if (t6 < 65536) {
            if ((e6 -= 3) < 0) break;
            s10.push(t6 >> 12 | 224, t6 >> 6 & 63 | 128, t6 & 63 | 128);
          } else if (t6 < 1114112) {
            if ((e6 -= 4) < 0) break;
            s10.push(t6 >> 18 | 240, t6 >> 12 & 63 | 128, t6 >> 6 & 63 | 128, t6 & 63 | 128);
          } else throw new Error("Invalid code point");
        }
        return s10;
      }
      a8(
        kt2,
        "utf8ToBytes"
      );
      function Uo(r6) {
        let e6 = [];
        for (let t6 = 0; t6 < r6.length; ++t6) e6.push(r6.charCodeAt(
          t6
        ) & 255);
        return e6;
      }
      a8(Uo, "asciiToBytes");
      function No(r6, e6) {
        let t6, n7, i8, s10 = [];
        for (let o9 = 0; o9 < r6.length && !((e6 -= 2) < 0); ++o9) t6 = r6.charCodeAt(o9), n7 = t6 >> 8, i8 = t6 % 256, s10.push(i8), s10.push(n7);
        return s10;
      }
      a8(No, "utf16leToBytes");
      function $n2(r6) {
        return Ft2.toByteArray(Oo(r6));
      }
      a8($n2, "base64ToBytes");
      function ot2(r6, e6, t6, n7) {
        let i8;
        for (i8 = 0; i8 < n7 && !(i8 + t6 >= e6.length || i8 >= r6.length); ++i8)
          e6[i8 + t6] = r6[i8];
        return i8;
      }
      a8(ot2, "blitBuffer");
      function oe(r6, e6) {
        return r6 instanceof e6 || r6 != null && r6.constructor != null && r6.constructor.name != null && r6.constructor.name === e6.name;
      }
      a8(oe, "isInstance");
      function qt4(r6) {
        return r6 !== r6;
      }
      a8(qt4, "numberIsNaN");
      var qo = function() {
        let r6 = "0123456789abcdef", e6 = new Array(256);
        for (let t6 = 0; t6 < 16; ++t6) {
          let n7 = t6 * 16;
          for (let i8 = 0; i8 < 16; ++i8) e6[n7 + i8] = r6[t6] + r6[i8];
        }
        return e6;
      }();
      function ge4(r6) {
        return typeof BigInt > "u" ? Qo : r6;
      }
      a8(ge4, "defineBigIntMethod");
      function Qo() {
        throw new Error("BigInt not supported");
      }
      a8(Qo, "BufferBigIntNotDefined");
    });
    p10 = z5(() => {
      "use strict";
      S6 = globalThis, E3 = globalThis.setImmediate ?? ((r6) => setTimeout(
        r6,
        0
      )), x10 = globalThis.clearImmediate ?? ((r6) => clearTimeout(r6)), g9 = globalThis.crypto ?? {};
      g9.subtle ?? (g9.subtle = {});
      y6 = typeof globalThis.Buffer == "function" && typeof globalThis.Buffer.allocUnsafe == "function" ? globalThis.Buffer : Vn2().Buffer, m11 = globalThis.process ?? {};
      m11.env ?? (m11.env = {});
      try {
        m11.nextTick(() => {
        });
      } catch {
        let e6 = Promise.resolve();
        m11.nextTick = e6.then.bind(e6);
      }
    });
    we4 = I6((th, Qt4) => {
      "use strict";
      p10();
      var Fe2 = typeof Reflect == "object" ? Reflect : null, Kn = Fe2 && typeof Fe2.apply == "function" ? Fe2.apply : a8(function(e6, t6, n7) {
        return Function.prototype.apply.call(e6, t6, n7);
      }, "ReflectApply"), at2;
      Fe2 && typeof Fe2.ownKeys == "function" ? at2 = Fe2.ownKeys : Object.getOwnPropertySymbols ? at2 = a8(function(e6) {
        return Object.getOwnPropertyNames(
          e6
        ).concat(Object.getOwnPropertySymbols(e6));
      }, "ReflectOwnKeys") : at2 = a8(function(e6) {
        return Object.getOwnPropertyNames(e6);
      }, "ReflectOwnKeys");
      function jo(r6) {
        console && console.warn && console.warn(r6);
      }
      a8(jo, "ProcessEmitWarning");
      var Yn = Number.isNaN || a8(function(e6) {
        return e6 !== e6;
      }, "NumberIsNaN");
      function L6() {
        L6.init.call(this);
      }
      a8(L6, "EventEmitter");
      Qt4.exports = L6;
      Qt4.exports.once = $o3;
      L6.EventEmitter = L6;
      L6.prototype._events = void 0;
      L6.prototype._eventsCount = 0;
      L6.prototype._maxListeners = void 0;
      var zn2 = 10;
      function ut2(r6) {
        if (typeof r6 != "function") throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof r6);
      }
      a8(ut2, "checkListener");
      Object.defineProperty(L6, "defaultMaxListeners", { enumerable: true, get: a8(function() {
        return zn2;
      }, "get"), set: a8(function(r6) {
        if (typeof r6 != "number" || r6 < 0 || Yn(r6)) throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + r6 + ".");
        zn2 = r6;
      }, "set") });
      L6.init = function() {
        (this._events === void 0 || this._events === Object.getPrototypeOf(this)._events) && (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0), this._maxListeners = this._maxListeners || void 0;
      };
      L6.prototype.setMaxListeners = a8(
        function(e6) {
          if (typeof e6 != "number" || e6 < 0 || Yn(e6)) throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + e6 + ".");
          return this._maxListeners = e6, this;
        },
        "setMaxListeners"
      );
      function Zn(r6) {
        return r6._maxListeners === void 0 ? L6.defaultMaxListeners : r6._maxListeners;
      }
      a8(Zn, "_getMaxListeners");
      L6.prototype.getMaxListeners = a8(function() {
        return Zn(this);
      }, "getMaxListeners");
      L6.prototype.emit = a8(function(e6) {
        for (var t6 = [], n7 = 1; n7 < arguments.length; n7++) t6.push(arguments[n7]);
        var i8 = e6 === "error", s10 = this._events;
        if (s10 !== void 0) i8 = i8 && s10.error === void 0;
        else if (!i8) return false;
        if (i8) {
          var o9;
          if (t6.length > 0 && (o9 = t6[0]), o9 instanceof Error) throw o9;
          var u7 = new Error("Unhandled error." + (o9 ? " (" + o9.message + ")" : ""));
          throw u7.context = o9, u7;
        }
        var c6 = s10[e6];
        if (c6 === void 0) return false;
        if (typeof c6 == "function") Kn(c6, this, t6);
        else for (var h8 = c6.length, l7 = ri2(c6, h8), n7 = 0; n7 < h8; ++n7) Kn(
          l7[n7],
          this,
          t6
        );
        return true;
      }, "emit");
      function Jn(r6, e6, t6, n7) {
        var i8, s10, o9;
        if (ut2(t6), s10 = r6._events, s10 === void 0 ? (s10 = r6._events = /* @__PURE__ */ Object.create(null), r6._eventsCount = 0) : (s10.newListener !== void 0 && (r6.emit(
          "newListener",
          e6,
          t6.listener ? t6.listener : t6
        ), s10 = r6._events), o9 = s10[e6]), o9 === void 0) o9 = s10[e6] = t6, ++r6._eventsCount;
        else if (typeof o9 == "function" ? o9 = s10[e6] = n7 ? [t6, o9] : [o9, t6] : n7 ? o9.unshift(
          t6
        ) : o9.push(t6), i8 = Zn(r6), i8 > 0 && o9.length > i8 && !o9.warned) {
          o9.warned = true;
          var u7 = new Error("Possible EventEmitter memory leak detected. " + o9.length + " " + String(e6) + " listeners added. Use emitter.setMaxListeners() to increase limit");
          u7.name = "MaxListenersExceededWarning", u7.emitter = r6, u7.type = e6, u7.count = o9.length, jo(u7);
        }
        return r6;
      }
      a8(Jn, "_addListener");
      L6.prototype.addListener = a8(function(e6, t6) {
        return Jn(this, e6, t6, false);
      }, "addListener");
      L6.prototype.on = L6.prototype.addListener;
      L6.prototype.prependListener = a8(function(e6, t6) {
        return Jn(this, e6, t6, true);
      }, "prependListener");
      function Wo() {
        if (!this.fired) return this.target.removeListener(this.type, this.wrapFn), this.fired = true, arguments.length === 0 ? this.listener.call(this.target) : this.listener.apply(this.target, arguments);
      }
      a8(
        Wo,
        "onceWrapper"
      );
      function Xn(r6, e6, t6) {
        var n7 = {
          fired: false,
          wrapFn: void 0,
          target: r6,
          type: e6,
          listener: t6
        }, i8 = Wo.bind(n7);
        return i8.listener = t6, n7.wrapFn = i8, i8;
      }
      a8(Xn, "_onceWrap");
      L6.prototype.once = a8(function(e6, t6) {
        return ut2(t6), this.on(e6, Xn(this, e6, t6)), this;
      }, "once");
      L6.prototype.prependOnceListener = a8(function(e6, t6) {
        return ut2(t6), this.prependListener(e6, Xn(
          this,
          e6,
          t6
        )), this;
      }, "prependOnceListener");
      L6.prototype.removeListener = a8(
        function(e6, t6) {
          var n7, i8, s10, o9, u7;
          if (ut2(t6), i8 = this._events, i8 === void 0) return this;
          if (n7 = i8[e6], n7 === void 0) return this;
          if (n7 === t6 || n7.listener === t6) --this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : (delete i8[e6], i8.removeListener && this.emit("removeListener", e6, n7.listener || t6));
          else if (typeof n7 != "function") {
            for (s10 = -1, o9 = n7.length - 1; o9 >= 0; o9--) if (n7[o9] === t6 || n7[o9].listener === t6) {
              u7 = n7[o9].listener, s10 = o9;
              break;
            }
            if (s10 < 0) return this;
            s10 === 0 ? n7.shift() : Ho2(n7, s10), n7.length === 1 && (i8[e6] = n7[0]), i8.removeListener !== void 0 && this.emit("removeListener", e6, u7 || t6);
          }
          return this;
        },
        "removeListener"
      );
      L6.prototype.off = L6.prototype.removeListener;
      L6.prototype.removeAllListeners = a8(function(e6) {
        var t6, n7, i8;
        if (n7 = this._events, n7 === void 0) return this;
        if (n7.removeListener === void 0) return arguments.length === 0 ? (this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0) : n7[e6] !== void 0 && (--this._eventsCount === 0 ? this._events = /* @__PURE__ */ Object.create(null) : delete n7[e6]), this;
        if (arguments.length === 0) {
          var s10 = Object.keys(n7), o9;
          for (i8 = 0; i8 < s10.length; ++i8) o9 = s10[i8], o9 !== "removeListener" && this.removeAllListeners(o9);
          return this.removeAllListeners(
            "removeListener"
          ), this._events = /* @__PURE__ */ Object.create(null), this._eventsCount = 0, this;
        }
        if (t6 = n7[e6], typeof t6 == "function") this.removeListener(e6, t6);
        else if (t6 !== void 0) for (i8 = t6.length - 1; i8 >= 0; i8--) this.removeListener(e6, t6[i8]);
        return this;
      }, "removeAllListeners");
      function ei(r6, e6, t6) {
        var n7 = r6._events;
        if (n7 === void 0) return [];
        var i8 = n7[e6];
        return i8 === void 0 ? [] : typeof i8 == "function" ? t6 ? [i8.listener || i8] : [i8] : t6 ? Go2(i8) : ri2(i8, i8.length);
      }
      a8(ei, "_listeners");
      L6.prototype.listeners = a8(function(e6) {
        return ei(this, e6, true);
      }, "listeners");
      L6.prototype.rawListeners = a8(function(e6) {
        return ei(this, e6, false);
      }, "rawListeners");
      L6.listenerCount = function(r6, e6) {
        return typeof r6.listenerCount == "function" ? r6.listenerCount(e6) : ti.call(r6, e6);
      };
      L6.prototype.listenerCount = ti;
      function ti(r6) {
        var e6 = this._events;
        if (e6 !== void 0) {
          var t6 = e6[r6];
          if (typeof t6 == "function") return 1;
          if (t6 !== void 0) return t6.length;
        }
        return 0;
      }
      a8(ti, "listenerCount");
      L6.prototype.eventNames = a8(function() {
        return this._eventsCount > 0 ? at2(this._events) : [];
      }, "eventNames");
      function ri2(r6, e6) {
        for (var t6 = new Array(e6), n7 = 0; n7 < e6; ++n7) t6[n7] = r6[n7];
        return t6;
      }
      a8(ri2, "arrayClone");
      function Ho2(r6, e6) {
        for (; e6 + 1 < r6.length; e6++) r6[e6] = r6[e6 + 1];
        r6.pop();
      }
      a8(Ho2, "spliceOne");
      function Go2(r6) {
        for (var e6 = new Array(r6.length), t6 = 0; t6 < e6.length; ++t6)
          e6[t6] = r6[t6].listener || r6[t6];
        return e6;
      }
      a8(Go2, "unwrapListeners");
      function $o3(r6, e6) {
        return new Promise(
          function(t6, n7) {
            function i8(o9) {
              r6.removeListener(e6, s10), n7(o9);
            }
            a8(i8, "errorListener");
            function s10() {
              typeof r6.removeListener == "function" && r6.removeListener("error", i8), t6([].slice.call(
                arguments
              ));
            }
            a8(s10, "resolver"), ni3(r6, e6, s10, { once: true }), e6 !== "error" && Vo2(r6, i8, { once: true });
          }
        );
      }
      a8($o3, "once");
      function Vo2(r6, e6, t6) {
        typeof r6.on == "function" && ni3(r6, "error", e6, t6);
      }
      a8(
        Vo2,
        "addErrorHandlerIfEventEmitter"
      );
      function ni3(r6, e6, t6, n7) {
        if (typeof r6.on == "function")
          n7.once ? r6.once(e6, t6) : r6.on(e6, t6);
        else if (typeof r6.addEventListener == "function") r6.addEventListener(
          e6,
          a8(function i8(s10) {
            n7.once && r6.removeEventListener(e6, i8), t6(s10);
          }, "wrapListener")
        );
        else
          throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof r6);
      }
      a8(ni3, "eventTargetAgnosticAddListener");
    });
    He4 = {};
    ie3(He4, { default: () => Ko3 });
    Ge4 = z5(() => {
      "use strict";
      p10();
      Ko3 = {};
    });
    ii2 = z5(
      () => {
        "use strict";
        p10();
        a8($e4, "sha256");
      }
    );
    si = z5(() => {
      "use strict";
      p10();
      U3 = class U4 {
        constructor() {
          _6(
            this,
            "_dataLength",
            0
          );
          _6(this, "_bufferLength", 0);
          _6(this, "_state", new Int32Array(4));
          _6(
            this,
            "_buffer",
            new ArrayBuffer(68)
          );
          _6(this, "_buffer8");
          _6(this, "_buffer32");
          this._buffer8 = new Uint8Array(
            this._buffer,
            0,
            68
          ), this._buffer32 = new Uint32Array(this._buffer, 0, 17), this.start();
        }
        static hashByteArray(e6, t6 = false) {
          return this.onePassHasher.start().appendByteArray(e6).end(t6);
        }
        static hashStr(e6, t6 = false) {
          return this.onePassHasher.start().appendStr(e6).end(t6);
        }
        static hashAsciiStr(e6, t6 = false) {
          return this.onePassHasher.start().appendAsciiStr(e6).end(t6);
        }
        static _hex(e6) {
          let t6 = U4.hexChars, n7 = U4.hexOut, i8, s10, o9, u7;
          for (u7 = 0; u7 < 4; u7 += 1) for (s10 = u7 * 8, i8 = e6[u7], o9 = 0; o9 < 8; o9 += 2) n7[s10 + 1 + o9] = t6.charAt(i8 & 15), i8 >>>= 4, n7[s10 + 0 + o9] = t6.charAt(i8 & 15), i8 >>>= 4;
          return n7.join("");
        }
        static _md5cycle(e6, t6) {
          let n7 = e6[0], i8 = e6[1], s10 = e6[2], o9 = e6[3];
          n7 += (i8 & s10 | ~i8 & o9) + t6[0] - 680876936 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[1] - 389564586 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[2] + 606105819 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[3] - 1044525330 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[4] - 176418897 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[5] + 1200080426 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[6] - 1473231341 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[7] - 45705983 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[8] + 1770035416 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[9] - 1958414417 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[10] - 42063 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[11] - 1990404162 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & s10 | ~i8 & o9) + t6[12] + 1804603682 | 0, n7 = (n7 << 7 | n7 >>> 25) + i8 | 0, o9 += (n7 & i8 | ~n7 & s10) + t6[13] - 40341101 | 0, o9 = (o9 << 12 | o9 >>> 20) + n7 | 0, s10 += (o9 & n7 | ~o9 & i8) + t6[14] - 1502002290 | 0, s10 = (s10 << 17 | s10 >>> 15) + o9 | 0, i8 += (s10 & o9 | ~s10 & n7) + t6[15] + 1236535329 | 0, i8 = (i8 << 22 | i8 >>> 10) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[1] - 165796510 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[6] - 1069501632 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[11] + 643717713 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[0] - 373897302 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[5] - 701558691 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[10] + 38016083 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[15] - 660478335 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[4] - 405537848 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[9] + 568446438 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[14] - 1019803690 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[3] - 187363961 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[8] + 1163531501 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 & o9 | s10 & ~o9) + t6[13] - 1444681467 | 0, n7 = (n7 << 5 | n7 >>> 27) + i8 | 0, o9 += (n7 & s10 | i8 & ~s10) + t6[2] - 51403784 | 0, o9 = (o9 << 9 | o9 >>> 23) + n7 | 0, s10 += (o9 & i8 | n7 & ~i8) + t6[7] + 1735328473 | 0, s10 = (s10 << 14 | s10 >>> 18) + o9 | 0, i8 += (s10 & n7 | o9 & ~n7) + t6[12] - 1926607734 | 0, i8 = (i8 << 20 | i8 >>> 12) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[5] - 378558 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[8] - 2022574463 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[11] + 1839030562 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[14] - 35309556 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[1] - 1530992060 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[4] + 1272893353 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[7] - 155497632 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[10] - 1094730640 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[13] + 681279174 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[0] - 358537222 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[3] - 722521979 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[6] + 76029189 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (i8 ^ s10 ^ o9) + t6[9] - 640364487 | 0, n7 = (n7 << 4 | n7 >>> 28) + i8 | 0, o9 += (n7 ^ i8 ^ s10) + t6[12] - 421815835 | 0, o9 = (o9 << 11 | o9 >>> 21) + n7 | 0, s10 += (o9 ^ n7 ^ i8) + t6[15] + 530742520 | 0, s10 = (s10 << 16 | s10 >>> 16) + o9 | 0, i8 += (s10 ^ o9 ^ n7) + t6[2] - 995338651 | 0, i8 = (i8 << 23 | i8 >>> 9) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[0] - 198630844 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[7] + 1126891415 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[14] - 1416354905 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[5] - 57434055 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[12] + 1700485571 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[3] - 1894986606 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[10] - 1051523 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[1] - 2054922799 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[8] + 1873313359 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[15] - 30611744 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[6] - 1560198380 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[13] + 1309151649 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, n7 += (s10 ^ (i8 | ~o9)) + t6[4] - 145523070 | 0, n7 = (n7 << 6 | n7 >>> 26) + i8 | 0, o9 += (i8 ^ (n7 | ~s10)) + t6[11] - 1120210379 | 0, o9 = (o9 << 10 | o9 >>> 22) + n7 | 0, s10 += (n7 ^ (o9 | ~i8)) + t6[2] + 718787259 | 0, s10 = (s10 << 15 | s10 >>> 17) + o9 | 0, i8 += (o9 ^ (s10 | ~n7)) + t6[9] - 343485551 | 0, i8 = (i8 << 21 | i8 >>> 11) + s10 | 0, e6[0] = n7 + e6[0] | 0, e6[1] = i8 + e6[1] | 0, e6[2] = s10 + e6[2] | 0, e6[3] = o9 + e6[3] | 0;
        }
        start() {
          return this._dataLength = 0, this._bufferLength = 0, this._state.set(U4.stateIdentity), this;
        }
        appendStr(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9;
          for (o9 = 0; o9 < e6.length; o9 += 1) {
            if (s10 = e6.charCodeAt(o9), s10 < 128) t6[i8++] = s10;
            else if (s10 < 2048) t6[i8++] = (s10 >>> 6) + 192, t6[i8++] = s10 & 63 | 128;
            else if (s10 < 55296 || s10 > 56319) t6[i8++] = (s10 >>> 12) + 224, t6[i8++] = s10 >>> 6 & 63 | 128, t6[i8++] = s10 & 63 | 128;
            else {
              if (s10 = (s10 - 55296) * 1024 + (e6.charCodeAt(++o9) - 56320) + 65536, s10 > 1114111) throw new Error("Unicode standard supports code points up to U+10FFFF");
              t6[i8++] = (s10 >>> 18) + 240, t6[i8++] = s10 >>> 12 & 63 | 128, t6[i8++] = s10 >>> 6 & 63 | 128, t6[i8++] = s10 & 63 | 128;
            }
            i8 >= 64 && (this._dataLength += 64, U4._md5cycle(this._state, n7), i8 -= 64, n7[0] = n7[16]);
          }
          return this._bufferLength = i8, this;
        }
        appendAsciiStr(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9 = 0;
          for (; ; ) {
            for (s10 = Math.min(e6.length - o9, 64 - i8); s10--; ) t6[i8++] = e6.charCodeAt(o9++);
            if (i8 < 64) break;
            this._dataLength += 64, U4._md5cycle(
              this._state,
              n7
            ), i8 = 0;
          }
          return this._bufferLength = i8, this;
        }
        appendByteArray(e6) {
          let t6 = this._buffer8, n7 = this._buffer32, i8 = this._bufferLength, s10, o9 = 0;
          for (; ; ) {
            for (s10 = Math.min(e6.length - o9, 64 - i8); s10--; ) t6[i8++] = e6[o9++];
            if (i8 < 64) break;
            this._dataLength += 64, U4._md5cycle(
              this._state,
              n7
            ), i8 = 0;
          }
          return this._bufferLength = i8, this;
        }
        getState() {
          let e6 = this._state;
          return { buffer: String.fromCharCode.apply(null, Array.from(this._buffer8)), buflen: this._bufferLength, length: this._dataLength, state: [e6[0], e6[1], e6[2], e6[3]] };
        }
        setState(e6) {
          let t6 = e6.buffer, n7 = e6.state, i8 = this._state, s10;
          for (this._dataLength = e6.length, this._bufferLength = e6.buflen, i8[0] = n7[0], i8[1] = n7[1], i8[2] = n7[2], i8[3] = n7[3], s10 = 0; s10 < t6.length; s10 += 1) this._buffer8[s10] = t6.charCodeAt(s10);
        }
        end(e6 = false) {
          let t6 = this._bufferLength, n7 = this._buffer8, i8 = this._buffer32, s10 = (t6 >> 2) + 1;
          this._dataLength += t6;
          let o9 = this._dataLength * 8;
          if (n7[t6] = 128, n7[t6 + 1] = n7[t6 + 2] = n7[t6 + 3] = 0, i8.set(U4.buffer32Identity.subarray(s10), s10), t6 > 55 && (U4._md5cycle(this._state, i8), i8.set(U4.buffer32Identity)), o9 <= 4294967295)
            i8[14] = o9;
          else {
            let u7 = o9.toString(16).match(/(.*?)(.{0,8})$/);
            if (u7 === null) return;
            let c6 = parseInt(
              u7[2],
              16
            ), h8 = parseInt(u7[1], 16) || 0;
            i8[14] = c6, i8[15] = h8;
          }
          return U4._md5cycle(this._state, i8), e6 ? this._state : U4._hex(this._state);
        }
      };
      a8(U3, "Md5"), _6(U3, "stateIdentity", new Int32Array(
        [1732584193, -271733879, -1732584194, 271733878]
      )), _6(U3, "buffer32Identity", new Int32Array(
        [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
      )), _6(U3, "hexChars", "0123456789abcdef"), _6(U3, "hexOut", []), _6(U3, "onePassHasher", new U3());
      Ve2 = U3;
    });
    jt3 = {};
    ie3(jt3, { createHash: () => Yo, createHmac: () => Zo, randomBytes: () => zo2 });
    Wt3 = z5(() => {
      "use strict";
      p10();
      ii2();
      si();
      a8(zo2, "randomBytes");
      a8(Yo, "createHash");
      a8(Zo, "createHmac");
    });
    Gt2 = I6((oi) => {
      "use strict";
      p10();
      oi.parse = function(r6, e6) {
        return new Ht3(r6, e6).parse();
      };
      var ct2 = class ct3 {
        constructor(e6, t6) {
          this.source = e6, this.transform = t6 || Jo, this.position = 0, this.entries = [], this.recorded = [], this.dimension = 0;
        }
        isEof() {
          return this.position >= this.source.length;
        }
        nextCharacter() {
          var e6 = this.source[this.position++];
          return e6 === "\\" ? { value: this.source[this.position++], escaped: true } : { value: e6, escaped: false };
        }
        record(e6) {
          this.recorded.push(e6);
        }
        newEntry(e6) {
          var t6;
          (this.recorded.length > 0 || e6) && (t6 = this.recorded.join(""), t6 === "NULL" && !e6 && (t6 = null), t6 !== null && (t6 = this.transform(t6)), this.entries.push(
            t6
          ), this.recorded = []);
        }
        consumeDimensions() {
          if (this.source[0] === "[") for (; !this.isEof(); ) {
            var e6 = this.nextCharacter();
            if (e6.value === "=") break;
          }
        }
        parse(e6) {
          var t6, n7, i8;
          for (this.consumeDimensions(); !this.isEof(); ) if (t6 = this.nextCharacter(), t6.value === "{" && !i8) this.dimension++, this.dimension > 1 && (n7 = new ct3(this.source.substr(this.position - 1), this.transform), this.entries.push(
            n7.parse(true)
          ), this.position += n7.position - 2);
          else if (t6.value === "}" && !i8) {
            if (this.dimension--, !this.dimension && (this.newEntry(), e6)) return this.entries;
          } else t6.value === '"' && !t6.escaped ? (i8 && this.newEntry(true), i8 = !i8) : t6.value === "," && !i8 ? this.newEntry() : this.record(
            t6.value
          );
          if (this.dimension !== 0) throw new Error("array dimension not balanced");
          return this.entries;
        }
      };
      a8(ct2, "ArrayParser");
      var Ht3 = ct2;
      function Jo(r6) {
        return r6;
      }
      a8(Jo, "identity");
    });
    $t2 = I6((wh, ai) => {
      p10();
      var Xo = Gt2();
      ai.exports = { create: a8(function(r6, e6) {
        return { parse: a8(
          function() {
            return Xo.parse(r6, e6);
          },
          "parse"
        ) };
      }, "create") };
    });
    hi2 = I6((Eh, ci2) => {
      "use strict";
      p10();
      var ea = /(\d{1,})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})(\.\d{1,})?.*?( BC)?$/, ta = /^(\d{1,})-(\d{2})-(\d{2})( BC)?$/, ra = /([Z+-])(\d{2})?:?(\d{2})?:?(\d{2})?/, na = /^-?infinity$/;
      ci2.exports = a8(function(e6) {
        if (na.test(e6)) return Number(e6.replace("i", "I"));
        var t6 = ea.exec(e6);
        if (!t6) return ia(e6) || null;
        var n7 = !!t6[8], i8 = parseInt(t6[1], 10);
        n7 && (i8 = ui2(i8));
        var s10 = parseInt(
          t6[2],
          10
        ) - 1, o9 = t6[3], u7 = parseInt(t6[4], 10), c6 = parseInt(t6[5], 10), h8 = parseInt(t6[6], 10), l7 = t6[7];
        l7 = l7 ? 1e3 * parseFloat(l7) : 0;
        var d7, b9 = sa(e6);
        return b9 != null ? (d7 = new Date(Date.UTC(
          i8,
          s10,
          o9,
          u7,
          c6,
          h8,
          l7
        )), Vt2(i8) && d7.setUTCFullYear(i8), b9 !== 0 && d7.setTime(d7.getTime() - b9)) : (d7 = new Date(
          i8,
          s10,
          o9,
          u7,
          c6,
          h8,
          l7
        ), Vt2(i8) && d7.setFullYear(i8)), d7;
      }, "parseDate");
      function ia(r6) {
        var e6 = ta.exec(r6);
        if (e6) {
          var t6 = parseInt(e6[1], 10), n7 = !!e6[4];
          n7 && (t6 = ui2(t6));
          var i8 = parseInt(
            e6[2],
            10
          ) - 1, s10 = e6[3], o9 = new Date(t6, i8, s10);
          return Vt2(t6) && o9.setFullYear(t6), o9;
        }
      }
      a8(ia, "getDate");
      function sa(r6) {
        if (r6.endsWith("+00")) return 0;
        var e6 = ra.exec(r6.split(" ")[1]);
        if (e6) {
          var t6 = e6[1];
          if (t6 === "Z") return 0;
          var n7 = t6 === "-" ? -1 : 1, i8 = parseInt(e6[2], 10) * 3600 + parseInt(
            e6[3] || 0,
            10
          ) * 60 + parseInt(e6[4] || 0, 10);
          return i8 * n7 * 1e3;
        }
      }
      a8(sa, "timeZoneOffset");
      function ui2(r6) {
        return -(r6 - 1);
      }
      a8(ui2, "bcYearToNegativeYear");
      function Vt2(r6) {
        return r6 >= 0 && r6 < 100;
      }
      a8(
        Vt2,
        "is0To99"
      );
    });
    fi = I6((_h2, li2) => {
      p10();
      li2.exports = aa;
      var oa = Object.prototype.hasOwnProperty;
      function aa(r6) {
        for (var e6 = 1; e6 < arguments.length; e6++) {
          var t6 = arguments[e6];
          for (var n7 in t6) oa.call(
            t6,
            n7
          ) && (r6[n7] = t6[n7]);
        }
        return r6;
      }
      a8(aa, "extend");
    });
    yi2 = I6((Th, di2) => {
      "use strict";
      p10();
      var ua = fi();
      di2.exports = Me2;
      function Me2(r6) {
        if (!(this instanceof Me2)) return new Me2(r6);
        ua(this, Sa(r6));
      }
      a8(Me2, "PostgresInterval");
      var ca = ["seconds", "minutes", "hours", "days", "months", "years"];
      Me2.prototype.toPostgres = function() {
        var r6 = ca.filter(this.hasOwnProperty, this);
        return this.milliseconds && r6.indexOf("seconds") < 0 && r6.push("seconds"), r6.length === 0 ? "0" : r6.map(function(e6) {
          var t6 = this[e6] || 0;
          return e6 === "seconds" && this.milliseconds && (t6 = (t6 + this.milliseconds / 1e3).toFixed(6).replace(
            /\.?0+$/,
            ""
          )), t6 + " " + e6;
        }, this).join(" ");
      };
      var ha = { years: "Y", months: "M", days: "D", hours: "H", minutes: "M", seconds: "S" }, la = ["years", "months", "days"], fa = ["hours", "minutes", "seconds"];
      Me2.prototype.toISOString = Me2.prototype.toISO = function() {
        var r6 = la.map(t6, this).join(""), e6 = fa.map(t6, this).join("");
        return "P" + r6 + "T" + e6;
        function t6(n7) {
          var i8 = this[n7] || 0;
          return n7 === "seconds" && this.milliseconds && (i8 = (i8 + this.milliseconds / 1e3).toFixed(6).replace(
            /0+$/,
            ""
          )), i8 + ha[n7];
        }
      };
      var Kt2 = "([+-]?\\d+)", pa = Kt2 + "\\s+years?", da = Kt2 + "\\s+mons?", ya = Kt2 + "\\s+days?", ma = "([+-])?([\\d]*):(\\d\\d):(\\d\\d)\\.?(\\d{1,6})?", ga = new RegExp([
        pa,
        da,
        ya,
        ma
      ].map(function(r6) {
        return "(" + r6 + ")?";
      }).join("\\s*")), pi2 = {
        years: 2,
        months: 4,
        days: 6,
        hours: 9,
        minutes: 10,
        seconds: 11,
        milliseconds: 12
      }, wa = ["hours", "minutes", "seconds", "milliseconds"];
      function ba(r6) {
        var e6 = r6 + "000000".slice(r6.length);
        return parseInt(
          e6,
          10
        ) / 1e3;
      }
      a8(ba, "parseMilliseconds");
      function Sa(r6) {
        if (!r6) return {};
        var e6 = ga.exec(
          r6
        ), t6 = e6[8] === "-";
        return Object.keys(pi2).reduce(function(n7, i8) {
          var s10 = pi2[i8], o9 = e6[s10];
          return !o9 || (o9 = i8 === "milliseconds" ? ba(o9) : parseInt(o9, 10), !o9) || (t6 && ~wa.indexOf(i8) && (o9 *= -1), n7[i8] = o9), n7;
        }, {});
      }
      a8(Sa, "parse");
    });
    gi = I6((Bh, mi2) => {
      "use strict";
      p10();
      mi2.exports = a8(function(e6) {
        if (/^\\x/.test(e6)) return new y6(
          e6.substr(2),
          "hex"
        );
        for (var t6 = "", n7 = 0; n7 < e6.length; ) if (e6[n7] !== "\\") t6 += e6[n7], ++n7;
        else if (/[0-7]{3}/.test(e6.substr(n7 + 1, 3))) t6 += String.fromCharCode(parseInt(e6.substr(n7 + 1, 3), 8)), n7 += 4;
        else {
          for (var i8 = 1; n7 + i8 < e6.length && e6[n7 + i8] === "\\"; ) i8++;
          for (var s10 = 0; s10 < Math.floor(i8 / 2); ++s10) t6 += "\\";
          n7 += Math.floor(i8 / 2) * 2;
        }
        return new y6(t6, "binary");
      }, "parseBytea");
    });
    _i3 = I6((Fh, vi) => {
      p10();
      var Ke3 = Gt2(), ze2 = $t2(), ht2 = hi2(), bi = yi2(), Si = gi();
      function lt3(r6) {
        return a8(function(t6) {
          return t6 === null ? t6 : r6(t6);
        }, "nullAllowed");
      }
      a8(lt3, "allowNull");
      function Ei3(r6) {
        return r6 === null ? r6 : r6 === "TRUE" || r6 === "t" || r6 === "true" || r6 === "y" || r6 === "yes" || r6 === "on" || r6 === "1";
      }
      a8(Ei3, "parseBool");
      function Ea(r6) {
        return r6 ? Ke3.parse(r6, Ei3) : null;
      }
      a8(Ea, "parseBoolArray");
      function xa(r6) {
        return parseInt(r6, 10);
      }
      a8(xa, "parseBaseTenInt");
      function zt2(r6) {
        return r6 ? Ke3.parse(r6, lt3(xa)) : null;
      }
      a8(zt2, "parseIntegerArray");
      function va(r6) {
        return r6 ? Ke3.parse(r6, lt3(function(e6) {
          return xi(e6).trim();
        })) : null;
      }
      a8(va, "parseBigIntegerArray");
      var _a506 = a8(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = Xt3(t6)), t6;
        });
        return e6.parse();
      }, "parsePointArray"), Yt2 = a8(function(r6) {
        if (!r6)
          return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = parseFloat(t6)), t6;
        });
        return e6.parse();
      }, "parseFloatArray"), re3 = a8(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6);
        return e6.parse();
      }, "parseStringArray"), Zt2 = a8(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = ht2(t6)), t6;
        });
        return e6.parse();
      }, "parseDateArray"), Aa = a8(function(r6) {
        if (!r6) return null;
        var e6 = ze2.create(r6, function(t6) {
          return t6 !== null && (t6 = bi(t6)), t6;
        });
        return e6.parse();
      }, "parseIntervalArray"), Ca = a8(function(r6) {
        return r6 ? Ke3.parse(r6, lt3(Si)) : null;
      }, "parseByteAArray"), Jt2 = a8(function(r6) {
        return parseInt(
          r6,
          10
        );
      }, "parseInteger"), xi = a8(function(r6) {
        var e6 = String(r6);
        return /^\d+$/.test(e6) ? e6 : r6;
      }, "parseBigInteger"), wi = a8(
        function(r6) {
          return r6 ? Ke3.parse(r6, lt3(JSON.parse)) : null;
        },
        "parseJsonArray"
      ), Xt3 = a8(function(r6) {
        return r6[0] !== "(" ? null : (r6 = r6.substring(1, r6.length - 1).split(","), { x: parseFloat(r6[0]), y: parseFloat(r6[1]) });
      }, "parsePoint"), Ta = a8(function(r6) {
        if (r6[0] !== "<" && r6[1] !== "(") return null;
        for (var e6 = "(", t6 = "", n7 = false, i8 = 2; i8 < r6.length - 1; i8++) {
          if (n7 || (e6 += r6[i8]), r6[i8] === ")") {
            n7 = true;
            continue;
          } else if (!n7) continue;
          r6[i8] !== "," && (t6 += r6[i8]);
        }
        var s10 = Xt3(e6);
        return s10.radius = parseFloat(t6), s10;
      }, "parseCircle"), Ia = a8(function(r6) {
        r6(
          20,
          xi
        ), r6(21, Jt2), r6(23, Jt2), r6(26, Jt2), r6(700, parseFloat), r6(701, parseFloat), r6(16, Ei3), r6(
          1082,
          ht2
        ), r6(1114, ht2), r6(1184, ht2), r6(600, Xt3), r6(651, re3), r6(718, Ta), r6(1e3, Ea), r6(1001, Ca), r6(
          1005,
          zt2
        ), r6(1007, zt2), r6(1028, zt2), r6(1016, va), r6(1017, _a506), r6(1021, Yt2), r6(1022, Yt2), r6(1231, Yt2), r6(1014, re3), r6(1015, re3), r6(1008, re3), r6(1009, re3), r6(1040, re3), r6(1041, re3), r6(1115, Zt2), r6(
          1182,
          Zt2
        ), r6(1185, Zt2), r6(1186, bi), r6(1187, Aa), r6(17, Si), r6(114, JSON.parse.bind(JSON)), r6(
          3802,
          JSON.parse.bind(JSON)
        ), r6(199, wi), r6(3807, wi), r6(3907, re3), r6(2951, re3), r6(791, re3), r6(
          1183,
          re3
        ), r6(1270, re3);
      }, "init");
      vi.exports = { init: Ia };
    });
    Ci = I6((kh, Ai2) => {
      "use strict";
      p10();
      var Z4 = 1e6;
      function Pa(r6) {
        var e6 = r6.readInt32BE(
          0
        ), t6 = r6.readUInt32BE(4), n7 = "";
        e6 < 0 && (e6 = ~e6 + (t6 === 0), t6 = ~t6 + 1 >>> 0, n7 = "-");
        var i8 = "", s10, o9, u7, c6, h8, l7;
        {
          if (s10 = e6 % Z4, e6 = e6 / Z4 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Z4 >>> 0, u7 = "" + (o9 - Z4 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        {
          if (s10 = e6 % Z4, e6 = e6 / Z4 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Z4 >>> 0, u7 = "" + (o9 - Z4 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        {
          if (s10 = e6 % Z4, e6 = e6 / Z4 >>> 0, o9 = 4294967296 * s10 + t6, t6 = o9 / Z4 >>> 0, u7 = "" + (o9 - Z4 * t6), t6 === 0 && e6 === 0) return n7 + u7 + i8;
          for (c6 = "", h8 = 6 - u7.length, l7 = 0; l7 < h8; l7++) c6 += "0";
          i8 = c6 + u7 + i8;
        }
        return s10 = e6 % Z4, o9 = 4294967296 * s10 + t6, u7 = "" + o9 % Z4, n7 + u7 + i8;
      }
      a8(Pa, "readInt8");
      Ai2.exports = Pa;
    });
    Li2 = I6((Nh, Bi2) => {
      p10();
      var Ba = Ci(), F6 = a8(function(r6, e6, t6, n7, i8) {
        t6 = t6 || 0, n7 = n7 || false, i8 = i8 || function(C6, B3, j7) {
          return C6 * Math.pow(2, j7) + B3;
        };
        var s10 = t6 >> 3, o9 = a8(function(C6) {
          return n7 ? ~C6 & 255 : C6;
        }, "inv"), u7 = 255, c6 = 8 - t6 % 8;
        e6 < c6 && (u7 = 255 << 8 - e6 & 255, c6 = e6), t6 && (u7 = u7 >> t6 % 8);
        var h8 = 0;
        t6 % 8 + e6 >= 8 && (h8 = i8(0, o9(r6[s10]) & u7, c6));
        for (var l7 = e6 + t6 >> 3, d7 = s10 + 1; d7 < l7; d7++) h8 = i8(h8, o9(r6[d7]), 8);
        var b9 = (e6 + t6) % 8;
        return b9 > 0 && (h8 = i8(h8, o9(r6[l7]) >> 8 - b9, b9)), h8;
      }, "parseBits"), Pi2 = a8(function(r6, e6, t6) {
        var n7 = Math.pow(2, t6 - 1) - 1, i8 = F6(r6, 1), s10 = F6(r6, t6, 1);
        if (s10 === 0) return 0;
        var o9 = 1, u7 = a8(function(h8, l7, d7) {
          h8 === 0 && (h8 = 1);
          for (var b9 = 1; b9 <= d7; b9++) o9 /= 2, (l7 & 1 << d7 - b9) > 0 && (h8 += o9);
          return h8;
        }, "parsePrecisionBits"), c6 = F6(r6, e6, t6 + 1, false, u7);
        return s10 == Math.pow(2, t6 + 1) - 1 ? c6 === 0 ? i8 === 0 ? 1 / 0 : -1 / 0 : NaN : (i8 === 0 ? 1 : -1) * Math.pow(2, s10 - n7) * c6;
      }, "parseFloatFromBits"), La = a8(function(r6) {
        return F6(r6, 1) == 1 ? -1 * (F6(r6, 15, 1, true) + 1) : F6(r6, 15, 1);
      }, "parseInt16"), Ti = a8(function(r6) {
        return F6(r6, 1) == 1 ? -1 * (F6(
          r6,
          31,
          1,
          true
        ) + 1) : F6(r6, 31, 1);
      }, "parseInt32"), Ra = a8(function(r6) {
        return Pi2(r6, 23, 8);
      }, "parseFloat32"), Fa = a8(function(r6) {
        return Pi2(r6, 52, 11);
      }, "parseFloat64"), Ma = a8(function(r6) {
        var e6 = F6(r6, 16, 32);
        if (e6 == 49152) return NaN;
        for (var t6 = Math.pow(1e4, F6(r6, 16, 16)), n7 = 0, i8 = [], s10 = F6(r6, 16), o9 = 0; o9 < s10; o9++) n7 += F6(r6, 16, 64 + 16 * o9) * t6, t6 /= 1e4;
        var u7 = Math.pow(10, F6(r6, 16, 48));
        return (e6 === 0 ? 1 : -1) * Math.round(n7 * u7) / u7;
      }, "parseNumeric"), Ii = a8(function(r6, e6) {
        var t6 = F6(
          e6,
          1
        ), n7 = F6(e6, 63, 1), i8 = new Date((t6 === 0 ? 1 : -1) * n7 / 1e3 + 9466848e5);
        return r6 || i8.setTime(i8.getTime() + i8.getTimezoneOffset() * 6e4), i8.usec = n7 % 1e3, i8.getMicroSeconds = function() {
          return this.usec;
        }, i8.setMicroSeconds = function(s10) {
          this.usec = s10;
        }, i8.getUTCMicroSeconds = function() {
          return this.usec;
        }, i8;
      }, "parseDate"), Ye2 = a8(function(r6) {
        for (var e6 = F6(r6, 32), t6 = F6(r6, 32, 32), n7 = F6(r6, 32, 64), i8 = 96, s10 = [], o9 = 0; o9 < e6; o9++) s10[o9] = F6(r6, 32, i8), i8 += 32, i8 += 32;
        var u7 = a8(function(h8) {
          var l7 = F6(r6, 32, i8);
          if (i8 += 32, l7 == 4294967295) return null;
          var d7;
          if (h8 == 23 || h8 == 20) return d7 = F6(r6, l7 * 8, i8), i8 += l7 * 8, d7;
          if (h8 == 25) return d7 = r6.toString(this.encoding, i8 >> 3, (i8 += l7 << 3) >> 3), d7;
          console.log("ERROR: ElementType not implemented: " + h8);
        }, "parseElement"), c6 = a8(function(h8, l7) {
          var d7 = [], b9;
          if (h8.length > 1) {
            var C6 = h8.shift();
            for (b9 = 0; b9 < C6; b9++) d7[b9] = c6(h8, l7);
            h8.unshift(
              C6
            );
          } else for (b9 = 0; b9 < h8[0]; b9++) d7[b9] = u7(l7);
          return d7;
        }, "parse");
        return c6(s10, n7);
      }, "parseArray"), Da = a8(function(r6) {
        return r6.toString("utf8");
      }, "parseText"), ka = a8(function(r6) {
        return r6 === null ? null : F6(r6, 8) > 0;
      }, "parseBool"), Oa = a8(function(r6) {
        r6(20, Ba), r6(21, La), r6(23, Ti), r6(
          26,
          Ti
        ), r6(1700, Ma), r6(700, Ra), r6(701, Fa), r6(16, ka), r6(1114, Ii.bind(null, false)), r6(1184, Ii.bind(
          null,
          true
        )), r6(1e3, Ye2), r6(1007, Ye2), r6(1016, Ye2), r6(1008, Ye2), r6(1009, Ye2), r6(25, Da);
      }, "init");
      Bi2.exports = { init: Oa };
    });
    Fi = I6((jh, Ri2) => {
      p10();
      Ri2.exports = {
        BOOL: 16,
        BYTEA: 17,
        CHAR: 18,
        INT8: 20,
        INT2: 21,
        INT4: 23,
        REGPROC: 24,
        TEXT: 25,
        OID: 26,
        TID: 27,
        XID: 28,
        CID: 29,
        JSON: 114,
        XML: 142,
        PG_NODE_TREE: 194,
        SMGR: 210,
        PATH: 602,
        POLYGON: 604,
        CIDR: 650,
        FLOAT4: 700,
        FLOAT8: 701,
        ABSTIME: 702,
        RELTIME: 703,
        TINTERVAL: 704,
        CIRCLE: 718,
        MACADDR8: 774,
        MONEY: 790,
        MACADDR: 829,
        INET: 869,
        ACLITEM: 1033,
        BPCHAR: 1042,
        VARCHAR: 1043,
        DATE: 1082,
        TIME: 1083,
        TIMESTAMP: 1114,
        TIMESTAMPTZ: 1184,
        INTERVAL: 1186,
        TIMETZ: 1266,
        BIT: 1560,
        VARBIT: 1562,
        NUMERIC: 1700,
        REFCURSOR: 1790,
        REGPROCEDURE: 2202,
        REGOPER: 2203,
        REGOPERATOR: 2204,
        REGCLASS: 2205,
        REGTYPE: 2206,
        UUID: 2950,
        TXID_SNAPSHOT: 2970,
        PG_LSN: 3220,
        PG_NDISTINCT: 3361,
        PG_DEPENDENCIES: 3402,
        TSVECTOR: 3614,
        TSQUERY: 3615,
        GTSVECTOR: 3642,
        REGCONFIG: 3734,
        REGDICTIONARY: 3769,
        JSONB: 3802,
        REGNAMESPACE: 4089,
        REGROLE: 4096
      };
    });
    Xe4 = I6((Je3) => {
      p10();
      var Ua = _i3(), Na = Li2(), qa = $t2(), Qa = Fi();
      Je3.getTypeParser = ja;
      Je3.setTypeParser = Wa;
      Je3.arrayParser = qa;
      Je3.builtins = Qa;
      var Ze2 = { text: {}, binary: {} };
      function Mi(r6) {
        return String(
          r6
        );
      }
      a8(Mi, "noParse");
      function ja(r6, e6) {
        return e6 = e6 || "text", Ze2[e6] && Ze2[e6][r6] || Mi;
      }
      a8(
        ja,
        "getTypeParser"
      );
      function Wa(r6, e6, t6) {
        typeof e6 == "function" && (t6 = e6, e6 = "text"), Ze2[e6][r6] = t6;
      }
      a8(Wa, "setTypeParser");
      Ua.init(function(r6, e6) {
        Ze2.text[r6] = e6;
      });
      Na.init(function(r6, e6) {
        Ze2.binary[r6] = e6;
      });
    });
    et4 = I6((Vh, er3) => {
      "use strict";
      p10();
      er3.exports = {
        host: "localhost",
        user: m11.platform === "win32" ? m11.env.USERNAME : m11.env.USER,
        database: void 0,
        password: null,
        connectionString: void 0,
        port: 5432,
        rows: 0,
        binary: false,
        max: 10,
        idleTimeoutMillis: 3e4,
        client_encoding: "",
        ssl: false,
        application_name: void 0,
        fallback_application_name: void 0,
        options: void 0,
        parseInputDatesAsUTC: false,
        statement_timeout: false,
        lock_timeout: false,
        idle_in_transaction_session_timeout: false,
        query_timeout: false,
        connect_timeout: 0,
        keepalives: 1,
        keepalives_idle: 0
      };
      var De3 = Xe4(), Ha = De3.getTypeParser(
        20,
        "text"
      ), Ga = De3.getTypeParser(1016, "text");
      er3.exports.__defineSetter__("parseInt8", function(r6) {
        De3.setTypeParser(20, "text", r6 ? De3.getTypeParser(23, "text") : Ha), De3.setTypeParser(1016, "text", r6 ? De3.getTypeParser(1007, "text") : Ga);
      });
    });
    tt3 = I6((zh, ki) => {
      "use strict";
      p10();
      var $a = (Wt3(), N4(jt3)), Va = et4();
      function Ka(r6) {
        var e6 = r6.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
        return '"' + e6 + '"';
      }
      a8(Ka, "escapeElement");
      function Di(r6) {
        for (var e6 = "{", t6 = 0; t6 < r6.length; t6++) t6 > 0 && (e6 = e6 + ","), r6[t6] === null || typeof r6[t6] > "u" ? e6 = e6 + "NULL" : Array.isArray(r6[t6]) ? e6 = e6 + Di(r6[t6]) : r6[t6] instanceof y6 ? e6 += "\\\\x" + r6[t6].toString("hex") : e6 += Ka(ft2(r6[t6]));
        return e6 = e6 + "}", e6;
      }
      a8(Di, "arrayString");
      var ft2 = a8(function(r6, e6) {
        if (r6 == null) return null;
        if (r6 instanceof y6) return r6;
        if (ArrayBuffer.isView(r6)) {
          var t6 = y6.from(r6.buffer, r6.byteOffset, r6.byteLength);
          return t6.length === r6.byteLength ? t6 : t6.slice(
            r6.byteOffset,
            r6.byteOffset + r6.byteLength
          );
        }
        return r6 instanceof Date ? Va.parseInputDatesAsUTC ? Za(r6) : Ya(r6) : Array.isArray(r6) ? Di(r6) : typeof r6 == "object" ? za(r6, e6) : r6.toString();
      }, "prepareValue");
      function za(r6, e6) {
        if (r6 && typeof r6.toPostgres == "function") {
          if (e6 = e6 || [], e6.indexOf(r6) !== -1) throw new Error('circular reference detected while preparing "' + r6 + '" for query');
          return e6.push(r6), ft2(r6.toPostgres(ft2), e6);
        }
        return JSON.stringify(r6);
      }
      a8(za, "prepareObject");
      function H5(r6, e6) {
        for (r6 = "" + r6; r6.length < e6; ) r6 = "0" + r6;
        return r6;
      }
      a8(
        H5,
        "pad"
      );
      function Ya(r6) {
        var e6 = -r6.getTimezoneOffset(), t6 = r6.getFullYear(), n7 = t6 < 1;
        n7 && (t6 = Math.abs(t6) + 1);
        var i8 = H5(t6, 4) + "-" + H5(r6.getMonth() + 1, 2) + "-" + H5(r6.getDate(), 2) + "T" + H5(r6.getHours(), 2) + ":" + H5(r6.getMinutes(), 2) + ":" + H5(r6.getSeconds(), 2) + "." + H5(
          r6.getMilliseconds(),
          3
        );
        return e6 < 0 ? (i8 += "-", e6 *= -1) : i8 += "+", i8 += H5(Math.floor(e6 / 60), 2) + ":" + H5(e6 % 60, 2), n7 && (i8 += " BC"), i8;
      }
      a8(Ya, "dateToString");
      function Za(r6) {
        var e6 = r6.getUTCFullYear(), t6 = e6 < 1;
        t6 && (e6 = Math.abs(e6) + 1);
        var n7 = H5(e6, 4) + "-" + H5(r6.getUTCMonth() + 1, 2) + "-" + H5(r6.getUTCDate(), 2) + "T" + H5(r6.getUTCHours(), 2) + ":" + H5(r6.getUTCMinutes(), 2) + ":" + H5(r6.getUTCSeconds(), 2) + "." + H5(r6.getUTCMilliseconds(), 3);
        return n7 += "+00:00", t6 && (n7 += " BC"), n7;
      }
      a8(Za, "dateToStringUTC");
      function Ja(r6, e6, t6) {
        return r6 = typeof r6 == "string" ? { text: r6 } : r6, e6 && (typeof e6 == "function" ? r6.callback = e6 : r6.values = e6), t6 && (r6.callback = t6), r6;
      }
      a8(Ja, "normalizeQueryConfig");
      var tr3 = a8(function(r6) {
        return $a.createHash("md5").update(r6, "utf-8").digest("hex");
      }, "md5"), Xa = a8(function(r6, e6, t6) {
        var n7 = tr3(e6 + r6), i8 = tr3(y6.concat([y6.from(n7), t6]));
        return "md5" + i8;
      }, "postgresMd5PasswordHash");
      ki.exports = { prepareValue: a8(function(e6) {
        return ft2(
          e6
        );
      }, "prepareValueWrapper"), normalizeQueryConfig: Ja, postgresMd5PasswordHash: Xa, md5: tr3 };
    });
    Qi3 = I6((Jh, qi3) => {
      "use strict";
      p10();
      var rr3 = (Wt3(), N4(jt3));
      function eu(r6) {
        if (r6.indexOf(
          "SCRAM-SHA-256"
        ) === -1) throw new Error("SASL: Only mechanism SCRAM-SHA-256 is currently supported");
        let e6 = rr3.randomBytes(18).toString("base64");
        return { mechanism: "SCRAM-SHA-256", clientNonce: e6, response: "n,,n=*,r=" + e6, message: "SASLInitialResponse" };
      }
      a8(eu, "startSession");
      function tu(r6, e6, t6) {
        if (r6.message !== "SASLInitialResponse") throw new Error(
          "SASL: Last message was not SASLInitialResponse"
        );
        if (typeof e6 != "string") throw new Error(
          "SASL: SCRAM-SERVER-FIRST-MESSAGE: client password must be a string"
        );
        if (typeof t6 != "string") throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: serverData must be a string");
        let n7 = iu2(t6);
        if (n7.nonce.startsWith(r6.clientNonce)) {
          if (n7.nonce.length === r6.clientNonce.length) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce");
        var i8 = y6.from(n7.salt, "base64"), s10 = au2(
          e6,
          i8,
          n7.iteration
        ), o9 = ke3(s10, "Client Key"), u7 = ou3(o9), c6 = "n=*,r=" + r6.clientNonce, h8 = "r=" + n7.nonce + ",s=" + n7.salt + ",i=" + n7.iteration, l7 = "c=biws,r=" + n7.nonce, d7 = c6 + "," + h8 + "," + l7, b9 = ke3(u7, d7), C6 = Ni2(
          o9,
          b9
        ), B3 = C6.toString("base64"), j7 = ke3(s10, "Server Key"), X4 = ke3(j7, d7);
        r6.message = "SASLResponse", r6.serverSignature = X4.toString("base64"), r6.response = l7 + ",p=" + B3;
      }
      a8(tu, "continueSession");
      function ru(r6, e6) {
        if (r6.message !== "SASLResponse") throw new Error("SASL: Last message was not SASLResponse");
        if (typeof e6 != "string") throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: serverData must be a string");
        let { serverSignature: t6 } = su2(
          e6
        );
        if (t6 !== r6.serverSignature) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature does not match");
      }
      a8(ru, "finalizeSession");
      function nu(r6) {
        if (typeof r6 != "string") throw new TypeError("SASL: text must be a string");
        return r6.split("").map(
          (e6, t6) => r6.charCodeAt(t6)
        ).every((e6) => e6 >= 33 && e6 <= 43 || e6 >= 45 && e6 <= 126);
      }
      a8(nu, "isPrintableChars");
      function Oi(r6) {
        return /^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(r6);
      }
      a8(Oi, "isBase64");
      function Ui(r6) {
        if (typeof r6 != "string") throw new TypeError(
          "SASL: attribute pairs text must be a string"
        );
        return new Map(r6.split(",").map((e6) => {
          if (!/^.=/.test(e6)) throw new Error("SASL: Invalid attribute pair entry");
          let t6 = e6[0], n7 = e6.substring(2);
          return [t6, n7];
        }));
      }
      a8(Ui, "parseAttributePairs");
      function iu2(r6) {
        let e6 = Ui(
          r6
        ), t6 = e6.get("r");
        if (t6) {
          if (!nu(t6)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce must only contain printable characters");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing");
        let n7 = e6.get("s");
        if (n7) {
          if (!Oi(n7)) throw new Error(
            "SASL: SCRAM-SERVER-FIRST-MESSAGE: salt must be base64"
          );
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing");
        let i8 = e6.get("i");
        if (i8) {
          if (!/^[1-9][0-9]*$/.test(i8)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: invalid iteration count");
        } else throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: iteration missing");
        let s10 = parseInt(i8, 10);
        return { nonce: t6, salt: n7, iteration: s10 };
      }
      a8(iu2, "parseServerFirstMessage");
      function su2(r6) {
        let t6 = Ui(r6).get("v");
        if (t6) {
          if (!Oi(t6)) throw new Error("SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature must be base64");
        } else throw new Error(
          "SASL: SCRAM-SERVER-FINAL-MESSAGE: server signature is missing"
        );
        return { serverSignature: t6 };
      }
      a8(su2, "parseServerFinalMessage");
      function Ni2(r6, e6) {
        if (!y6.isBuffer(r6)) throw new TypeError(
          "first argument must be a Buffer"
        );
        if (!y6.isBuffer(e6)) throw new TypeError("second argument must be a Buffer");
        if (r6.length !== e6.length) throw new Error("Buffer lengths must match");
        if (r6.length === 0) throw new Error("Buffers cannot be empty");
        return y6.from(r6.map((t6, n7) => r6[n7] ^ e6[n7]));
      }
      a8(Ni2, "xorBuffers");
      function ou3(r6) {
        return rr3.createHash(
          "sha256"
        ).update(r6).digest();
      }
      a8(ou3, "sha256");
      function ke3(r6, e6) {
        return rr3.createHmac(
          "sha256",
          r6
        ).update(e6).digest();
      }
      a8(ke3, "hmacSha256");
      function au2(r6, e6, t6) {
        for (var n7 = ke3(
          r6,
          y6.concat([e6, y6.from([0, 0, 0, 1])])
        ), i8 = n7, s10 = 0; s10 < t6 - 1; s10++) n7 = ke3(r6, n7), i8 = Ni2(i8, n7);
        return i8;
      }
      a8(au2, "Hi");
      qi3.exports = { startSession: eu, continueSession: tu, finalizeSession: ru };
    });
    nr4 = {};
    ie3(nr4, { join: () => uu2 });
    ir3 = z5(() => {
      "use strict";
      p10();
      a8(uu2, "join");
    });
    sr4 = {};
    ie3(sr4, { stat: () => cu });
    or5 = z5(
      () => {
        "use strict";
        p10();
        a8(cu, "stat");
      }
    );
    ar3 = {};
    ie3(ar3, { default: () => hu });
    ur3 = z5(() => {
      "use strict";
      p10();
      hu = {};
    });
    ji = {};
    ie3(ji, { StringDecoder: () => cr2 });
    Wi2 = z5(() => {
      "use strict";
      p10();
      hr2 = class hr {
        constructor(e6) {
          _6(this, "td");
          this.td = new TextDecoder(e6);
        }
        write(e6) {
          return this.td.decode(e6, { stream: true });
        }
        end(e6) {
          return this.td.decode(e6);
        }
      };
      a8(hr2, "StringDecoder");
      cr2 = hr2;
    });
    Vi2 = I6((ul, $i2) => {
      "use strict";
      p10();
      var { Transform: lu } = (ur3(), N4(ar3)), { StringDecoder: fu } = (Wi2(), N4(ji)), be3 = Symbol("last"), pt2 = Symbol("decoder");
      function pu(r6, e6, t6) {
        let n7;
        if (this.overflow) {
          if (n7 = this[pt2].write(r6).split(this.matcher), n7.length === 1) return t6();
          n7.shift(), this.overflow = false;
        } else this[be3] += this[pt2].write(r6), n7 = this[be3].split(this.matcher);
        this[be3] = n7.pop();
        for (let i8 = 0; i8 < n7.length; i8++) try {
          Gi2(this, this.mapper(n7[i8]));
        } catch (s10) {
          return t6(
            s10
          );
        }
        if (this.overflow = this[be3].length > this.maxLength, this.overflow && !this.skipOverflow) {
          t6(new Error("maximum buffer reached"));
          return;
        }
        t6();
      }
      a8(pu, "transform");
      function du(r6) {
        if (this[be3] += this[pt2].end(), this[be3]) try {
          Gi2(this, this.mapper(this[be3]));
        } catch (e6) {
          return r6(e6);
        }
        r6();
      }
      a8(du, "flush");
      function Gi2(r6, e6) {
        e6 !== void 0 && r6.push(e6);
      }
      a8(Gi2, "push");
      function Hi(r6) {
        return r6;
      }
      a8(Hi, "noop");
      function yu(r6, e6, t6) {
        switch (r6 = r6 || /\r?\n/, e6 = e6 || Hi, t6 = t6 || {}, arguments.length) {
          case 1:
            typeof r6 == "function" ? (e6 = r6, r6 = /\r?\n/) : typeof r6 == "object" && !(r6 instanceof RegExp) && !r6[Symbol.split] && (t6 = r6, r6 = /\r?\n/);
            break;
          case 2:
            typeof r6 == "function" ? (t6 = e6, e6 = r6, r6 = /\r?\n/) : typeof e6 == "object" && (t6 = e6, e6 = Hi);
        }
        t6 = Object.assign({}, t6), t6.autoDestroy = true, t6.transform = pu, t6.flush = du, t6.readableObjectMode = true;
        let n7 = new lu(t6);
        return n7[be3] = "", n7[pt2] = new fu("utf8"), n7.matcher = r6, n7.mapper = e6, n7.maxLength = t6.maxLength, n7.skipOverflow = t6.skipOverflow || false, n7.overflow = false, n7._destroy = function(i8, s10) {
          this._writableState.errorEmitted = false, s10(i8);
        }, n7;
      }
      a8(yu, "split");
      $i2.exports = yu;
    });
    Yi2 = I6((ll, le2) => {
      "use strict";
      p10();
      var Ki = (ir3(), N4(nr4)), mu = (ur3(), N4(ar3)).Stream, gu = Vi2(), zi2 = (Ge4(), N4(He4)), wu = 5432, dt2 = m11.platform === "win32", rt2 = m11.stderr, bu = 56, Su = 7, Eu = 61440, xu = 32768;
      function vu(r6) {
        return (r6 & Eu) == xu;
      }
      a8(vu, "isRegFile");
      var Oe2 = [
        "host",
        "port",
        "database",
        "user",
        "password"
      ], lr2 = Oe2.length, _u = Oe2[lr2 - 1];
      function fr3() {
        var r6 = rt2 instanceof mu && rt2.writable === true;
        if (r6) {
          var e6 = Array.prototype.slice.call(arguments).concat(`
`);
          rt2.write(zi2.format.apply(zi2, e6));
        }
      }
      a8(fr3, "warn");
      Object.defineProperty(
        le2.exports,
        "isWin",
        { get: a8(function() {
          return dt2;
        }, "get"), set: a8(function(r6) {
          dt2 = r6;
        }, "set") }
      );
      le2.exports.warnTo = function(r6) {
        var e6 = rt2;
        return rt2 = r6, e6;
      };
      le2.exports.getFileName = function(r6) {
        var e6 = r6 || m11.env, t6 = e6.PGPASSFILE || (dt2 ? Ki.join(e6.APPDATA || "./", "postgresql", "pgpass.conf") : Ki.join(e6.HOME || "./", ".pgpass"));
        return t6;
      };
      le2.exports.usePgPass = function(r6, e6) {
        return Object.prototype.hasOwnProperty.call(m11.env, "PGPASSWORD") ? false : dt2 ? true : (e6 = e6 || "<unkn>", vu(r6.mode) ? r6.mode & (bu | Su) ? (fr3('WARNING: password file "%s" has group or world access; permissions should be u=rw (0600) or less', e6), false) : true : (fr3('WARNING: password file "%s" is not a plain file', e6), false));
      };
      var Au2 = le2.exports.match = function(r6, e6) {
        return Oe2.slice(0, -1).reduce(function(t6, n7, i8) {
          return i8 == 1 && Number(r6[n7] || wu) === Number(
            e6[n7]
          ) ? t6 && true : t6 && (e6[n7] === "*" || e6[n7] === r6[n7]);
        }, true);
      };
      le2.exports.getPassword = function(r6, e6, t6) {
        var n7, i8 = e6.pipe(gu());
        function s10(c6) {
          var h8 = Cu(c6);
          h8 && Tu2(h8) && Au2(r6, h8) && (n7 = h8[_u], i8.end());
        }
        a8(s10, "onLine");
        var o9 = a8(function() {
          e6.destroy(), t6(n7);
        }, "onEnd"), u7 = a8(function(c6) {
          e6.destroy(), fr3("WARNING: error on reading file: %s", c6), t6(void 0);
        }, "onErr");
        e6.on("error", u7), i8.on("data", s10).on("end", o9).on("error", u7);
      };
      var Cu = le2.exports.parseLine = function(r6) {
        if (r6.length < 11 || r6.match(/^\s+#/)) return null;
        for (var e6 = "", t6 = "", n7 = 0, i8 = 0, s10 = 0, o9 = {}, u7 = false, c6 = a8(function(l7, d7, b9) {
          var C6 = r6.substring(d7, b9);
          Object.hasOwnProperty.call(
            m11.env,
            "PGPASS_NO_DEESCAPE"
          ) || (C6 = C6.replace(/\\([:\\])/g, "$1")), o9[Oe2[l7]] = C6;
        }, "addToObj"), h8 = 0; h8 < r6.length - 1; h8 += 1) {
          if (e6 = r6.charAt(h8 + 1), t6 = r6.charAt(h8), u7 = n7 == lr2 - 1, u7) {
            c6(n7, i8);
            break;
          }
          h8 >= 0 && e6 == ":" && t6 !== "\\" && (c6(n7, i8, h8 + 1), i8 = h8 + 2, n7 += 1);
        }
        return o9 = Object.keys(o9).length === lr2 ? o9 : null, o9;
      }, Tu2 = le2.exports.isValidEntry = function(r6) {
        for (var e6 = { 0: function(o9) {
          return o9.length > 0;
        }, 1: function(o9) {
          return o9 === "*" ? true : (o9 = Number(o9), isFinite(o9) && o9 > 0 && o9 < 9007199254740992 && Math.floor(o9) === o9);
        }, 2: function(o9) {
          return o9.length > 0;
        }, 3: function(o9) {
          return o9.length > 0;
        }, 4: function(o9) {
          return o9.length > 0;
        } }, t6 = 0; t6 < Oe2.length; t6 += 1) {
          var n7 = e6[t6], i8 = r6[Oe2[t6]] || "", s10 = n7(i8);
          if (!s10) return false;
        }
        return true;
      };
    });
    Ji2 = I6((yl, pr2) => {
      "use strict";
      p10();
      var dl = (ir3(), N4(nr4)), Zi2 = (or5(), N4(sr4)), yt2 = Yi2();
      pr2.exports = function(r6, e6) {
        var t6 = yt2.getFileName();
        Zi2.stat(t6, function(n7, i8) {
          if (n7 || !yt2.usePgPass(i8, t6)) return e6(void 0);
          var s10 = Zi2.createReadStream(t6);
          yt2.getPassword(
            r6,
            s10,
            e6
          );
        });
      };
      pr2.exports.warnTo = yt2.warnTo;
    });
    gt5 = I6((gl, Xi3) => {
      "use strict";
      p10();
      var Iu = Xe4();
      function mt3(r6) {
        this._types = r6 || Iu, this.text = {}, this.binary = {};
      }
      a8(mt3, "TypeOverrides");
      mt3.prototype.getOverrides = function(r6) {
        switch (r6) {
          case "text":
            return this.text;
          case "binary":
            return this.binary;
          default:
            return {};
        }
      };
      mt3.prototype.setTypeParser = function(r6, e6, t6) {
        typeof e6 == "function" && (t6 = e6, e6 = "text"), this.getOverrides(e6)[r6] = t6;
      };
      mt3.prototype.getTypeParser = function(r6, e6) {
        return e6 = e6 || "text", this.getOverrides(e6)[r6] || this._types.getTypeParser(r6, e6);
      };
      Xi3.exports = mt3;
    });
    es3 = {};
    ie3(es3, { default: () => Pu });
    ts2 = z5(() => {
      "use strict";
      p10();
      Pu = {};
    });
    rs2 = {};
    ie3(rs2, { parse: () => dr });
    yr = z5(() => {
      "use strict";
      p10();
      a8(dr, "parse");
    });
    is2 = I6((vl, ns2) => {
      "use strict";
      p10();
      var Bu = (yr(), N4(rs2)), mr = (or5(), N4(sr4));
      function gr(r6) {
        if (r6.charAt(0) === "/") {
          var t6 = r6.split(" ");
          return { host: t6[0], database: t6[1] };
        }
        var e6 = Bu.parse(/ |%[^a-f0-9]|%[a-f0-9][^a-f0-9]/i.test(r6) ? encodeURI(r6).replace(
          /\%25(\d\d)/g,
          "%$1"
        ) : r6, true), t6 = e6.query;
        for (var n7 in t6) Array.isArray(t6[n7]) && (t6[n7] = t6[n7][t6[n7].length - 1]);
        var i8 = (e6.auth || ":").split(":");
        if (t6.user = i8[0], t6.password = i8.splice(1).join(":"), t6.port = e6.port, e6.protocol == "socket:") return t6.host = decodeURI(e6.pathname), t6.database = e6.query.db, t6.client_encoding = e6.query.encoding, t6;
        t6.host || (t6.host = e6.hostname);
        var s10 = e6.pathname;
        if (!t6.host && s10 && /^%2f/i.test(s10)) {
          var o9 = s10.split("/");
          t6.host = decodeURIComponent(
            o9[0]
          ), s10 = o9.splice(1).join("/");
        }
        switch (s10 && s10.charAt(0) === "/" && (s10 = s10.slice(1) || null), t6.database = s10 && decodeURI(s10), (t6.ssl === "true" || t6.ssl === "1") && (t6.ssl = true), t6.ssl === "0" && (t6.ssl = false), (t6.sslcert || t6.sslkey || t6.sslrootcert || t6.sslmode) && (t6.ssl = {}), t6.sslcert && (t6.ssl.cert = mr.readFileSync(t6.sslcert).toString()), t6.sslkey && (t6.ssl.key = mr.readFileSync(
          t6.sslkey
        ).toString()), t6.sslrootcert && (t6.ssl.ca = mr.readFileSync(t6.sslrootcert).toString()), t6.sslmode) {
          case "disable": {
            t6.ssl = false;
            break;
          }
          case "prefer":
          case "require":
          case "verify-ca":
          case "verify-full":
            break;
          case "no-verify": {
            t6.ssl.rejectUnauthorized = false;
            break;
          }
        }
        return t6;
      }
      a8(gr, "parse");
      ns2.exports = gr;
      gr.parse = gr;
    });
    wt4 = I6((Cl, as) => {
      "use strict";
      p10();
      var Lu2 = (ts2(), N4(es3)), os4 = et4(), ss = is2().parse, $4 = a8(
        function(r6, e6, t6) {
          return t6 === void 0 ? t6 = m11.env["PG" + r6.toUpperCase()] : t6 === false || (t6 = m11.env[t6]), e6[r6] || t6 || os4[r6];
        },
        "val"
      ), Ru = a8(function() {
        switch (m11.env.PGSSLMODE) {
          case "disable":
            return false;
          case "prefer":
          case "require":
          case "verify-ca":
          case "verify-full":
            return true;
          case "no-verify":
            return { rejectUnauthorized: false };
        }
        return os4.ssl;
      }, "readSSLConfigFromEnvironment"), Ue3 = a8(
        function(r6) {
          return "'" + ("" + r6).replace(/\\/g, "\\\\").replace(/'/g, "\\'") + "'";
        },
        "quoteParamValue"
      ), ne3 = a8(function(r6, e6, t6) {
        var n7 = e6[t6];
        n7 != null && r6.push(t6 + "=" + Ue3(n7));
      }, "add"), br = class br {
        constructor(e6) {
          e6 = typeof e6 == "string" ? ss(e6) : e6 || {}, e6.connectionString && (e6 = Object.assign({}, e6, ss(e6.connectionString))), this.user = $4("user", e6), this.database = $4("database", e6), this.database === void 0 && (this.database = this.user), this.port = parseInt(
            $4("port", e6),
            10
          ), this.host = $4("host", e6), Object.defineProperty(this, "password", {
            configurable: true,
            enumerable: false,
            writable: true,
            value: $4("password", e6)
          }), this.binary = $4("binary", e6), this.options = $4("options", e6), this.ssl = typeof e6.ssl > "u" ? Ru() : e6.ssl, typeof this.ssl == "string" && this.ssl === "true" && (this.ssl = true), this.ssl === "no-verify" && (this.ssl = { rejectUnauthorized: false }), this.ssl && this.ssl.key && Object.defineProperty(this.ssl, "key", { enumerable: false }), this.client_encoding = $4("client_encoding", e6), this.replication = $4("replication", e6), this.isDomainSocket = !(this.host || "").indexOf("/"), this.application_name = $4("application_name", e6, "PGAPPNAME"), this.fallback_application_name = $4("fallback_application_name", e6, false), this.statement_timeout = $4("statement_timeout", e6, false), this.lock_timeout = $4(
            "lock_timeout",
            e6,
            false
          ), this.idle_in_transaction_session_timeout = $4("idle_in_transaction_session_timeout", e6, false), this.query_timeout = $4("query_timeout", e6, false), e6.connectionTimeoutMillis === void 0 ? this.connect_timeout = m11.env.PGCONNECT_TIMEOUT || 0 : this.connect_timeout = Math.floor(e6.connectionTimeoutMillis / 1e3), e6.keepAlive === false ? this.keepalives = 0 : e6.keepAlive === true && (this.keepalives = 1), typeof e6.keepAliveInitialDelayMillis == "number" && (this.keepalives_idle = Math.floor(e6.keepAliveInitialDelayMillis / 1e3));
        }
        getLibpqConnectionString(e6) {
          var t6 = [];
          ne3(t6, this, "user"), ne3(t6, this, "password"), ne3(t6, this, "port"), ne3(t6, this, "application_name"), ne3(t6, this, "fallback_application_name"), ne3(t6, this, "connect_timeout"), ne3(
            t6,
            this,
            "options"
          );
          var n7 = typeof this.ssl == "object" ? this.ssl : this.ssl ? { sslmode: this.ssl } : {};
          if (ne3(t6, n7, "sslmode"), ne3(t6, n7, "sslca"), ne3(t6, n7, "sslkey"), ne3(t6, n7, "sslcert"), ne3(t6, n7, "sslrootcert"), this.database && t6.push("dbname=" + Ue3(this.database)), this.replication && t6.push("replication=" + Ue3(this.replication)), this.host && t6.push("host=" + Ue3(this.host)), this.isDomainSocket) return e6(null, t6.join(" "));
          this.client_encoding && t6.push("client_encoding=" + Ue3(this.client_encoding)), Lu2.lookup(this.host, function(i8, s10) {
            return i8 ? e6(i8, null) : (t6.push("hostaddr=" + Ue3(s10)), e6(null, t6.join(" ")));
          });
        }
      };
      a8(br, "ConnectionParameters");
      var wr = br;
      as.exports = wr;
    });
    hs = I6((Pl, cs2) => {
      "use strict";
      p10();
      var Fu2 = Xe4(), us2 = /^([A-Za-z]+)(?: (\d+))?(?: (\d+))?/, Er2 = class Er {
        constructor(e6, t6) {
          this.command = null, this.rowCount = null, this.oid = null, this.rows = [], this.fields = [], this._parsers = void 0, this._types = t6, this.RowCtor = null, this.rowAsArray = e6 === "array", this.rowAsArray && (this.parseRow = this._parseRowAsArray);
        }
        addCommandComplete(e6) {
          var t6;
          e6.text ? t6 = us2.exec(e6.text) : t6 = us2.exec(e6.command), t6 && (this.command = t6[1], t6[3] ? (this.oid = parseInt(t6[2], 10), this.rowCount = parseInt(t6[3], 10)) : t6[2] && (this.rowCount = parseInt(
            t6[2],
            10
          )));
        }
        _parseRowAsArray(e6) {
          for (var t6 = new Array(e6.length), n7 = 0, i8 = e6.length; n7 < i8; n7++) {
            var s10 = e6[n7];
            s10 !== null ? t6[n7] = this._parsers[n7](s10) : t6[n7] = null;
          }
          return t6;
        }
        parseRow(e6) {
          for (var t6 = {}, n7 = 0, i8 = e6.length; n7 < i8; n7++) {
            var s10 = e6[n7], o9 = this.fields[n7].name;
            s10 !== null ? t6[o9] = this._parsers[n7](
              s10
            ) : t6[o9] = null;
          }
          return t6;
        }
        addRow(e6) {
          this.rows.push(e6);
        }
        addFields(e6) {
          this.fields = e6, this.fields.length && (this._parsers = new Array(e6.length));
          for (var t6 = 0; t6 < e6.length; t6++) {
            var n7 = e6[t6];
            this._types ? this._parsers[t6] = this._types.getTypeParser(n7.dataTypeID, n7.format || "text") : this._parsers[t6] = Fu2.getTypeParser(n7.dataTypeID, n7.format || "text");
          }
        }
      };
      a8(Er2, "Result");
      var Sr = Er2;
      cs2.exports = Sr;
    });
    ds3 = I6((Rl, ps3) => {
      "use strict";
      p10();
      var { EventEmitter: Mu2 } = we4(), ls = hs(), fs9 = tt3(), vr = class vr extends Mu2 {
        constructor(e6, t6, n7) {
          super(), e6 = fs9.normalizeQueryConfig(e6, t6, n7), this.text = e6.text, this.values = e6.values, this.rows = e6.rows, this.types = e6.types, this.name = e6.name, this.binary = e6.binary, this.portal = e6.portal || "", this.callback = e6.callback, this._rowMode = e6.rowMode, m11.domain && e6.callback && (this.callback = m11.domain.bind(e6.callback)), this._result = new ls(this._rowMode, this.types), this._results = this._result, this.isPreparedStatement = false, this._canceledDueToError = false, this._promise = null;
        }
        requiresPreparation() {
          return this.name || this.rows ? true : !this.text || !this.values ? false : this.values.length > 0;
        }
        _checkForMultirow() {
          this._result.command && (Array.isArray(this._results) || (this._results = [this._result]), this._result = new ls(
            this._rowMode,
            this.types
          ), this._results.push(this._result));
        }
        handleRowDescription(e6) {
          this._checkForMultirow(), this._result.addFields(e6.fields), this._accumulateRows = this.callback || !this.listeners("row").length;
        }
        handleDataRow(e6) {
          let t6;
          if (!this._canceledDueToError) {
            try {
              t6 = this._result.parseRow(e6.fields);
            } catch (n7) {
              this._canceledDueToError = n7;
              return;
            }
            this.emit("row", t6, this._result), this._accumulateRows && this._result.addRow(t6);
          }
        }
        handleCommandComplete(e6, t6) {
          this._checkForMultirow(), this._result.addCommandComplete(e6), this.rows && t6.sync();
        }
        handleEmptyQuery(e6) {
          this.rows && e6.sync();
        }
        handleError(e6, t6) {
          if (this._canceledDueToError && (e6 = this._canceledDueToError, this._canceledDueToError = false), this.callback) return this.callback(e6);
          this.emit("error", e6);
        }
        handleReadyForQuery(e6) {
          if (this._canceledDueToError) return this.handleError(
            this._canceledDueToError,
            e6
          );
          if (this.callback) try {
            this.callback(null, this._results);
          } catch (t6) {
            m11.nextTick(() => {
              throw t6;
            });
          }
          this.emit("end", this._results);
        }
        submit(e6) {
          if (typeof this.text != "string" && typeof this.name != "string") return new Error("A query must have either text or a name. Supplying neither is unsupported.");
          let t6 = e6.parsedStatements[this.name];
          return this.text && t6 && this.text !== t6 ? new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`) : this.values && !Array.isArray(this.values) ? new Error("Query values must be an array") : (this.requiresPreparation() ? this.prepare(e6) : e6.query(this.text), null);
        }
        hasBeenParsed(e6) {
          return this.name && e6.parsedStatements[this.name];
        }
        handlePortalSuspended(e6) {
          this._getRows(e6, this.rows);
        }
        _getRows(e6, t6) {
          e6.execute(
            { portal: this.portal, rows: t6 }
          ), t6 ? e6.flush() : e6.sync();
        }
        prepare(e6) {
          this.isPreparedStatement = true, this.hasBeenParsed(e6) || e6.parse({ text: this.text, name: this.name, types: this.types });
          try {
            e6.bind({ portal: this.portal, statement: this.name, values: this.values, binary: this.binary, valueMapper: fs9.prepareValue });
          } catch (t6) {
            this.handleError(t6, e6);
            return;
          }
          e6.describe(
            { type: "P", name: this.portal || "" }
          ), this._getRows(e6, this.rows);
        }
        handleCopyInResponse(e6) {
          e6.sendCopyFail("No source stream defined");
        }
        handleCopyData(e6, t6) {
        }
      };
      a8(vr, "Query");
      var xr = vr;
      ps3.exports = xr;
    });
    gs2 = {};
    ie3(gs2, { Socket: () => Ae5, isIP: () => Du });
    bt = z5(() => {
      "use strict";
      p10();
      ms2 = Ie4(we4(), 1);
      a8(Du, "isIP");
      ys3 = /^[^.]+\./, v10 = class v11 extends ms2.EventEmitter {
        constructor() {
          super(...arguments);
          _6(this, "opts", {});
          _6(this, "connecting", false);
          _6(this, "pending", true);
          _6(this, "writable", true);
          _6(this, "encrypted", false);
          _6(this, "authorized", false);
          _6(this, "destroyed", false);
          _6(this, "ws", null);
          _6(this, "writeBuffer");
          _6(this, "tlsState", 0);
          _6(
            this,
            "tlsRead"
          );
          _6(this, "tlsWrite");
        }
        static get poolQueryViaFetch() {
          return v11.opts.poolQueryViaFetch ?? v11.defaults.poolQueryViaFetch;
        }
        static set poolQueryViaFetch(t6) {
          v11.opts.poolQueryViaFetch = t6;
        }
        static get fetchEndpoint() {
          return v11.opts.fetchEndpoint ?? v11.defaults.fetchEndpoint;
        }
        static set fetchEndpoint(t6) {
          v11.opts.fetchEndpoint = t6;
        }
        static get fetchConnectionCache() {
          return true;
        }
        static set fetchConnectionCache(t6) {
          console.warn("The `fetchConnectionCache` option is deprecated (now always `true`)");
        }
        static get fetchFunction() {
          return v11.opts.fetchFunction ?? v11.defaults.fetchFunction;
        }
        static set fetchFunction(t6) {
          v11.opts.fetchFunction = t6;
        }
        static get webSocketConstructor() {
          return v11.opts.webSocketConstructor ?? v11.defaults.webSocketConstructor;
        }
        static set webSocketConstructor(t6) {
          v11.opts.webSocketConstructor = t6;
        }
        get webSocketConstructor() {
          return this.opts.webSocketConstructor ?? v11.webSocketConstructor;
        }
        set webSocketConstructor(t6) {
          this.opts.webSocketConstructor = t6;
        }
        static get wsProxy() {
          return v11.opts.wsProxy ?? v11.defaults.wsProxy;
        }
        static set wsProxy(t6) {
          v11.opts.wsProxy = t6;
        }
        get wsProxy() {
          return this.opts.wsProxy ?? v11.wsProxy;
        }
        set wsProxy(t6) {
          this.opts.wsProxy = t6;
        }
        static get coalesceWrites() {
          return v11.opts.coalesceWrites ?? v11.defaults.coalesceWrites;
        }
        static set coalesceWrites(t6) {
          v11.opts.coalesceWrites = t6;
        }
        get coalesceWrites() {
          return this.opts.coalesceWrites ?? v11.coalesceWrites;
        }
        set coalesceWrites(t6) {
          this.opts.coalesceWrites = t6;
        }
        static get useSecureWebSocket() {
          return v11.opts.useSecureWebSocket ?? v11.defaults.useSecureWebSocket;
        }
        static set useSecureWebSocket(t6) {
          v11.opts.useSecureWebSocket = t6;
        }
        get useSecureWebSocket() {
          return this.opts.useSecureWebSocket ?? v11.useSecureWebSocket;
        }
        set useSecureWebSocket(t6) {
          this.opts.useSecureWebSocket = t6;
        }
        static get forceDisablePgSSL() {
          return v11.opts.forceDisablePgSSL ?? v11.defaults.forceDisablePgSSL;
        }
        static set forceDisablePgSSL(t6) {
          v11.opts.forceDisablePgSSL = t6;
        }
        get forceDisablePgSSL() {
          return this.opts.forceDisablePgSSL ?? v11.forceDisablePgSSL;
        }
        set forceDisablePgSSL(t6) {
          this.opts.forceDisablePgSSL = t6;
        }
        static get disableSNI() {
          return v11.opts.disableSNI ?? v11.defaults.disableSNI;
        }
        static set disableSNI(t6) {
          v11.opts.disableSNI = t6;
        }
        get disableSNI() {
          return this.opts.disableSNI ?? v11.disableSNI;
        }
        set disableSNI(t6) {
          this.opts.disableSNI = t6;
        }
        static get pipelineConnect() {
          return v11.opts.pipelineConnect ?? v11.defaults.pipelineConnect;
        }
        static set pipelineConnect(t6) {
          v11.opts.pipelineConnect = t6;
        }
        get pipelineConnect() {
          return this.opts.pipelineConnect ?? v11.pipelineConnect;
        }
        set pipelineConnect(t6) {
          this.opts.pipelineConnect = t6;
        }
        static get subtls() {
          return v11.opts.subtls ?? v11.defaults.subtls;
        }
        static set subtls(t6) {
          v11.opts.subtls = t6;
        }
        get subtls() {
          return this.opts.subtls ?? v11.subtls;
        }
        set subtls(t6) {
          this.opts.subtls = t6;
        }
        static get pipelineTLS() {
          return v11.opts.pipelineTLS ?? v11.defaults.pipelineTLS;
        }
        static set pipelineTLS(t6) {
          v11.opts.pipelineTLS = t6;
        }
        get pipelineTLS() {
          return this.opts.pipelineTLS ?? v11.pipelineTLS;
        }
        set pipelineTLS(t6) {
          this.opts.pipelineTLS = t6;
        }
        static get rootCerts() {
          return v11.opts.rootCerts ?? v11.defaults.rootCerts;
        }
        static set rootCerts(t6) {
          v11.opts.rootCerts = t6;
        }
        get rootCerts() {
          return this.opts.rootCerts ?? v11.rootCerts;
        }
        set rootCerts(t6) {
          this.opts.rootCerts = t6;
        }
        wsProxyAddrForHost(t6, n7) {
          let i8 = this.wsProxy;
          if (i8 === void 0) throw new Error("No WebSocket proxy is configured. Please see https://github.com/neondatabase/serverless/blob/main/CONFIG.md#wsproxy-string--host-string-port-number--string--string");
          return typeof i8 == "function" ? i8(t6, n7) : `${i8}?address=${t6}:${n7}`;
        }
        setNoDelay() {
          return this;
        }
        setKeepAlive() {
          return this;
        }
        ref() {
          return this;
        }
        unref() {
          return this;
        }
        connect(t6, n7, i8) {
          this.connecting = true, i8 && this.once("connect", i8);
          let s10 = a8(() => {
            this.connecting = false, this.pending = false, this.emit("connect"), this.emit("ready");
          }, "handleWebSocketOpen"), o9 = a8((c6, h8 = false) => {
            c6.binaryType = "arraybuffer", c6.addEventListener("error", (l7) => {
              this.emit("error", l7), this.emit("close");
            }), c6.addEventListener("message", (l7) => {
              if (this.tlsState === 0) {
                let d7 = y6.from(l7.data);
                this.emit(
                  "data",
                  d7
                );
              }
            }), c6.addEventListener("close", () => {
              this.emit("close");
            }), h8 ? s10() : c6.addEventListener(
              "open",
              s10
            );
          }, "configureWebSocket"), u7;
          try {
            u7 = this.wsProxyAddrForHost(n7, typeof t6 == "string" ? parseInt(t6, 10) : t6);
          } catch (c6) {
            this.emit("error", c6), this.emit("close");
            return;
          }
          try {
            let h8 = (this.useSecureWebSocket ? "wss:" : "ws:") + "//" + u7;
            if (this.webSocketConstructor !== void 0) this.ws = new this.webSocketConstructor(h8), o9(this.ws);
            else try {
              this.ws = new WebSocket(
                h8
              ), o9(this.ws);
            } catch {
              this.ws = new __unstable_WebSocket(h8), o9(this.ws);
            }
          } catch (c6) {
            let l7 = (this.useSecureWebSocket ? "https:" : "http:") + "//" + u7;
            fetch(l7, { headers: { Upgrade: "websocket" } }).then((d7) => {
              if (this.ws = d7.webSocket, this.ws == null) throw c6;
              this.ws.accept(), o9(
                this.ws,
                true
              );
            }).catch((d7) => {
              this.emit("error", new Error(`All attempts to open a WebSocket to connect to the database failed. Please refer to https://github.com/neondatabase/serverless/blob/main/CONFIG.md#websocketconstructor-typeof-websocket--undefined. Details: ${d7.message}`)), this.emit("close");
            });
          }
        }
        async startTls(t6) {
          if (this.subtls === void 0) throw new Error("For Postgres SSL connections, you must set `neonConfig.subtls` to the subtls library. See https://github.com/neondatabase/serverless/blob/main/CONFIG.md for more information.");
          this.tlsState = 1;
          let n7 = this.subtls.TrustedCert.fromPEM(this.rootCerts), i8 = new this.subtls.WebSocketReadQueue(this.ws), s10 = i8.read.bind(
            i8
          ), o9 = this.rawWrite.bind(this), [u7, c6] = await this.subtls.startTls(t6, n7, s10, o9, { useSNI: !this.disableSNI, expectPreData: this.pipelineTLS ? new Uint8Array([83]) : void 0 });
          this.tlsRead = u7, this.tlsWrite = c6, this.tlsState = 2, this.encrypted = true, this.authorized = true, this.emit(
            "secureConnection",
            this
          ), this.tlsReadLoop();
        }
        async tlsReadLoop() {
          for (; ; ) {
            let t6 = await this.tlsRead();
            if (t6 === void 0) break;
            {
              let n7 = y6.from(t6);
              this.emit("data", n7);
            }
          }
        }
        rawWrite(t6) {
          if (!this.coalesceWrites) {
            this.ws.send(t6);
            return;
          }
          if (this.writeBuffer === void 0) this.writeBuffer = t6, setTimeout(
            () => {
              this.ws.send(this.writeBuffer), this.writeBuffer = void 0;
            },
            0
          );
          else {
            let n7 = new Uint8Array(this.writeBuffer.length + t6.length);
            n7.set(this.writeBuffer), n7.set(t6, this.writeBuffer.length), this.writeBuffer = n7;
          }
        }
        write(t6, n7 = "utf8", i8 = (s10) => {
        }) {
          return t6.length === 0 ? (i8(), true) : (typeof t6 == "string" && (t6 = y6.from(t6, n7)), this.tlsState === 0 ? (this.rawWrite(t6), i8()) : this.tlsState === 1 ? this.once("secureConnection", () => {
            this.write(
              t6,
              n7,
              i8
            );
          }) : (this.tlsWrite(t6), i8()), true);
        }
        end(t6 = y6.alloc(0), n7 = "utf8", i8 = () => {
        }) {
          return this.write(t6, n7, () => {
            this.ws.close(), i8();
          }), this;
        }
        destroy() {
          return this.destroyed = true, this.end();
        }
      };
      a8(v10, "Socket"), _6(v10, "defaults", {
        poolQueryViaFetch: false,
        fetchEndpoint: a8((t6, n7, i8) => {
          let s10;
          return i8?.jwtAuth ? s10 = t6.replace(ys3, "apiauth.") : s10 = t6.replace(ys3, "api."), "https://" + s10 + "/sql";
        }, "fetchEndpoint"),
        fetchConnectionCache: true,
        fetchFunction: void 0,
        webSocketConstructor: void 0,
        wsProxy: a8((t6) => t6 + "/v2", "wsProxy"),
        useSecureWebSocket: true,
        forceDisablePgSSL: true,
        coalesceWrites: true,
        pipelineConnect: "password",
        subtls: void 0,
        rootCerts: "",
        pipelineTLS: false,
        disableSNI: false
      }), _6(v10, "opts", {});
      Ae5 = v10;
    });
    Jr = I6((T4) => {
      "use strict";
      p10();
      Object.defineProperty(T4, "__esModule", { value: true });
      T4.NoticeMessage = T4.DataRowMessage = T4.CommandCompleteMessage = T4.ReadyForQueryMessage = T4.NotificationResponseMessage = T4.BackendKeyDataMessage = T4.AuthenticationMD5Password = T4.ParameterStatusMessage = T4.ParameterDescriptionMessage = T4.RowDescriptionMessage = T4.Field = T4.CopyResponse = T4.CopyDataMessage = T4.DatabaseError = T4.copyDone = T4.emptyQuery = T4.replicationStart = T4.portalSuspended = T4.noData = T4.closeComplete = T4.bindComplete = T4.parseComplete = void 0;
      T4.parseComplete = { name: "parseComplete", length: 5 };
      T4.bindComplete = { name: "bindComplete", length: 5 };
      T4.closeComplete = { name: "closeComplete", length: 5 };
      T4.noData = { name: "noData", length: 5 };
      T4.portalSuspended = { name: "portalSuspended", length: 5 };
      T4.replicationStart = { name: "replicationStart", length: 4 };
      T4.emptyQuery = { name: "emptyQuery", length: 4 };
      T4.copyDone = { name: "copyDone", length: 4 };
      var Ur2 = class Ur extends Error {
        constructor(e6, t6, n7) {
          super(
            e6
          ), this.length = t6, this.name = n7;
        }
      };
      a8(Ur2, "DatabaseError");
      var _r = Ur2;
      T4.DatabaseError = _r;
      var Nr2 = class Nr {
        constructor(e6, t6) {
          this.length = e6, this.chunk = t6, this.name = "copyData";
        }
      };
      a8(Nr2, "CopyDataMessage");
      var Ar = Nr2;
      T4.CopyDataMessage = Ar;
      var qr2 = class qr {
        constructor(e6, t6, n7, i8) {
          this.length = e6, this.name = t6, this.binary = n7, this.columnTypes = new Array(i8);
        }
      };
      a8(qr2, "CopyResponse");
      var Cr2 = qr2;
      T4.CopyResponse = Cr2;
      var Qr = class Qr {
        constructor(e6, t6, n7, i8, s10, o9, u7) {
          this.name = e6, this.tableID = t6, this.columnID = n7, this.dataTypeID = i8, this.dataTypeSize = s10, this.dataTypeModifier = o9, this.format = u7;
        }
      };
      a8(Qr, "Field");
      var Tr = Qr;
      T4.Field = Tr;
      var jr2 = class jr {
        constructor(e6, t6) {
          this.length = e6, this.fieldCount = t6, this.name = "rowDescription", this.fields = new Array(
            this.fieldCount
          );
        }
      };
      a8(jr2, "RowDescriptionMessage");
      var Ir = jr2;
      T4.RowDescriptionMessage = Ir;
      var Wr2 = class Wr {
        constructor(e6, t6) {
          this.length = e6, this.parameterCount = t6, this.name = "parameterDescription", this.dataTypeIDs = new Array(this.parameterCount);
        }
      };
      a8(Wr2, "ParameterDescriptionMessage");
      var Pr2 = Wr2;
      T4.ParameterDescriptionMessage = Pr2;
      var Hr2 = class Hr {
        constructor(e6, t6, n7) {
          this.length = e6, this.parameterName = t6, this.parameterValue = n7, this.name = "parameterStatus";
        }
      };
      a8(Hr2, "ParameterStatusMessage");
      var Br2 = Hr2;
      T4.ParameterStatusMessage = Br2;
      var Gr2 = class Gr {
        constructor(e6, t6) {
          this.length = e6, this.salt = t6, this.name = "authenticationMD5Password";
        }
      };
      a8(Gr2, "AuthenticationMD5Password");
      var Lr = Gr2;
      T4.AuthenticationMD5Password = Lr;
      var $r = class $r {
        constructor(e6, t6, n7) {
          this.length = e6, this.processID = t6, this.secretKey = n7, this.name = "backendKeyData";
        }
      };
      a8(
        $r,
        "BackendKeyDataMessage"
      );
      var Rr = $r;
      T4.BackendKeyDataMessage = Rr;
      var Vr2 = class Vr {
        constructor(e6, t6, n7, i8) {
          this.length = e6, this.processId = t6, this.channel = n7, this.payload = i8, this.name = "notification";
        }
      };
      a8(Vr2, "NotificationResponseMessage");
      var Fr = Vr2;
      T4.NotificationResponseMessage = Fr;
      var Kr2 = class Kr {
        constructor(e6, t6) {
          this.length = e6, this.status = t6, this.name = "readyForQuery";
        }
      };
      a8(Kr2, "ReadyForQueryMessage");
      var Mr = Kr2;
      T4.ReadyForQueryMessage = Mr;
      var zr2 = class zr {
        constructor(e6, t6) {
          this.length = e6, this.text = t6, this.name = "commandComplete";
        }
      };
      a8(zr2, "CommandCompleteMessage");
      var Dr = zr2;
      T4.CommandCompleteMessage = Dr;
      var Yr3 = class Yr {
        constructor(e6, t6) {
          this.length = e6, this.fields = t6, this.name = "dataRow", this.fieldCount = t6.length;
        }
      };
      a8(Yr3, "DataRowMessage");
      var kr = Yr3;
      T4.DataRowMessage = kr;
      var Zr2 = class Zr {
        constructor(e6, t6) {
          this.length = e6, this.message = t6, this.name = "notice";
        }
      };
      a8(Zr2, "NoticeMessage");
      var Or = Zr2;
      T4.NoticeMessage = Or;
    });
    ws3 = I6((St2) => {
      "use strict";
      p10();
      Object.defineProperty(St2, "__esModule", { value: true });
      St2.Writer = void 0;
      var en2 = class en {
        constructor(e6 = 256) {
          this.size = e6, this.offset = 5, this.headerPosition = 0, this.buffer = y6.allocUnsafe(e6);
        }
        ensure(e6) {
          var t6 = this.buffer.length - this.offset;
          if (t6 < e6) {
            var n7 = this.buffer, i8 = n7.length + (n7.length >> 1) + e6;
            this.buffer = y6.allocUnsafe(
              i8
            ), n7.copy(this.buffer);
          }
        }
        addInt32(e6) {
          return this.ensure(4), this.buffer[this.offset++] = e6 >>> 24 & 255, this.buffer[this.offset++] = e6 >>> 16 & 255, this.buffer[this.offset++] = e6 >>> 8 & 255, this.buffer[this.offset++] = e6 >>> 0 & 255, this;
        }
        addInt16(e6) {
          return this.ensure(2), this.buffer[this.offset++] = e6 >>> 8 & 255, this.buffer[this.offset++] = e6 >>> 0 & 255, this;
        }
        addCString(e6) {
          if (!e6) this.ensure(1);
          else {
            var t6 = y6.byteLength(e6);
            this.ensure(t6 + 1), this.buffer.write(
              e6,
              this.offset,
              "utf-8"
            ), this.offset += t6;
          }
          return this.buffer[this.offset++] = 0, this;
        }
        addString(e6 = "") {
          var t6 = y6.byteLength(e6);
          return this.ensure(t6), this.buffer.write(e6, this.offset), this.offset += t6, this;
        }
        add(e6) {
          return this.ensure(e6.length), e6.copy(this.buffer, this.offset), this.offset += e6.length, this;
        }
        join(e6) {
          if (e6) {
            this.buffer[this.headerPosition] = e6;
            let t6 = this.offset - (this.headerPosition + 1);
            this.buffer.writeInt32BE(t6, this.headerPosition + 1);
          }
          return this.buffer.slice(e6 ? 0 : 5, this.offset);
        }
        flush(e6) {
          var t6 = this.join(e6);
          return this.offset = 5, this.headerPosition = 0, this.buffer = y6.allocUnsafe(this.size), t6;
        }
      };
      a8(en2, "Writer");
      var Xr2 = en2;
      St2.Writer = Xr2;
    });
    Ss2 = I6((xt2) => {
      "use strict";
      p10();
      Object.defineProperty(xt2, "__esModule", { value: true });
      xt2.serialize = void 0;
      var tn2 = ws3(), M3 = new tn2.Writer(), ku = a8((r6) => {
        M3.addInt16(3).addInt16(
          0
        );
        for (let n7 of Object.keys(r6)) M3.addCString(n7).addCString(r6[n7]);
        M3.addCString("client_encoding").addCString("UTF8");
        var e6 = M3.addCString("").flush(), t6 = e6.length + 4;
        return new tn2.Writer().addInt32(t6).add(e6).flush();
      }, "startup"), Ou = a8(() => {
        let r6 = y6.allocUnsafe(8);
        return r6.writeInt32BE(8, 0), r6.writeInt32BE(80877103, 4), r6;
      }, "requestSsl"), Uu = a8((r6) => M3.addCString(r6).flush(112), "password"), Nu = a8(function(r6, e6) {
        return M3.addCString(r6).addInt32(
          y6.byteLength(e6)
        ).addString(e6), M3.flush(112);
      }, "sendSASLInitialResponseMessage"), qu = a8(
        function(r6) {
          return M3.addString(r6).flush(112);
        },
        "sendSCRAMClientFinalMessage"
      ), Qu = a8(
        (r6) => M3.addCString(r6).flush(81),
        "query"
      ), bs3 = [], ju = a8((r6) => {
        let e6 = r6.name || "";
        e6.length > 63 && (console.error("Warning! Postgres only supports 63 characters for query names."), console.error("You supplied %s (%s)", e6, e6.length), console.error("This can cause conflicts and silent errors executing queries"));
        let t6 = r6.types || bs3;
        for (var n7 = t6.length, i8 = M3.addCString(e6).addCString(r6.text).addInt16(n7), s10 = 0; s10 < n7; s10++) i8.addInt32(t6[s10]);
        return M3.flush(80);
      }, "parse"), Ne3 = new tn2.Writer(), Wu = a8(function(r6, e6) {
        for (let t6 = 0; t6 < r6.length; t6++) {
          let n7 = e6 ? e6(r6[t6], t6) : r6[t6];
          n7 == null ? (M3.addInt16(0), Ne3.addInt32(-1)) : n7 instanceof y6 ? (M3.addInt16(1), Ne3.addInt32(n7.length), Ne3.add(n7)) : (M3.addInt16(0), Ne3.addInt32(y6.byteLength(
            n7
          )), Ne3.addString(n7));
        }
      }, "writeValues"), Hu = a8((r6 = {}) => {
        let e6 = r6.portal || "", t6 = r6.statement || "", n7 = r6.binary || false, i8 = r6.values || bs3, s10 = i8.length;
        return M3.addCString(e6).addCString(t6), M3.addInt16(s10), Wu(i8, r6.valueMapper), M3.addInt16(s10), M3.add(Ne3.flush()), M3.addInt16(n7 ? 1 : 0), M3.flush(66);
      }, "bind"), Gu = y6.from([69, 0, 0, 0, 9, 0, 0, 0, 0, 0]), $u = a8((r6) => {
        if (!r6 || !r6.portal && !r6.rows) return Gu;
        let e6 = r6.portal || "", t6 = r6.rows || 0, n7 = y6.byteLength(e6), i8 = 4 + n7 + 1 + 4, s10 = y6.allocUnsafe(1 + i8);
        return s10[0] = 69, s10.writeInt32BE(i8, 1), s10.write(e6, 5, "utf-8"), s10[n7 + 5] = 0, s10.writeUInt32BE(t6, s10.length - 4), s10;
      }, "execute"), Vu = a8((r6, e6) => {
        let t6 = y6.allocUnsafe(16);
        return t6.writeInt32BE(16, 0), t6.writeInt16BE(1234, 4), t6.writeInt16BE(5678, 6), t6.writeInt32BE(
          r6,
          8
        ), t6.writeInt32BE(e6, 12), t6;
      }, "cancel"), rn2 = a8(
        (r6, e6) => {
          let n7 = 4 + y6.byteLength(e6) + 1, i8 = y6.allocUnsafe(1 + n7);
          return i8[0] = r6, i8.writeInt32BE(n7, 1), i8.write(e6, 5, "utf-8"), i8[n7] = 0, i8;
        },
        "cstringMessage"
      ), Ku = M3.addCString("P").flush(68), zu = M3.addCString("S").flush(68), Yu = a8((r6) => r6.name ? rn2(68, `${r6.type}${r6.name || ""}`) : r6.type === "P" ? Ku : zu, "describe"), Zu = a8(
        (r6) => {
          let e6 = `${r6.type}${r6.name || ""}`;
          return rn2(67, e6);
        },
        "close"
      ), Ju = a8((r6) => M3.add(r6).flush(
        100
      ), "copyData"), Xu = a8((r6) => rn2(102, r6), "copyFail"), Et2 = a8((r6) => y6.from([r6, 0, 0, 0, 4]), "codeOnlyBuffer"), ec = Et2(72), tc = Et2(83), rc2 = Et2(88), nc = Et2(99), ic = {
        startup: ku,
        password: Uu,
        requestSsl: Ou,
        sendSASLInitialResponseMessage: Nu,
        sendSCRAMClientFinalMessage: qu,
        query: Qu,
        parse: ju,
        bind: Hu,
        execute: $u,
        describe: Yu,
        close: Zu,
        flush: a8(() => ec, "flush"),
        sync: a8(
          () => tc,
          "sync"
        ),
        end: a8(() => rc2, "end"),
        copyData: Ju,
        copyDone: a8(() => nc, "copyDone"),
        copyFail: Xu,
        cancel: Vu
      };
      xt2.serialize = ic;
    });
    Es2 = I6((vt2) => {
      "use strict";
      p10();
      Object.defineProperty(vt2, "__esModule", { value: true });
      vt2.BufferReader = void 0;
      var sc = y6.allocUnsafe(0), sn2 = class sn {
        constructor(e6 = 0) {
          this.offset = e6, this.buffer = sc, this.encoding = "utf-8";
        }
        setBuffer(e6, t6) {
          this.offset = e6, this.buffer = t6;
        }
        int16() {
          let e6 = this.buffer.readInt16BE(this.offset);
          return this.offset += 2, e6;
        }
        byte() {
          let e6 = this.buffer[this.offset];
          return this.offset++, e6;
        }
        int32() {
          let e6 = this.buffer.readInt32BE(this.offset);
          return this.offset += 4, e6;
        }
        string(e6) {
          let t6 = this.buffer.toString(this.encoding, this.offset, this.offset + e6);
          return this.offset += e6, t6;
        }
        cstring() {
          let e6 = this.offset, t6 = e6;
          for (; this.buffer[t6++] !== 0; ) ;
          return this.offset = t6, this.buffer.toString(this.encoding, e6, t6 - 1);
        }
        bytes(e6) {
          let t6 = this.buffer.slice(this.offset, this.offset + e6);
          return this.offset += e6, t6;
        }
      };
      a8(sn2, "BufferReader");
      var nn2 = sn2;
      vt2.BufferReader = nn2;
    });
    _s3 = I6((_t2) => {
      "use strict";
      p10();
      Object.defineProperty(_t2, "__esModule", { value: true });
      _t2.Parser = void 0;
      var D6 = Jr(), oc = Es2(), on3 = 1, ac = 4, xs = on3 + ac, vs3 = y6.allocUnsafe(0), un2 = class un {
        constructor(e6) {
          if (this.buffer = vs3, this.bufferLength = 0, this.bufferOffset = 0, this.reader = new oc.BufferReader(), e6?.mode === "binary") throw new Error("Binary mode not supported yet");
          this.mode = e6?.mode || "text";
        }
        parse(e6, t6) {
          this.mergeBuffer(e6);
          let n7 = this.bufferOffset + this.bufferLength, i8 = this.bufferOffset;
          for (; i8 + xs <= n7; ) {
            let s10 = this.buffer[i8], o9 = this.buffer.readUInt32BE(
              i8 + on3
            ), u7 = on3 + o9;
            if (u7 + i8 <= n7) {
              let c6 = this.handlePacket(i8 + xs, s10, o9, this.buffer);
              t6(c6), i8 += u7;
            } else
              break;
          }
          i8 === n7 ? (this.buffer = vs3, this.bufferLength = 0, this.bufferOffset = 0) : (this.bufferLength = n7 - i8, this.bufferOffset = i8);
        }
        mergeBuffer(e6) {
          if (this.bufferLength > 0) {
            let t6 = this.bufferLength + e6.byteLength;
            if (t6 + this.bufferOffset > this.buffer.byteLength) {
              let i8;
              if (t6 <= this.buffer.byteLength && this.bufferOffset >= this.bufferLength) i8 = this.buffer;
              else {
                let s10 = this.buffer.byteLength * 2;
                for (; t6 >= s10; ) s10 *= 2;
                i8 = y6.allocUnsafe(s10);
              }
              this.buffer.copy(
                i8,
                0,
                this.bufferOffset,
                this.bufferOffset + this.bufferLength
              ), this.buffer = i8, this.bufferOffset = 0;
            }
            e6.copy(this.buffer, this.bufferOffset + this.bufferLength), this.bufferLength = t6;
          } else this.buffer = e6, this.bufferOffset = 0, this.bufferLength = e6.byteLength;
        }
        handlePacket(e6, t6, n7, i8) {
          switch (t6) {
            case 50:
              return D6.bindComplete;
            case 49:
              return D6.parseComplete;
            case 51:
              return D6.closeComplete;
            case 110:
              return D6.noData;
            case 115:
              return D6.portalSuspended;
            case 99:
              return D6.copyDone;
            case 87:
              return D6.replicationStart;
            case 73:
              return D6.emptyQuery;
            case 68:
              return this.parseDataRowMessage(
                e6,
                n7,
                i8
              );
            case 67:
              return this.parseCommandCompleteMessage(e6, n7, i8);
            case 90:
              return this.parseReadyForQueryMessage(e6, n7, i8);
            case 65:
              return this.parseNotificationMessage(
                e6,
                n7,
                i8
              );
            case 82:
              return this.parseAuthenticationResponse(e6, n7, i8);
            case 83:
              return this.parseParameterStatusMessage(e6, n7, i8);
            case 75:
              return this.parseBackendKeyData(e6, n7, i8);
            case 69:
              return this.parseErrorMessage(e6, n7, i8, "error");
            case 78:
              return this.parseErrorMessage(
                e6,
                n7,
                i8,
                "notice"
              );
            case 84:
              return this.parseRowDescriptionMessage(e6, n7, i8);
            case 116:
              return this.parseParameterDescriptionMessage(e6, n7, i8);
            case 71:
              return this.parseCopyInMessage(
                e6,
                n7,
                i8
              );
            case 72:
              return this.parseCopyOutMessage(e6, n7, i8);
            case 100:
              return this.parseCopyData(
                e6,
                n7,
                i8
              );
            default:
              return new D6.DatabaseError("received invalid response: " + t6.toString(
                16
              ), n7, "error");
          }
        }
        parseReadyForQueryMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.string(1);
          return new D6.ReadyForQueryMessage(t6, i8);
        }
        parseCommandCompleteMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.cstring();
          return new D6.CommandCompleteMessage(
            t6,
            i8
          );
        }
        parseCopyData(e6, t6, n7) {
          let i8 = n7.slice(e6, e6 + (t6 - 4));
          return new D6.CopyDataMessage(
            t6,
            i8
          );
        }
        parseCopyInMessage(e6, t6, n7) {
          return this.parseCopyMessage(e6, t6, n7, "copyInResponse");
        }
        parseCopyOutMessage(e6, t6, n7) {
          return this.parseCopyMessage(e6, t6, n7, "copyOutResponse");
        }
        parseCopyMessage(e6, t6, n7, i8) {
          this.reader.setBuffer(e6, n7);
          let s10 = this.reader.byte() !== 0, o9 = this.reader.int16(), u7 = new D6.CopyResponse(t6, i8, s10, o9);
          for (let c6 = 0; c6 < o9; c6++) u7.columnTypes[c6] = this.reader.int16();
          return u7;
        }
        parseNotificationMessage(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int32(), s10 = this.reader.cstring(), o9 = this.reader.cstring();
          return new D6.NotificationResponseMessage(t6, i8, s10, o9);
        }
        parseRowDescriptionMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int16(), s10 = new D6.RowDescriptionMessage(t6, i8);
          for (let o9 = 0; o9 < i8; o9++) s10.fields[o9] = this.parseField();
          return s10;
        }
        parseField() {
          let e6 = this.reader.cstring(), t6 = this.reader.int32(), n7 = this.reader.int16(), i8 = this.reader.int32(), s10 = this.reader.int16(), o9 = this.reader.int32(), u7 = this.reader.int16() === 0 ? "text" : "binary";
          return new D6.Field(e6, t6, n7, i8, s10, o9, u7);
        }
        parseParameterDescriptionMessage(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int16(), s10 = new D6.ParameterDescriptionMessage(t6, i8);
          for (let o9 = 0; o9 < i8; o9++) s10.dataTypeIDs[o9] = this.reader.int32();
          return s10;
        }
        parseDataRowMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int16(), s10 = new Array(i8);
          for (let o9 = 0; o9 < i8; o9++) {
            let u7 = this.reader.int32();
            s10[o9] = u7 === -1 ? null : this.reader.string(u7);
          }
          return new D6.DataRowMessage(
            t6,
            s10
          );
        }
        parseParameterStatusMessage(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.cstring(), s10 = this.reader.cstring();
          return new D6.ParameterStatusMessage(t6, i8, s10);
        }
        parseBackendKeyData(e6, t6, n7) {
          this.reader.setBuffer(e6, n7);
          let i8 = this.reader.int32(), s10 = this.reader.int32();
          return new D6.BackendKeyDataMessage(t6, i8, s10);
        }
        parseAuthenticationResponse(e6, t6, n7) {
          this.reader.setBuffer(
            e6,
            n7
          );
          let i8 = this.reader.int32(), s10 = { name: "authenticationOk", length: t6 };
          switch (i8) {
            case 0:
              break;
            case 3:
              s10.length === 8 && (s10.name = "authenticationCleartextPassword");
              break;
            case 5:
              if (s10.length === 12) {
                s10.name = "authenticationMD5Password";
                let u7 = this.reader.bytes(4);
                return new D6.AuthenticationMD5Password(t6, u7);
              }
              break;
            case 10:
              s10.name = "authenticationSASL", s10.mechanisms = [];
              let o9;
              do
                o9 = this.reader.cstring(), o9 && s10.mechanisms.push(o9);
              while (o9);
              break;
            case 11:
              s10.name = "authenticationSASLContinue", s10.data = this.reader.string(t6 - 8);
              break;
            case 12:
              s10.name = "authenticationSASLFinal", s10.data = this.reader.string(t6 - 8);
              break;
            default:
              throw new Error("Unknown authenticationOk message type " + i8);
          }
          return s10;
        }
        parseErrorMessage(e6, t6, n7, i8) {
          this.reader.setBuffer(e6, n7);
          let s10 = {}, o9 = this.reader.string(1);
          for (; o9 !== "\0"; ) s10[o9] = this.reader.cstring(), o9 = this.reader.string(1);
          let u7 = s10.M, c6 = i8 === "notice" ? new D6.NoticeMessage(
            t6,
            u7
          ) : new D6.DatabaseError(u7, t6, i8);
          return c6.severity = s10.S, c6.code = s10.C, c6.detail = s10.D, c6.hint = s10.H, c6.position = s10.P, c6.internalPosition = s10.p, c6.internalQuery = s10.q, c6.where = s10.W, c6.schema = s10.s, c6.table = s10.t, c6.column = s10.c, c6.dataType = s10.d, c6.constraint = s10.n, c6.file = s10.F, c6.line = s10.L, c6.routine = s10.R, c6;
        }
      };
      a8(un2, "Parser");
      var an3 = un2;
      _t2.Parser = an3;
    });
    cn3 = I6((Se3) => {
      "use strict";
      p10();
      Object.defineProperty(Se3, "__esModule", { value: true });
      Se3.DatabaseError = Se3.serialize = Se3.parse = void 0;
      var uc = Jr();
      Object.defineProperty(
        Se3,
        "DatabaseError",
        { enumerable: true, get: a8(function() {
          return uc.DatabaseError;
        }, "get") }
      );
      var cc = Ss2();
      Object.defineProperty(Se3, "serialize", { enumerable: true, get: a8(function() {
        return cc.serialize;
      }, "get") });
      var hc = _s3();
      function lc3(r6, e6) {
        let t6 = new hc.Parser();
        return r6.on("data", (n7) => t6.parse(n7, e6)), new Promise((n7) => r6.on("end", () => n7()));
      }
      a8(lc3, "parse");
      Se3.parse = lc3;
    });
    As2 = {};
    ie3(As2, { connect: () => fc });
    Cs = z5(() => {
      "use strict";
      p10();
      a8(fc, "connect");
    });
    fn2 = I6((nf, Ps) => {
      "use strict";
      p10();
      var Ts = (bt(), N4(gs2)), pc = we4().EventEmitter, {
        parse: dc,
        serialize: Q3
      } = cn3(), Is = Q3.flush(), yc = Q3.sync(), mc = Q3.end(), ln2 = class ln extends pc {
        constructor(e6) {
          super(), e6 = e6 || {}, this.stream = e6.stream || new Ts.Socket(), this._keepAlive = e6.keepAlive, this._keepAliveInitialDelayMillis = e6.keepAliveInitialDelayMillis, this.lastBuffer = false, this.parsedStatements = {}, this.ssl = e6.ssl || false, this._ending = false, this._emitMessage = false;
          var t6 = this;
          this.on("newListener", function(n7) {
            n7 === "message" && (t6._emitMessage = true);
          });
        }
        connect(e6, t6) {
          var n7 = this;
          this._connecting = true, this.stream.setNoDelay(true), this.stream.connect(
            e6,
            t6
          ), this.stream.once("connect", function() {
            n7._keepAlive && n7.stream.setKeepAlive(
              true,
              n7._keepAliveInitialDelayMillis
            ), n7.emit("connect");
          });
          let i8 = a8(function(s10) {
            n7._ending && (s10.code === "ECONNRESET" || s10.code === "EPIPE") || n7.emit("error", s10);
          }, "reportStreamError");
          if (this.stream.on("error", i8), this.stream.on("close", function() {
            n7.emit("end");
          }), !this.ssl) return this.attachListeners(this.stream);
          this.stream.once("data", function(s10) {
            var o9 = s10.toString("utf8");
            switch (o9) {
              case "S":
                break;
              case "N":
                return n7.stream.end(), n7.emit("error", new Error("The server does not support SSL connections"));
              default:
                return n7.stream.end(), n7.emit("error", new Error("There was an error establishing an SSL connection"));
            }
            var u7 = (Cs(), N4(As2));
            let c6 = { socket: n7.stream };
            n7.ssl !== true && (Object.assign(
              c6,
              n7.ssl
            ), "key" in n7.ssl && (c6.key = n7.ssl.key)), Ts.isIP(t6) === 0 && (c6.servername = t6);
            try {
              n7.stream = u7.connect(c6);
            } catch (h8) {
              return n7.emit("error", h8);
            }
            n7.attachListeners(n7.stream), n7.stream.on("error", i8), n7.emit("sslconnect");
          });
        }
        attachListeners(e6) {
          e6.on("end", () => {
            this.emit("end");
          }), dc(e6, (t6) => {
            var n7 = t6.name === "error" ? "errorMessage" : t6.name;
            this._emitMessage && this.emit("message", t6), this.emit(n7, t6);
          });
        }
        requestSsl() {
          this.stream.write(Q3.requestSsl());
        }
        startup(e6) {
          this.stream.write(Q3.startup(e6));
        }
        cancel(e6, t6) {
          this._send(Q3.cancel(e6, t6));
        }
        password(e6) {
          this._send(Q3.password(e6));
        }
        sendSASLInitialResponseMessage(e6, t6) {
          this._send(Q3.sendSASLInitialResponseMessage(
            e6,
            t6
          ));
        }
        sendSCRAMClientFinalMessage(e6) {
          this._send(Q3.sendSCRAMClientFinalMessage(e6));
        }
        _send(e6) {
          return this.stream.writable ? this.stream.write(e6) : false;
        }
        query(e6) {
          this._send(Q3.query(
            e6
          ));
        }
        parse(e6) {
          this._send(Q3.parse(e6));
        }
        bind(e6) {
          this._send(Q3.bind(e6));
        }
        execute(e6) {
          this._send(Q3.execute(e6));
        }
        flush() {
          this.stream.writable && this.stream.write(Is);
        }
        sync() {
          this._ending = true, this._send(Is), this._send(yc);
        }
        ref() {
          this.stream.ref();
        }
        unref() {
          this.stream.unref();
        }
        end() {
          if (this._ending = true, !this._connecting || !this.stream.writable) {
            this.stream.end();
            return;
          }
          return this.stream.write(mc, () => {
            this.stream.end();
          });
        }
        close(e6) {
          this._send(Q3.close(e6));
        }
        describe(e6) {
          this._send(Q3.describe(e6));
        }
        sendCopyFromChunk(e6) {
          this._send(Q3.copyData(e6));
        }
        endCopyFrom() {
          this._send(Q3.copyDone());
        }
        sendCopyFail(e6) {
          this._send(Q3.copyFail(e6));
        }
      };
      a8(ln2, "Connection");
      var hn3 = ln2;
      Ps.exports = hn3;
    });
    Rs = I6((uf, Ls2) => {
      "use strict";
      p10();
      var gc = we4().EventEmitter, af = (Ge4(), N4(He4)), wc = tt3(), pn2 = Qi3(), bc = Ji2(), Sc = gt5(), Ec = wt4(), Bs2 = ds3(), xc = et4(), vc = fn2(), dn2 = class dn extends gc {
        constructor(e6) {
          super(), this.connectionParameters = new Ec(e6), this.user = this.connectionParameters.user, this.database = this.connectionParameters.database, this.port = this.connectionParameters.port, this.host = this.connectionParameters.host, Object.defineProperty(this, "password", { configurable: true, enumerable: false, writable: true, value: this.connectionParameters.password }), this.replication = this.connectionParameters.replication;
          var t6 = e6 || {};
          this._Promise = t6.Promise || S6.Promise, this._types = new Sc(t6.types), this._ending = false, this._connecting = false, this._connected = false, this._connectionError = false, this._queryable = true, this.connection = t6.connection || new vc({ stream: t6.stream, ssl: this.connectionParameters.ssl, keepAlive: t6.keepAlive || false, keepAliveInitialDelayMillis: t6.keepAliveInitialDelayMillis || 0, encoding: this.connectionParameters.client_encoding || "utf8" }), this.queryQueue = [], this.binary = t6.binary || xc.binary, this.processID = null, this.secretKey = null, this.ssl = this.connectionParameters.ssl || false, this.ssl && this.ssl.key && Object.defineProperty(this.ssl, "key", { enumerable: false }), this._connectionTimeoutMillis = t6.connectionTimeoutMillis || 0;
        }
        _errorAllQueries(e6) {
          let t6 = a8(
            (n7) => {
              m11.nextTick(() => {
                n7.handleError(e6, this.connection);
              });
            },
            "enqueueError"
          );
          this.activeQuery && (t6(this.activeQuery), this.activeQuery = null), this.queryQueue.forEach(t6), this.queryQueue.length = 0;
        }
        _connect(e6) {
          var t6 = this, n7 = this.connection;
          if (this._connectionCallback = e6, this._connecting || this._connected) {
            let i8 = new Error("Client has already been connected. You cannot reuse a client.");
            m11.nextTick(() => {
              e6(i8);
            });
            return;
          }
          this._connecting = true, this.connectionTimeoutHandle, this._connectionTimeoutMillis > 0 && (this.connectionTimeoutHandle = setTimeout(() => {
            n7._ending = true, n7.stream.destroy(new Error("timeout expired"));
          }, this._connectionTimeoutMillis)), this.host && this.host.indexOf("/") === 0 ? n7.connect(this.host + "/.s.PGSQL." + this.port) : n7.connect(this.port, this.host), n7.on("connect", function() {
            t6.ssl ? n7.requestSsl() : n7.startup(t6.getStartupConf());
          }), n7.on("sslconnect", function() {
            n7.startup(t6.getStartupConf());
          }), this._attachListeners(n7), n7.once("end", () => {
            let i8 = this._ending ? new Error("Connection terminated") : new Error("Connection terminated unexpectedly");
            clearTimeout(this.connectionTimeoutHandle), this._errorAllQueries(i8), this._ending || (this._connecting && !this._connectionError ? this._connectionCallback ? this._connectionCallback(i8) : this._handleErrorEvent(i8) : this._connectionError || this._handleErrorEvent(
              i8
            )), m11.nextTick(() => {
              this.emit("end");
            });
          });
        }
        connect(e6) {
          if (e6) {
            this._connect(e6);
            return;
          }
          return new this._Promise((t6, n7) => {
            this._connect((i8) => {
              i8 ? n7(i8) : t6();
            });
          });
        }
        _attachListeners(e6) {
          e6.on("authenticationCleartextPassword", this._handleAuthCleartextPassword.bind(this)), e6.on("authenticationMD5Password", this._handleAuthMD5Password.bind(this)), e6.on("authenticationSASL", this._handleAuthSASL.bind(this)), e6.on("authenticationSASLContinue", this._handleAuthSASLContinue.bind(this)), e6.on("authenticationSASLFinal", this._handleAuthSASLFinal.bind(this)), e6.on("backendKeyData", this._handleBackendKeyData.bind(this)), e6.on("error", this._handleErrorEvent.bind(this)), e6.on(
            "errorMessage",
            this._handleErrorMessage.bind(this)
          ), e6.on("readyForQuery", this._handleReadyForQuery.bind(this)), e6.on("notice", this._handleNotice.bind(this)), e6.on("rowDescription", this._handleRowDescription.bind(this)), e6.on("dataRow", this._handleDataRow.bind(this)), e6.on("portalSuspended", this._handlePortalSuspended.bind(this)), e6.on(
            "emptyQuery",
            this._handleEmptyQuery.bind(this)
          ), e6.on("commandComplete", this._handleCommandComplete.bind(this)), e6.on("parseComplete", this._handleParseComplete.bind(this)), e6.on("copyInResponse", this._handleCopyInResponse.bind(this)), e6.on("copyData", this._handleCopyData.bind(this)), e6.on("notification", this._handleNotification.bind(this));
        }
        _checkPgPass(e6) {
          let t6 = this.connection;
          typeof this.password == "function" ? this._Promise.resolve().then(
            () => this.password()
          ).then((n7) => {
            if (n7 !== void 0) {
              if (typeof n7 != "string") {
                t6.emit("error", new TypeError("Password must be a string"));
                return;
              }
              this.connectionParameters.password = this.password = n7;
            } else this.connectionParameters.password = this.password = null;
            e6();
          }).catch((n7) => {
            t6.emit("error", n7);
          }) : this.password !== null ? e6() : bc(
            this.connectionParameters,
            (n7) => {
              n7 !== void 0 && (this.connectionParameters.password = this.password = n7), e6();
            }
          );
        }
        _handleAuthCleartextPassword(e6) {
          this._checkPgPass(() => {
            this.connection.password(this.password);
          });
        }
        _handleAuthMD5Password(e6) {
          this._checkPgPass(() => {
            let t6 = wc.postgresMd5PasswordHash(
              this.user,
              this.password,
              e6.salt
            );
            this.connection.password(t6);
          });
        }
        _handleAuthSASL(e6) {
          this._checkPgPass(() => {
            this.saslSession = pn2.startSession(e6.mechanisms), this.connection.sendSASLInitialResponseMessage(
              this.saslSession.mechanism,
              this.saslSession.response
            );
          });
        }
        _handleAuthSASLContinue(e6) {
          pn2.continueSession(this.saslSession, this.password, e6.data), this.connection.sendSCRAMClientFinalMessage(
            this.saslSession.response
          );
        }
        _handleAuthSASLFinal(e6) {
          pn2.finalizeSession(
            this.saslSession,
            e6.data
          ), this.saslSession = null;
        }
        _handleBackendKeyData(e6) {
          this.processID = e6.processID, this.secretKey = e6.secretKey;
        }
        _handleReadyForQuery(e6) {
          this._connecting && (this._connecting = false, this._connected = true, clearTimeout(this.connectionTimeoutHandle), this._connectionCallback && (this._connectionCallback(null, this), this._connectionCallback = null), this.emit("connect"));
          let { activeQuery: t6 } = this;
          this.activeQuery = null, this.readyForQuery = true, t6 && t6.handleReadyForQuery(this.connection), this._pulseQueryQueue();
        }
        _handleErrorWhileConnecting(e6) {
          if (!this._connectionError) {
            if (this._connectionError = true, clearTimeout(this.connectionTimeoutHandle), this._connectionCallback) return this._connectionCallback(e6);
            this.emit("error", e6);
          }
        }
        _handleErrorEvent(e6) {
          if (this._connecting) return this._handleErrorWhileConnecting(e6);
          this._queryable = false, this._errorAllQueries(e6), this.emit("error", e6);
        }
        _handleErrorMessage(e6) {
          if (this._connecting)
            return this._handleErrorWhileConnecting(e6);
          let t6 = this.activeQuery;
          if (!t6) {
            this._handleErrorEvent(
              e6
            );
            return;
          }
          this.activeQuery = null, t6.handleError(e6, this.connection);
        }
        _handleRowDescription(e6) {
          this.activeQuery.handleRowDescription(e6);
        }
        _handleDataRow(e6) {
          this.activeQuery.handleDataRow(
            e6
          );
        }
        _handlePortalSuspended(e6) {
          this.activeQuery.handlePortalSuspended(this.connection);
        }
        _handleEmptyQuery(e6) {
          this.activeQuery.handleEmptyQuery(this.connection);
        }
        _handleCommandComplete(e6) {
          this.activeQuery.handleCommandComplete(e6, this.connection);
        }
        _handleParseComplete(e6) {
          this.activeQuery.name && (this.connection.parsedStatements[this.activeQuery.name] = this.activeQuery.text);
        }
        _handleCopyInResponse(e6) {
          this.activeQuery.handleCopyInResponse(
            this.connection
          );
        }
        _handleCopyData(e6) {
          this.activeQuery.handleCopyData(e6, this.connection);
        }
        _handleNotification(e6) {
          this.emit("notification", e6);
        }
        _handleNotice(e6) {
          this.emit("notice", e6);
        }
        getStartupConf() {
          var e6 = this.connectionParameters, t6 = { user: e6.user, database: e6.database }, n7 = e6.application_name || e6.fallback_application_name;
          return n7 && (t6.application_name = n7), e6.replication && (t6.replication = "" + e6.replication), e6.statement_timeout && (t6.statement_timeout = String(parseInt(
            e6.statement_timeout,
            10
          ))), e6.lock_timeout && (t6.lock_timeout = String(parseInt(e6.lock_timeout, 10))), e6.idle_in_transaction_session_timeout && (t6.idle_in_transaction_session_timeout = String(parseInt(
            e6.idle_in_transaction_session_timeout,
            10
          ))), e6.options && (t6.options = e6.options), t6;
        }
        cancel(e6, t6) {
          if (e6.activeQuery === t6) {
            var n7 = this.connection;
            this.host && this.host.indexOf("/") === 0 ? n7.connect(this.host + "/.s.PGSQL." + this.port) : n7.connect(this.port, this.host), n7.on("connect", function() {
              n7.cancel(
                e6.processID,
                e6.secretKey
              );
            });
          } else e6.queryQueue.indexOf(t6) !== -1 && e6.queryQueue.splice(e6.queryQueue.indexOf(t6), 1);
        }
        setTypeParser(e6, t6, n7) {
          return this._types.setTypeParser(e6, t6, n7);
        }
        getTypeParser(e6, t6) {
          return this._types.getTypeParser(e6, t6);
        }
        escapeIdentifier(e6) {
          return '"' + e6.replace(
            /"/g,
            '""'
          ) + '"';
        }
        escapeLiteral(e6) {
          for (var t6 = false, n7 = "'", i8 = 0; i8 < e6.length; i8++) {
            var s10 = e6[i8];
            s10 === "'" ? n7 += s10 + s10 : s10 === "\\" ? (n7 += s10 + s10, t6 = true) : n7 += s10;
          }
          return n7 += "'", t6 === true && (n7 = " E" + n7), n7;
        }
        _pulseQueryQueue() {
          if (this.readyForQuery === true) if (this.activeQuery = this.queryQueue.shift(), this.activeQuery) {
            this.readyForQuery = false, this.hasExecuted = true;
            let e6 = this.activeQuery.submit(this.connection);
            e6 && m11.nextTick(() => {
              this.activeQuery.handleError(e6, this.connection), this.readyForQuery = true, this._pulseQueryQueue();
            });
          } else this.hasExecuted && (this.activeQuery = null, this.emit("drain"));
        }
        query(e6, t6, n7) {
          var i8, s10, o9, u7, c6;
          if (e6 == null) throw new TypeError("Client was passed a null or undefined query");
          return typeof e6.submit == "function" ? (o9 = e6.query_timeout || this.connectionParameters.query_timeout, s10 = i8 = e6, typeof t6 == "function" && (i8.callback = i8.callback || t6)) : (o9 = this.connectionParameters.query_timeout, i8 = new Bs2(
            e6,
            t6,
            n7
          ), i8.callback || (s10 = new this._Promise((h8, l7) => {
            i8.callback = (d7, b9) => d7 ? l7(d7) : h8(b9);
          }))), o9 && (c6 = i8.callback, u7 = setTimeout(() => {
            var h8 = new Error("Query read timeout");
            m11.nextTick(
              () => {
                i8.handleError(h8, this.connection);
              }
            ), c6(h8), i8.callback = () => {
            };
            var l7 = this.queryQueue.indexOf(i8);
            l7 > -1 && this.queryQueue.splice(l7, 1), this._pulseQueryQueue();
          }, o9), i8.callback = (h8, l7) => {
            clearTimeout(u7), c6(h8, l7);
          }), this.binary && !i8.binary && (i8.binary = true), i8._result && !i8._result._types && (i8._result._types = this._types), this._queryable ? this._ending ? (m11.nextTick(() => {
            i8.handleError(
              new Error("Client was closed and is not queryable"),
              this.connection
            );
          }), s10) : (this.queryQueue.push(i8), this._pulseQueryQueue(), s10) : (m11.nextTick(
            () => {
              i8.handleError(new Error("Client has encountered a connection error and is not queryable"), this.connection);
            }
          ), s10);
        }
        ref() {
          this.connection.ref();
        }
        unref() {
          this.connection.unref();
        }
        end(e6) {
          if (this._ending = true, !this.connection._connecting) if (e6) e6();
          else return this._Promise.resolve();
          if (this.activeQuery || !this._queryable ? this.connection.stream.destroy() : this.connection.end(), e6) this.connection.once("end", e6);
          else return new this._Promise((t6) => {
            this.connection.once("end", t6);
          });
        }
      };
      a8(dn2, "Client");
      var At3 = dn2;
      At3.Query = Bs2;
      Ls2.exports = At3;
    });
    ks3 = I6((lf, Ds3) => {
      "use strict";
      p10();
      var _c14 = we4().EventEmitter, Fs = a8(function() {
      }, "NOOP"), Ms2 = a8(
        (r6, e6) => {
          let t6 = r6.findIndex(e6);
          return t6 === -1 ? void 0 : r6.splice(t6, 1)[0];
        },
        "removeWhere"
      ), gn2 = class gn {
        constructor(e6, t6, n7) {
          this.client = e6, this.idleListener = t6, this.timeoutId = n7;
        }
      };
      a8(gn2, "IdleItem");
      var yn2 = gn2, wn3 = class wn {
        constructor(e6) {
          this.callback = e6;
        }
      };
      a8(wn3, "PendingItem");
      var qe2 = wn3;
      function Ac() {
        throw new Error("Release called on client which has already been released to the pool.");
      }
      a8(Ac, "throwOnDoubleRelease");
      function Ct4(r6, e6) {
        if (e6) return { callback: e6, result: void 0 };
        let t6, n7, i8 = a8(function(o9, u7) {
          o9 ? t6(o9) : n7(u7);
        }, "cb"), s10 = new r6(function(o9, u7) {
          n7 = o9, t6 = u7;
        }).catch((o9) => {
          throw Error.captureStackTrace(
            o9
          ), o9;
        });
        return { callback: i8, result: s10 };
      }
      a8(Ct4, "promisify");
      function Cc3(r6, e6) {
        return a8(
          function t6(n7) {
            n7.client = e6, e6.removeListener("error", t6), e6.on("error", () => {
              r6.log("additional client error after disconnection due to error", n7);
            }), r6._remove(e6), r6.emit("error", n7, e6);
          },
          "idleListener"
        );
      }
      a8(Cc3, "makeIdleListener");
      var bn3 = class bn extends _c14 {
        constructor(e6, t6) {
          super(), this.options = Object.assign({}, e6), e6 != null && "password" in e6 && Object.defineProperty(
            this.options,
            "password",
            { configurable: true, enumerable: false, writable: true, value: e6.password }
          ), e6 != null && e6.ssl && e6.ssl.key && Object.defineProperty(this.options.ssl, "key", { enumerable: false }), this.options.max = this.options.max || this.options.poolSize || 10, this.options.maxUses = this.options.maxUses || 1 / 0, this.options.allowExitOnIdle = this.options.allowExitOnIdle || false, this.options.maxLifetimeSeconds = this.options.maxLifetimeSeconds || 0, this.log = this.options.log || function() {
          }, this.Client = this.options.Client || t6 || Tt3().Client, this.Promise = this.options.Promise || S6.Promise, typeof this.options.idleTimeoutMillis > "u" && (this.options.idleTimeoutMillis = 1e4), this._clients = [], this._idle = [], this._expired = /* @__PURE__ */ new WeakSet(), this._pendingQueue = [], this._endCallback = void 0, this.ending = false, this.ended = false;
        }
        _isFull() {
          return this._clients.length >= this.options.max;
        }
        _pulseQueue() {
          if (this.log("pulse queue"), this.ended) {
            this.log("pulse queue ended");
            return;
          }
          if (this.ending) {
            this.log(
              "pulse queue on ending"
            ), this._idle.length && this._idle.slice().map((t6) => {
              this._remove(
                t6.client
              );
            }), this._clients.length || (this.ended = true, this._endCallback());
            return;
          }
          if (!this._pendingQueue.length) {
            this.log("no queued requests");
            return;
          }
          if (!this._idle.length && this._isFull()) return;
          let e6 = this._pendingQueue.shift();
          if (this._idle.length) {
            let t6 = this._idle.pop();
            clearTimeout(t6.timeoutId);
            let n7 = t6.client;
            n7.ref && n7.ref();
            let i8 = t6.idleListener;
            return this._acquireClient(n7, e6, i8, false);
          }
          if (!this._isFull()) return this.newClient(e6);
          throw new Error("unexpected condition");
        }
        _remove(e6) {
          let t6 = Ms2(this._idle, (n7) => n7.client === e6);
          t6 !== void 0 && clearTimeout(t6.timeoutId), this._clients = this._clients.filter((n7) => n7 !== e6), e6.end(), this.emit("remove", e6);
        }
        connect(e6) {
          if (this.ending) {
            let i8 = new Error("Cannot use a pool after calling end on the pool");
            return e6 ? e6(i8) : this.Promise.reject(
              i8
            );
          }
          let t6 = Ct4(this.Promise, e6), n7 = t6.result;
          if (this._isFull() || this._idle.length) {
            if (this._idle.length && m11.nextTick(() => this._pulseQueue()), !this.options.connectionTimeoutMillis)
              return this._pendingQueue.push(new qe2(t6.callback)), n7;
            let i8 = a8((u7, c6, h8) => {
              clearTimeout(
                o9
              ), t6.callback(u7, c6, h8);
            }, "queueCallback"), s10 = new qe2(i8), o9 = setTimeout(() => {
              Ms2(
                this._pendingQueue,
                (u7) => u7.callback === i8
              ), s10.timedOut = true, t6.callback(new Error("timeout exceeded when trying to connect"));
            }, this.options.connectionTimeoutMillis);
            return this._pendingQueue.push(s10), n7;
          }
          return this.newClient(new qe2(t6.callback)), n7;
        }
        newClient(e6) {
          let t6 = new this.Client(this.options);
          this._clients.push(t6);
          let n7 = Cc3(this, t6);
          this.log("checking client timeout");
          let i8, s10 = false;
          this.options.connectionTimeoutMillis && (i8 = setTimeout(() => {
            this.log("ending client due to timeout"), s10 = true, t6.connection ? t6.connection.stream.destroy() : t6.end();
          }, this.options.connectionTimeoutMillis)), this.log("connecting new client"), t6.connect((o9) => {
            if (i8 && clearTimeout(i8), t6.on("error", n7), o9) this.log("client failed to connect", o9), this._clients = this._clients.filter((u7) => u7 !== t6), s10 && (o9.message = "Connection terminated due to connection timeout"), this._pulseQueue(), e6.timedOut || e6.callback(
              o9,
              void 0,
              Fs
            );
            else {
              if (this.log("new client connected"), this.options.maxLifetimeSeconds !== 0) {
                let u7 = setTimeout(() => {
                  this.log("ending client due to expired lifetime"), this._expired.add(t6), this._idle.findIndex((h8) => h8.client === t6) !== -1 && this._acquireClient(
                    t6,
                    new qe2((h8, l7, d7) => d7()),
                    n7,
                    false
                  );
                }, this.options.maxLifetimeSeconds * 1e3);
                u7.unref(), t6.once(
                  "end",
                  () => clearTimeout(u7)
                );
              }
              return this._acquireClient(t6, e6, n7, true);
            }
          });
        }
        _acquireClient(e6, t6, n7, i8) {
          i8 && this.emit("connect", e6), this.emit("acquire", e6), e6.release = this._releaseOnce(e6, n7), e6.removeListener("error", n7), t6.timedOut ? i8 && this.options.verify ? this.options.verify(
            e6,
            e6.release
          ) : e6.release() : i8 && this.options.verify ? this.options.verify(e6, (s10) => {
            if (s10) return e6.release(s10), t6.callback(s10, void 0, Fs);
            t6.callback(void 0, e6, e6.release);
          }) : t6.callback(
            void 0,
            e6,
            e6.release
          );
        }
        _releaseOnce(e6, t6) {
          let n7 = false;
          return (i8) => {
            n7 && Ac(), n7 = true, this._release(
              e6,
              t6,
              i8
            );
          };
        }
        _release(e6, t6, n7) {
          if (e6.on("error", t6), e6._poolUseCount = (e6._poolUseCount || 0) + 1, this.emit("release", n7, e6), n7 || this.ending || !e6._queryable || e6._ending || e6._poolUseCount >= this.options.maxUses) {
            e6._poolUseCount >= this.options.maxUses && this.log("remove expended client"), this._remove(e6), this._pulseQueue();
            return;
          }
          if (this._expired.has(e6)) {
            this.log("remove expired client"), this._expired.delete(e6), this._remove(e6), this._pulseQueue();
            return;
          }
          let s10;
          this.options.idleTimeoutMillis && (s10 = setTimeout(() => {
            this.log("remove idle client"), this._remove(e6);
          }, this.options.idleTimeoutMillis), this.options.allowExitOnIdle && s10.unref()), this.options.allowExitOnIdle && e6.unref(), this._idle.push(new yn2(e6, t6, s10)), this._pulseQueue();
        }
        query(e6, t6, n7) {
          if (typeof e6 == "function") {
            let s10 = Ct4(this.Promise, e6);
            return E3(function() {
              return s10.callback(new Error("Passing a function as the first parameter to pool.query is not supported"));
            }), s10.result;
          }
          typeof t6 == "function" && (n7 = t6, t6 = void 0);
          let i8 = Ct4(this.Promise, n7);
          return n7 = i8.callback, this.connect((s10, o9) => {
            if (s10)
              return n7(s10);
            let u7 = false, c6 = a8((h8) => {
              u7 || (u7 = true, o9.release(h8), n7(h8));
            }, "onError");
            o9.once("error", c6), this.log("dispatching query");
            try {
              o9.query(e6, t6, (h8, l7) => {
                if (this.log("query dispatched"), o9.removeListener("error", c6), !u7) return u7 = true, o9.release(h8), h8 ? n7(h8) : n7(
                  void 0,
                  l7
                );
              });
            } catch (h8) {
              return o9.release(h8), n7(h8);
            }
          }), i8.result;
        }
        end(e6) {
          if (this.log("ending"), this.ending) {
            let n7 = new Error("Called end on pool more than once");
            return e6 ? e6(n7) : this.Promise.reject(n7);
          }
          this.ending = true;
          let t6 = Ct4(this.Promise, e6);
          return this._endCallback = t6.callback, this._pulseQueue(), t6.result;
        }
        get waitingCount() {
          return this._pendingQueue.length;
        }
        get idleCount() {
          return this._idle.length;
        }
        get expiredCount() {
          return this._clients.reduce((e6, t6) => e6 + (this._expired.has(t6) ? 1 : 0), 0);
        }
        get totalCount() {
          return this._clients.length;
        }
      };
      a8(bn3, "Pool");
      var mn2 = bn3;
      Ds3.exports = mn2;
    });
    Os2 = {};
    ie3(Os2, { default: () => Tc });
    Us3 = z5(() => {
      "use strict";
      p10();
      Tc = {};
    });
    Ns = I6((yf, Ic) => {
      Ic.exports = { name: "pg", version: "8.8.0", description: "PostgreSQL client - pure javascript & libpq with the same API", keywords: [
        "database",
        "libpq",
        "pg",
        "postgre",
        "postgres",
        "postgresql",
        "rdbms"
      ], homepage: "https://github.com/brianc/node-postgres", repository: { type: "git", url: "git://github.com/brianc/node-postgres.git", directory: "packages/pg" }, author: "Brian Carlson <brian.m.carlson@gmail.com>", main: "./lib", dependencies: {
        "buffer-writer": "2.0.0",
        "packet-reader": "1.0.0",
        "pg-connection-string": "^2.5.0",
        "pg-pool": "^3.5.2",
        "pg-protocol": "^1.5.0",
        "pg-types": "^2.1.0",
        pgpass: "1.x"
      }, devDependencies: { async: "2.6.4", bluebird: "3.5.2", co: "4.6.0", "pg-copy-streams": "0.3.0" }, peerDependencies: { "pg-native": ">=3.0.1" }, peerDependenciesMeta: {
        "pg-native": { optional: true }
      }, scripts: { test: "make test-all" }, files: ["lib", "SPONSORS.md"], license: "MIT", engines: { node: ">= 8.0.0" }, gitHead: "c99fb2c127ddf8d712500db2c7b9a5491a178655" };
    });
    js = I6((mf, Qs2) => {
      "use strict";
      p10();
      var qs2 = we4().EventEmitter, Pc = (Ge4(), N4(He4)), Sn4 = tt3(), Qe3 = Qs2.exports = function(r6, e6, t6) {
        qs2.call(this), r6 = Sn4.normalizeQueryConfig(r6, e6, t6), this.text = r6.text, this.values = r6.values, this.name = r6.name, this.callback = r6.callback, this.state = "new", this._arrayMode = r6.rowMode === "array", this._emitRowEvents = false, this.on("newListener", function(n7) {
          n7 === "row" && (this._emitRowEvents = true);
        }.bind(this));
      };
      Pc.inherits(
        Qe3,
        qs2
      );
      var Bc = { sqlState: "code", statementPosition: "position", messagePrimary: "message", context: "where", schemaName: "schema", tableName: "table", columnName: "column", dataTypeName: "dataType", constraintName: "constraint", sourceFile: "file", sourceLine: "line", sourceFunction: "routine" };
      Qe3.prototype.handleError = function(r6) {
        var e6 = this.native.pq.resultErrorFields();
        if (e6) for (var t6 in e6) {
          var n7 = Bc[t6] || t6;
          r6[n7] = e6[t6];
        }
        this.callback ? this.callback(r6) : this.emit("error", r6), this.state = "error";
      };
      Qe3.prototype.then = function(r6, e6) {
        return this._getPromise().then(r6, e6);
      };
      Qe3.prototype.catch = function(r6) {
        return this._getPromise().catch(r6);
      };
      Qe3.prototype._getPromise = function() {
        return this._promise ? this._promise : (this._promise = new Promise(function(r6, e6) {
          this._once("end", r6), this._once(
            "error",
            e6
          );
        }.bind(this)), this._promise);
      };
      Qe3.prototype.submit = function(r6) {
        this.state = "running";
        var e6 = this;
        this.native = r6.native, r6.native.arrayMode = this._arrayMode;
        var t6 = a8(
          function(s10, o9, u7) {
            if (r6.native.arrayMode = false, E3(function() {
              e6.emit("_done");
            }), s10) return e6.handleError(s10);
            e6._emitRowEvents && (u7.length > 1 ? o9.forEach((c6, h8) => {
              c6.forEach((l7) => {
                e6.emit(
                  "row",
                  l7,
                  u7[h8]
                );
              });
            }) : o9.forEach(function(c6) {
              e6.emit("row", c6, u7);
            })), e6.state = "end", e6.emit(
              "end",
              u7
            ), e6.callback && e6.callback(null, u7);
          },
          "after"
        );
        if (m11.domain && (t6 = m11.domain.bind(
          t6
        )), this.name) {
          this.name.length > 63 && (console.error("Warning! Postgres only supports 63 characters for query names."), console.error(
            "You supplied %s (%s)",
            this.name,
            this.name.length
          ), console.error("This can cause conflicts and silent errors executing queries"));
          var n7 = (this.values || []).map(Sn4.prepareValue);
          if (r6.namedQueries[this.name]) {
            if (this.text && r6.namedQueries[this.name] !== this.text) {
              let s10 = new Error(`Prepared statements must be unique - '${this.name}' was used for a different statement`);
              return t6(s10);
            }
            return r6.native.execute(this.name, n7, t6);
          }
          return r6.native.prepare(
            this.name,
            this.text,
            n7.length,
            function(s10) {
              return s10 ? t6(s10) : (r6.namedQueries[e6.name] = e6.text, e6.native.execute(e6.name, n7, t6));
            }
          );
        } else if (this.values) {
          if (!Array.isArray(this.values)) {
            let s10 = new Error("Query values must be an array");
            return t6(s10);
          }
          var i8 = this.values.map(Sn4.prepareValue);
          r6.native.query(this.text, i8, t6);
        } else r6.native.query(this.text, t6);
      };
    });
    $s2 = I6((Sf, Gs2) => {
      "use strict";
      p10();
      var Lc = (Us3(), N4(Os2)), Rc = gt5(), bf = Ns(), Ws = we4().EventEmitter, Fc = (Ge4(), N4(He4)), Mc = wt4(), Hs2 = js(), J3 = Gs2.exports = function(r6) {
        Ws.call(this), r6 = r6 || {}, this._Promise = r6.Promise || S6.Promise, this._types = new Rc(r6.types), this.native = new Lc({ types: this._types }), this._queryQueue = [], this._ending = false, this._connecting = false, this._connected = false, this._queryable = true;
        var e6 = this.connectionParameters = new Mc(
          r6
        );
        this.user = e6.user, Object.defineProperty(this, "password", {
          configurable: true,
          enumerable: false,
          writable: true,
          value: e6.password
        }), this.database = e6.database, this.host = e6.host, this.port = e6.port, this.namedQueries = {};
      };
      J3.Query = Hs2;
      Fc.inherits(J3, Ws);
      J3.prototype._errorAllQueries = function(r6) {
        let e6 = a8(
          (t6) => {
            m11.nextTick(() => {
              t6.native = this.native, t6.handleError(r6);
            });
          },
          "enqueueError"
        );
        this._hasActiveQuery() && (e6(this._activeQuery), this._activeQuery = null), this._queryQueue.forEach(e6), this._queryQueue.length = 0;
      };
      J3.prototype._connect = function(r6) {
        var e6 = this;
        if (this._connecting) {
          m11.nextTick(() => r6(new Error("Client has already been connected. You cannot reuse a client.")));
          return;
        }
        this._connecting = true, this.connectionParameters.getLibpqConnectionString(function(t6, n7) {
          if (t6) return r6(
            t6
          );
          e6.native.connect(n7, function(i8) {
            if (i8) return e6.native.end(), r6(i8);
            e6._connected = true, e6.native.on("error", function(s10) {
              e6._queryable = false, e6._errorAllQueries(s10), e6.emit("error", s10);
            }), e6.native.on("notification", function(s10) {
              e6.emit("notification", { channel: s10.relname, payload: s10.extra });
            }), e6.emit("connect"), e6._pulseQueryQueue(true), r6();
          });
        });
      };
      J3.prototype.connect = function(r6) {
        if (r6) {
          this._connect(r6);
          return;
        }
        return new this._Promise(
          (e6, t6) => {
            this._connect((n7) => {
              n7 ? t6(n7) : e6();
            });
          }
        );
      };
      J3.prototype.query = function(r6, e6, t6) {
        var n7, i8, s10, o9, u7;
        if (r6 == null) throw new TypeError("Client was passed a null or undefined query");
        if (typeof r6.submit == "function") s10 = r6.query_timeout || this.connectionParameters.query_timeout, i8 = n7 = r6, typeof e6 == "function" && (r6.callback = e6);
        else if (s10 = this.connectionParameters.query_timeout, n7 = new Hs2(r6, e6, t6), !n7.callback) {
          let c6, h8;
          i8 = new this._Promise((l7, d7) => {
            c6 = l7, h8 = d7;
          }), n7.callback = (l7, d7) => l7 ? h8(l7) : c6(d7);
        }
        return s10 && (u7 = n7.callback, o9 = setTimeout(() => {
          var c6 = new Error("Query read timeout");
          m11.nextTick(() => {
            n7.handleError(c6, this.connection);
          }), u7(c6), n7.callback = () => {
          };
          var h8 = this._queryQueue.indexOf(n7);
          h8 > -1 && this._queryQueue.splice(h8, 1), this._pulseQueryQueue();
        }, s10), n7.callback = (c6, h8) => {
          clearTimeout(o9), u7(c6, h8);
        }), this._queryable ? this._ending ? (n7.native = this.native, m11.nextTick(() => {
          n7.handleError(
            new Error("Client was closed and is not queryable")
          );
        }), i8) : (this._queryQueue.push(
          n7
        ), this._pulseQueryQueue(), i8) : (n7.native = this.native, m11.nextTick(() => {
          n7.handleError(
            new Error("Client has encountered a connection error and is not queryable")
          );
        }), i8);
      };
      J3.prototype.end = function(r6) {
        var e6 = this;
        this._ending = true, this._connected || this.once(
          "connect",
          this.end.bind(this, r6)
        );
        var t6;
        return r6 || (t6 = new this._Promise(function(n7, i8) {
          r6 = a8((s10) => s10 ? i8(s10) : n7(), "cb");
        })), this.native.end(function() {
          e6._errorAllQueries(new Error(
            "Connection terminated"
          )), m11.nextTick(() => {
            e6.emit("end"), r6 && r6();
          });
        }), t6;
      };
      J3.prototype._hasActiveQuery = function() {
        return this._activeQuery && this._activeQuery.state !== "error" && this._activeQuery.state !== "end";
      };
      J3.prototype._pulseQueryQueue = function(r6) {
        if (this._connected && !this._hasActiveQuery()) {
          var e6 = this._queryQueue.shift();
          if (!e6) {
            r6 || this.emit("drain");
            return;
          }
          this._activeQuery = e6, e6.submit(this);
          var t6 = this;
          e6.once(
            "_done",
            function() {
              t6._pulseQueryQueue();
            }
          );
        }
      };
      J3.prototype.cancel = function(r6) {
        this._activeQuery === r6 ? this.native.cancel(function() {
        }) : this._queryQueue.indexOf(r6) !== -1 && this._queryQueue.splice(this._queryQueue.indexOf(r6), 1);
      };
      J3.prototype.ref = function() {
      };
      J3.prototype.unref = function() {
      };
      J3.prototype.setTypeParser = function(r6, e6, t6) {
        return this._types.setTypeParser(r6, e6, t6);
      };
      J3.prototype.getTypeParser = function(r6, e6) {
        return this._types.getTypeParser(r6, e6);
      };
    });
    En6 = I6((vf, Vs3) => {
      "use strict";
      p10();
      Vs3.exports = $s2();
    });
    Tt3 = I6((Af, nt2) => {
      "use strict";
      p10();
      var Dc = Rs(), kc = et4(), Oc = fn2(), Uc = ks3(), { DatabaseError: Nc2 } = cn3(), qc2 = a8((r6) => {
        var e6;
        return e6 = class extends Uc {
          constructor(n7) {
            super(n7, r6);
          }
        }, a8(e6, "BoundPool"), e6;
      }, "poolFactory"), xn5 = a8(function(r6) {
        this.defaults = kc, this.Client = r6, this.Query = this.Client.Query, this.Pool = qc2(this.Client), this._pools = [], this.Connection = Oc, this.types = Xe4(), this.DatabaseError = Nc2;
      }, "PG");
      typeof m11.env.NODE_PG_FORCE_NATIVE < "u" ? nt2.exports = new xn5(En6()) : (nt2.exports = new xn5(Dc), Object.defineProperty(nt2.exports, "native", { configurable: true, enumerable: false, get() {
        var r6 = null;
        try {
          r6 = new xn5(En6());
        } catch (e6) {
          if (e6.code !== "MODULE_NOT_FOUND") throw e6;
        }
        return Object.defineProperty(nt2.exports, "native", { value: r6 }), r6;
      } }));
    });
    p10();
    Pt2 = Ie4(Tt3());
    bt();
    p10();
    bt();
    yr();
    Ys3 = Ie4(tt3());
    Zs3 = Ie4(gt5());
    It2 = class It3 extends Error {
      constructor(t6) {
        super(t6);
        _6(this, "name", "NeonDbError");
        _6(this, "severity");
        _6(this, "code");
        _6(this, "detail");
        _6(this, "hint");
        _6(this, "position");
        _6(this, "internalPosition");
        _6(this, "internalQuery");
        _6(this, "where");
        _6(this, "schema");
        _6(this, "table");
        _6(this, "column");
        _6(this, "dataType");
        _6(this, "constraint");
        _6(this, "file");
        _6(this, "line");
        _6(this, "routine");
        _6(this, "sourceError");
        "captureStackTrace" in Error && typeof Error.captureStackTrace == "function" && Error.captureStackTrace(
          this,
          It3
        );
      }
    };
    a8(It2, "NeonDbError");
    fe2 = It2;
    Ks3 = "transaction() expects an array of queries, or a function returning an array of queries";
    Qc3 = [
      "severity",
      "code",
      "detail",
      "hint",
      "position",
      "internalPosition",
      "internalQuery",
      "where",
      "schema",
      "table",
      "column",
      "dataType",
      "constraint",
      "file",
      "line",
      "routine"
    ];
    a8(Js3, "neon");
    a8(jc, "createNeonQueryPromise");
    a8(zs3, "processQueryResult");
    a8(Wc2, "getAuthToken");
    eo2 = Ie4(wt4());
    je3 = Ie4(Tt3());
    _n5 = class _n6 extends Pt2.Client {
      constructor(t6) {
        super(t6);
        this.config = t6;
      }
      get neonConfig() {
        return this.connection.stream;
      }
      connect(t6) {
        let { neonConfig: n7 } = this;
        n7.forceDisablePgSSL && (this.ssl = this.connection.ssl = false), this.ssl && n7.useSecureWebSocket && console.warn("SSL is enabled for both Postgres (e.g. ?sslmode=require in the connection string + forceDisablePgSSL = false) and the WebSocket tunnel (useSecureWebSocket = true). Double encryption will increase latency and CPU usage. It may be appropriate to disable SSL in the Postgres connection parameters or set forceDisablePgSSL = true.");
        let i8 = this.config?.host !== void 0 || this.config?.connectionString !== void 0 || m11.env.PGHOST !== void 0, s10 = m11.env.USER ?? m11.env.USERNAME;
        if (!i8 && this.host === "localhost" && this.user === s10 && this.database === s10 && this.password === null) throw new Error(`No database host or connection string was set, and key parameters have default values (host: localhost, user: ${s10}, db: ${s10}, password: null). Is an environment variable missing? Alternatively, if you intended to connect with these parameters, please set the host to 'localhost' explicitly.`);
        let o9 = super.connect(t6), u7 = n7.pipelineTLS && this.ssl, c6 = n7.pipelineConnect === "password";
        if (!u7 && !n7.pipelineConnect) return o9;
        let h8 = this.connection;
        if (u7 && h8.on("connect", () => h8.stream.emit("data", "S")), c6) {
          h8.removeAllListeners(
            "authenticationCleartextPassword"
          ), h8.removeAllListeners("readyForQuery"), h8.once(
            "readyForQuery",
            () => h8.on("readyForQuery", this._handleReadyForQuery.bind(this))
          );
          let l7 = this.ssl ? "sslconnect" : "connect";
          h8.on(l7, () => {
            this._handleAuthCleartextPassword(), this._handleReadyForQuery();
          });
        }
        return o9;
      }
      async _handleAuthSASLContinue(t6) {
        let n7 = this.saslSession, i8 = this.password, s10 = t6.data;
        if (n7.message !== "SASLInitialResponse" || typeof i8 != "string" || typeof s10 != "string") throw new Error("SASL: protocol error");
        let o9 = Object.fromEntries(s10.split(",").map((K4) => {
          if (!/^.=/.test(K4)) throw new Error("SASL: Invalid attribute pair entry");
          let k9 = K4[0], me2 = K4.substring(2);
          return [k9, me2];
        })), u7 = o9.r, c6 = o9.s, h8 = o9.i;
        if (!u7 || !/^[!-+--~]+$/.test(u7)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: nonce missing/unprintable");
        if (!c6 || !/^(?:[a-zA-Z0-9+/]{4})*(?:[a-zA-Z0-9+/]{2}==|[a-zA-Z0-9+/]{3}=)?$/.test(c6)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: salt missing/not base64");
        if (!h8 || !/^[1-9][0-9]*$/.test(h8)) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: missing/invalid iteration count");
        if (!u7.startsWith(n7.clientNonce)) throw new Error(
          "SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce does not start with client nonce"
        );
        if (u7.length === n7.clientNonce.length) throw new Error("SASL: SCRAM-SERVER-FIRST-MESSAGE: server nonce is too short");
        let l7 = parseInt(h8, 10), d7 = y6.from(c6, "base64"), b9 = new TextEncoder(), C6 = b9.encode(i8), B3 = await g9.subtle.importKey("raw", C6, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]), j7 = new Uint8Array(await g9.subtle.sign("HMAC", B3, y6.concat([d7, y6.from(
          [0, 0, 0, 1]
        )]))), X4 = j7;
        for (var pe2 = 0; pe2 < l7 - 1; pe2++) j7 = new Uint8Array(await g9.subtle.sign(
          "HMAC",
          B3,
          j7
        )), X4 = y6.from(X4.map((K4, k9) => X4[k9] ^ j7[k9]));
        let A5 = X4, w10 = await g9.subtle.importKey(
          "raw",
          A5,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        ), P5 = new Uint8Array(await g9.subtle.sign("HMAC", w10, b9.encode("Client Key"))), V2 = await g9.subtle.digest(
          "SHA-256",
          P5
        ), O6 = "n=*,r=" + n7.clientNonce, W4 = "r=" + u7 + ",s=" + c6 + ",i=" + l7, ae = "c=biws,r=" + u7, ee3 = O6 + "," + W4 + "," + ae, R5 = await g9.subtle.importKey(
          "raw",
          V2,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        );
        var G4 = new Uint8Array(await g9.subtle.sign("HMAC", R5, b9.encode(ee3))), ue = y6.from(P5.map((K4, k9) => P5[k9] ^ G4[k9])), de2 = ue.toString("base64");
        let Ee2 = await g9.subtle.importKey(
          "raw",
          A5,
          { name: "HMAC", hash: { name: "SHA-256" } },
          false,
          ["sign"]
        ), ce3 = await g9.subtle.sign(
          "HMAC",
          Ee2,
          b9.encode("Server Key")
        ), Ce3 = await g9.subtle.importKey("raw", ce3, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]);
        var ye3 = y6.from(await g9.subtle.sign(
          "HMAC",
          Ce3,
          b9.encode(ee3)
        ));
        n7.message = "SASLResponse", n7.serverSignature = ye3.toString("base64"), n7.response = ae + ",p=" + de2, this.connection.sendSCRAMClientFinalMessage(this.saslSession.response);
      }
    };
    a8(_n5, "NeonClient");
    vn5 = _n5;
    a8(Hc, "promisify");
    An3 = class An4 extends Pt2.Pool {
      constructor() {
        super(...arguments);
        _6(this, "Client", vn5);
        _6(this, "hasFetchUnsupportedListeners", false);
      }
      on(t6, n7) {
        return t6 !== "error" && (this.hasFetchUnsupportedListeners = true), super.on(t6, n7);
      }
      query(t6, n7, i8) {
        if (!Ae5.poolQueryViaFetch || this.hasFetchUnsupportedListeners || typeof t6 == "function")
          return super.query(t6, n7, i8);
        typeof n7 == "function" && (i8 = n7, n7 = void 0);
        let s10 = Hc(
          this.Promise,
          i8
        );
        i8 = s10.callback;
        try {
          let o9 = new eo2.default(this.options), u7 = encodeURIComponent, c6 = encodeURI, h8 = `postgresql://${u7(o9.user)}:${u7(o9.password)}@${u7(o9.host)}/${c6(o9.database)}`, l7 = typeof t6 == "string" ? t6 : t6.text, d7 = n7 ?? t6.values ?? [];
          Js3(h8, { fullResults: true, arrayMode: t6.rowMode === "array" })(l7, d7, { types: t6.types ?? this.options?.types }).then((C6) => i8(void 0, C6)).catch((C6) => i8(
            C6
          ));
        } catch (o9) {
          i8(o9);
        }
        return s10.result;
      }
    };
    a8(An3, "NeonPool");
    Xs2 = An3;
    export_ClientBase3 = je3.ClientBase;
    export_Connection3 = je3.Connection;
    export_DatabaseError3 = je3.DatabaseError;
    export_Query3 = je3.Query;
    export_defaults3 = je3.defaults;
    export_types3 = je3.types;
  }
});

// ../drizzle-orm/dist/neon-serverless/session.js
var _a475, _b347, NeonPreparedQuery, _a476, _b348, _NeonSession, NeonSession, _a477, _b349, _NeonTransaction, NeonTransaction;
var init_session10 = __esm({
  "../drizzle-orm/dist/neon-serverless/session.js"() {
    "use strict";
    init_serverless3();
    init_cache();
    init_entity();
    init_logger();
    init_pg_core();
    init_session2();
    init_sql();
    init_utils();
    NeonPreparedQuery = class extends (_b347 = PgPreparedQuery, _a475 = entityKind, _b347) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, name3, _isResponseInArrayMode, customResultMapper) {
        super({ sql: queryString, params }, cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQueryConfig");
        __publicField(this, "queryConfig");
        this.client = client;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
        this.rawQueryConfig = {
          name: name3,
          text: queryString,
          types: {
            // @ts-ignore
            getTypeParser: (typeId, format2) => {
              if (typeId === export_types3.builtins.TIMESTAMPTZ) {
                return (val2) => val2;
              }
              if (typeId === export_types3.builtins.TIMESTAMP) {
                return (val2) => val2;
              }
              if (typeId === export_types3.builtins.DATE) {
                return (val2) => val2;
              }
              if (typeId === export_types3.builtins.INTERVAL) {
                return (val2) => val2;
              }
              if (typeId === 1231) {
                return (val2) => val2;
              }
              if (typeId === 1115) {
                return (val2) => val2;
              }
              if (typeId === 1185) {
                return (val2) => val2;
              }
              if (typeId === 1187) {
                return (val2) => val2;
              }
              if (typeId === 1182) {
                return (val2) => val2;
              }
              return export_types3.getTypeParser(typeId, format2);
            }
          }
        };
        this.queryConfig = {
          name: name3,
          text: queryString,
          rowMode: "array",
          types: {
            // @ts-ignore
            getTypeParser: (typeId, format2) => {
              if (typeId === export_types3.builtins.TIMESTAMPTZ) {
                return (val2) => val2;
              }
              if (typeId === export_types3.builtins.TIMESTAMP) {
                return (val2) => val2;
              }
              if (typeId === export_types3.builtins.DATE) {
                return (val2) => val2;
              }
              if (typeId === export_types3.builtins.INTERVAL) {
                return (val2) => val2;
              }
              if (typeId === 1231) {
                return (val2) => val2;
              }
              if (typeId === 1115) {
                return (val2) => val2;
              }
              if (typeId === 1185) {
                return (val2) => val2;
              }
              if (typeId === 1187) {
                return (val2) => val2;
              }
              if (typeId === 1182) {
                return (val2) => val2;
              }
              return export_types3.getTypeParser(typeId, format2);
            }
          }
        };
      }
      async execute(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQueryConfig.text, params);
        const { fields, client, rawQueryConfig: rawQuery, queryConfig: query, joinsNotNullableMap, customResultMapper } = this;
        if (!fields && !customResultMapper) {
          return await this.queryWithCache(rawQuery.text, params, async () => {
            return await client.query(rawQuery, params);
          });
        }
        const result = await this.queryWithCache(query.text, params, async () => {
          return await client.query(query, params);
        });
        return customResultMapper ? customResultMapper(result.rows) : result.rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      all(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQueryConfig.text, params);
        return this.queryWithCache(this.rawQueryConfig.text, params, async () => {
          return await this.client.query(this.rawQueryConfig, params);
        }).then((result) => result.rows);
      }
      values(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQueryConfig.text, params);
        return this.queryWithCache(this.queryConfig.text, params, async () => {
          return await this.client.query(this.queryConfig, params);
        }).then((result) => result.rows);
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(NeonPreparedQuery, _a475, "NeonPreparedQuery");
    _NeonSession = class _NeonSession extends (_b348 = PgSession, _a476 = entityKind, _b348) {
      constructor(client, dialect6, schema6, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, name3, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return new NeonPreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          name3,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      async query(query, params) {
        this.logger.logQuery(query, params);
        const result = await this.client.query({
          rowMode: "array",
          text: query,
          values: params
        });
        return result;
      }
      async queryObjects(query, params) {
        return this.client.query(query, params);
      }
      async count(sql22) {
        const res = await this.execute(sql22);
        return Number(
          res["rows"][0]["count"]
        );
      }
      async transaction(transaction, config = {}) {
        const session = this.client instanceof Xs2 ? new _NeonSession(await this.client.connect(), this.dialect, this.schema, this.options) : this;
        const tx = new NeonTransaction(this.dialect, session, this.schema);
        await tx.execute(sql`begin ${tx.getTransactionConfigSQL(config)}`);
        try {
          const result = await transaction(tx);
          await tx.execute(sql`commit`);
          return result;
        } catch (error2) {
          await tx.execute(sql`rollback`);
          throw error2;
        } finally {
          if (this.client instanceof Xs2) {
            session.client.release();
          }
        }
      }
    };
    __publicField(_NeonSession, _a476, "NeonSession");
    NeonSession = _NeonSession;
    _NeonTransaction = class _NeonTransaction extends (_b349 = PgTransaction, _a477 = entityKind, _b349) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _NeonTransaction(this.dialect, this.session, this.schema, this.nestedIndex + 1);
        await tx.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await tx.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (e6) {
          await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw e6;
        }
      }
    };
    __publicField(_NeonTransaction, _a477, "NeonTransaction");
    NeonTransaction = _NeonTransaction;
  }
});

// ../drizzle-orm/dist/neon-serverless/driver.js
function construct6(client, config = {}) {
  const dialect6 = new PgDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const driver2 = new NeonDriver(client, dialect6, { logger: logger2, cache: config.cache });
  const session = driver2.createSession(schema6);
  const db2 = new NeonDatabase(dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function drizzle6(...params) {
  if (typeof params[0] === "string") {
    const instance2 = new Xs2({
      connectionString: params[0]
    });
    return construct6(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ws: ws4, ...drizzleConfig } = params[0];
    if (ws4) {
      Ae5.webSocketConstructor = ws4;
    }
    if (client) return construct6(client, drizzleConfig);
    const instance2 = typeof connection2 === "string" ? new Xs2({
      connectionString: connection2
    }) : new Xs2(connection2);
    return construct6(instance2, drizzleConfig);
  }
  return construct6(params[0], params[1]);
}
var _a478, NeonDriver, _a479, _b350, NeonDatabase;
var init_driver6 = __esm({
  "../drizzle-orm/dist/neon-serverless/driver.js"() {
    "use strict";
    init_serverless3();
    init_entity();
    init_logger();
    init_db2();
    init_dialect2();
    init_relations();
    init_utils();
    init_session10();
    _a478 = entityKind;
    NeonDriver = class {
      constructor(client, dialect6, options = {}) {
        this.client = client;
        this.dialect = dialect6;
        this.options = options;
      }
      createSession(schema6) {
        return new NeonSession(this.client, this.dialect, schema6, {
          logger: this.options.logger,
          cache: this.options.cache
        });
      }
    };
    __publicField(NeonDriver, _a478, "NeonDriver");
    NeonDatabase = class extends (_b350 = PgDatabase, _a479 = entityKind, _b350) {
    };
    __publicField(NeonDatabase, _a479, "NeonServerlessDatabase");
    ((drizzle22) => {
      function mock(config) {
        return construct6({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle6 || (drizzle6 = {}));
  }
});

// ../drizzle-orm/dist/neon-serverless/index.js
var neon_serverless_exports = {};
__export(neon_serverless_exports, {
  NeonDatabase: () => NeonDatabase,
  NeonDriver: () => NeonDriver,
  NeonPreparedQuery: () => NeonPreparedQuery,
  NeonSession: () => NeonSession,
  NeonTransaction: () => NeonTransaction,
  drizzle: () => drizzle6
});
var init_neon_serverless = __esm({
  "../drizzle-orm/dist/neon-serverless/index.js"() {
    "use strict";
    init_driver6();
    init_session10();
  }
});

// ../drizzle-orm/dist/neon-serverless/migrator.js
var migrator_exports6 = {};
__export(migrator_exports6, {
  migrate: () => migrate6
});
async function migrate6(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator7 = __esm({
  "../drizzle-orm/dist/neon-serverless/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/chars.js
var require_chars = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/chars.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.$v = exports2.$s = exports2.$r = exports2.$p = exports2.$o = exports2.$n = exports2.$m = exports2.$j = exports2.$b = exports2.$Z = exports2.$Y = exports2.$X = exports2.$V = exports2.$T = exports2.$S = exports2.$R = exports2.$Q = exports2.$P = exports2.$O = exports2.$M = exports2.$L = exports2.$K = exports2.$I = exports2.$H = exports2.$E = exports2.$D = exports2.$C = exports2.$A = exports2.$1 = exports2.$0 = void 0;
    exports2.ord = ord;
    exports2.chr = chr;
    exports2.$0 = ord("0");
    exports2.$1 = ord("1");
    exports2.$A = ord("A");
    exports2.$C = ord("C");
    exports2.$D = ord("D");
    exports2.$E = ord("E");
    exports2.$H = ord("H");
    exports2.$I = ord("I");
    exports2.$K = ord("K");
    exports2.$L = ord("L");
    exports2.$M = ord("M");
    exports2.$O = ord("O");
    exports2.$P = ord("P");
    exports2.$Q = ord("Q");
    exports2.$R = ord("R");
    exports2.$S = ord("S");
    exports2.$T = ord("T");
    exports2.$V = ord("V");
    exports2.$X = ord("X");
    exports2.$Y = ord("Y");
    exports2.$Z = ord("Z");
    exports2.$b = ord("b");
    exports2.$j = ord("j");
    exports2.$m = ord("m");
    exports2.$n = ord("n");
    exports2.$o = ord("o");
    exports2.$p = ord("p");
    exports2.$r = ord("r");
    exports2.$s = ord("s");
    exports2.$v = ord("v");
    function ord(str) {
      const ch = str.charCodeAt(0);
      if (ch <= 0 || ch >= 255) {
        throw new TypeError(`char "${ch}" is outside ASCII`);
      }
      return ch & 255;
    }
    function chr(ch) {
      if (ch <= 0 || ch >= 255) {
        throw new TypeError(`char "${ch}" is outside ASCII`);
      }
      return String.fromCharCode(ch);
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/buffer.js
var require_buffer = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/buffer.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ReadBuffer = exports2.ReadMessageBuffer = exports2.WriteMessageBuffer = exports2.WriteBuffer = exports2.BufferError = exports2.encodeB64 = exports2.decodeB64 = exports2.utf8Decoder = exports2.utf8Encoder = void 0;
    exports2.uuidToBuffer = uuidToBuffer;
    var chars = __importStar(require_chars());
    exports2.utf8Encoder = new TextEncoder();
    exports2.utf8Decoder = new TextDecoder("utf8");
    var decodeB64;
    var encodeB64;
    if (typeof Buffer === "function") {
      exports2.decodeB64 = decodeB64 = (b64) => {
        return Buffer.from(b64, "base64");
      };
      exports2.encodeB64 = encodeB64 = (data) => {
        const buf = !Buffer.isBuffer(data) ? Buffer.from(data.buffer, data.byteOffset, data.byteLength) : data;
        return buf.toString("base64");
      };
    } else {
      exports2.decodeB64 = decodeB64 = (b64) => {
        const binaryString = atob(b64);
        const size2 = binaryString.length;
        const bytes2 = new Uint8Array(size2);
        for (let i8 = 0; i8 < size2; i8++) {
          bytes2[i8] = binaryString.charCodeAt(i8);
        }
        return bytes2;
      };
      exports2.encodeB64 = encodeB64 = (data) => {
        const binaryString = String.fromCharCode(...data);
        return btoa(binaryString);
      };
    }
    var BUFFER_INC_SIZE = 4096;
    var EMPTY_BUFFER = new Uint8Array(0);
    var BufferError = class extends Error {
    };
    exports2.BufferError = BufferError;
    var WriteBuffer = class {
      constructor() {
        __publicField(this, "_rawBuffer");
        __publicField(this, "buffer");
        __publicField(this, "size");
        __publicField(this, "pos");
        this.size = BUFFER_INC_SIZE;
        this.pos = 0;
        this._rawBuffer = new Uint8Array(this.size);
        this.buffer = new DataView(this._rawBuffer.buffer);
      }
      get position() {
        return this.pos;
      }
      reset() {
        this.pos = 0;
      }
      ensureAlloced(extraLength) {
        const newSize = this.pos + extraLength;
        if (newSize > this.size) {
          this.__realloc(newSize);
        }
      }
      __realloc(newSize) {
        newSize += BUFFER_INC_SIZE;
        const newBuffer = new Uint8Array(newSize);
        newBuffer.set(this._rawBuffer);
        this._rawBuffer = newBuffer;
        this.buffer = new DataView(this._rawBuffer.buffer);
        this.size = newSize;
      }
      writeChar(ch) {
        this.ensureAlloced(1);
        this.buffer.setUint8(this.pos, ch);
        this.pos++;
        return this;
      }
      writeString(s10) {
        return this.writeBytes(exports2.utf8Encoder.encode(s10));
      }
      writeBytes(buf) {
        this.ensureAlloced(buf.length + 4);
        this.buffer.setInt32(this.pos, buf.length);
        this.pos += 4;
        this._rawBuffer.set(buf, this.pos);
        this.pos += buf.length;
        return this;
      }
      writeInt16(i8) {
        this.ensureAlloced(2);
        this.buffer.setInt16(this.pos, i8);
        this.pos += 2;
        return this;
      }
      writeInt32(i8) {
        this.ensureAlloced(4);
        this.buffer.setInt32(this.pos, i8);
        this.pos += 4;
        return this;
      }
      writeFloat32(i8) {
        this.ensureAlloced(4);
        this.buffer.setFloat32(this.pos, i8);
        this.pos += 4;
        return this;
      }
      writeFloat64(i8) {
        this.ensureAlloced(8);
        this.buffer.setFloat64(this.pos, i8);
        this.pos += 8;
        return this;
      }
      writeUInt8(i8) {
        this.ensureAlloced(1);
        this.buffer.setUint8(this.pos, i8);
        this.pos += 1;
        return this;
      }
      writeUInt16(i8) {
        this.ensureAlloced(2);
        this.buffer.setUint16(this.pos, i8);
        this.pos += 2;
        return this;
      }
      writeUInt32(i8) {
        this.ensureAlloced(4);
        this.buffer.setUint32(this.pos, i8);
        this.pos += 4;
        return this;
      }
      writeInt64(i8) {
        this.ensureAlloced(8);
        const hi3 = Math.floor(i8 / 4294967296);
        const lo = i8 - hi3 * 4294967296;
        this.buffer.setInt32(this.pos, hi3);
        this.buffer.setUint32(this.pos + 4, lo);
        this.pos += 8;
        return this;
      }
      writeBigInt64(i8) {
        let ii3 = i8;
        if (ii3 < 0n) {
          ii3 = 18446744073709551616n + i8;
        }
        const hi3 = ii3 >> 32n;
        const lo = ii3 & 0xffffffffn;
        this.writeUInt32(Number(hi3));
        this.writeUInt32(Number(lo));
        return this;
      }
      writeBuffer(buf) {
        const len = buf.length;
        this.ensureAlloced(len);
        this._rawBuffer.set(buf, this.pos);
        this.pos += len;
        return this;
      }
      writeDeferredSize() {
        const startPos = this.pos;
        this.writeInt32(0);
        return () => {
          this.buffer.setInt32(startPos, this.pos - (startPos + 4));
        };
      }
      unwrap() {
        return this._rawBuffer.subarray(0, this.pos);
      }
    };
    exports2.WriteBuffer = WriteBuffer;
    var WriteMessageBuffer = class {
      constructor() {
        __publicField(this, "buffer");
        __publicField(this, "messagePos");
        this.messagePos = -1;
        this.buffer = new WriteBuffer();
      }
      reset() {
        this.messagePos = -1;
        this.buffer.reset();
        return this;
      }
      beginMessage(mtype) {
        if (this.messagePos >= 0) {
          throw new BufferError("cannot begin a new message: the previous message is not finished");
        }
        this.messagePos = this.buffer.position;
        this.buffer.writeChar(mtype);
        this.buffer.writeInt32(0);
        return this;
      }
      endMessage() {
        if (this.messagePos < 0) {
          throw new BufferError("cannot end the message: no current message");
        }
        this.buffer.buffer.setInt32(this.messagePos + 1, this.buffer.position - this.messagePos - 1);
        this.messagePos = -1;
        return this;
      }
      writeChar(ch) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeChar: no current message");
        }
        this.buffer.writeChar(ch);
        return this;
      }
      writeString(s10) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeString: no current message");
        }
        this.buffer.writeString(s10);
        return this;
      }
      writeBytes(val2) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeBytes: no current message");
        }
        this.buffer.writeBytes(val2);
        return this;
      }
      writeInt16(i8) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeInt16: no current message");
        }
        this.buffer.writeInt16(i8);
        return this;
      }
      writeInt32(i8) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeInt32: no current message");
        }
        this.buffer.writeInt32(i8);
        return this;
      }
      writeUInt16(i8) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeInt16: no current message");
        }
        this.buffer.writeUInt16(i8);
        return this;
      }
      writeUInt32(i8) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeInt32: no current message");
        }
        this.buffer.writeUInt32(i8);
        return this;
      }
      writeBigInt64(i8) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeChar: no current message");
        }
        this.buffer.writeBigInt64(i8);
        return this;
      }
      writeFlags(h8, l7) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeChar: no current message");
        }
        this.buffer.writeUInt32(h8);
        this.buffer.writeUInt32(l7);
        return this;
      }
      writeBuffer(buf) {
        if (this.messagePos < 0) {
          throw new BufferError("cannot writeBuffer: no current message");
        }
        this.buffer.writeBuffer(buf);
        return this;
      }
      writeSync() {
        if (this.messagePos >= 0) {
          throw new BufferError("cannot writeSync: the previous message is not finished");
        }
        this.buffer.writeBuffer(SYNC_MESSAGE);
        return this;
      }
      writeFlush() {
        if (this.messagePos >= 0) {
          throw new BufferError("cannot writeFlush: the previous message is not finished");
        }
        this.buffer.writeBuffer(FLUSH_MESSAGE);
        return this;
      }
      unwrap() {
        if (this.messagePos >= 0) {
          throw new BufferError("cannot unwrap: an unfinished message is in the buffer");
        }
        return this.buffer.unwrap();
      }
    };
    exports2.WriteMessageBuffer = WriteMessageBuffer;
    var SYNC_MESSAGE = new WriteMessageBuffer().beginMessage(chars.$S).endMessage().unwrap();
    var FLUSH_MESSAGE = new WriteMessageBuffer().beginMessage(chars.$H).endMessage().unwrap();
    var byteToHex2 = [];
    for (let i8 = 0; i8 < 256; ++i8) {
      byteToHex2.push((i8 + 256).toString(16).slice(1));
    }
    function uuidToBuffer(uuid2) {
      const buf = new Uint8Array(16);
      for (let i8 = 0; i8 < 16; i8++) {
        buf[i8] = parseInt(uuid2.slice(i8 * 2, i8 * 2 + 2), 16);
      }
      return buf;
    }
    var ReadMessageBuffer = class {
      constructor() {
        __publicField(this, "bufs");
        __publicField(this, "len");
        __publicField(this, "buf0");
        __publicField(this, "pos0");
        __publicField(this, "len0");
        __publicField(this, "curMessageType");
        __publicField(this, "curMessageLen");
        __publicField(this, "curMessageLenUnread");
        __publicField(this, "curMessageReady");
        this.bufs = [];
        this.buf0 = null;
        this.pos0 = 0;
        this.len0 = 0;
        this.len = 0;
        this.curMessageType = 0;
        this.curMessageLen = 0;
        this.curMessageLenUnread = 0;
        this.curMessageReady = false;
      }
      get length() {
        return this.len;
      }
      feed(buf) {
        if (this.buf0 == null || this.pos0 === this.len0 && this.bufs.length === 0) {
          this.buf0 = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
          this.len0 = buf.byteLength;
          this.pos0 = 0;
          this.len = this.len0;
        } else {
          this.feedEnqueue(buf);
        }
      }
      feedEnqueue(buf) {
        this.bufs.push(buf);
        this.len += buf.byteLength;
      }
      ensureFirstBuf() {
        if (this.pos0 === this.len0) {
          this.__nextBuf();
        }
        const buf0 = this.buf0;
        if (buf0 == null || buf0.byteLength < 1) {
          throw new BufferError("empty buffer");
        }
        return buf0;
      }
      checkOverread(size2) {
        if (this.curMessageLenUnread < size2 || size2 > this.len) {
          throw new BufferError("buffer overread");
        }
      }
      __nextBuf() {
        const nextBuf = this.bufs.shift();
        if (nextBuf == null) {
          throw new BufferError("buffer overread");
        }
        this.buf0 = new DataView(nextBuf.buffer, nextBuf.byteOffset, nextBuf.byteLength);
        this.pos0 = 0;
        this.len0 = nextBuf.byteLength;
      }
      discardBuffer(size2) {
        this.ensureFirstBuf();
        while (true) {
          if (this.pos0 + size2 > this.len0) {
            const nread = this.len0 - this.pos0;
            this.pos0 = this.len0;
            this.len -= nread;
            size2 -= nread;
            this.ensureFirstBuf();
          } else {
            this.pos0 += size2;
            this.len -= size2;
            break;
          }
        }
      }
      _finishMessage() {
        this.curMessageLen = 0;
        this.curMessageLenUnread = 0;
        this.curMessageReady = false;
        this.curMessageType = 0;
      }
      __readBufferCopy(buf0, size2) {
        const ret = new Uint8Array(size2);
        let retPos = 0;
        while (true) {
          if (this.pos0 + size2 > this.len0) {
            const nread = this.len0 - this.pos0;
            ret.set(new Uint8Array(buf0.buffer, buf0.byteOffset + this.pos0, nread), retPos);
            retPos += nread;
            this.pos0 = this.len0;
            this.len -= nread;
            size2 -= nread;
            buf0 = this.ensureFirstBuf();
          } else {
            ret.set(new Uint8Array(buf0.buffer, buf0.byteOffset + this.pos0, size2), retPos);
            this.pos0 += size2;
            this.len -= size2;
            break;
          }
        }
        return ret;
      }
      _readBuffer(size2) {
        if (size2 === 0) {
          return EMPTY_BUFFER;
        }
        const buf0 = this.ensureFirstBuf();
        if (this.pos0 + size2 <= this.len0) {
          const ret = new Uint8Array(buf0.buffer, buf0.byteOffset + this.pos0, size2);
          this.pos0 += size2;
          this.len -= size2;
          return ret;
        }
        return this.__readBufferCopy(buf0, size2);
      }
      readBuffer(size2) {
        this.checkOverread(size2);
        const buf = this._readBuffer(size2);
        this.curMessageLenUnread -= size2;
        return buf;
      }
      readUUID() {
        const buf = this.readBuffer(16);
        return byteToHex2[buf[0]] + byteToHex2[buf[1]] + byteToHex2[buf[2]] + byteToHex2[buf[3]] + byteToHex2[buf[4]] + byteToHex2[buf[5]] + byteToHex2[buf[6]] + byteToHex2[buf[7]] + byteToHex2[buf[8]] + byteToHex2[buf[9]] + byteToHex2[buf[10]] + byteToHex2[buf[11]] + byteToHex2[buf[12]] + byteToHex2[buf[13]] + byteToHex2[buf[14]] + byteToHex2[buf[15]];
      }
      readChar() {
        this.checkOverread(1);
        const buf0 = this.ensureFirstBuf();
        const ret = buf0.getUint8(this.pos0);
        this.pos0++;
        this.curMessageLenUnread--;
        this.len--;
        return ret;
      }
      readInt16() {
        this.checkOverread(2);
        const buf0 = this.ensureFirstBuf();
        if (this.pos0 + 2 <= this.len0) {
          const ret = buf0.getInt16(this.pos0);
          this.pos0 += 2;
          this.curMessageLenUnread -= 2;
          this.len -= 2;
          return ret;
        }
        const buf = this._readBuffer(2);
        this.curMessageLenUnread -= 2;
        return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getInt16(0);
      }
      readInt32() {
        this.checkOverread(4);
        const buf0 = this.ensureFirstBuf();
        if (this.pos0 + 4 <= this.len0) {
          const ret = buf0.getInt32(this.pos0);
          this.pos0 += 4;
          this.curMessageLenUnread -= 4;
          this.len -= 4;
          return ret;
        }
        const buf = this._readBuffer(4);
        this.curMessageLenUnread -= 4;
        return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getInt32(0);
      }
      readUInt16() {
        this.checkOverread(2);
        const buf0 = this.ensureFirstBuf();
        if (this.pos0 + 2 <= this.len0) {
          const ret = buf0.getUint16(this.pos0);
          this.pos0 += 2;
          this.curMessageLenUnread -= 2;
          this.len -= 2;
          return ret;
        }
        const buf = this._readBuffer(2);
        this.curMessageLenUnread -= 2;
        return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint16(0);
      }
      readUInt32() {
        this.checkOverread(4);
        const buf0 = this.ensureFirstBuf();
        if (this.pos0 + 4 <= this.len0) {
          const ret = buf0.getUint32(this.pos0);
          this.pos0 += 4;
          this.curMessageLenUnread -= 4;
          this.len -= 4;
          return ret;
        }
        const buf = this._readBuffer(4);
        this.curMessageLenUnread -= 4;
        return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getUint32(0);
      }
      readBigInt64() {
        this.checkOverread(8);
        const buf0 = this.ensureFirstBuf();
        if (this.pos0 + 8 <= this.len0) {
          const ret = buf0.getBigInt64(this.pos0);
          this.pos0 += 8;
          this.curMessageLenUnread -= 8;
          this.len -= 8;
          return ret;
        }
        const buf = this._readBuffer(8);
        this.curMessageLenUnread -= 8;
        return new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getBigInt64(0);
      }
      readString() {
        const len = this.readInt32();
        const buf = this.readBuffer(len);
        return exports2.utf8Decoder.decode(buf);
      }
      readLenPrefixedBuffer() {
        const len = this.readInt32();
        return this.readBuffer(len);
      }
      takeMessage() {
        if (this.curMessageReady) {
          return true;
        }
        if (this.curMessageType === 0) {
          if (this.len < 1) {
            return false;
          }
          const buf0 = this.ensureFirstBuf();
          this.curMessageType = buf0.getUint8(this.pos0);
          this.pos0++;
          this.len--;
        }
        if (this.curMessageLen === 0) {
          if (this.len < 4) {
            return false;
          }
          const buf0 = this.ensureFirstBuf();
          if (this.pos0 + 4 <= this.len0) {
            this.curMessageLen = buf0.getInt32(this.pos0);
            this.pos0 += 4;
            this.len -= 4;
          } else {
            const buf = this._readBuffer(4);
            this.curMessageLen = new DataView(buf.buffer, buf.byteOffset, buf.byteLength).getInt32(0);
          }
          this.curMessageLenUnread = this.curMessageLen - 4;
        }
        if (this.len < this.curMessageLenUnread) {
          return false;
        }
        this.curMessageReady = true;
        return true;
      }
      getMessageType() {
        return this.curMessageType;
      }
      takeMessageType(mtype) {
        if (this.curMessageReady) {
          return this.curMessageType === mtype;
        }
        if (this.len >= 1) {
          const buf0 = this.ensureFirstBuf();
          const unreadMessageType = buf0.getUint8(this.pos0);
          return mtype === unreadMessageType && this.takeMessage();
        }
        return false;
      }
      putMessage() {
        if (!this.curMessageReady) {
          throw new BufferError("cannot put message: no message taken");
        }
        if (this.curMessageLenUnread !== this.curMessageLen - 4) {
          throw new BufferError("cannot put message: message is partially read");
        }
        this.curMessageReady = false;
      }
      discardMessage() {
        if (!this.curMessageReady) {
          throw new BufferError("no message to discard");
        }
        if (this.curMessageLenUnread > 0) {
          this.discardBuffer(this.curMessageLenUnread);
        }
        this._finishMessage();
      }
      consumeMessage() {
        if (!this.curMessageReady) {
          throw new BufferError("no message to consume");
        }
        let buf;
        if (this.curMessageLenUnread > 0) {
          buf = this._readBuffer(this.curMessageLenUnread);
          this.curMessageLenUnread = 0;
        } else {
          buf = EMPTY_BUFFER;
        }
        this._finishMessage();
        return buf;
      }
      consumeMessageInto(frb) {
        if (!this.curMessageReady) {
          throw new BufferError("no message to consume");
        }
        if (this.curMessageLenUnread > 0) {
          if (this.pos0 + this.curMessageLenUnread <= this.len0) {
            ReadBuffer.init(frb, new Uint8Array(this.buf0.buffer, this.buf0.byteOffset + this.pos0, this.curMessageLenUnread));
            this.pos0 += this.curMessageLenUnread;
            this.len -= this.curMessageLenUnread;
          } else {
            const buf = this._readBuffer(this.curMessageLenUnread);
            ReadBuffer.init(frb, buf);
          }
          this.curMessageLenUnread = 0;
        } else {
          ReadBuffer.init(frb, EMPTY_BUFFER);
        }
        this._finishMessage();
      }
      finishMessage() {
        if (this.curMessageType === 0 || !this.curMessageReady) {
          return;
        }
        if (this.curMessageLenUnread) {
          throw new BufferError(`cannot finishMessage: unread data in message "${chars.chr(this.curMessageType)}"`);
        }
        this._finishMessage();
      }
    };
    exports2.ReadMessageBuffer = ReadMessageBuffer;
    var ReadBuffer = class {
      constructor(buf) {
        __publicField(this, "_rawBuffer");
        __publicField(this, "buffer");
        __publicField(this, "pos");
        __publicField(this, "len");
        this._rawBuffer = buf;
        this.buffer = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
        this.len = buf.length;
        this.pos = 0;
      }
      get position() {
        return this.pos;
      }
      get length() {
        return this.len - this.pos;
      }
      finish(message) {
        if (this.len !== this.pos) {
          throw new BufferError(message ?? "unexpected trailing data in buffer");
        }
      }
      discard(size2) {
        if (this.pos + size2 > this.len) {
          throw new BufferError("buffer overread");
        }
        this.pos += size2;
      }
      readUInt8() {
        if (this.pos + 1 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getUint8(this.pos);
        this.pos++;
        return num;
      }
      readUInt16() {
        if (this.pos + 2 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getUint16(this.pos);
        this.pos += 2;
        return num;
      }
      readInt8() {
        if (this.pos + 1 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getInt8(this.pos);
        this.pos++;
        return num;
      }
      readInt16() {
        if (this.pos + 2 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getInt16(this.pos);
        this.pos += 2;
        return num;
      }
      readInt32() {
        if (this.pos + 4 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getInt32(this.pos);
        this.pos += 4;
        return num;
      }
      readFloat32() {
        if (this.pos + 4 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getFloat32(this.pos);
        this.pos += 4;
        return num;
      }
      readFloat64(le2) {
        if (this.pos + 8 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getFloat64(this.pos, le2);
        this.pos += 8;
        return num;
      }
      readUInt32(le2) {
        if (this.pos + 4 > this.len) {
          throw new BufferError("buffer overread");
        }
        const num = this.buffer.getUint32(this.pos, le2);
        this.pos += 4;
        return num;
      }
      reportInt64Overflow(hi3, lo) {
        const bhi = BigInt(hi3);
        const blo = BigInt(lo >>> 0);
        const num = bhi * BigInt(4294967296) + blo;
        throw new BufferError(`integer overflow: cannot unpack <std::int64>'${num.toString()}' into JavaScript Number type without losing precision`);
      }
      readInt64() {
        if (this.pos + 8 > this.len) {
          throw new BufferError("buffer overread");
        }
        const hi3 = this.buffer.getInt32(this.pos);
        const lo = this.buffer.getInt32(this.pos + 4);
        this.pos += 8;
        if (hi3 === 0) {
          return lo >>> 0;
        } else if (hi3 >= -2097152 && hi3 < 2097152) {
          return hi3 * 4294967296 + (lo >>> 0);
        }
        return this.reportInt64Overflow(hi3, lo);
      }
      readBigInt64() {
        if (this.pos + 8 > this.len) {
          throw new BufferError("buffer overread");
        }
        const ret = this.buffer.getBigInt64(this.pos);
        this.pos += 8;
        return ret;
      }
      readBoolean() {
        return this.readUInt8() !== 0;
      }
      readBuffer(size2) {
        if (this.pos + size2 > this.len) {
          throw new BufferError("buffer overread");
        }
        const buf = this._rawBuffer.subarray(this.pos, this.pos + size2);
        this.pos += size2;
        return buf;
      }
      readUUIDBytes() {
        return this.readBuffer(16);
      }
      readUUID(dash = "") {
        if (this.pos + 16 > this.len) {
          throw new BufferError("buffer overread");
        }
        const buf = this._rawBuffer;
        const pos = this.pos;
        const uuid2 = byteToHex2[buf[pos + 0]] + byteToHex2[buf[pos + 1]] + byteToHex2[buf[pos + 2]] + byteToHex2[buf[pos + 3]] + dash + byteToHex2[buf[pos + 4]] + byteToHex2[buf[pos + 5]] + dash + byteToHex2[buf[pos + 6]] + byteToHex2[buf[pos + 7]] + dash + byteToHex2[buf[pos + 8]] + byteToHex2[buf[pos + 9]] + dash + byteToHex2[buf[pos + 10]] + byteToHex2[buf[pos + 11]] + byteToHex2[buf[pos + 12]] + byteToHex2[buf[pos + 13]] + byteToHex2[buf[pos + 14]] + byteToHex2[buf[pos + 15]];
        this.pos += 16;
        return uuid2;
      }
      readString() {
        const len = this.readUInt32();
        const buf = this.readBuffer(len);
        return exports2.utf8Decoder.decode(buf);
      }
      consumeAsString() {
        if (this.pos === this.len) {
          return "";
        }
        const res = exports2.utf8Decoder.decode(this._rawBuffer.subarray(this.pos, this.len));
        this.pos = this.len;
        return res;
      }
      consumeAsBuffer() {
        const res = this._rawBuffer.subarray(this.pos, this.len);
        this.pos = this.len;
        return res;
      }
      sliceInto(frb, size2) {
        if (this.pos + size2 > this.len) {
          throw new BufferError("buffer overread");
        }
        frb._rawBuffer = this._rawBuffer;
        frb.buffer = this.buffer;
        frb.pos = this.pos;
        frb.len = this.pos + size2;
        this.pos += size2;
      }
      static init(frb, buffer2) {
        frb._rawBuffer = buffer2;
        frb.buffer = new DataView(buffer2.buffer, buffer2.byteOffset, buffer2.byteLength);
        frb.pos = 0;
        frb.len = buffer2.byteLength;
      }
      static alloc() {
        return new this(EMPTY_BUFFER);
      }
    };
    exports2.ReadBuffer = ReadBuffer;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/base.js
var require_base = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/base.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ErrorAttr = exports2.GelError = void 0;
    exports2.prettyPrintError = prettyPrintError;
    var buffer_1 = require_buffer();
    var GelError = class extends Error {
      constructor(message, options) {
        super(void 0, options);
        __publicField(this, "_message");
        __publicField(this, "_query");
        __publicField(this, "_attrs");
        Object.defineProperties(this, {
          _message: { writable: true, enumerable: false },
          _query: { writable: true, enumerable: false },
          _attrs: { writable: true, enumerable: false }
        });
        this._message = message ?? "";
      }
      get message() {
        return this._message + (this._query && this._attrs ? prettyPrintError(this._attrs, this._query) : "");
      }
      get name() {
        return this.constructor.name;
      }
      hasTag(tag) {
        const error_type = this.constructor;
        return error_type.tags[tag] ?? false;
      }
    };
    __publicField(GelError, "tags", {});
    exports2.GelError = GelError;
    var ErrorAttr;
    (function(ErrorAttr2) {
      ErrorAttr2[ErrorAttr2["hint"] = 1] = "hint";
      ErrorAttr2[ErrorAttr2["details"] = 2] = "details";
      ErrorAttr2[ErrorAttr2["serverTraceback"] = 257] = "serverTraceback";
      ErrorAttr2[ErrorAttr2["positionStart"] = -15] = "positionStart";
      ErrorAttr2[ErrorAttr2["positionEnd"] = -14] = "positionEnd";
      ErrorAttr2[ErrorAttr2["lineStart"] = -13] = "lineStart";
      ErrorAttr2[ErrorAttr2["columnStart"] = -12] = "columnStart";
      ErrorAttr2[ErrorAttr2["utf16ColumnStart"] = -11] = "utf16ColumnStart";
      ErrorAttr2[ErrorAttr2["lineEnd"] = -10] = "lineEnd";
      ErrorAttr2[ErrorAttr2["columnEnd"] = -9] = "columnEnd";
      ErrorAttr2[ErrorAttr2["utf16ColumnEnd"] = -8] = "utf16ColumnEnd";
      ErrorAttr2[ErrorAttr2["characterStart"] = -7] = "characterStart";
      ErrorAttr2[ErrorAttr2["characterEnd"] = -6] = "characterEnd";
    })(ErrorAttr || (exports2.ErrorAttr = ErrorAttr = {}));
    function tryParseInt(val2) {
      if (val2 == null)
        return null;
      try {
        return parseInt(val2 instanceof Uint8Array ? buffer_1.utf8Decoder.decode(val2) : val2, 10);
      } catch {
        return null;
      }
    }
    function readAttrStr(val2) {
      return val2 instanceof Uint8Array ? buffer_1.utf8Decoder.decode(val2) : val2 ?? "";
    }
    function prettyPrintError(attrs, query) {
      let errMessage = "\n";
      const lineStart = tryParseInt(attrs.get(ErrorAttr.lineStart));
      const lineEnd = tryParseInt(attrs.get(ErrorAttr.lineEnd));
      const colStart = tryParseInt(attrs.get(ErrorAttr.utf16ColumnStart));
      const colEnd = tryParseInt(attrs.get(ErrorAttr.utf16ColumnEnd));
      if (lineStart != null && lineEnd != null && colStart != null && colEnd != null) {
        const queryLines = query.split("\n");
        const lineNoWidth = lineEnd.toString().length;
        errMessage += "|".padStart(lineNoWidth + 3) + "\n";
        for (let i8 = lineStart; i8 < lineEnd + 1; i8++) {
          const line2 = queryLines[i8 - 1];
          const start2 = i8 === lineStart ? colStart : 0;
          const end = i8 === lineEnd ? colEnd : line2.length;
          errMessage += ` ${i8.toString().padStart(lineNoWidth)} | ${line2}
`;
          errMessage += `${"|".padStart(lineNoWidth + 3)} ${"".padStart(end - start2, "^").padStart(end)}
`;
        }
      }
      if (attrs.has(ErrorAttr.details)) {
        errMessage += `Details: ${readAttrStr(attrs.get(ErrorAttr.details))}
`;
      }
      if (attrs.has(ErrorAttr.hint)) {
        errMessage += `Hint: ${readAttrStr(attrs.get(ErrorAttr.hint))}
`;
      }
      return errMessage;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/tags.js
var require_tags = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/tags.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SHOULD_RETRY = exports2.SHOULD_RECONNECT = void 0;
    exports2.SHOULD_RECONNECT = Symbol("SHOULD_RECONNECT");
    exports2.SHOULD_RETRY = Symbol("SHOULD_RETRY");
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/index.js
var require_errors = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __exportStar = exports2 && exports2.__exportStar || function(m12, exports3) {
      for (var p11 in m12) if (p11 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p11)) __createBinding(exports3, m12, p11);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DuplicatePropertyDefinitionError = exports2.DuplicateLinkDefinitionError = exports2.DuplicateModuleDefinitionError = exports2.DuplicateDefinitionError = exports2.InvalidCastDefinitionError = exports2.InvalidConstraintDefinitionError = exports2.InvalidFunctionDefinitionError = exports2.InvalidAliasDefinitionError = exports2.InvalidOperatorDefinitionError = exports2.InvalidDatabaseDefinitionError = exports2.InvalidUserDefinitionError = exports2.InvalidPropertyDefinitionError = exports2.InvalidLinkDefinitionError = exports2.InvalidModuleDefinitionError = exports2.InvalidDefinitionError = exports2.SchemaDefinitionError = exports2.SchemaError = exports2.DeprecatedScopingError = exports2.UnknownParameterError = exports2.UnknownDatabaseError = exports2.UnknownUserError = exports2.UnknownPropertyError = exports2.UnknownLinkError = exports2.UnknownModuleError = exports2.InvalidReferenceError = exports2.InvalidPropertyTargetError = exports2.InvalidLinkTargetError = exports2.InvalidTargetError = exports2.InvalidTypeError = exports2.GraphQLSyntaxError = exports2.SchemaSyntaxError = exports2.EdgeQLSyntaxError = exports2.InvalidSyntaxError = exports2.QueryError = exports2.UnsafeIsolationLevelError = exports2.DisabledCapabilityError = exports2.UnsupportedCapabilityError = exports2.CapabilityError = exports2.ResultCardinalityMismatchError = exports2.StateMismatchError = exports2.ParameterTypeMismatchError = exports2.InputDataError = exports2.UnexpectedMessageError = exports2.TypeSpecNotFoundError = exports2.UnsupportedProtocolVersionError = exports2.BinaryProtocolError = exports2.ProtocolError = exports2.UnsupportedFeatureError = exports2.InternalServerError = exports2.GelError = void 0;
    exports2.QueryArgumentError = exports2.InterfaceError = exports2.ClientConnectionClosedError = exports2.ClientConnectionTimeoutError = exports2.ClientConnectionFailedTemporarilyError = exports2.ClientConnectionFailedError = exports2.ClientConnectionError = exports2.ClientError = exports2.MigrationStatusMessage = exports2.StatusMessage = exports2.WarningMessage = exports2.LogMessage = exports2.UnsupportedBackendFeatureError = exports2.BackendError = exports2.ServerBlockedError = exports2.UnknownTenantError = exports2.ServerOfflineError = exports2.BackendUnavailableError = exports2.AvailabilityError = exports2.AuthenticationError = exports2.AccessError = exports2.ConfigurationError = exports2.WatchError = exports2.TransactionDeadlockError = exports2.TransactionSerializationError = exports2.TransactionConflictError = exports2.TransactionError = exports2.MissingRequiredError = exports2.CardinalityViolationError = exports2.ConstraintViolationError = exports2.IntegrityError = exports2.QueryAssertionError = exports2.AccessPolicyError = exports2.NumericOutOfRangeError = exports2.DivisionByZeroError = exports2.InvalidValueError = exports2.ExecutionError = exports2.IdleTransactionTimeoutError = exports2.TransactionTimeoutError = exports2.QueryTimeoutError = exports2.IdleSessionTimeoutError = exports2.SessionTimeoutError = exports2.DuplicateMigrationError = exports2.DuplicateCastDefinitionError = exports2.DuplicateConstraintDefinitionError = exports2.DuplicateFunctionDefinitionError = exports2.DuplicateViewDefinitionError = exports2.DuplicateOperatorDefinitionError = exports2.DuplicateDatabaseDefinitionError = exports2.DuplicateUserDefinitionError = void 0;
    exports2.InternalClientError = exports2.NoDataError = exports2.InvalidArgumentError = exports2.UnknownArgumentError = exports2.MissingArgumentError = void 0;
    var base_1 = require_base();
    var tags = __importStar(require_tags());
    var base_2 = require_base();
    Object.defineProperty(exports2, "GelError", { enumerable: true, get: function() {
      return base_2.GelError;
    } });
    __exportStar(require_tags(), exports2);
    var InternalServerError = class extends base_1.GelError {
      get code() {
        return 16777216;
      }
    };
    exports2.InternalServerError = InternalServerError;
    var UnsupportedFeatureError = class extends base_1.GelError {
      get code() {
        return 33554432;
      }
    };
    exports2.UnsupportedFeatureError = UnsupportedFeatureError;
    var ProtocolError = class extends base_1.GelError {
      get code() {
        return 50331648;
      }
    };
    exports2.ProtocolError = ProtocolError;
    var BinaryProtocolError = class extends ProtocolError {
      get code() {
        return 50397184;
      }
    };
    exports2.BinaryProtocolError = BinaryProtocolError;
    var UnsupportedProtocolVersionError = class extends BinaryProtocolError {
      get code() {
        return 50397185;
      }
    };
    exports2.UnsupportedProtocolVersionError = UnsupportedProtocolVersionError;
    var TypeSpecNotFoundError = class extends BinaryProtocolError {
      get code() {
        return 50397186;
      }
    };
    exports2.TypeSpecNotFoundError = TypeSpecNotFoundError;
    var UnexpectedMessageError = class extends BinaryProtocolError {
      get code() {
        return 50397187;
      }
    };
    exports2.UnexpectedMessageError = UnexpectedMessageError;
    var InputDataError = class extends ProtocolError {
      get code() {
        return 50462720;
      }
    };
    exports2.InputDataError = InputDataError;
    var ParameterTypeMismatchError = class extends InputDataError {
      get code() {
        return 50462976;
      }
    };
    exports2.ParameterTypeMismatchError = ParameterTypeMismatchError;
    var StateMismatchError = class extends InputDataError {
      get code() {
        return 50463232;
      }
    };
    __publicField(StateMismatchError, "tags", { [tags.SHOULD_RETRY]: true });
    exports2.StateMismatchError = StateMismatchError;
    var ResultCardinalityMismatchError = class extends ProtocolError {
      get code() {
        return 50528256;
      }
    };
    exports2.ResultCardinalityMismatchError = ResultCardinalityMismatchError;
    var CapabilityError = class extends ProtocolError {
      get code() {
        return 50593792;
      }
    };
    exports2.CapabilityError = CapabilityError;
    var UnsupportedCapabilityError = class extends CapabilityError {
      get code() {
        return 50594048;
      }
    };
    exports2.UnsupportedCapabilityError = UnsupportedCapabilityError;
    var DisabledCapabilityError = class extends CapabilityError {
      get code() {
        return 50594304;
      }
    };
    exports2.DisabledCapabilityError = DisabledCapabilityError;
    var UnsafeIsolationLevelError = class extends CapabilityError {
      get code() {
        return 50594560;
      }
    };
    exports2.UnsafeIsolationLevelError = UnsafeIsolationLevelError;
    var QueryError = class extends base_1.GelError {
      get code() {
        return 67108864;
      }
    };
    exports2.QueryError = QueryError;
    var InvalidSyntaxError = class extends QueryError {
      get code() {
        return 67174400;
      }
    };
    exports2.InvalidSyntaxError = InvalidSyntaxError;
    var EdgeQLSyntaxError = class extends InvalidSyntaxError {
      get code() {
        return 67174656;
      }
    };
    exports2.EdgeQLSyntaxError = EdgeQLSyntaxError;
    var SchemaSyntaxError = class extends InvalidSyntaxError {
      get code() {
        return 67174912;
      }
    };
    exports2.SchemaSyntaxError = SchemaSyntaxError;
    var GraphQLSyntaxError = class extends InvalidSyntaxError {
      get code() {
        return 67175168;
      }
    };
    exports2.GraphQLSyntaxError = GraphQLSyntaxError;
    var InvalidTypeError = class extends QueryError {
      get code() {
        return 67239936;
      }
    };
    exports2.InvalidTypeError = InvalidTypeError;
    var InvalidTargetError = class extends InvalidTypeError {
      get code() {
        return 67240192;
      }
    };
    exports2.InvalidTargetError = InvalidTargetError;
    var InvalidLinkTargetError = class extends InvalidTargetError {
      get code() {
        return 67240193;
      }
    };
    exports2.InvalidLinkTargetError = InvalidLinkTargetError;
    var InvalidPropertyTargetError = class extends InvalidTargetError {
      get code() {
        return 67240194;
      }
    };
    exports2.InvalidPropertyTargetError = InvalidPropertyTargetError;
    var InvalidReferenceError = class extends QueryError {
      get code() {
        return 67305472;
      }
    };
    exports2.InvalidReferenceError = InvalidReferenceError;
    var UnknownModuleError = class extends InvalidReferenceError {
      get code() {
        return 67305473;
      }
    };
    exports2.UnknownModuleError = UnknownModuleError;
    var UnknownLinkError = class extends InvalidReferenceError {
      get code() {
        return 67305474;
      }
    };
    exports2.UnknownLinkError = UnknownLinkError;
    var UnknownPropertyError = class extends InvalidReferenceError {
      get code() {
        return 67305475;
      }
    };
    exports2.UnknownPropertyError = UnknownPropertyError;
    var UnknownUserError = class extends InvalidReferenceError {
      get code() {
        return 67305476;
      }
    };
    exports2.UnknownUserError = UnknownUserError;
    var UnknownDatabaseError = class extends InvalidReferenceError {
      get code() {
        return 67305477;
      }
    };
    exports2.UnknownDatabaseError = UnknownDatabaseError;
    var UnknownParameterError = class extends InvalidReferenceError {
      get code() {
        return 67305478;
      }
    };
    exports2.UnknownParameterError = UnknownParameterError;
    var DeprecatedScopingError = class extends InvalidReferenceError {
      get code() {
        return 67305479;
      }
    };
    exports2.DeprecatedScopingError = DeprecatedScopingError;
    var SchemaError = class extends QueryError {
      get code() {
        return 67371008;
      }
    };
    exports2.SchemaError = SchemaError;
    var SchemaDefinitionError = class extends QueryError {
      get code() {
        return 67436544;
      }
    };
    exports2.SchemaDefinitionError = SchemaDefinitionError;
    var InvalidDefinitionError = class extends SchemaDefinitionError {
      get code() {
        return 67436800;
      }
    };
    exports2.InvalidDefinitionError = InvalidDefinitionError;
    var InvalidModuleDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436801;
      }
    };
    exports2.InvalidModuleDefinitionError = InvalidModuleDefinitionError;
    var InvalidLinkDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436802;
      }
    };
    exports2.InvalidLinkDefinitionError = InvalidLinkDefinitionError;
    var InvalidPropertyDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436803;
      }
    };
    exports2.InvalidPropertyDefinitionError = InvalidPropertyDefinitionError;
    var InvalidUserDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436804;
      }
    };
    exports2.InvalidUserDefinitionError = InvalidUserDefinitionError;
    var InvalidDatabaseDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436805;
      }
    };
    exports2.InvalidDatabaseDefinitionError = InvalidDatabaseDefinitionError;
    var InvalidOperatorDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436806;
      }
    };
    exports2.InvalidOperatorDefinitionError = InvalidOperatorDefinitionError;
    var InvalidAliasDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436807;
      }
    };
    exports2.InvalidAliasDefinitionError = InvalidAliasDefinitionError;
    var InvalidFunctionDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436808;
      }
    };
    exports2.InvalidFunctionDefinitionError = InvalidFunctionDefinitionError;
    var InvalidConstraintDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436809;
      }
    };
    exports2.InvalidConstraintDefinitionError = InvalidConstraintDefinitionError;
    var InvalidCastDefinitionError = class extends InvalidDefinitionError {
      get code() {
        return 67436810;
      }
    };
    exports2.InvalidCastDefinitionError = InvalidCastDefinitionError;
    var DuplicateDefinitionError = class extends SchemaDefinitionError {
      get code() {
        return 67437056;
      }
    };
    exports2.DuplicateDefinitionError = DuplicateDefinitionError;
    var DuplicateModuleDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437057;
      }
    };
    exports2.DuplicateModuleDefinitionError = DuplicateModuleDefinitionError;
    var DuplicateLinkDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437058;
      }
    };
    exports2.DuplicateLinkDefinitionError = DuplicateLinkDefinitionError;
    var DuplicatePropertyDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437059;
      }
    };
    exports2.DuplicatePropertyDefinitionError = DuplicatePropertyDefinitionError;
    var DuplicateUserDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437060;
      }
    };
    exports2.DuplicateUserDefinitionError = DuplicateUserDefinitionError;
    var DuplicateDatabaseDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437061;
      }
    };
    exports2.DuplicateDatabaseDefinitionError = DuplicateDatabaseDefinitionError;
    var DuplicateOperatorDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437062;
      }
    };
    exports2.DuplicateOperatorDefinitionError = DuplicateOperatorDefinitionError;
    var DuplicateViewDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437063;
      }
    };
    exports2.DuplicateViewDefinitionError = DuplicateViewDefinitionError;
    var DuplicateFunctionDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437064;
      }
    };
    exports2.DuplicateFunctionDefinitionError = DuplicateFunctionDefinitionError;
    var DuplicateConstraintDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437065;
      }
    };
    exports2.DuplicateConstraintDefinitionError = DuplicateConstraintDefinitionError;
    var DuplicateCastDefinitionError = class extends DuplicateDefinitionError {
      get code() {
        return 67437066;
      }
    };
    exports2.DuplicateCastDefinitionError = DuplicateCastDefinitionError;
    var DuplicateMigrationError = class extends DuplicateDefinitionError {
      get code() {
        return 67437067;
      }
    };
    exports2.DuplicateMigrationError = DuplicateMigrationError;
    var SessionTimeoutError = class extends QueryError {
      get code() {
        return 67502080;
      }
    };
    exports2.SessionTimeoutError = SessionTimeoutError;
    var IdleSessionTimeoutError = class extends SessionTimeoutError {
      get code() {
        return 67502336;
      }
    };
    __publicField(IdleSessionTimeoutError, "tags", { [tags.SHOULD_RETRY]: true });
    exports2.IdleSessionTimeoutError = IdleSessionTimeoutError;
    var QueryTimeoutError = class extends SessionTimeoutError {
      get code() {
        return 67502592;
      }
    };
    exports2.QueryTimeoutError = QueryTimeoutError;
    var TransactionTimeoutError = class extends SessionTimeoutError {
      get code() {
        return 67504640;
      }
    };
    exports2.TransactionTimeoutError = TransactionTimeoutError;
    var IdleTransactionTimeoutError = class extends TransactionTimeoutError {
      get code() {
        return 67504641;
      }
    };
    exports2.IdleTransactionTimeoutError = IdleTransactionTimeoutError;
    var ExecutionError = class extends base_1.GelError {
      get code() {
        return 83886080;
      }
    };
    exports2.ExecutionError = ExecutionError;
    var InvalidValueError = class extends ExecutionError {
      get code() {
        return 83951616;
      }
    };
    exports2.InvalidValueError = InvalidValueError;
    var DivisionByZeroError = class extends InvalidValueError {
      get code() {
        return 83951617;
      }
    };
    exports2.DivisionByZeroError = DivisionByZeroError;
    var NumericOutOfRangeError = class extends InvalidValueError {
      get code() {
        return 83951618;
      }
    };
    exports2.NumericOutOfRangeError = NumericOutOfRangeError;
    var AccessPolicyError = class extends InvalidValueError {
      get code() {
        return 83951619;
      }
    };
    exports2.AccessPolicyError = AccessPolicyError;
    var QueryAssertionError = class extends InvalidValueError {
      get code() {
        return 83951620;
      }
    };
    exports2.QueryAssertionError = QueryAssertionError;
    var IntegrityError = class extends ExecutionError {
      get code() {
        return 84017152;
      }
    };
    exports2.IntegrityError = IntegrityError;
    var ConstraintViolationError = class extends IntegrityError {
      get code() {
        return 84017153;
      }
    };
    exports2.ConstraintViolationError = ConstraintViolationError;
    var CardinalityViolationError = class extends IntegrityError {
      get code() {
        return 84017154;
      }
    };
    exports2.CardinalityViolationError = CardinalityViolationError;
    var MissingRequiredError = class extends IntegrityError {
      get code() {
        return 84017155;
      }
    };
    exports2.MissingRequiredError = MissingRequiredError;
    var TransactionError = class extends ExecutionError {
      get code() {
        return 84082688;
      }
    };
    exports2.TransactionError = TransactionError;
    var TransactionConflictError = class extends TransactionError {
      get code() {
        return 84082944;
      }
    };
    __publicField(TransactionConflictError, "tags", { [tags.SHOULD_RETRY]: true });
    exports2.TransactionConflictError = TransactionConflictError;
    var TransactionSerializationError = class extends TransactionConflictError {
      get code() {
        return 84082945;
      }
    };
    __publicField(TransactionSerializationError, "tags", { [tags.SHOULD_RETRY]: true });
    exports2.TransactionSerializationError = TransactionSerializationError;
    var TransactionDeadlockError = class extends TransactionConflictError {
      get code() {
        return 84082946;
      }
    };
    __publicField(TransactionDeadlockError, "tags", { [tags.SHOULD_RETRY]: true });
    exports2.TransactionDeadlockError = TransactionDeadlockError;
    var WatchError = class extends ExecutionError {
      get code() {
        return 84148224;
      }
    };
    exports2.WatchError = WatchError;
    var ConfigurationError = class extends base_1.GelError {
      get code() {
        return 100663296;
      }
    };
    exports2.ConfigurationError = ConfigurationError;
    var AccessError = class extends base_1.GelError {
      get code() {
        return 117440512;
      }
    };
    exports2.AccessError = AccessError;
    var AuthenticationError = class extends AccessError {
      get code() {
        return 117506048;
      }
    };
    exports2.AuthenticationError = AuthenticationError;
    var AvailabilityError = class extends base_1.GelError {
      get code() {
        return 134217728;
      }
    };
    exports2.AvailabilityError = AvailabilityError;
    var BackendUnavailableError = class extends AvailabilityError {
      get code() {
        return 134217729;
      }
    };
    __publicField(BackendUnavailableError, "tags", { [tags.SHOULD_RETRY]: true });
    exports2.BackendUnavailableError = BackendUnavailableError;
    var ServerOfflineError = class extends AvailabilityError {
      get code() {
        return 134217730;
      }
    };
    __publicField(ServerOfflineError, "tags", {
      [tags.SHOULD_RECONNECT]: true,
      [tags.SHOULD_RETRY]: true
    });
    exports2.ServerOfflineError = ServerOfflineError;
    var UnknownTenantError = class extends AvailabilityError {
      get code() {
        return 134217731;
      }
    };
    __publicField(UnknownTenantError, "tags", {
      [tags.SHOULD_RECONNECT]: true,
      [tags.SHOULD_RETRY]: true
    });
    exports2.UnknownTenantError = UnknownTenantError;
    var ServerBlockedError = class extends AvailabilityError {
      get code() {
        return 134217732;
      }
    };
    exports2.ServerBlockedError = ServerBlockedError;
    var BackendError = class extends base_1.GelError {
      get code() {
        return 150994944;
      }
    };
    exports2.BackendError = BackendError;
    var UnsupportedBackendFeatureError = class extends BackendError {
      get code() {
        return 150995200;
      }
    };
    exports2.UnsupportedBackendFeatureError = UnsupportedBackendFeatureError;
    var LogMessage = class extends base_1.GelError {
      get code() {
        return 4026531840;
      }
    };
    exports2.LogMessage = LogMessage;
    var WarningMessage = class extends LogMessage {
      get code() {
        return 4026597376;
      }
    };
    exports2.WarningMessage = WarningMessage;
    var StatusMessage = class extends LogMessage {
      get code() {
        return 4026662912;
      }
    };
    exports2.StatusMessage = StatusMessage;
    var MigrationStatusMessage = class extends StatusMessage {
      get code() {
        return 4026662913;
      }
    };
    exports2.MigrationStatusMessage = MigrationStatusMessage;
    var ClientError2 = class extends base_1.GelError {
      get code() {
        return 4278190080;
      }
    };
    exports2.ClientError = ClientError2;
    var ClientConnectionError = class extends ClientError2 {
      get code() {
        return 4278255616;
      }
    };
    exports2.ClientConnectionError = ClientConnectionError;
    var ClientConnectionFailedError = class extends ClientConnectionError {
      get code() {
        return 4278255872;
      }
    };
    exports2.ClientConnectionFailedError = ClientConnectionFailedError;
    var ClientConnectionFailedTemporarilyError = class extends ClientConnectionFailedError {
      get code() {
        return 4278255873;
      }
    };
    __publicField(ClientConnectionFailedTemporarilyError, "tags", {
      [tags.SHOULD_RECONNECT]: true,
      [tags.SHOULD_RETRY]: true
    });
    exports2.ClientConnectionFailedTemporarilyError = ClientConnectionFailedTemporarilyError;
    var ClientConnectionTimeoutError = class extends ClientConnectionError {
      get code() {
        return 4278256128;
      }
    };
    __publicField(ClientConnectionTimeoutError, "tags", {
      [tags.SHOULD_RECONNECT]: true,
      [tags.SHOULD_RETRY]: true
    });
    exports2.ClientConnectionTimeoutError = ClientConnectionTimeoutError;
    var ClientConnectionClosedError = class extends ClientConnectionError {
      get code() {
        return 4278256384;
      }
    };
    __publicField(ClientConnectionClosedError, "tags", {
      [tags.SHOULD_RECONNECT]: true,
      [tags.SHOULD_RETRY]: true
    });
    exports2.ClientConnectionClosedError = ClientConnectionClosedError;
    var InterfaceError = class extends ClientError2 {
      get code() {
        return 4278321152;
      }
    };
    exports2.InterfaceError = InterfaceError;
    var QueryArgumentError = class extends InterfaceError {
      get code() {
        return 4278321408;
      }
    };
    exports2.QueryArgumentError = QueryArgumentError;
    var MissingArgumentError = class extends QueryArgumentError {
      get code() {
        return 4278321409;
      }
    };
    exports2.MissingArgumentError = MissingArgumentError;
    var UnknownArgumentError = class extends QueryArgumentError {
      get code() {
        return 4278321410;
      }
    };
    exports2.UnknownArgumentError = UnknownArgumentError;
    var InvalidArgumentError = class extends QueryArgumentError {
      get code() {
        return 4278321411;
      }
    };
    exports2.InvalidArgumentError = InvalidArgumentError;
    var NoDataError = class extends ClientError2 {
      get code() {
        return 4278386688;
      }
    };
    exports2.NoDataError = NoDataError;
    var InternalClientError = class extends ClientError2 {
      get code() {
        return 4278452224;
      }
    };
    exports2.InternalClientError = InternalClientError;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/lru.js
var require_lru = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/lru.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var errors_1 = require_errors();
    var Node3 = class {
      constructor(key, value) {
        __publicField(this, "key");
        __publicField(this, "value");
        __publicField(this, "next");
        __publicField(this, "prev");
        this.key = key;
        this.value = value;
        this.next = null;
        this.prev = null;
      }
    };
    var Deque = class {
      constructor() {
        __publicField(this, "head");
        __publicField(this, "tail");
        __publicField(this, "len");
        this.head = null;
        this.tail = null;
        this.len = 0;
      }
      get length() {
        return this.len;
      }
      push(key, value) {
        const node = new Node3(key, value);
        if (this.head == null) {
          this.head = node;
          this.tail = node;
        } else {
          this.head.prev = node;
          node.next = this.head;
          this.head = node;
        }
        this.len++;
        return node;
      }
      moveToTop(node) {
        if (node.prev == null) {
          return;
        }
        const prev = node.prev;
        const next = node.next;
        prev.next = next;
        if (next != null) {
          next.prev = prev;
        }
        if (this.tail === node) {
          this.tail = prev;
        }
        node.prev = null;
        node.next = this.head;
        this.head.prev = node;
        this.head = node;
      }
      deleteBottom() {
        if (!this.len || !this.tail || !this.head) {
          return null;
        }
        if (this.tail === this.head) {
          this.len = 0;
          const node = this.tail;
          this.tail = null;
          this.head = null;
          return node;
        }
        const tail = this.tail;
        const beforeLast = this.tail.prev;
        beforeLast.next = null;
        this.tail.prev = null;
        this.tail.next = null;
        this.tail = beforeLast;
        this.len--;
        return tail;
      }
    };
    var LRU = class {
      constructor({ capacity }) {
        __publicField(this, "capacity");
        __publicField(this, "map");
        __publicField(this, "deque");
        if (capacity <= 0) {
          throw new TypeError("capacity is expected to be greater than 0");
        }
        this.capacity = capacity;
        this.map = /* @__PURE__ */ new Map();
        this.deque = new Deque();
      }
      get length() {
        const len = this.map.size;
        if (len !== this.deque.length) {
          throw new errors_1.InternalClientError("deque & map disagree on elements count");
        }
        return len;
      }
      has(key) {
        return this.map.has(key);
      }
      get(key) {
        const node = this.map.get(key);
        if (node != null) {
          this.deque.moveToTop(node);
          return node.value;
        }
        return void 0;
      }
      set(key, value) {
        const existingNode = this.map.get(key);
        if (existingNode != null) {
          existingNode.value = value;
          this.deque.moveToTop(existingNode);
        } else {
          const newNode = this.deque.push(key, value);
          this.map.set(key, newNode);
          while (this.deque.length > this.capacity) {
            const bottomNode = this.deque.deleteBottom();
            this.map.delete(bottomNode.key);
          }
        }
      }
      *keys() {
        let node = this.deque.head;
        while (node != null) {
          yield node.key;
          node = node.next;
        }
      }
      *entries() {
        let node = this.deque.head;
        while (node != null) {
          yield [node.key, node.value];
          node = node.next;
        }
      }
      *values() {
        let node = this.deque.head;
        while (node != null) {
          yield node.value;
          node = node.next;
        }
      }
    };
    exports2.default = LRU;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/consts.js
var require_consts = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/consts.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.KNOWN_TYPENAMES = exports2.KNOWN_TYPES = exports2.INVALID_CODEC_ID = exports2.NULL_CODEC_ID = void 0;
    exports2.NULL_CODEC_ID = "00000000000000000000000000000000";
    exports2.INVALID_CODEC_ID = "ffffffffffffffffffffffffffffffff";
    exports2.KNOWN_TYPES = /* @__PURE__ */ new Map([
      ["00000000000000000000000000000001", "anytype"],
      ["00000000000000000000000000000002", "anytuple"],
      ["00000000000000000000000000000003", "anyobject"],
      ["000000000000000000000000000000f0", "std"],
      ["000000000000000000000000000000ff", "empty-tuple"],
      ["00000000000000000000000000000100", "std::uuid"],
      ["00000000000000000000000000000101", "std::str"],
      ["00000000000000000000000000000102", "std::bytes"],
      ["00000000000000000000000000000103", "std::int16"],
      ["00000000000000000000000000000104", "std::int32"],
      ["00000000000000000000000000000105", "std::int64"],
      ["00000000000000000000000000000106", "std::float32"],
      ["00000000000000000000000000000107", "std::float64"],
      ["00000000000000000000000000000108", "std::decimal"],
      ["00000000000000000000000000000109", "std::bool"],
      ["0000000000000000000000000000010a", "std::datetime"],
      ["0000000000000000000000000000010b", "cal::local_datetime"],
      ["0000000000000000000000000000010c", "cal::local_date"],
      ["0000000000000000000000000000010d", "cal::local_time"],
      ["0000000000000000000000000000010e", "std::duration"],
      ["0000000000000000000000000000010f", "std::json"],
      ["00000000000000000000000000000110", "std::bigint"],
      ["00000000000000000000000000000111", "cal::relative_duration"],
      ["00000000000000000000000000000112", "cal::date_duration"],
      ["00000000000000000000000000000130", "cfg::memory"],
      ["00000000000000000000000001000001", "std::pg::json"],
      ["00000000000000000000000001000002", "std::pg::timestamptz"],
      ["00000000000000000000000001000003", "std::pg::timestamp"],
      ["00000000000000000000000001000004", "std::pg::date"],
      ["00000000000000000000000001000005", "std::pg::interval"],
      ["9565dd8804f511eea6910b6ebe179825", "ext::pgvector::vector"],
      ["4ba84534188e43b4a7cecea2af0f405b", "ext::pgvector::halfvec"],
      ["003e434dcac2430ab238fb39d73447d2", "ext::pgvector::sparsevec"],
      ["44c901c0d922489483c8061bd05e4840", "ext::postgis::geometry"],
      ["4d7388783a5f4821ab769d8e7d6b32c4", "ext::postgis::geography"],
      ["7fae553663114f608eb9096a5d972f48", "ext::postgis::box2d"],
      ["c1a50ff8fded48b085c24905a8481433", "ext::postgis::box3d"]
    ]);
    exports2.KNOWN_TYPENAMES = (() => {
      const res = /* @__PURE__ */ new Map();
      for (const [id, name3] of exports2.KNOWN_TYPES.entries()) {
        res.set(name3, id);
      }
      return res;
    })();
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/ifaces.js
var require_ifaces = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/ifaces.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ScalarCodec = exports2.Codec = void 0;
    var buffer_1 = require_buffer();
    var consts_1 = require_consts();
    var Codec = class {
      constructor(tid) {
        __publicField(this, "tid");
        __publicField(this, "tidBuffer");
        this.tid = tid;
        this.tidBuffer = (0, buffer_1.uuidToBuffer)(tid);
      }
      getKnownTypeName() {
        return "anytype";
      }
    };
    exports2.Codec = Codec;
    var ScalarCodec = class extends Codec {
      constructor(tid, typeName) {
        super(tid);
        __publicField(this, "typeName");
        __publicField(this, "ancestors", null);
        __publicField(this, "tsType", "unknown");
        __publicField(this, "tsModule", null);
        this.typeName = typeName;
      }
      derive(tid, typeName, ancestors) {
        const self2 = this.constructor;
        const codec = new self2(tid, typeName);
        codec.ancestors = ancestors;
        return codec;
      }
      getSubcodecs() {
        return [];
      }
      getKind() {
        return "scalar";
      }
      getKnownTypeName() {
        if (this.typeName) {
          return this.typeName;
        }
        return consts_1.KNOWN_TYPES.get(this.tid) || "anytype";
      }
    };
    exports2.ScalarCodec = ScalarCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/boolean.js
var require_boolean = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/boolean.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.BoolCodec = void 0;
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    var BoolCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "boolean");
      }
      encode(buf, object2, ctx) {
        const val2 = ctx.preEncode(this, object2);
        const typeOf = typeof val2;
        if (typeOf !== "boolean" && typeOf !== "number") {
          throw new errors_1.InvalidArgumentError(`a boolean or a number was expected, got "${val2}"`);
        }
        buf.writeInt32(1);
        buf.writeChar(val2 ? 1 : 0);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.readUInt8() !== 0);
      }
    };
    exports2.BoolCodec = BoolCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/numbers.js
var require_numbers = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/numbers.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Float64Codec = exports2.Float32Codec = exports2.Int16Codec = exports2.Int32Codec = exports2.Int64Codec = void 0;
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    var Int64Codec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "number");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const val2 = ctx.preEncode(this, object2);
          buf.writeInt32(8);
          buf.writeBigInt64(val2);
          return;
        }
        if (typeof object2 !== "number") {
          throw new errors_1.InvalidArgumentError(`a number was expected, got "${object2}"`);
        }
        buf.writeInt32(8);
        buf.writeInt64(object2);
      }
      decode(buf, ctx) {
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, buf.readBigInt64());
        }
        return buf.readInt64();
      }
    };
    exports2.Int64Codec = Int64Codec;
    var Int32Codec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "number");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (typeof object2 !== "number") {
          throw new errors_1.InvalidArgumentError(`a number was expected, got "${object2}"`);
        }
        buf.writeInt32(4);
        buf.writeInt32(object2);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.readInt32());
      }
    };
    exports2.Int32Codec = Int32Codec;
    var Int16Codec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "number");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (typeof object2 !== "number") {
          throw new errors_1.InvalidArgumentError(`a number was expected, got "${object2}"`);
        }
        buf.writeInt32(2);
        buf.writeInt16(object2);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.readInt16());
      }
    };
    exports2.Int16Codec = Int16Codec;
    var Float32Codec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "number");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (typeof object2 !== "number") {
          throw new errors_1.InvalidArgumentError(`a number was expected, got "${object2}"`);
        }
        buf.writeInt32(4);
        buf.writeFloat32(object2);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.readFloat32());
      }
    };
    exports2.Float32Codec = Float32Codec;
    var Float64Codec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "number");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (typeof object2 !== "number") {
          throw new errors_1.InvalidArgumentError(`a number was expected, got "${object2}"`);
        }
        buf.writeInt32(8);
        buf.writeFloat64(object2);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.readFloat64());
      }
    };
    exports2.Float64Codec = Float64Codec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/numerics.js
var require_numerics = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/numerics.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DecimalStringCodec = exports2.BigIntCodec = void 0;
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    var NUMERIC_POS = 0;
    var NUMERIC_NEG = 16384;
    var BigIntCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "bigint");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (typeof object2 !== "bigint") {
          throw new errors_1.InvalidArgumentError(`a bigint was expected, got "${object2}"`);
        }
        const digits = [];
        let sign = NUMERIC_POS;
        let uval = object2;
        if (object2 === 0n) {
          buf.writeUInt32(8);
          buf.writeUInt32(0);
          buf.writeUInt16(NUMERIC_POS);
          buf.writeUInt16(0);
          return;
        }
        if (object2 < 0n) {
          sign = NUMERIC_NEG;
          uval = -uval;
        }
        while (uval) {
          const mod = uval % 10000n;
          uval /= 10000n;
          digits.push(mod);
        }
        buf.writeUInt32(8 + digits.length * 2);
        buf.writeUInt16(digits.length);
        buf.writeUInt16(digits.length - 1);
        buf.writeUInt16(sign);
        buf.writeUInt16(0);
        for (let i8 = digits.length - 1; i8 >= 0; i8--) {
          buf.writeUInt16(Number(digits[i8]));
        }
      }
      decode(buf, ctx) {
        const val2 = BigInt(decodeBigIntToString(buf));
        return ctx.postDecode(this, val2);
      }
    };
    exports2.BigIntCodec = BigIntCodec;
    var DecimalStringCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "string");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (typeof object2 !== "string") {
          throw new errors_1.InvalidArgumentError(`a string was expected, got "${object2}"`);
        }
        const match2 = object2.match(/^(-?)([0-9]+)(?:\.([0-9]+))?(?:[eE]([-+]?[0-9]+))?$/);
        if (!match2) {
          throw new errors_1.InvalidArgumentError(`invalid decimal string "${object2}"`);
        }
        const [_7, sign, int3, _frac, _exp] = match2;
        const frac = _frac ?? "";
        const exp = _exp ? parseInt(_exp, 10) : 0;
        const sdigits = int3.padStart(Math.ceil(int3.length / 4) * 4, "0") + frac.padEnd(Math.ceil(frac.length / 4) * 4, "0");
        const digits = [];
        for (let i8 = 0, len = sdigits.length; i8 < len; i8 += 4) {
          digits.push(parseInt(sdigits.slice(i8, i8 + 4), 10));
        }
        buf.writeUInt32(8 + digits.length * 2);
        buf.writeUInt16(digits.length);
        buf.writeInt16(Math.ceil((int3.length + exp) / 4) - 1);
        buf.writeUInt16(sign === "-" ? NUMERIC_NEG : NUMERIC_POS);
        buf.writeUInt16(Math.max(frac.length - exp, 0));
        for (let i8 = 0, len = digits.length; i8 < len; i8++) {
          buf.writeUInt16(digits[i8]);
        }
      }
      decode(buf, ctx) {
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, decodeDecimalToString(buf));
        }
        return decodeDecimalToString(buf);
      }
    };
    exports2.DecimalStringCodec = DecimalStringCodec;
    function decodeBigIntToString(buf) {
      const ndigits = buf.readUInt16();
      const weight = buf.readInt16();
      const sign = buf.readUInt16();
      const dscale = buf.readUInt16();
      let result = "";
      switch (sign) {
        case NUMERIC_POS:
          break;
        case NUMERIC_NEG:
          result += "-";
          break;
        default:
          throw new errors_1.ProtocolError("bad bigint sign data");
      }
      if (dscale !== 0) {
        throw new errors_1.ProtocolError("bigint data has fractional part");
      }
      if (ndigits === 0) {
        return "0";
      }
      let i8 = weight;
      let d7 = 0;
      while (i8 >= 0) {
        if (i8 <= weight && d7 < ndigits) {
          const digit = buf.readUInt16().toString();
          result += d7 > 0 ? digit.padStart(4, "0") : digit;
          d7++;
        } else {
          result += "0000";
        }
        i8--;
      }
      return result;
    }
    function decodeDecimalToString(buf) {
      const ndigits = buf.readUInt16();
      const weight = buf.readInt16();
      const sign = buf.readUInt16();
      const dscale = buf.readUInt16();
      let result = "";
      switch (sign) {
        case NUMERIC_POS:
          break;
        case NUMERIC_NEG:
          result += "-";
          break;
        default:
          throw new errors_1.ProtocolError("bad decimal sign data");
      }
      let d7 = 0;
      if (weight < 0) {
        d7 = weight + 1;
        result += "0";
      } else {
        for (d7 = 0; d7 <= weight; d7++) {
          const digit = d7 < ndigits ? buf.readUInt16() : 0;
          let sdigit = digit.toString();
          if (d7 > 0) {
            sdigit = sdigit.padStart(4, "0");
          }
          result += sdigit;
        }
      }
      if (dscale > 0) {
        result += ".";
        const end = result.length + dscale;
        for (let i8 = 0; i8 < dscale; d7++, i8 += 4) {
          const digit = d7 >= 0 && d7 < ndigits ? buf.readUInt16() : 0;
          result += digit.toString().padStart(4, "0");
        }
        result = result.slice(0, end);
      }
      return result;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/text.js
var require_text = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/text.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StrCodec = void 0;
    var buffer_1 = require_buffer();
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    var StrCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "string");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (typeof object2 !== "string") {
          throw new errors_1.InvalidArgumentError(`a string was expected, got "${object2}"`);
        }
        const val2 = object2;
        const strbuf = buffer_1.utf8Encoder.encode(val2);
        buf.writeInt32(strbuf.length);
        buf.writeBuffer(strbuf);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.consumeAsString());
      }
    };
    exports2.StrCodec = StrCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/uuid.js
var require_uuid = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/uuid.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.UUIDCodec = void 0;
    var buffer_1 = require_buffer();
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    function UUIDBufferFromString(uuid2) {
      let uuidClean = uuid2;
      if (uuidClean.length !== 32) {
        uuidClean = uuidClean.replace(/-/g, "");
        if (uuidClean.length !== 32) {
          throw new TypeError(`invalid UUID "${uuid2}"`);
        }
      }
      try {
        return (0, buffer_1.uuidToBuffer)(uuidClean);
      } catch {
        throw new TypeError(`invalid UUID "${uuid2}"`);
      }
    }
    var UUIDCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "string");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const val2 = ctx.preEncode(this, object2);
          if (!(val2 instanceof Uint8Array)) {
            throw new errors_1.InvalidArgumentError(`a Uint8Array was expected from a custom UUID codec`);
          }
          if (val2.length != 16) {
            throw new errors_1.InvalidArgumentError(`a 16-element long Uint8Array was expected from a custom UUID codec`);
          }
          buf.writeInt32(16);
          buf.writeBuffer(val2);
          return;
        }
        if (typeof object2 === "string") {
          const ubuf = UUIDBufferFromString(object2);
          buf.writeInt32(16);
          buf.writeBuffer(ubuf);
        } else {
          throw new errors_1.InvalidArgumentError(`cannot encode UUID "${object2}": invalid type`);
        }
      }
      decode(buf, ctx) {
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, buf.readUUIDBytes());
        }
        return buf.readUUID("-");
      }
    };
    exports2.UUIDCodec = UUIDCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/bytes.js
var require_bytes = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/bytes.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.BytesCodec = void 0;
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    var BytesCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "Uint8Array");
      }
      encode(buf, object2, ctx) {
        const val2 = ctx.preEncode(this, object2);
        if (!(val2 instanceof Uint8Array)) {
          throw new errors_1.InvalidArgumentError(`a Uint8Array or Buffer was expected, got "${val2}"`);
        }
        buf.writeInt32(val2.length);
        buf.writeBuffer(val2);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.consumeAsBuffer());
      }
    };
    exports2.BytesCodec = BytesCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/json.js
var require_json = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/json.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PgTextJSONStringCodec = exports2.PgTextJSONCodec = exports2.JSONCodec = void 0;
    var buffer_1 = require_buffer();
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    var JSONCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "unknown");
        __publicField(this, "jsonFormat", 1);
      }
      encode(buf, object2, ctx) {
        let val2;
        if (ctx.hasOverload(this)) {
          val2 = ctx.preEncode(this, object2);
        } else {
          try {
            val2 = JSON.stringify(object2);
          } catch (_err) {
            throw new errors_1.InvalidArgumentError(`a JSON-serializable value was expected, got "${object2}"`);
          }
        }
        if (typeof val2 !== "string") {
          throw new errors_1.InvalidArgumentError(`a JSON-serializable value was expected, got "${object2}"`);
        }
        const strbuf = buffer_1.utf8Encoder.encode(val2);
        if (this.jsonFormat !== null) {
          buf.writeInt32(strbuf.length + 1);
          buf.writeChar(this.jsonFormat);
        } else {
          buf.writeInt32(strbuf.length);
        }
        buf.writeBuffer(strbuf);
      }
      decode(buf, ctx) {
        if (this.jsonFormat !== null) {
          const format2 = buf.readUInt8();
          if (format2 !== this.jsonFormat) {
            throw new errors_1.ProtocolError(`unexpected JSON format ${format2}`);
          }
        }
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, buf.consumeAsString());
        } else {
          return JSON.parse(buf.consumeAsString());
        }
      }
    };
    exports2.JSONCodec = JSONCodec;
    var PgTextJSONCodec = class extends JSONCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "jsonFormat", null);
      }
    };
    exports2.PgTextJSONCodec = PgTextJSONCodec;
    var PgTextJSONStringCodec = class extends ifaces_1.ScalarCodec {
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          object2 = ctx.preEncode(this, object2);
        }
        if (typeof object2 !== "string") {
          throw new errors_1.InvalidArgumentError(`a string was expected, got "${object2}"`);
        }
        const strbuf = buffer_1.utf8Encoder.encode(object2);
        buf.writeInt32(strbuf.length);
        buf.writeBuffer(strbuf);
      }
      decode(buf, ctx) {
        return ctx.postDecode(this, buf.consumeAsString());
      }
    };
    exports2.PgTextJSONStringCodec = PgTextJSONStringCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/dateutil.js
var require_dateutil = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/dateutil.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isLeapYear = isLeapYear3;
    exports2.daysInMonth = daysInMonth;
    exports2.daysBeforeMonth = daysBeforeMonth;
    exports2.ymd2ord = ymd2ord;
    exports2.ord2ymd = ord2ymd;
    function isLeapYear3(year3) {
      return year3 % 4 === 0 && (year3 % 100 !== 0 || year3 % 400 === 0);
    }
    function daysInMonth(year3, month) {
      if (month === 2 && isLeapYear3(year3)) {
        return 29;
      }
      return _DAYS_IN_MONTH[month];
    }
    function daysBeforeYear(year3) {
      const y7 = year3 - 1;
      return y7 * 365 + Math.trunc(y7 / 4) - Math.trunc(y7 / 100) + Math.trunc(y7 / 400);
    }
    function daysBeforeMonth(year3, month) {
      return _DAYS_BEFORE_MONTH[month] + (month > 2 && isLeapYear3(year3) ? 1 : 0);
    }
    var _DI400Y = daysBeforeYear(401);
    var _DI100Y = daysBeforeYear(101);
    var _DI4Y = daysBeforeYear(5);
    var _DAYS_IN_MONTH = [-1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
    var _DAYS_BEFORE_MONTH = (() => {
      const dbf = [-1];
      let dbm = 0;
      for (let i8 = 1; i8 < _DAYS_IN_MONTH.length; i8++) {
        const dim = _DAYS_IN_MONTH[i8];
        dbf.push(dbm);
        dbm += dim;
      }
      return dbf;
    })();
    function ymd2ord(year3, month, day) {
      return daysBeforeYear(year3) + daysBeforeMonth(year3, month) + day;
    }
    function divmod(dividend, divisor) {
      const quotient = Math.floor(dividend / divisor);
      return [quotient, dividend - divisor * quotient];
    }
    function ord2ymd(n7) {
      n7--;
      let n400;
      [n400, n7] = divmod(n7, _DI400Y);
      let year3 = n400 * 400 + 1;
      let n100;
      [n100, n7] = divmod(n7, _DI100Y);
      let n42;
      [n42, n7] = divmod(n7, _DI4Y);
      let n1;
      [n1, n7] = divmod(n7, 365);
      year3 += n100 * 100 + n42 * 4 + n1;
      if (n1 === 4 || n100 === 4) {
        return [year3 - 1, 12, 31];
      }
      const leapyear = n1 === 3 && (n42 !== 24 || n100 === 3);
      let month = n7 + 50 >> 5;
      let preceding = _DAYS_BEFORE_MONTH[month] + (month > 2 && leapyear ? 1 : 0);
      if (preceding > n7) {
        month -= 1;
        preceding -= _DAYS_IN_MONTH[month] + (month === 2 && leapyear ? 1 : 0);
      }
      n7 -= preceding;
      return [year3, month, n7 + 1];
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/datetime.js
var require_datetime = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/datetime.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DateDuration = exports2.RelativeDuration = exports2.Duration = exports2.LocalDateTime = exports2.LocalDate = exports2.localDateInstances = exports2.LocalTime = exports2.localTimeInstances = exports2.DATE_PRIVATE = void 0;
    exports2.LocalDateToOrdinal = LocalDateToOrdinal;
    exports2.LocalDateFromOrdinal = LocalDateFromOrdinal;
    exports2.parseHumanDurationString = parseHumanDurationString;
    var dateutil_1 = require_dateutil();
    exports2.DATE_PRIVATE = Symbol.for("gel.datetime");
    function toNumber(val2) {
      const n7 = Number(val2);
      if (Number.isNaN(n7)) {
        return 0;
      }
      return n7;
    }
    function assertInteger(val2) {
      if (!Number.isInteger(val2)) {
        throw new RangeError(`unsupported fractional value ${val2}`);
      }
      return val2;
    }
    exports2.localTimeInstances = /* @__PURE__ */ new WeakMap();
    var LocalTime = class {
      constructor(isoHour = 0, isoMinute = 0, isoSecond = 0, isoMillisecond = 0, isoMicrosecond = 0, isoNanosecond = 0) {
        __publicField(this, "hour");
        __publicField(this, "minute");
        __publicField(this, "second");
        __publicField(this, "millisecond");
        __publicField(this, "microsecond");
        __publicField(this, "nanosecond");
        isoHour = Math.floor(toNumber(isoHour));
        isoMinute = Math.floor(toNumber(isoMinute));
        isoSecond = Math.floor(toNumber(isoSecond));
        isoMillisecond = Math.floor(toNumber(isoMillisecond));
        isoMicrosecond = Math.floor(toNumber(isoMicrosecond));
        isoNanosecond = Math.floor(toNumber(isoNanosecond));
        if (isoHour < 0 || isoHour > 23) {
          throw new RangeError(`invalid number of hours ${isoHour}: expected a value in 0-23 range`);
        }
        if (isoMinute < 0 || isoMinute > 59) {
          throw new RangeError(`invalid number of minutes ${isoMinute}: expected a value in 0-59 range`);
        }
        if (isoSecond < 0 || isoSecond > 59) {
          throw new RangeError(`invalid number of seconds ${isoSecond}: expected a value in 0-59 range`);
        }
        if (isoMillisecond < 0 || isoMillisecond > 999) {
          throw new RangeError(`invalid number of milliseconds ${isoMillisecond}: expected a value in 0-999 range`);
        }
        if (isoMicrosecond < 0 || isoMicrosecond > 999) {
          throw new RangeError(`invalid number of microseconds ${isoMicrosecond}: expected a value in 0-999 range`);
        }
        if (isoNanosecond < 0 || isoNanosecond > 999) {
          throw new RangeError(`invalid number of nanoseconds ${isoNanosecond}: expected a value in 0-999 range`);
        }
        this.hour = isoHour;
        this.minute = isoMinute;
        this.second = isoSecond;
        this.millisecond = isoMillisecond;
        this.microsecond = isoMicrosecond;
        this.nanosecond = isoNanosecond;
        forwardJsonAsToString(this);
        throwOnValueOf(this, "LocalTime");
      }
      toString() {
        const hh = this.hour.toString().padStart(2, "0");
        const mm = this.minute.toString().padStart(2, "0");
        const ss = this.second.toString().padStart(2, "0");
        let repr = `${hh}:${mm}:${ss}`;
        if (this.millisecond || this.microsecond || this.nanosecond) {
          repr += `.${this.millisecond.toString().padStart(3, "0")}${this.microsecond.toString().padStart(3, "0")}${this.nanosecond.toString().padStart(3, "0")}`.replace(/(?:0+)$/, "");
        }
        return repr;
      }
    };
    exports2.LocalTime = LocalTime;
    exports2.localDateInstances = /* @__PURE__ */ new WeakMap();
    var LocalDate = class {
      constructor(isoYear, isoMonth, isoDay) {
        isoYear = Math.trunc(toNumber(isoYear));
        isoMonth = Math.floor(toNumber(isoMonth));
        isoDay = Math.floor(toNumber(isoDay));
        if (isoYear < -271820 || isoYear > 275759) {
          throw new RangeError(`invalid year ${isoYear}: expected a value in -271820-275759 range`);
        }
        if (isoMonth < 1 || isoMonth > 12) {
          throw new RangeError(`invalid month ${isoMonth}: expected a value in 1-12 range`);
        }
        const maxDays = (0, dateutil_1.daysInMonth)(isoYear, isoMonth);
        if (isoDay < 1 || isoDay > maxDays) {
          throw new RangeError(`invalid number of days ${isoDay}: expected a value in 1-${maxDays} range`);
        }
        const date4 = new Date(Date.UTC(isoYear, isoMonth - 1, isoDay));
        if (isoYear >= 0 && isoYear <= 99) {
          date4.setUTCFullYear(isoYear);
        }
        exports2.localDateInstances.set(this, date4);
        forwardJsonAsToString(this);
        throwOnValueOf(this, "LocalDate");
      }
      get year() {
        return exports2.localDateInstances.get(this).getUTCFullYear();
      }
      get month() {
        return exports2.localDateInstances.get(this).getUTCMonth() + 1;
      }
      get day() {
        return exports2.localDateInstances.get(this).getUTCDate();
      }
      get dayOfWeek() {
        return (exports2.localDateInstances.get(this).getUTCDay() + 6) % 7 + 1;
      }
      get dayOfYear() {
        const date4 = exports2.localDateInstances.get(this);
        return (0, dateutil_1.daysBeforeMonth)(date4.getUTCFullYear(), date4.getUTCMonth() + 1) + date4.getUTCDate();
      }
      get daysInWeek() {
        return 7;
      }
      get daysInMonth() {
        const date4 = exports2.localDateInstances.get(this);
        return (0, dateutil_1.daysInMonth)(date4.getUTCFullYear(), date4.getUTCMonth() + 1);
      }
      get daysInYear() {
        return this.inLeapYear ? 366 : 365;
      }
      get monthsInYear() {
        return 12;
      }
      get inLeapYear() {
        return (0, dateutil_1.isLeapYear)(exports2.localDateInstances.get(this).getUTCFullYear());
      }
      toString() {
        const year3 = this.year < 0 || this.year > 9999 ? (this.year < 0 ? "-" : "+") + Math.abs(this.year).toString().padStart(6, "0") : this.year.toString().padStart(4, "0");
        const month = this.month.toString().padStart(2, "0");
        const day = this.day.toString().padStart(2, "0");
        return `${year3}-${month}-${day}`;
      }
    };
    exports2.LocalDate = LocalDate;
    function LocalDateToOrdinal(localdate) {
      return (0, dateutil_1.ymd2ord)(localdate.year, localdate.month, localdate.day);
    }
    function LocalDateFromOrdinal(ordinal) {
      const [year3, month, day] = (0, dateutil_1.ord2ymd)(ordinal);
      return new LocalDate(year3, month, day);
    }
    var LocalDateTime = class extends LocalDate {
      constructor(isoYear, isoMonth, isoDay, isoHour = 0, isoMinute = 0, isoSecond = 0, isoMillisecond = 0, isoMicrosecond = 0, isoNanosecond = 0) {
        super(isoYear, isoMonth, isoDay);
        const time4 = new LocalTime(isoHour, isoMinute, isoSecond, isoMillisecond, isoMicrosecond, isoNanosecond);
        exports2.localTimeInstances.set(this, time4);
        throwOnValueOf(this, "LocalDateTime");
      }
      get hour() {
        return exports2.localTimeInstances.get(this).hour;
      }
      get minute() {
        return exports2.localTimeInstances.get(this).minute;
      }
      get second() {
        return exports2.localTimeInstances.get(this).second;
      }
      get millisecond() {
        return exports2.localTimeInstances.get(this).millisecond;
      }
      get microsecond() {
        return exports2.localTimeInstances.get(this).microsecond;
      }
      get nanosecond() {
        return exports2.localTimeInstances.get(this).nanosecond;
      }
      toString() {
        return `${super.toString()}T${exports2.localTimeInstances.get(this).toString()}`;
      }
    };
    exports2.LocalDateTime = LocalDateTime;
    var durationRegex2 = new RegExp(`^(\\-|\\+)?P(?:(\\d+)Y)?(?:(\\d+)M)?(?:(\\d+)W)?(?:(\\d+)D)?(T(?:(\\d+)(\\.\\d{1,10})?H)?(?:(\\d+)(\\.\\d{1,10})?M)?(?:(\\d+)(\\.\\d{1,9})?S)?)?$`, "i");
    var Duration = class _Duration {
      constructor(years = 0, months = 0, weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0, microseconds = 0, nanoseconds = 0) {
        __publicField(this, "years");
        __publicField(this, "months");
        __publicField(this, "weeks");
        __publicField(this, "days");
        __publicField(this, "hours");
        __publicField(this, "minutes");
        __publicField(this, "seconds");
        __publicField(this, "milliseconds");
        __publicField(this, "microseconds");
        __publicField(this, "nanoseconds");
        __publicField(this, "sign");
        years = assertInteger(toNumber(years));
        months = assertInteger(toNumber(months));
        weeks = assertInteger(toNumber(weeks));
        days = assertInteger(toNumber(days));
        hours = assertInteger(toNumber(hours));
        minutes = assertInteger(toNumber(minutes));
        seconds = assertInteger(toNumber(seconds));
        milliseconds = assertInteger(toNumber(milliseconds));
        microseconds = assertInteger(toNumber(microseconds));
        nanoseconds = assertInteger(toNumber(nanoseconds));
        const fields = [
          years,
          months,
          weeks,
          days,
          hours,
          minutes,
          seconds,
          milliseconds,
          microseconds,
          nanoseconds
        ];
        let sign = 0;
        for (const field of fields) {
          if (field === Infinity || field === -Infinity) {
            throw new RangeError("infinite values not allowed as duration fields");
          }
          const fieldSign = Math.sign(field);
          if (sign && fieldSign && fieldSign !== sign) {
            throw new RangeError("mixed-sign values not allowed as duration fields");
          }
          sign = sign || fieldSign;
        }
        this.years = years || 0;
        this.months = months || 0;
        this.weeks = weeks || 0;
        this.days = days || 0;
        this.hours = hours || 0;
        this.minutes = minutes || 0;
        this.seconds = seconds || 0;
        this.milliseconds = milliseconds || 0;
        this.microseconds = microseconds || 0;
        this.nanoseconds = nanoseconds || 0;
        this.sign = sign || 0;
        forwardJsonAsToString(this);
        throwOnValueOf(this, "TemporalDuration");
      }
      get blank() {
        return this.sign === 0;
      }
      toString() {
        let dateParts = "";
        if (this.years) {
          dateParts += BigInt(Math.abs(this.years)) + "Y";
        }
        if (this.months) {
          dateParts += BigInt(Math.abs(this.months)) + "M";
        }
        if (this.weeks) {
          dateParts += BigInt(Math.abs(this.weeks)) + "W";
        }
        if (this.days) {
          dateParts += BigInt(Math.abs(this.days)) + "D";
        }
        let timeParts = "";
        if (this.hours) {
          timeParts += BigInt(Math.abs(this.hours)) + "H";
        }
        if (this.minutes) {
          timeParts += BigInt(Math.abs(this.minutes)) + "M";
        }
        if (!dateParts && !timeParts || this.seconds || this.milliseconds || this.microseconds || this.nanoseconds) {
          const totalNanoseconds = (BigInt(Math.abs(this.seconds)) * BigInt(1e9) + BigInt(Math.abs(this.milliseconds)) * BigInt(1e6) + BigInt(Math.abs(this.microseconds)) * BigInt(1e3) + BigInt(Math.abs(this.nanoseconds))).toString().padStart(10, "0");
          const seconds = totalNanoseconds.slice(0, -9);
          const fracSeconds = totalNanoseconds.slice(-9).replace(/0+$/, "");
          timeParts += seconds + (fracSeconds.length ? "." + fracSeconds : "") + "S";
        }
        return (this.sign === -1 ? "-" : "") + "P" + dateParts + (timeParts ? "T" + timeParts : "");
      }
      static from(item) {
        let result;
        if (item instanceof _Duration) {
          result = item;
        }
        if (typeof item === "object") {
          if (item.years === void 0 && item.months === void 0 && item.weeks === void 0 && item.days === void 0 && item.hours === void 0 && item.minutes === void 0 && item.seconds === void 0 && item.milliseconds === void 0 && item.microseconds === void 0 && item.nanoseconds === void 0) {
            throw new TypeError(`invalid duration-like`);
          }
          result = item;
        } else {
          const str = String(item);
          const matches = str.match(durationRegex2);
          if (!matches) {
            throw new RangeError(`invalid duration: ${str}`);
          }
          const [_duration, _sign, years, months, weeks, days, _time2, hours, fHours, minutes, fMinutes, seconds, fSeconds] = matches;
          if (_duration.length < 3 || _time2.length === 1) {
            throw new RangeError(`invalid duration: ${str}`);
          }
          const sign = _sign === "-" ? -1 : 1;
          result = {};
          if (years) {
            result.years = sign * Number(years);
          }
          if (months) {
            result.months = sign * Number(months);
          }
          if (weeks) {
            result.weeks = sign * Number(weeks);
          }
          if (days) {
            result.days = sign * Number(days);
          }
          if (hours) {
            result.hours = sign * Number(hours);
          }
          if (fHours) {
            if (minutes || fMinutes || seconds || fSeconds) {
              throw new RangeError("only the smallest unit can be fractional");
            }
            result.minutes = Number(fHours) * 60;
          } else {
            result.minutes = toNumber(minutes);
          }
          if (fMinutes) {
            if (seconds || fSeconds) {
              throw new RangeError("only the smallest unit can be fractional");
            }
            result.seconds = Number(fMinutes) * 60;
          } else if (seconds) {
            result.seconds = Number(seconds);
          } else {
            result.seconds = result.minutes % 1 * 60;
          }
          if (fSeconds) {
            const ns2 = fSeconds.slice(1).padEnd(9, "0");
            result.milliseconds = Number(ns2.slice(0, 3));
            result.microseconds = Number(ns2.slice(3, 6));
            result.nanoseconds = sign * Number(ns2.slice(6));
          } else {
            result.milliseconds = result.seconds % 1 * 1e3;
            result.microseconds = result.milliseconds % 1 * 1e3;
            result.nanoseconds = sign * Math.floor(result.microseconds % 1 * 1e3);
          }
          result.minutes = sign * Math.floor(result.minutes);
          result.seconds = sign * Math.floor(result.seconds);
          result.milliseconds = sign * Math.floor(result.milliseconds);
          result.microseconds = sign * Math.floor(result.microseconds);
        }
        return new _Duration(result.years, result.months, result.weeks, result.days, result.hours, result.minutes, result.seconds, result.milliseconds, result.microseconds, result.nanoseconds);
      }
    };
    exports2.Duration = Duration;
    var RelativeDuration = class {
      constructor(years = 0, months = 0, weeks = 0, days = 0, hours = 0, minutes = 0, seconds = 0, milliseconds = 0, microseconds = 0) {
        __publicField(this, "years");
        __publicField(this, "months");
        __publicField(this, "weeks");
        __publicField(this, "days");
        __publicField(this, "hours");
        __publicField(this, "minutes");
        __publicField(this, "seconds");
        __publicField(this, "milliseconds");
        __publicField(this, "microseconds");
        this.years = Math.trunc(years) || 0;
        this.months = Math.trunc(months) || 0;
        this.weeks = Math.trunc(weeks) || 0;
        this.days = Math.trunc(days) || 0;
        this.hours = Math.trunc(hours) || 0;
        this.minutes = Math.trunc(minutes) || 0;
        this.seconds = Math.trunc(seconds) || 0;
        this.milliseconds = Math.trunc(milliseconds) || 0;
        this.microseconds = Math.trunc(microseconds) || 0;
        forwardJsonAsToString(this);
        throwOnValueOf(this, "RelativeDuration");
      }
      toString() {
        let str = "P";
        if (this.years) {
          str += `${this.years}Y`;
        }
        if (this.months) {
          str += `${this.months}M`;
        }
        const days = this.days + 7 * this.weeks;
        if (days) {
          str += `${days}D`;
        }
        let timeParts = "";
        if (this.hours) {
          timeParts += `${this.hours}H`;
        }
        if (this.minutes) {
          timeParts += `${this.minutes}M`;
        }
        const seconds = this.seconds + this.milliseconds / 1e3 + this.microseconds / 1e6;
        if (seconds !== 0) {
          timeParts += `${seconds}S`;
        }
        if (timeParts) {
          str += `T${timeParts}`;
        }
        if (str === "P") {
          return "PT0S";
        }
        return str;
      }
    };
    exports2.RelativeDuration = RelativeDuration;
    var DateDuration = class {
      constructor(years = 0, months = 0, weeks = 0, days = 0) {
        __publicField(this, "years");
        __publicField(this, "months");
        __publicField(this, "weeks");
        __publicField(this, "days");
        this.years = Math.trunc(years) || 0;
        this.months = Math.trunc(months) || 0;
        this.weeks = Math.trunc(weeks) || 0;
        this.days = Math.trunc(days) || 0;
        forwardJsonAsToString(this);
        throwOnValueOf(this, "DateDuration");
      }
      toString() {
        let str = "P";
        if (this.years) {
          str += `${this.years}Y`;
        }
        if (this.months) {
          str += `${this.months}M`;
        }
        const days = this.days + 7 * this.weeks;
        if (days) {
          str += `${days}D`;
        }
        if (str === "P") {
          return "PT0S";
        }
        return str;
      }
    };
    exports2.DateDuration = DateDuration;
    var humanDurationPrefixes = {
      h: 36e5,
      hou: 36e5,
      m: 6e4,
      min: 6e4,
      s: 1e3,
      sec: 1e3,
      ms: 1,
      mil: 1
    };
    function parseHumanDurationString(durationStr) {
      const regex = /(\d+|\d+\.\d+|\.\d+)\s*(hours?|minutes?|seconds?|milliseconds?|ms|h|m|s)\s*/g;
      let duration = 0;
      const seen = /* @__PURE__ */ new Set();
      let match2 = regex.exec(durationStr);
      let lastIndex = 0;
      while (match2) {
        if (match2.index !== lastIndex) {
          throw new Error(`invalid duration "${durationStr}"`);
        }
        const mult = humanDurationPrefixes[match2[2].slice(0, 3)];
        if (seen.has(mult)) {
          throw new Error(`invalid duration "${durationStr}"`);
        }
        duration += Number(match2[1]) * mult;
        seen.add(mult);
        lastIndex = regex.lastIndex;
        match2 = regex.exec(durationStr);
      }
      if (lastIndex !== durationStr.length) {
        throw new Error(`invalid duration "${durationStr}"`);
      }
      return duration;
    }
    var forwardJsonAsToString = (obj) => {
      Object.defineProperty(obj, "toJSON", {
        value: () => obj.toString(),
        enumerable: false,
        configurable: true
      });
    };
    var throwOnValueOf = (obj, typename) => {
      Object.defineProperty(obj, "valueOf", {
        value: () => {
          throw new TypeError(`Not possible to compare ${typename}`);
        },
        enumerable: false,
        configurable: true
      });
    };
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/datetime.js
var require_datetime2 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/datetime.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.DateDurationCodec = exports2.RelativeDurationCodec = exports2.DurationCodec = exports2.LocalTimeCodec = exports2.LocalDateCodec = exports2.LocalDateTimeCodec = exports2.DateTimeCodec = void 0;
    exports2.checkValidGelDuration = checkValidGelDuration;
    var ifaces_1 = require_ifaces();
    var datetime_1 = require_datetime();
    var dateutil_1 = require_dateutil();
    var errors_1 = require_errors();
    var TIMESHIFT = 9466848e5;
    var BI_TIMESHIFT_US = BigInt(TIMESHIFT) * 1000n;
    var DATESHIFT_ORD = (0, dateutil_1.ymd2ord)(2e3, 1, 1);
    var DateTimeCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "Date");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const val2 = ctx.preEncode(this, object2);
          if (typeof val2 != "bigint") {
            throw new errors_1.InvalidArgumentError(`a bigint was expected out of a custom std::datetime codec`);
          }
          buf.writeInt32(8);
          buf.writeBigInt64(val2 - BI_TIMESHIFT_US);
          return;
        }
        if (!(object2 instanceof Date)) {
          throw new errors_1.InvalidArgumentError(`a Date instance was expected, got "${object2}"`);
        }
        const ms3 = object2.getTime() - TIMESHIFT;
        const us2 = ms3 * 1e3;
        buf.writeInt32(8);
        buf.writeInt64(us2);
      }
      decode(buf, ctx) {
        if (ctx.hasOverload(this)) {
          const us3 = buf.readBigInt64();
          return ctx.postDecode(this, us3 + BI_TIMESHIFT_US);
        }
        const us2 = Number(buf.readBigInt64());
        let ms3 = Math.round(us2 / 1e3);
        if (Math.abs(us2 % 1e3) === 500 && Math.abs(ms3) % 2 === 1) {
          ms3 -= 1;
        }
        ms3 += TIMESHIFT;
        return new Date(ms3);
      }
    };
    exports2.DateTimeCodec = DateTimeCodec;
    var LocalDateTimeCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "LocalDateTime");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          let us3 = ctx.preEncode(this, object2);
          if (typeof us3 != "bigint") {
            throw new errors_1.InvalidArgumentError(`a bigint was expected out of a custom cal::local_datetime codec`);
          }
          us3 -= BI_TIMESHIFT_US;
          buf.writeInt32(8);
          buf.writeBigInt64(us3);
          return;
        }
        if (!(object2 instanceof datetime_1.LocalDateTime)) {
          throw new errors_1.InvalidArgumentError(`a LocalDateTime instance was expected, got "${object2}"`);
        }
        const ms3 = BigInt(datetime_1.localDateInstances.get(object2).getTime() - TIMESHIFT);
        let us2 = ms3 * 1000n + BigInt(object2.hour * 36e8 + object2.minute * 6e7 + object2.second * 1e6 + object2.millisecond * 1e3 + object2.microsecond);
        if (object2.nanosecond === 500 && Math.abs(object2.microsecond) % 2 === 1 || object2.nanosecond > 500) {
          us2 += 1n;
        }
        buf.writeInt32(8);
        buf.writeBigInt64(us2);
      }
      decode(buf, ctx) {
        const bi_us = buf.readBigInt64();
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, BigInt(bi_us + BI_TIMESHIFT_US));
        }
        const bi_ms = bi_us / 1000n;
        let us2 = Number(bi_us - bi_ms * 1000n);
        let ms3 = Number(bi_ms);
        if (us2 < 0) {
          us2 += 1e3;
          ms3 -= 1;
        }
        ms3 += TIMESHIFT;
        const date4 = new Date(ms3);
        return new datetime_1.LocalDateTime(date4.getUTCFullYear(), date4.getUTCMonth() + 1, date4.getUTCDate(), date4.getUTCHours(), date4.getUTCMinutes(), date4.getUTCSeconds(), date4.getUTCMilliseconds(), us2);
      }
    };
    exports2.LocalDateTimeCodec = LocalDateTimeCodec;
    var LocalDateCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "LocalDate");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const ret = ctx.preEncode(this, object2);
          const ord2 = (0, dateutil_1.ymd2ord)(...ret);
          buf.writeInt32(4);
          buf.writeInt32(ord2 - DATESHIFT_ORD);
          return;
        }
        if (!(object2 instanceof datetime_1.LocalDate)) {
          throw new errors_1.InvalidArgumentError(`a LocalDate instance was expected, got "${object2}"`);
        }
        const ord = (0, datetime_1.LocalDateToOrdinal)(object2);
        buf.writeInt32(4);
        buf.writeInt32(ord - DATESHIFT_ORD);
      }
      decode(buf, ctx) {
        const ord = buf.readInt32() + DATESHIFT_ORD;
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, (0, dateutil_1.ord2ymd)(ord));
        }
        return (0, datetime_1.LocalDateFromOrdinal)(ord);
      }
    };
    exports2.LocalDateCodec = LocalDateCodec;
    var LocalTimeCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "LocalTime");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const us3 = ctx.preEncode(this, object2);
          if (typeof us3 != "bigint") {
            throw new errors_1.InvalidArgumentError(`a bigint was expected out of a custom cal::local_time codec`);
          }
          buf.writeInt32(8);
          buf.writeBigInt64(us3);
          return;
        }
        if (!(object2 instanceof datetime_1.LocalTime)) {
          throw new errors_1.InvalidArgumentError(`a LocalTime instance was expected, got "${object2}"`);
        }
        let us2 = object2.hour * 36e8 + object2.minute * 6e7 + object2.second * 1e6 + object2.millisecond * 1e3 + object2.microsecond;
        if (object2.nanosecond === 500 && us2 % 2 === 1 || object2.nanosecond > 500) {
          us2 += 1;
        }
        buf.writeInt32(8);
        buf.writeInt64(us2);
      }
      decode(buf, ctx) {
        const bius = buf.readBigInt64();
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, bius);
        }
        let us2 = Number(bius);
        let seconds = Math.floor(us2 / 1e6);
        const ms3 = Math.floor(us2 % 1e6 / 1e3);
        us2 = us2 % 1e6 - ms3 * 1e3;
        let minutes = Math.floor(seconds / 60);
        seconds = Math.floor(seconds % 60);
        const hours = Math.floor(minutes / 60);
        minutes = Math.floor(minutes % 60);
        return new datetime_1.LocalTime(hours, minutes, seconds, ms3, us2);
      }
    };
    exports2.LocalTimeCodec = LocalTimeCodec;
    var unencodableDurationFields = [
      "years",
      "months",
      "weeks",
      "days"
    ];
    function checkValidGelDuration(duration) {
      for (const field of unencodableDurationFields) {
        if (duration[field] !== 0) {
          return field;
        }
      }
      return null;
    }
    var DurationCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "Duration");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const us3 = ctx.preEncode(this, object2);
          if (typeof us3 != "bigint") {
            throw new errors_1.InvalidArgumentError(`a bigint was expected out of a custom std::duration codec`);
          }
          buf.writeInt32(16);
          buf.writeBigInt64(us3);
          buf.writeInt32(0);
          buf.writeInt32(0);
          return;
        }
        if (!(object2 instanceof datetime_1.Duration)) {
          throw new errors_1.InvalidArgumentError(`a Duration instance was expected, got "${object2}"`);
        }
        const invalidField = checkValidGelDuration(object2);
        if (invalidField) {
          throw new errors_1.InvalidArgumentError(`Cannot encode a 'Duration' with a non-zero number of ${invalidField}`);
        }
        let us2 = BigInt(Math.abs(object2.microseconds));
        us2 += BigInt(Math.abs(object2.milliseconds)) * BigInt(1e3);
        us2 += BigInt(Math.abs(object2.seconds)) * BigInt(1e6);
        us2 += BigInt(Math.abs(object2.minutes)) * BigInt(6e7);
        us2 += BigInt(Math.abs(object2.hours)) * BigInt(36e8);
        if (Math.abs(object2.nanoseconds) === 500 && Math.abs(object2.microseconds) % 2 === 1 || Math.abs(object2.nanoseconds) > 500) {
          us2 += 1n;
        }
        if (object2.sign < 0) {
          us2 *= -1n;
        }
        buf.writeInt32(16);
        buf.writeBigInt64(us2);
        buf.writeInt32(0);
        buf.writeInt32(0);
      }
      decode(buf, ctx) {
        let bius = buf.readBigInt64();
        const days = buf.readInt32();
        const months = buf.readInt32();
        if (days !== 0) {
          throw new errors_1.ProtocolError("non-zero reserved bytes in duration");
        }
        if (months !== 0) {
          throw new errors_1.ProtocolError("non-zero reserved bytes in duration");
        }
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, bius);
        }
        let sign = 1;
        if (Number(bius) < 0) {
          sign = -1;
          bius *= -1n;
        }
        const biMillion = 1000000n;
        const biSeconds = bius / biMillion;
        let us2 = Number(bius - biSeconds * biMillion);
        const ms3 = Math.floor(us2 / 1e3);
        us2 = us2 % 1e3;
        let seconds = Number(biSeconds);
        let minutes = Math.floor(seconds / 60);
        seconds = Math.floor(seconds % 60);
        const hours = Math.floor(minutes / 60);
        minutes = Math.floor(minutes % 60);
        return new datetime_1.Duration(0, 0, 0, 0, hours * sign, minutes * sign, seconds * sign, ms3 * sign, us2 * sign);
      }
    };
    exports2.DurationCodec = DurationCodec;
    var RelativeDurationCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "RelativeDuration");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const ret = ctx.preEncode(this, object2);
          buf.writeInt32(16);
          buf.writeBigInt64(ret[2]);
          buf.writeInt32(ret[1]);
          buf.writeInt32(ret[0]);
          return;
        }
        if (!(object2 instanceof datetime_1.RelativeDuration)) {
          throw new errors_1.InvalidArgumentError(`
        a RelativeDuration instance was expected, got "${object2}"
      `);
        }
        const us2 = BigInt(object2.microseconds) + BigInt(object2.milliseconds) * BigInt(1e3) + BigInt(object2.seconds) * BigInt(1e6) + BigInt(object2.minutes) * BigInt(6e7) + BigInt(object2.hours) * BigInt(36e8);
        buf.writeInt32(16);
        buf.writeBigInt64(us2);
        buf.writeInt32(object2.days + 7 * object2.weeks);
        buf.writeInt32(object2.months + 12 * object2.years);
      }
      decode(buf, ctx) {
        let bius = buf.readBigInt64();
        let days = buf.readInt32();
        let months = buf.readInt32();
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, [
            months,
            days,
            bius
          ]);
        }
        let sign = 1;
        if (Number(bius) < 0) {
          sign = -1;
          bius *= -1n;
        }
        const million = BigInt(1e6);
        const biSeconds = bius / million;
        let us2 = Number(bius - biSeconds * million);
        const ms3 = Math.trunc(us2 / 1e3);
        us2 = us2 % 1e3;
        let seconds = Number(biSeconds);
        let minutes = Math.trunc(seconds / 60);
        seconds = Math.trunc(seconds % 60);
        const hours = Math.trunc(minutes / 60);
        minutes = Math.trunc(minutes % 60);
        const weeks = Math.trunc(days / 7);
        days = Math.trunc(days % 7);
        const years = Math.trunc(months / 12);
        months = Math.trunc(months % 12);
        return new datetime_1.RelativeDuration(years, months, weeks, days, hours * sign, minutes * sign, seconds * sign, ms3 * sign, us2 * sign);
      }
    };
    exports2.RelativeDurationCodec = RelativeDurationCodec;
    var DateDurationCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "DateDuration");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const ret = ctx.preEncode(this, object2);
          buf.writeInt32(16);
          buf.writeInt64(0);
          buf.writeInt32(ret[1]);
          buf.writeInt32(ret[0]);
          return;
        }
        if (!(object2 instanceof datetime_1.DateDuration)) {
          throw new errors_1.InvalidArgumentError(`
        a DateDuration instance was expected, got "${object2}"
      `);
        }
        buf.writeInt32(16);
        buf.writeInt64(0);
        buf.writeInt32(object2.days + 7 * object2.weeks);
        buf.writeInt32(object2.months + 12 * object2.years);
      }
      decode(buf, ctx) {
        buf.discard(8);
        let days = buf.readInt32();
        let months = buf.readInt32();
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, [months, days]);
        }
        const weeks = Math.trunc(days / 7);
        days = Math.trunc(days % 7);
        const years = Math.trunc(months / 12);
        months = Math.trunc(months % 12);
        return new datetime_1.DateDuration(years, months, weeks, days);
      }
    };
    exports2.DateDurationCodec = DateDurationCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/memory.js
var require_memory = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/memory.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ConfigMemory = void 0;
    var KiB = 1024;
    var MiB = 1024 * KiB;
    var GiB = 1024 * MiB;
    var TiB = 1024 * GiB;
    var PiB = 1024 * TiB;
    var ConfigMemory = class {
      constructor(bytes2) {
        __publicField(this, "_bytes");
        this._bytes = bytes2;
      }
      get bytes() {
        return Number(this._bytes);
      }
      get bytesBigInt() {
        return this._bytes;
      }
      get kibibytes() {
        return Number(this._bytes) / KiB;
      }
      get mebibytes() {
        return Number(this._bytes) / MiB;
      }
      get gibibytes() {
        return Number(this._bytes) / GiB;
      }
      get tebibytes() {
        return Number(this._bytes) / TiB;
      }
      get pebibytes() {
        return Number(this._bytes) / PiB;
      }
      toString() {
        const bytes2 = this._bytes;
        const bigPiB = BigInt(PiB);
        if (bytes2 >= bigPiB && Number(bytes2 % bigPiB) === 0) {
          return `${bytes2 / bigPiB}PiB`;
        }
        const bigTiB = BigInt(TiB);
        if (bytes2 >= bigTiB && Number(bytes2 % bigTiB) === 0) {
          return `${bytes2 / bigTiB}TiB`;
        }
        const bigGiB = BigInt(GiB);
        if (bytes2 >= bigGiB && Number(bytes2 % bigGiB) === 0) {
          return `${bytes2 / bigGiB}GiB`;
        }
        const bigMiB = BigInt(MiB);
        if (bytes2 >= bigMiB && Number(bytes2 % bigMiB) === 0) {
          return `${bytes2 / bigMiB}MiB`;
        }
        const bigKiB = BigInt(KiB);
        if (bytes2 >= bigKiB && Number(bytes2 % bigKiB) === 0) {
          return `${bytes2 / bigKiB}KiB`;
        }
        return `${bytes2}B`;
      }
    };
    exports2.ConfigMemory = ConfigMemory;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/memory.js
var require_memory2 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/memory.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ConfigMemoryCodec = void 0;
    var ifaces_1 = require_ifaces();
    var memory_1 = require_memory();
    var errors_1 = require_errors();
    var ConfigMemoryCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "ConfigMemory");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const val2 = ctx.preEncode(this, object2);
          if (typeof val2 != "bigint") {
            throw new errors_1.InvalidArgumentError(`a bigint was expected out of a custom cfg::memory codec`);
          }
          buf.writeInt32(8);
          buf.writeBigInt64(val2);
          return;
        }
        if (!(object2 instanceof memory_1.ConfigMemory)) {
          throw new errors_1.InvalidArgumentError(`a ConfigMemory instance was expected, got "${object2}"`);
        }
        buf.writeInt32(8);
        buf.writeBigInt64(object2._bytes);
      }
      decode(buf, ctx) {
        const val2 = buf.readBigInt64();
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, val2);
        }
        return new memory_1.ConfigMemory(val2);
      }
    };
    exports2.ConfigMemoryCodec = ConfigMemoryCodec;
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/messages.cjs
var require_messages2 = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/messages.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    var THIS_IS_NOT_AN_OBJECT = exports2.THIS_IS_NOT_AN_OBJECT = "This is not an object";
    var THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = exports2.THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT = "This is not a Float16Array object";
    var THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY = exports2.THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY = "This constructor is not a subclass of Float16Array";
    var THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT = exports2.THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT = "The constructor property value is not an object";
    var SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT = exports2.SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT = "Species constructor didn't return TypedArray object";
    var DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH = exports2.DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH = "Derived constructor created TypedArray object which was too small length";
    var ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER = exports2.ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER = "Attempting to access detached ArrayBuffer";
    var CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT = exports2.CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT = "Cannot convert undefined or null to object";
    var CANNOT_MIX_BIGINT_AND_OTHER_TYPES = exports2.CANNOT_MIX_BIGINT_AND_OTHER_TYPES = "Cannot mix BigInt and other types, use explicit conversions";
    var ITERATOR_PROPERTY_IS_NOT_CALLABLE = exports2.ITERATOR_PROPERTY_IS_NOT_CALLABLE = "@@iterator property is not callable";
    var REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE = exports2.REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE = "Reduce of empty array with no initial value";
    var THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED = exports2.THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED = "The comparison function must be either a function or undefined";
    var OFFSET_IS_OUT_OF_BOUNDS = exports2.OFFSET_IS_OUT_OF_BOUNDS = "Offset is out of bounds";
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/primordials.cjs
var require_primordials = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/primordials.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    var _messages = require_messages2();
    function uncurryThis(target) {
      return (thisArg, ...args2) => {
        return ReflectApply(target, thisArg, args2);
      };
    }
    function uncurryThisGetter(target, key) {
      return uncurryThis(ReflectGetOwnPropertyDescriptor(target, key).get);
    }
    var {
      apply: ReflectApply,
      construct: ReflectConstruct,
      defineProperty: ReflectDefineProperty,
      get: ReflectGet,
      getOwnPropertyDescriptor: ReflectGetOwnPropertyDescriptor,
      getPrototypeOf: ReflectGetPrototypeOf,
      has: ReflectHas,
      ownKeys: ReflectOwnKeys,
      set: ReflectSet,
      setPrototypeOf: ReflectSetPrototypeOf
    } = Reflect;
    exports2.ReflectSetPrototypeOf = ReflectSetPrototypeOf;
    exports2.ReflectSet = ReflectSet;
    exports2.ReflectOwnKeys = ReflectOwnKeys;
    exports2.ReflectHas = ReflectHas;
    exports2.ReflectGetPrototypeOf = ReflectGetPrototypeOf;
    exports2.ReflectGetOwnPropertyDescriptor = ReflectGetOwnPropertyDescriptor;
    exports2.ReflectGet = ReflectGet;
    exports2.ReflectDefineProperty = ReflectDefineProperty;
    exports2.ReflectConstruct = ReflectConstruct;
    exports2.ReflectApply = ReflectApply;
    var NativeProxy = exports2.NativeProxy = Proxy;
    var {
      EPSILON,
      MAX_SAFE_INTEGER,
      isFinite: NumberIsFinite,
      isNaN: NumberIsNaN
    } = Number;
    exports2.NumberIsNaN = NumberIsNaN;
    exports2.NumberIsFinite = NumberIsFinite;
    exports2.MAX_SAFE_INTEGER = MAX_SAFE_INTEGER;
    exports2.EPSILON = EPSILON;
    var {
      iterator: SymbolIterator,
      species: SymbolSpecies,
      toStringTag: SymbolToStringTag,
      for: SymbolFor
    } = Symbol;
    exports2.SymbolFor = SymbolFor;
    exports2.SymbolToStringTag = SymbolToStringTag;
    exports2.SymbolSpecies = SymbolSpecies;
    exports2.SymbolIterator = SymbolIterator;
    var NativeObject = exports2.NativeObject = Object;
    var {
      create: ObjectCreate,
      defineProperty: ObjectDefineProperty,
      freeze: ObjectFreeze,
      is: ObjectIs
    } = NativeObject;
    exports2.ObjectIs = ObjectIs;
    exports2.ObjectFreeze = ObjectFreeze;
    exports2.ObjectDefineProperty = ObjectDefineProperty;
    exports2.ObjectCreate = ObjectCreate;
    var ObjectPrototype = NativeObject.prototype;
    var ObjectPrototype__lookupGetter__ = exports2.ObjectPrototype__lookupGetter__ = ObjectPrototype.__lookupGetter__ ? uncurryThis(ObjectPrototype.__lookupGetter__) : (object2, key) => {
      if (object2 == null) {
        throw NativeTypeError(_messages.CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT);
      }
      let target = NativeObject(object2);
      do {
        const descriptor = ReflectGetOwnPropertyDescriptor(target, key);
        if (descriptor !== void 0) {
          if (ObjectHasOwn(descriptor, "get")) {
            return descriptor.get;
          }
          return;
        }
      } while ((target = ReflectGetPrototypeOf(target)) !== null);
    };
    var ObjectHasOwn = exports2.ObjectHasOwn = NativeObject.hasOwn || uncurryThis(ObjectPrototype.hasOwnProperty);
    var NativeArray = Array;
    var ArrayIsArray = exports2.ArrayIsArray = NativeArray.isArray;
    var ArrayPrototype = NativeArray.prototype;
    var ArrayPrototypeJoin = exports2.ArrayPrototypeJoin = uncurryThis(ArrayPrototype.join);
    var ArrayPrototypePush = exports2.ArrayPrototypePush = uncurryThis(ArrayPrototype.push);
    var ArrayPrototypeToLocaleString = exports2.ArrayPrototypeToLocaleString = uncurryThis(ArrayPrototype.toLocaleString);
    var NativeArrayPrototypeSymbolIterator = exports2.NativeArrayPrototypeSymbolIterator = ArrayPrototype[SymbolIterator];
    var ArrayPrototypeSymbolIterator = exports2.ArrayPrototypeSymbolIterator = uncurryThis(NativeArrayPrototypeSymbolIterator);
    var {
      abs: MathAbs,
      trunc: MathTrunc
    } = Math;
    exports2.MathTrunc = MathTrunc;
    exports2.MathAbs = MathAbs;
    var NativeArrayBuffer = exports2.NativeArrayBuffer = ArrayBuffer;
    var ArrayBufferIsView = exports2.ArrayBufferIsView = NativeArrayBuffer.isView;
    var ArrayBufferPrototype = NativeArrayBuffer.prototype;
    var ArrayBufferPrototypeSlice = exports2.ArrayBufferPrototypeSlice = uncurryThis(ArrayBufferPrototype.slice);
    var ArrayBufferPrototypeGetByteLength = exports2.ArrayBufferPrototypeGetByteLength = uncurryThisGetter(ArrayBufferPrototype, "byteLength");
    var NativeSharedArrayBuffer = exports2.NativeSharedArrayBuffer = typeof SharedArrayBuffer !== "undefined" ? SharedArrayBuffer : null;
    var SharedArrayBufferPrototypeGetByteLength = exports2.SharedArrayBufferPrototypeGetByteLength = NativeSharedArrayBuffer && uncurryThisGetter(NativeSharedArrayBuffer.prototype, "byteLength");
    var TypedArray = exports2.TypedArray = ReflectGetPrototypeOf(Uint8Array);
    var TypedArrayFrom = TypedArray.from;
    var TypedArrayPrototype = exports2.TypedArrayPrototype = TypedArray.prototype;
    var NativeTypedArrayPrototypeSymbolIterator = exports2.NativeTypedArrayPrototypeSymbolIterator = TypedArrayPrototype[SymbolIterator];
    var TypedArrayPrototypeKeys = exports2.TypedArrayPrototypeKeys = uncurryThis(TypedArrayPrototype.keys);
    var TypedArrayPrototypeValues = exports2.TypedArrayPrototypeValues = uncurryThis(TypedArrayPrototype.values);
    var TypedArrayPrototypeEntries = exports2.TypedArrayPrototypeEntries = uncurryThis(TypedArrayPrototype.entries);
    var TypedArrayPrototypeSet = exports2.TypedArrayPrototypeSet = uncurryThis(TypedArrayPrototype.set);
    var TypedArrayPrototypeReverse = exports2.TypedArrayPrototypeReverse = uncurryThis(TypedArrayPrototype.reverse);
    var TypedArrayPrototypeFill = exports2.TypedArrayPrototypeFill = uncurryThis(TypedArrayPrototype.fill);
    var TypedArrayPrototypeCopyWithin = exports2.TypedArrayPrototypeCopyWithin = uncurryThis(TypedArrayPrototype.copyWithin);
    var TypedArrayPrototypeSort = exports2.TypedArrayPrototypeSort = uncurryThis(TypedArrayPrototype.sort);
    var TypedArrayPrototypeSlice = exports2.TypedArrayPrototypeSlice = uncurryThis(TypedArrayPrototype.slice);
    var TypedArrayPrototypeSubarray = exports2.TypedArrayPrototypeSubarray = uncurryThis(TypedArrayPrototype.subarray);
    var TypedArrayPrototypeGetBuffer = exports2.TypedArrayPrototypeGetBuffer = uncurryThisGetter(TypedArrayPrototype, "buffer");
    var TypedArrayPrototypeGetByteOffset = exports2.TypedArrayPrototypeGetByteOffset = uncurryThisGetter(TypedArrayPrototype, "byteOffset");
    var TypedArrayPrototypeGetLength = exports2.TypedArrayPrototypeGetLength = uncurryThisGetter(TypedArrayPrototype, "length");
    var TypedArrayPrototypeGetSymbolToStringTag = exports2.TypedArrayPrototypeGetSymbolToStringTag = uncurryThisGetter(TypedArrayPrototype, SymbolToStringTag);
    var NativeUint8Array = exports2.NativeUint8Array = Uint8Array;
    var NativeUint16Array = exports2.NativeUint16Array = Uint16Array;
    var Uint16ArrayFrom = (...args2) => {
      return ReflectApply(TypedArrayFrom, NativeUint16Array, args2);
    };
    exports2.Uint16ArrayFrom = Uint16ArrayFrom;
    var NativeUint32Array = exports2.NativeUint32Array = Uint32Array;
    var NativeFloat32Array = exports2.NativeFloat32Array = Float32Array;
    var ArrayIteratorPrototype = exports2.ArrayIteratorPrototype = ReflectGetPrototypeOf([][SymbolIterator]());
    var ArrayIteratorPrototypeNext = exports2.ArrayIteratorPrototypeNext = uncurryThis(ArrayIteratorPrototype.next);
    var GeneratorPrototypeNext = exports2.GeneratorPrototypeNext = uncurryThis(function* () {
    }().next);
    var IteratorPrototype = exports2.IteratorPrototype = ReflectGetPrototypeOf(ArrayIteratorPrototype);
    var DataViewPrototype = DataView.prototype;
    var DataViewPrototypeGetUint16 = exports2.DataViewPrototypeGetUint16 = uncurryThis(DataViewPrototype.getUint16);
    var DataViewPrototypeSetUint16 = exports2.DataViewPrototypeSetUint16 = uncurryThis(DataViewPrototype.setUint16);
    var NativeTypeError = exports2.NativeTypeError = TypeError;
    var NativeRangeError = exports2.NativeRangeError = RangeError;
    var NativeWeakSet = exports2.NativeWeakSet = WeakSet;
    var WeakSetPrototype = NativeWeakSet.prototype;
    var WeakSetPrototypeAdd = exports2.WeakSetPrototypeAdd = uncurryThis(WeakSetPrototype.add);
    var WeakSetPrototypeHas = exports2.WeakSetPrototypeHas = uncurryThis(WeakSetPrototype.has);
    var NativeWeakMap = exports2.NativeWeakMap = WeakMap;
    var WeakMapPrototype = NativeWeakMap.prototype;
    var WeakMapPrototypeGet = exports2.WeakMapPrototypeGet = uncurryThis(WeakMapPrototype.get);
    var WeakMapPrototypeHas = exports2.WeakMapPrototypeHas = uncurryThis(WeakMapPrototype.has);
    var WeakMapPrototypeSet = exports2.WeakMapPrototypeSet = uncurryThis(WeakMapPrototype.set);
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/arrayIterator.cjs
var require_arrayIterator = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/arrayIterator.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.safeIfNeeded = safeIfNeeded;
    exports2.wrap = wrap;
    var _primordials = require_primordials();
    var arrayIterators = new _primordials.NativeWeakMap();
    var SafeIteratorPrototype = (0, _primordials.ObjectCreate)(null, {
      next: {
        value: function next() {
          const arrayIterator = (0, _primordials.WeakMapPrototypeGet)(arrayIterators, this);
          return (0, _primordials.ArrayIteratorPrototypeNext)(arrayIterator);
        }
      },
      [_primordials.SymbolIterator]: {
        value: function values2() {
          return this;
        }
      }
    });
    function safeIfNeeded(array3) {
      if (array3[_primordials.SymbolIterator] === _primordials.NativeArrayPrototypeSymbolIterator && _primordials.ArrayIteratorPrototype.next === _primordials.ArrayIteratorPrototypeNext) {
        return array3;
      }
      const safe = (0, _primordials.ObjectCreate)(SafeIteratorPrototype);
      (0, _primordials.WeakMapPrototypeSet)(arrayIterators, safe, (0, _primordials.ArrayPrototypeSymbolIterator)(array3));
      return safe;
    }
    var generators = new _primordials.NativeWeakMap();
    var DummyArrayIteratorPrototype = (0, _primordials.ObjectCreate)(_primordials.IteratorPrototype, {
      next: {
        value: function next() {
          const generator = (0, _primordials.WeakMapPrototypeGet)(generators, this);
          return (0, _primordials.GeneratorPrototypeNext)(generator);
        },
        writable: true,
        configurable: true
      }
    });
    for (const key of (0, _primordials.ReflectOwnKeys)(_primordials.ArrayIteratorPrototype)) {
      if (key === "next") {
        continue;
      }
      (0, _primordials.ObjectDefineProperty)(DummyArrayIteratorPrototype, key, (0, _primordials.ReflectGetOwnPropertyDescriptor)(_primordials.ArrayIteratorPrototype, key));
    }
    function wrap(generator) {
      const dummy = (0, _primordials.ObjectCreate)(DummyArrayIteratorPrototype);
      (0, _primordials.WeakMapPrototypeSet)(generators, dummy, generator);
      return dummy;
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/is.cjs
var require_is = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/is.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isAnyArrayBuffer = isAnyArrayBuffer;
    exports2.isCanonicalIntegerIndexString = isCanonicalIntegerIndexString;
    exports2.isNativeBigIntTypedArray = isNativeBigIntTypedArray;
    exports2.isNativeTypedArray = isNativeTypedArray;
    exports2.isObject = isObject;
    exports2.isObjectLike = isObjectLike;
    exports2.isOrdinaryArray = isOrdinaryArray;
    exports2.isOrdinaryNativeTypedArray = isOrdinaryNativeTypedArray;
    exports2.isSharedArrayBuffer = isSharedArrayBuffer;
    var _primordials = require_primordials();
    function isObject(value) {
      return value !== null && typeof value === "object" || typeof value === "function";
    }
    function isObjectLike(value) {
      return value !== null && typeof value === "object";
    }
    function isNativeTypedArray(value) {
      return (0, _primordials.TypedArrayPrototypeGetSymbolToStringTag)(value) !== void 0;
    }
    function isNativeBigIntTypedArray(value) {
      const typedArrayName = (0, _primordials.TypedArrayPrototypeGetSymbolToStringTag)(value);
      return typedArrayName === "BigInt64Array" || typedArrayName === "BigUint64Array";
    }
    function isArrayBuffer2(value) {
      try {
        if ((0, _primordials.ArrayIsArray)(value)) {
          return false;
        }
        (0, _primordials.ArrayBufferPrototypeGetByteLength)(value);
        return true;
      } catch (e6) {
        return false;
      }
    }
    function isSharedArrayBuffer(value) {
      if (_primordials.NativeSharedArrayBuffer === null) {
        return false;
      }
      try {
        (0, _primordials.SharedArrayBufferPrototypeGetByteLength)(value);
        return true;
      } catch (e6) {
        return false;
      }
    }
    function isAnyArrayBuffer(value) {
      return isArrayBuffer2(value) || isSharedArrayBuffer(value);
    }
    function isOrdinaryArray(value) {
      if (!(0, _primordials.ArrayIsArray)(value)) {
        return false;
      }
      return value[_primordials.SymbolIterator] === _primordials.NativeArrayPrototypeSymbolIterator && _primordials.ArrayIteratorPrototype.next === _primordials.ArrayIteratorPrototypeNext;
    }
    function isOrdinaryNativeTypedArray(value) {
      if (!isNativeTypedArray(value)) {
        return false;
      }
      return value[_primordials.SymbolIterator] === _primordials.NativeTypedArrayPrototypeSymbolIterator && _primordials.ArrayIteratorPrototype.next === _primordials.ArrayIteratorPrototypeNext;
    }
    function isCanonicalIntegerIndexString(value) {
      if (typeof value !== "string") {
        return false;
      }
      const number2 = +value;
      if (value !== number2 + "") {
        return false;
      }
      if (!(0, _primordials.NumberIsFinite)(number2)) {
        return false;
      }
      return number2 === (0, _primordials.MathTrunc)(number2);
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/brand.cjs
var require_brand = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/brand.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.hasFloat16ArrayBrand = hasFloat16ArrayBrand;
    var _is = require_is();
    var _messages = require_messages2();
    var _primordials = require_primordials();
    var brand = exports2.brand = (0, _primordials.SymbolFor)("__Float16Array__");
    function hasFloat16ArrayBrand(target) {
      if (!(0, _is.isObjectLike)(target)) {
        return false;
      }
      const prototype = (0, _primordials.ReflectGetPrototypeOf)(target);
      if (!(0, _is.isObjectLike)(prototype)) {
        return false;
      }
      const constructor = prototype.constructor;
      if (constructor === void 0) {
        return false;
      }
      if (!(0, _is.isObject)(constructor)) {
        throw (0, _primordials.NativeTypeError)(_messages.THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);
      }
      return (0, _primordials.ReflectHas)(constructor, brand);
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/converter.cjs
var require_converter = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/converter.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.convertToNumber = convertToNumber;
    exports2.roundToFloat16 = roundToFloat16;
    exports2.roundToFloat16Bits = roundToFloat16Bits;
    var _primordials = require_primordials();
    var INVERSE_OF_EPSILON = 1 / _primordials.EPSILON;
    function roundTiesToEven(num) {
      return num + INVERSE_OF_EPSILON - INVERSE_OF_EPSILON;
    }
    var FLOAT16_MIN_VALUE = 6103515625e-14;
    var FLOAT16_MAX_VALUE = 65504;
    var FLOAT16_EPSILON = 9765625e-10;
    var FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE = FLOAT16_EPSILON * FLOAT16_MIN_VALUE;
    var FLOAT16_EPSILON_DEVIDED_BY_EPSILON = FLOAT16_EPSILON * INVERSE_OF_EPSILON;
    function roundToFloat16(num) {
      const number2 = +num;
      if (!(0, _primordials.NumberIsFinite)(number2) || number2 === 0) {
        return number2;
      }
      const sign = number2 > 0 ? 1 : -1;
      const absolute = (0, _primordials.MathAbs)(number2);
      if (absolute < FLOAT16_MIN_VALUE) {
        return sign * roundTiesToEven(absolute / FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE) * FLOAT16_EPSILON_MULTIPLIED_BY_FLOAT16_MIN_VALUE;
      }
      const temp = (1 + FLOAT16_EPSILON_DEVIDED_BY_EPSILON) * absolute;
      const result = temp - (temp - absolute);
      if (result > FLOAT16_MAX_VALUE || (0, _primordials.NumberIsNaN)(result)) {
        return sign * Infinity;
      }
      return sign * result;
    }
    var buffer2 = new _primordials.NativeArrayBuffer(4);
    var floatView = new _primordials.NativeFloat32Array(buffer2);
    var uint32View = new _primordials.NativeUint32Array(buffer2);
    var baseTable = new _primordials.NativeUint16Array(512);
    var shiftTable = new _primordials.NativeUint8Array(512);
    for (let i8 = 0; i8 < 256; ++i8) {
      const e6 = i8 - 127;
      if (e6 < -24) {
        baseTable[i8] = 0;
        baseTable[i8 | 256] = 32768;
        shiftTable[i8] = 24;
        shiftTable[i8 | 256] = 24;
      } else if (e6 < -14) {
        baseTable[i8] = 1024 >> -e6 - 14;
        baseTable[i8 | 256] = 1024 >> -e6 - 14 | 32768;
        shiftTable[i8] = -e6 - 1;
        shiftTable[i8 | 256] = -e6 - 1;
      } else if (e6 <= 15) {
        baseTable[i8] = e6 + 15 << 10;
        baseTable[i8 | 256] = e6 + 15 << 10 | 32768;
        shiftTable[i8] = 13;
        shiftTable[i8 | 256] = 13;
      } else if (e6 < 128) {
        baseTable[i8] = 31744;
        baseTable[i8 | 256] = 64512;
        shiftTable[i8] = 24;
        shiftTable[i8 | 256] = 24;
      } else {
        baseTable[i8] = 31744;
        baseTable[i8 | 256] = 64512;
        shiftTable[i8] = 13;
        shiftTable[i8 | 256] = 13;
      }
    }
    function roundToFloat16Bits(num) {
      floatView[0] = roundToFloat16(num);
      const f9 = uint32View[0];
      const e6 = f9 >> 23 & 511;
      return baseTable[e6] + ((f9 & 8388607) >> shiftTable[e6]);
    }
    var mantissaTable = new _primordials.NativeUint32Array(2048);
    for (let i8 = 1; i8 < 1024; ++i8) {
      let m12 = i8 << 13;
      let e6 = 0;
      while ((m12 & 8388608) === 0) {
        m12 <<= 1;
        e6 -= 8388608;
      }
      m12 &= ~8388608;
      e6 += 947912704;
      mantissaTable[i8] = m12 | e6;
    }
    for (let i8 = 1024; i8 < 2048; ++i8) {
      mantissaTable[i8] = 939524096 + (i8 - 1024 << 13);
    }
    var exponentTable = new _primordials.NativeUint32Array(64);
    for (let i8 = 1; i8 < 31; ++i8) {
      exponentTable[i8] = i8 << 23;
    }
    exponentTable[31] = 1199570944;
    exponentTable[32] = 2147483648;
    for (let i8 = 33; i8 < 63; ++i8) {
      exponentTable[i8] = 2147483648 + (i8 - 32 << 23);
    }
    exponentTable[63] = 3347054592;
    var offsetTable = new _primordials.NativeUint16Array(64);
    for (let i8 = 1; i8 < 64; ++i8) {
      if (i8 !== 32) {
        offsetTable[i8] = 1024;
      }
    }
    function convertToNumber(float16bits) {
      const i8 = float16bits >> 10;
      uint32View[0] = mantissaTable[offsetTable[i8] + (float16bits & 1023)] + exponentTable[i8];
      return floatView[0];
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/spec.cjs
var require_spec = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/_util/spec.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.IsDetachedBuffer = IsDetachedBuffer;
    exports2.SpeciesConstructor = SpeciesConstructor;
    exports2.ToIntegerOrInfinity = ToIntegerOrInfinity;
    exports2.ToLength = ToLength;
    exports2.defaultCompare = defaultCompare;
    var _is = require_is();
    var _messages = require_messages2();
    var _primordials = require_primordials();
    function ToIntegerOrInfinity(target) {
      const number2 = +target;
      if ((0, _primordials.NumberIsNaN)(number2) || number2 === 0) {
        return 0;
      }
      return (0, _primordials.MathTrunc)(number2);
    }
    function ToLength(target) {
      const length = ToIntegerOrInfinity(target);
      if (length < 0) {
        return 0;
      }
      return length < _primordials.MAX_SAFE_INTEGER ? length : _primordials.MAX_SAFE_INTEGER;
    }
    function SpeciesConstructor(target, defaultConstructor) {
      if (!(0, _is.isObject)(target)) {
        throw (0, _primordials.NativeTypeError)(_messages.THIS_IS_NOT_AN_OBJECT);
      }
      const constructor = target.constructor;
      if (constructor === void 0) {
        return defaultConstructor;
      }
      if (!(0, _is.isObject)(constructor)) {
        throw (0, _primordials.NativeTypeError)(_messages.THE_CONSTRUCTOR_PROPERTY_VALUE_IS_NOT_AN_OBJECT);
      }
      const species = constructor[_primordials.SymbolSpecies];
      if (species == null) {
        return defaultConstructor;
      }
      return species;
    }
    function IsDetachedBuffer(buffer2) {
      if ((0, _is.isSharedArrayBuffer)(buffer2)) {
        return false;
      }
      try {
        (0, _primordials.ArrayBufferPrototypeSlice)(buffer2, 0, 0);
        return false;
      } catch (e6) {
      }
      return true;
    }
    function defaultCompare(x11, y7) {
      const isXNaN = (0, _primordials.NumberIsNaN)(x11);
      const isYNaN = (0, _primordials.NumberIsNaN)(y7);
      if (isXNaN && isYNaN) {
        return 0;
      }
      if (isXNaN) {
        return 1;
      }
      if (isYNaN) {
        return -1;
      }
      if (x11 < y7) {
        return -1;
      }
      if (x11 > y7) {
        return 1;
      }
      if (x11 === 0 && y7 === 0) {
        const isXPlusZero = (0, _primordials.ObjectIs)(x11, 0);
        const isYPlusZero = (0, _primordials.ObjectIs)(y7, 0);
        if (!isXPlusZero && isYPlusZero) {
          return -1;
        }
        if (isXPlusZero && !isYPlusZero) {
          return 1;
        }
      }
      return 0;
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/Float16Array.cjs
var require_Float16Array = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/Float16Array.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isFloat16Array = isFloat16Array;
    var _arrayIterator = require_arrayIterator();
    var _brand = require_brand();
    var _converter = require_converter();
    var _is = require_is();
    var _messages = require_messages2();
    var _primordials = require_primordials();
    var _spec = require_spec();
    var BYTES_PER_ELEMENT = 2;
    var float16bitsArrays = new _primordials.NativeWeakMap();
    function isFloat16Array(target) {
      return (0, _primordials.WeakMapPrototypeHas)(float16bitsArrays, target) || !(0, _primordials.ArrayBufferIsView)(target) && (0, _brand.hasFloat16ArrayBrand)(target);
    }
    function assertFloat16Array(target) {
      if (!isFloat16Array(target)) {
        throw (0, _primordials.NativeTypeError)(_messages.THIS_IS_NOT_A_FLOAT16ARRAY_OBJECT);
      }
    }
    function assertSpeciesTypedArray(target, count2) {
      const isTargetFloat16Array = isFloat16Array(target);
      const isTargetTypedArray = (0, _is.isNativeTypedArray)(target);
      if (!isTargetFloat16Array && !isTargetTypedArray) {
        throw (0, _primordials.NativeTypeError)(_messages.SPECIES_CONSTRUCTOR_DIDNT_RETURN_TYPEDARRAY_OBJECT);
      }
      if (typeof count2 === "number") {
        let length;
        if (isTargetFloat16Array) {
          const float16bitsArray = getFloat16BitsArray(target);
          length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        } else {
          length = (0, _primordials.TypedArrayPrototypeGetLength)(target);
        }
        if (length < count2) {
          throw (0, _primordials.NativeTypeError)(_messages.DERIVED_CONSTRUCTOR_CREATED_TYPEDARRAY_OBJECT_WHICH_WAS_TOO_SMALL_LENGTH);
        }
      }
      if ((0, _is.isNativeBigIntTypedArray)(target)) {
        throw (0, _primordials.NativeTypeError)(_messages.CANNOT_MIX_BIGINT_AND_OTHER_TYPES);
      }
    }
    function getFloat16BitsArray(float16) {
      const float16bitsArray = (0, _primordials.WeakMapPrototypeGet)(float16bitsArrays, float16);
      if (float16bitsArray !== void 0) {
        const buffer3 = (0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray);
        if ((0, _spec.IsDetachedBuffer)(buffer3)) {
          throw (0, _primordials.NativeTypeError)(_messages.ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
        }
        return float16bitsArray;
      }
      const buffer2 = float16.buffer;
      if ((0, _spec.IsDetachedBuffer)(buffer2)) {
        throw (0, _primordials.NativeTypeError)(_messages.ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
      }
      const cloned = (0, _primordials.ReflectConstruct)(Float16Array, [buffer2, float16.byteOffset, float16.length], float16.constructor);
      return (0, _primordials.WeakMapPrototypeGet)(float16bitsArrays, cloned);
    }
    function copyToArray(float16bitsArray) {
      const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
      const array3 = [];
      for (let i8 = 0; i8 < length; ++i8) {
        array3[i8] = (0, _converter.convertToNumber)(float16bitsArray[i8]);
      }
      return array3;
    }
    var TypedArrayPrototypeGetters = new _primordials.NativeWeakSet();
    for (const key of (0, _primordials.ReflectOwnKeys)(_primordials.TypedArrayPrototype)) {
      if (key === _primordials.SymbolToStringTag) {
        continue;
      }
      const descriptor = (0, _primordials.ReflectGetOwnPropertyDescriptor)(_primordials.TypedArrayPrototype, key);
      if ((0, _primordials.ObjectHasOwn)(descriptor, "get") && typeof descriptor.get === "function") {
        (0, _primordials.WeakSetPrototypeAdd)(TypedArrayPrototypeGetters, descriptor.get);
      }
    }
    var handler = (0, _primordials.ObjectFreeze)({
      get(target, key, receiver) {
        if ((0, _is.isCanonicalIntegerIndexString)(key) && (0, _primordials.ObjectHasOwn)(target, key)) {
          return (0, _converter.convertToNumber)((0, _primordials.ReflectGet)(target, key));
        }
        if ((0, _primordials.WeakSetPrototypeHas)(TypedArrayPrototypeGetters, (0, _primordials.ObjectPrototype__lookupGetter__)(target, key))) {
          return (0, _primordials.ReflectGet)(target, key);
        }
        return (0, _primordials.ReflectGet)(target, key, receiver);
      },
      set(target, key, value, receiver) {
        if ((0, _is.isCanonicalIntegerIndexString)(key) && (0, _primordials.ObjectHasOwn)(target, key)) {
          return (0, _primordials.ReflectSet)(target, key, (0, _converter.roundToFloat16Bits)(value));
        }
        return (0, _primordials.ReflectSet)(target, key, value, receiver);
      },
      getOwnPropertyDescriptor(target, key) {
        if ((0, _is.isCanonicalIntegerIndexString)(key) && (0, _primordials.ObjectHasOwn)(target, key)) {
          const descriptor = (0, _primordials.ReflectGetOwnPropertyDescriptor)(target, key);
          descriptor.value = (0, _converter.convertToNumber)(descriptor.value);
          return descriptor;
        }
        return (0, _primordials.ReflectGetOwnPropertyDescriptor)(target, key);
      },
      defineProperty(target, key, descriptor) {
        if ((0, _is.isCanonicalIntegerIndexString)(key) && (0, _primordials.ObjectHasOwn)(target, key) && (0, _primordials.ObjectHasOwn)(descriptor, "value")) {
          descriptor.value = (0, _converter.roundToFloat16Bits)(descriptor.value);
          return (0, _primordials.ReflectDefineProperty)(target, key, descriptor);
        }
        return (0, _primordials.ReflectDefineProperty)(target, key, descriptor);
      }
    });
    var Float16Array = class _Float16Array {
      constructor(input, _byteOffset, _length) {
        let float16bitsArray;
        if (isFloat16Array(input)) {
          float16bitsArray = (0, _primordials.ReflectConstruct)(_primordials.NativeUint16Array, [getFloat16BitsArray(input)], new.target);
        } else if ((0, _is.isObject)(input) && !(0, _is.isAnyArrayBuffer)(input)) {
          let list;
          let length;
          if ((0, _is.isNativeTypedArray)(input)) {
            list = input;
            length = (0, _primordials.TypedArrayPrototypeGetLength)(input);
            const buffer2 = (0, _primordials.TypedArrayPrototypeGetBuffer)(input);
            if ((0, _spec.IsDetachedBuffer)(buffer2)) {
              throw (0, _primordials.NativeTypeError)(_messages.ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
            }
            if ((0, _is.isNativeBigIntTypedArray)(input)) {
              throw (0, _primordials.NativeTypeError)(_messages.CANNOT_MIX_BIGINT_AND_OTHER_TYPES);
            }
            const data = new _primordials.NativeArrayBuffer(length * BYTES_PER_ELEMENT);
            float16bitsArray = (0, _primordials.ReflectConstruct)(_primordials.NativeUint16Array, [data], new.target);
          } else {
            const iterator = input[_primordials.SymbolIterator];
            if (iterator != null && typeof iterator !== "function") {
              throw (0, _primordials.NativeTypeError)(_messages.ITERATOR_PROPERTY_IS_NOT_CALLABLE);
            }
            if (iterator != null) {
              if ((0, _is.isOrdinaryArray)(input)) {
                list = input;
                length = input.length;
              } else {
                list = [...input];
                length = list.length;
              }
            } else {
              list = input;
              length = (0, _spec.ToLength)(list.length);
            }
            float16bitsArray = (0, _primordials.ReflectConstruct)(_primordials.NativeUint16Array, [length], new.target);
          }
          for (let i8 = 0; i8 < length; ++i8) {
            float16bitsArray[i8] = (0, _converter.roundToFloat16Bits)(list[i8]);
          }
        } else {
          float16bitsArray = (0, _primordials.ReflectConstruct)(_primordials.NativeUint16Array, arguments, new.target);
        }
        const proxy2 = new _primordials.NativeProxy(float16bitsArray, handler);
        (0, _primordials.WeakMapPrototypeSet)(float16bitsArrays, proxy2, float16bitsArray);
        return proxy2;
      }
      static from(src, ...opts) {
        const Constructor = this;
        if (!(0, _primordials.ReflectHas)(Constructor, _brand.brand)) {
          throw (0, _primordials.NativeTypeError)(_messages.THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY);
        }
        if (Constructor === _Float16Array) {
          if (isFloat16Array(src) && opts.length === 0) {
            const float16bitsArray = getFloat16BitsArray(src);
            const uint16 = new _primordials.NativeUint16Array((0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetByteOffset)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray));
            return new _Float16Array((0, _primordials.TypedArrayPrototypeGetBuffer)((0, _primordials.TypedArrayPrototypeSlice)(uint16)));
          }
          if (opts.length === 0) {
            return new _Float16Array((0, _primordials.TypedArrayPrototypeGetBuffer)((0, _primordials.Uint16ArrayFrom)(src, _converter.roundToFloat16Bits)));
          }
          const mapFunc = opts[0];
          const thisArg = opts[1];
          return new _Float16Array((0, _primordials.TypedArrayPrototypeGetBuffer)((0, _primordials.Uint16ArrayFrom)(src, function(val2, ...args2) {
            return (0, _converter.roundToFloat16Bits)((0, _primordials.ReflectApply)(mapFunc, this, [val2, ...(0, _arrayIterator.safeIfNeeded)(args2)]));
          }, thisArg)));
        }
        let list;
        let length;
        const iterator = src[_primordials.SymbolIterator];
        if (iterator != null && typeof iterator !== "function") {
          throw (0, _primordials.NativeTypeError)(_messages.ITERATOR_PROPERTY_IS_NOT_CALLABLE);
        }
        if (iterator != null) {
          if ((0, _is.isOrdinaryArray)(src)) {
            list = src;
            length = src.length;
          } else if ((0, _is.isOrdinaryNativeTypedArray)(src)) {
            list = src;
            length = (0, _primordials.TypedArrayPrototypeGetLength)(src);
          } else {
            list = [...src];
            length = list.length;
          }
        } else {
          if (src == null) {
            throw (0, _primordials.NativeTypeError)(_messages.CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT);
          }
          list = (0, _primordials.NativeObject)(src);
          length = (0, _spec.ToLength)(list.length);
        }
        const array3 = new Constructor(length);
        if (opts.length === 0) {
          for (let i8 = 0; i8 < length; ++i8) {
            array3[i8] = list[i8];
          }
        } else {
          const mapFunc = opts[0];
          const thisArg = opts[1];
          for (let i8 = 0; i8 < length; ++i8) {
            array3[i8] = (0, _primordials.ReflectApply)(mapFunc, thisArg, [list[i8], i8]);
          }
        }
        return array3;
      }
      static of(...items) {
        const Constructor = this;
        if (!(0, _primordials.ReflectHas)(Constructor, _brand.brand)) {
          throw (0, _primordials.NativeTypeError)(_messages.THIS_CONSTRUCTOR_IS_NOT_A_SUBCLASS_OF_FLOAT16ARRAY);
        }
        const length = items.length;
        if (Constructor === _Float16Array) {
          const proxy2 = new _Float16Array(length);
          const float16bitsArray = getFloat16BitsArray(proxy2);
          for (let i8 = 0; i8 < length; ++i8) {
            float16bitsArray[i8] = (0, _converter.roundToFloat16Bits)(items[i8]);
          }
          return proxy2;
        }
        const array3 = new Constructor(length);
        for (let i8 = 0; i8 < length; ++i8) {
          array3[i8] = items[i8];
        }
        return array3;
      }
      keys() {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        return (0, _primordials.TypedArrayPrototypeKeys)(float16bitsArray);
      }
      values() {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        return (0, _arrayIterator.wrap)(function* () {
          for (const val2 of (0, _primordials.TypedArrayPrototypeValues)(float16bitsArray)) {
            yield (0, _converter.convertToNumber)(val2);
          }
        }());
      }
      entries() {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        return (0, _arrayIterator.wrap)(function* () {
          for (const [i8, val2] of (0, _primordials.TypedArrayPrototypeEntries)(float16bitsArray)) {
            yield [i8, (0, _converter.convertToNumber)(val2)];
          }
        }());
      }
      at(index7) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const relativeIndex = (0, _spec.ToIntegerOrInfinity)(index7);
        const k9 = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;
        if (k9 < 0 || k9 >= length) {
          return;
        }
        return (0, _converter.convertToNumber)(float16bitsArray[k9]);
      }
      with(index7, value) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const relativeIndex = (0, _spec.ToIntegerOrInfinity)(index7);
        const k9 = relativeIndex >= 0 ? relativeIndex : length + relativeIndex;
        const number2 = +value;
        if (k9 < 0 || k9 >= length) {
          throw (0, _primordials.NativeRangeError)(_messages.OFFSET_IS_OUT_OF_BOUNDS);
        }
        const uint16 = new _primordials.NativeUint16Array((0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetByteOffset)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray));
        const cloned = new _Float16Array((0, _primordials.TypedArrayPrototypeGetBuffer)((0, _primordials.TypedArrayPrototypeSlice)(uint16)));
        const array3 = getFloat16BitsArray(cloned);
        array3[k9] = (0, _converter.roundToFloat16Bits)(number2);
        return cloned;
      }
      map(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        const Constructor = (0, _spec.SpeciesConstructor)(float16bitsArray, _Float16Array);
        if (Constructor === _Float16Array) {
          const proxy2 = new _Float16Array(length);
          const array4 = getFloat16BitsArray(proxy2);
          for (let i8 = 0; i8 < length; ++i8) {
            const val2 = (0, _converter.convertToNumber)(float16bitsArray[i8]);
            array4[i8] = (0, _converter.roundToFloat16Bits)((0, _primordials.ReflectApply)(callback, thisArg, [val2, i8, this]));
          }
          return proxy2;
        }
        const array3 = new Constructor(length);
        assertSpeciesTypedArray(array3, length);
        for (let i8 = 0; i8 < length; ++i8) {
          const val2 = (0, _converter.convertToNumber)(float16bitsArray[i8]);
          array3[i8] = (0, _primordials.ReflectApply)(callback, thisArg, [val2, i8, this]);
        }
        return array3;
      }
      filter(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        const kept = [];
        for (let i8 = 0; i8 < length; ++i8) {
          const val2 = (0, _converter.convertToNumber)(float16bitsArray[i8]);
          if ((0, _primordials.ReflectApply)(callback, thisArg, [val2, i8, this])) {
            (0, _primordials.ArrayPrototypePush)(kept, val2);
          }
        }
        const Constructor = (0, _spec.SpeciesConstructor)(float16bitsArray, _Float16Array);
        const array3 = new Constructor(kept);
        assertSpeciesTypedArray(array3);
        return array3;
      }
      reduce(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        if (length === 0 && opts.length === 0) {
          throw (0, _primordials.NativeTypeError)(_messages.REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);
        }
        let accumulator, start2;
        if (opts.length === 0) {
          accumulator = (0, _converter.convertToNumber)(float16bitsArray[0]);
          start2 = 1;
        } else {
          accumulator = opts[0];
          start2 = 0;
        }
        for (let i8 = start2; i8 < length; ++i8) {
          accumulator = callback(accumulator, (0, _converter.convertToNumber)(float16bitsArray[i8]), i8, this);
        }
        return accumulator;
      }
      reduceRight(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        if (length === 0 && opts.length === 0) {
          throw (0, _primordials.NativeTypeError)(_messages.REDUCE_OF_EMPTY_ARRAY_WITH_NO_INITIAL_VALUE);
        }
        let accumulator, start2;
        if (opts.length === 0) {
          accumulator = (0, _converter.convertToNumber)(float16bitsArray[length - 1]);
          start2 = length - 2;
        } else {
          accumulator = opts[0];
          start2 = length - 1;
        }
        for (let i8 = start2; i8 >= 0; --i8) {
          accumulator = callback(accumulator, (0, _converter.convertToNumber)(float16bitsArray[i8]), i8, this);
        }
        return accumulator;
      }
      forEach(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        for (let i8 = 0; i8 < length; ++i8) {
          (0, _primordials.ReflectApply)(callback, thisArg, [(0, _converter.convertToNumber)(float16bitsArray[i8]), i8, this]);
        }
      }
      find(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        for (let i8 = 0; i8 < length; ++i8) {
          const value = (0, _converter.convertToNumber)(float16bitsArray[i8]);
          if ((0, _primordials.ReflectApply)(callback, thisArg, [value, i8, this])) {
            return value;
          }
        }
      }
      findIndex(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        for (let i8 = 0; i8 < length; ++i8) {
          const value = (0, _converter.convertToNumber)(float16bitsArray[i8]);
          if ((0, _primordials.ReflectApply)(callback, thisArg, [value, i8, this])) {
            return i8;
          }
        }
        return -1;
      }
      findLast(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        for (let i8 = length - 1; i8 >= 0; --i8) {
          const value = (0, _converter.convertToNumber)(float16bitsArray[i8]);
          if ((0, _primordials.ReflectApply)(callback, thisArg, [value, i8, this])) {
            return value;
          }
        }
      }
      findLastIndex(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        for (let i8 = length - 1; i8 >= 0; --i8) {
          const value = (0, _converter.convertToNumber)(float16bitsArray[i8]);
          if ((0, _primordials.ReflectApply)(callback, thisArg, [value, i8, this])) {
            return i8;
          }
        }
        return -1;
      }
      every(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        for (let i8 = 0; i8 < length; ++i8) {
          if (!(0, _primordials.ReflectApply)(callback, thisArg, [(0, _converter.convertToNumber)(float16bitsArray[i8]), i8, this])) {
            return false;
          }
        }
        return true;
      }
      some(callback, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const thisArg = opts[0];
        for (let i8 = 0; i8 < length; ++i8) {
          if ((0, _primordials.ReflectApply)(callback, thisArg, [(0, _converter.convertToNumber)(float16bitsArray[i8]), i8, this])) {
            return true;
          }
        }
        return false;
      }
      set(input, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const targetOffset = (0, _spec.ToIntegerOrInfinity)(opts[0]);
        if (targetOffset < 0) {
          throw (0, _primordials.NativeRangeError)(_messages.OFFSET_IS_OUT_OF_BOUNDS);
        }
        if (input == null) {
          throw (0, _primordials.NativeTypeError)(_messages.CANNOT_CONVERT_UNDEFINED_OR_NULL_TO_OBJECT);
        }
        if ((0, _is.isNativeBigIntTypedArray)(input)) {
          throw (0, _primordials.NativeTypeError)(_messages.CANNOT_MIX_BIGINT_AND_OTHER_TYPES);
        }
        if (isFloat16Array(input)) {
          return (0, _primordials.TypedArrayPrototypeSet)(getFloat16BitsArray(this), getFloat16BitsArray(input), targetOffset);
        }
        if ((0, _is.isNativeTypedArray)(input)) {
          const buffer2 = (0, _primordials.TypedArrayPrototypeGetBuffer)(input);
          if ((0, _spec.IsDetachedBuffer)(buffer2)) {
            throw (0, _primordials.NativeTypeError)(_messages.ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
          }
        }
        const targetLength = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const src = (0, _primordials.NativeObject)(input);
        const srcLength = (0, _spec.ToLength)(src.length);
        if (targetOffset === Infinity || srcLength + targetOffset > targetLength) {
          throw (0, _primordials.NativeRangeError)(_messages.OFFSET_IS_OUT_OF_BOUNDS);
        }
        for (let i8 = 0; i8 < srcLength; ++i8) {
          float16bitsArray[i8 + targetOffset] = (0, _converter.roundToFloat16Bits)(src[i8]);
        }
      }
      reverse() {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        (0, _primordials.TypedArrayPrototypeReverse)(float16bitsArray);
        return this;
      }
      toReversed() {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const uint16 = new _primordials.NativeUint16Array((0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetByteOffset)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray));
        const cloned = new _Float16Array((0, _primordials.TypedArrayPrototypeGetBuffer)((0, _primordials.TypedArrayPrototypeSlice)(uint16)));
        const clonedFloat16bitsArray = getFloat16BitsArray(cloned);
        (0, _primordials.TypedArrayPrototypeReverse)(clonedFloat16bitsArray);
        return cloned;
      }
      fill(value, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        (0, _primordials.TypedArrayPrototypeFill)(float16bitsArray, (0, _converter.roundToFloat16Bits)(value), ...(0, _arrayIterator.safeIfNeeded)(opts));
        return this;
      }
      copyWithin(target, start2, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        (0, _primordials.TypedArrayPrototypeCopyWithin)(float16bitsArray, target, start2, ...(0, _arrayIterator.safeIfNeeded)(opts));
        return this;
      }
      sort(compareFn) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const sortCompare = compareFn !== void 0 ? compareFn : _spec.defaultCompare;
        (0, _primordials.TypedArrayPrototypeSort)(float16bitsArray, (x11, y7) => {
          return sortCompare((0, _converter.convertToNumber)(x11), (0, _converter.convertToNumber)(y7));
        });
        return this;
      }
      toSorted(compareFn) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        if (compareFn !== void 0 && typeof compareFn !== "function") {
          throw new _primordials.NativeTypeError(_messages.THE_COMPARISON_FUNCTION_MUST_BE_EITHER_A_FUNCTION_OR_UNDEFINED);
        }
        const sortCompare = compareFn !== void 0 ? compareFn : _spec.defaultCompare;
        const uint16 = new _primordials.NativeUint16Array((0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetByteOffset)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray));
        const cloned = new _Float16Array((0, _primordials.TypedArrayPrototypeGetBuffer)((0, _primordials.TypedArrayPrototypeSlice)(uint16)));
        const clonedFloat16bitsArray = getFloat16BitsArray(cloned);
        (0, _primordials.TypedArrayPrototypeSort)(clonedFloat16bitsArray, (x11, y7) => {
          return sortCompare((0, _converter.convertToNumber)(x11), (0, _converter.convertToNumber)(y7));
        });
        return cloned;
      }
      slice(start2, end) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const Constructor = (0, _spec.SpeciesConstructor)(float16bitsArray, _Float16Array);
        if (Constructor === _Float16Array) {
          const uint16 = new _primordials.NativeUint16Array((0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetByteOffset)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray));
          return new _Float16Array((0, _primordials.TypedArrayPrototypeGetBuffer)((0, _primordials.TypedArrayPrototypeSlice)(uint16, start2, end)));
        }
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        const relativeStart = (0, _spec.ToIntegerOrInfinity)(start2);
        const relativeEnd = end === void 0 ? length : (0, _spec.ToIntegerOrInfinity)(end);
        let k9;
        if (relativeStart === -Infinity) {
          k9 = 0;
        } else if (relativeStart < 0) {
          k9 = length + relativeStart > 0 ? length + relativeStart : 0;
        } else {
          k9 = length < relativeStart ? length : relativeStart;
        }
        let final;
        if (relativeEnd === -Infinity) {
          final = 0;
        } else if (relativeEnd < 0) {
          final = length + relativeEnd > 0 ? length + relativeEnd : 0;
        } else {
          final = length < relativeEnd ? length : relativeEnd;
        }
        const count2 = final - k9 > 0 ? final - k9 : 0;
        const array3 = new Constructor(count2);
        assertSpeciesTypedArray(array3, count2);
        if (count2 === 0) {
          return array3;
        }
        const buffer2 = (0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray);
        if ((0, _spec.IsDetachedBuffer)(buffer2)) {
          throw (0, _primordials.NativeTypeError)(_messages.ATTEMPTING_TO_ACCESS_DETACHED_ARRAYBUFFER);
        }
        let n7 = 0;
        while (k9 < final) {
          array3[n7] = (0, _converter.convertToNumber)(float16bitsArray[k9]);
          ++k9;
          ++n7;
        }
        return array3;
      }
      subarray(begin, end) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const Constructor = (0, _spec.SpeciesConstructor)(float16bitsArray, _Float16Array);
        const uint16 = new _primordials.NativeUint16Array((0, _primordials.TypedArrayPrototypeGetBuffer)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetByteOffset)(float16bitsArray), (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray));
        const uint16Subarray = (0, _primordials.TypedArrayPrototypeSubarray)(uint16, begin, end);
        const array3 = new Constructor((0, _primordials.TypedArrayPrototypeGetBuffer)(uint16Subarray), (0, _primordials.TypedArrayPrototypeGetByteOffset)(uint16Subarray), (0, _primordials.TypedArrayPrototypeGetLength)(uint16Subarray));
        assertSpeciesTypedArray(array3);
        return array3;
      }
      indexOf(element, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        let from = (0, _spec.ToIntegerOrInfinity)(opts[0]);
        if (from === Infinity) {
          return -1;
        }
        if (from < 0) {
          from += length;
          if (from < 0) {
            from = 0;
          }
        }
        for (let i8 = from; i8 < length; ++i8) {
          if ((0, _primordials.ObjectHasOwn)(float16bitsArray, i8) && (0, _converter.convertToNumber)(float16bitsArray[i8]) === element) {
            return i8;
          }
        }
        return -1;
      }
      lastIndexOf(element, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        let from = opts.length >= 1 ? (0, _spec.ToIntegerOrInfinity)(opts[0]) : length - 1;
        if (from === -Infinity) {
          return -1;
        }
        if (from >= 0) {
          from = from < length - 1 ? from : length - 1;
        } else {
          from += length;
        }
        for (let i8 = from; i8 >= 0; --i8) {
          if ((0, _primordials.ObjectHasOwn)(float16bitsArray, i8) && (0, _converter.convertToNumber)(float16bitsArray[i8]) === element) {
            return i8;
          }
        }
        return -1;
      }
      includes(element, ...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const length = (0, _primordials.TypedArrayPrototypeGetLength)(float16bitsArray);
        let from = (0, _spec.ToIntegerOrInfinity)(opts[0]);
        if (from === Infinity) {
          return false;
        }
        if (from < 0) {
          from += length;
          if (from < 0) {
            from = 0;
          }
        }
        const isNaN2 = (0, _primordials.NumberIsNaN)(element);
        for (let i8 = from; i8 < length; ++i8) {
          const value = (0, _converter.convertToNumber)(float16bitsArray[i8]);
          if (isNaN2 && (0, _primordials.NumberIsNaN)(value)) {
            return true;
          }
          if (value === element) {
            return true;
          }
        }
        return false;
      }
      join(separator) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const array3 = copyToArray(float16bitsArray);
        return (0, _primordials.ArrayPrototypeJoin)(array3, separator);
      }
      toLocaleString(...opts) {
        assertFloat16Array(this);
        const float16bitsArray = getFloat16BitsArray(this);
        const array3 = copyToArray(float16bitsArray);
        return (0, _primordials.ArrayPrototypeToLocaleString)(array3, ...(0, _arrayIterator.safeIfNeeded)(opts));
      }
      get [_primordials.SymbolToStringTag]() {
        if (isFloat16Array(this)) {
          return "Float16Array";
        }
      }
    };
    exports2.Float16Array = Float16Array;
    (0, _primordials.ObjectDefineProperty)(Float16Array, "BYTES_PER_ELEMENT", {
      value: BYTES_PER_ELEMENT
    });
    (0, _primordials.ObjectDefineProperty)(Float16Array, _brand.brand, {});
    (0, _primordials.ReflectSetPrototypeOf)(Float16Array, _primordials.TypedArray);
    var Float16ArrayPrototype = Float16Array.prototype;
    (0, _primordials.ObjectDefineProperty)(Float16ArrayPrototype, "BYTES_PER_ELEMENT", {
      value: BYTES_PER_ELEMENT
    });
    (0, _primordials.ObjectDefineProperty)(Float16ArrayPrototype, _primordials.SymbolIterator, {
      value: Float16ArrayPrototype.values,
      writable: true,
      configurable: true
    });
    (0, _primordials.ReflectSetPrototypeOf)(Float16ArrayPrototype, _primordials.TypedArrayPrototype);
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/isTypedArray.cjs
var require_isTypedArray = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/isTypedArray.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.isTypedArray = isTypedArray;
    var _Float16Array = require_Float16Array();
    var _is = require_is();
    function isTypedArray(target) {
      return (0, _is.isNativeTypedArray)(target) || (0, _Float16Array.isFloat16Array)(target);
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/DataView.cjs
var require_DataView = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/DataView.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.getFloat16 = getFloat16;
    exports2.setFloat16 = setFloat16;
    var _arrayIterator = require_arrayIterator();
    var _converter = require_converter();
    var _primordials = require_primordials();
    function getFloat16(dataView, byteOffset, ...opts) {
      return (0, _converter.convertToNumber)((0, _primordials.DataViewPrototypeGetUint16)(dataView, byteOffset, ...(0, _arrayIterator.safeIfNeeded)(opts)));
    }
    function setFloat16(dataView, byteOffset, value, ...opts) {
      return (0, _primordials.DataViewPrototypeSetUint16)(dataView, byteOffset, (0, _converter.roundToFloat16Bits)(value), ...(0, _arrayIterator.safeIfNeeded)(opts));
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/f16round.cjs
var require_f16round = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/f16round.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    exports2.f16round = f16round;
    var _converter = require_converter();
    function f16round(x11) {
      return (0, _converter.roundToFloat16)(x11);
    }
  }
});

// ../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/index.cjs
var require_lib4 = __commonJS({
  "../node_modules/.pnpm/@petamoriken+float16@3.9.2/node_modules/@petamoriken/float16/lib/index.cjs"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", {
      value: true
    });
    var _Float16Array = require_Float16Array();
    exports2.Float16Array = _Float16Array.Float16Array;
    exports2.isFloat16Array = _Float16Array.isFloat16Array;
    var _isTypedArray = require_isTypedArray();
    exports2.isTypedArray = _isTypedArray.isTypedArray;
    var _DataView = require_DataView();
    exports2.getFloat16 = _DataView.getFloat16;
    exports2.setFloat16 = _DataView.setFloat16;
    var _f16round = require_f16round();
    exports2.f16round = _f16round.f16round;
    exports2.hfround = _f16round.f16round;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/utils.js
var require_utils4 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/utils.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.setFloat16 = exports2.isFloat16Array = exports2.getFloat16 = exports2.Float16Array = void 0;
    exports2.getUniqueId = getUniqueId;
    exports2.sleep = sleep;
    exports2.versionEqual = versionEqual;
    exports2.versionGreaterThan = versionGreaterThan;
    exports2.versionGreaterThanOrEqual = versionGreaterThanOrEqual;
    exports2.getAuthenticatedFetch = getAuthenticatedFetch;
    var float16_1 = require_lib4();
    Object.defineProperty(exports2, "Float16Array", { enumerable: true, get: function() {
      return float16_1.Float16Array;
    } });
    Object.defineProperty(exports2, "getFloat16", { enumerable: true, get: function() {
      return float16_1.getFloat16;
    } });
    Object.defineProperty(exports2, "isFloat16Array", { enumerable: true, get: function() {
      return float16_1.isFloat16Array;
    } });
    Object.defineProperty(exports2, "setFloat16", { enumerable: true, get: function() {
      return float16_1.setFloat16;
    } });
    var idCounter = {};
    function getUniqueId(prefix2 = "") {
      if (!idCounter[prefix2]) {
        idCounter[prefix2] = 0;
      }
      const id = ++idCounter[prefix2];
      return `_gel_${prefix2}_${id.toString(16)}_`;
    }
    function sleep(durationMillis) {
      return new Promise((accept) => {
        setTimeout(() => accept(), durationMillis);
      });
    }
    function versionEqual(left, right) {
      return left[0] === right[0] && left[1] === right[1];
    }
    function versionGreaterThan(left, right) {
      if (left[0] > right[0]) {
        return true;
      }
      if (left[0] < right[0]) {
        return false;
      }
      return left[1] > right[1];
    }
    function versionGreaterThanOrEqual(left, right) {
      if (left[0] === right[0] && left[1] === right[1]) {
        return true;
      }
      return versionGreaterThan(left, right);
    }
    var _tokens = /* @__PURE__ */ new WeakMap();
    async function getAuthenticatedFetch(config, httpSCRAMAuth, basePath) {
      let token = config.secretKey ?? _tokens.get(config);
      const { address, tlsSecurity, database } = config;
      const protocol2 = tlsSecurity === "insecure" ? "http" : "https";
      const baseUrl = `${protocol2}://${address[0]}:${address[1]}`;
      const databaseUrl = `${baseUrl}/db/${database}/${basePath ?? ""}`;
      if (!token && config.password != null) {
        token = await httpSCRAMAuth(baseUrl, config.user, config.password);
        _tokens.set(config, token);
      }
      return (input, init3) => {
        let path3;
        if (typeof input === "string") {
          path3 = input;
        } else if (input instanceof Request) {
          path3 = input.url;
        } else
          path3 = input.toString();
        const url = new URL(path3, databaseUrl);
        const headers = new Headers(init3?.headers);
        if (config.user !== void 0) {
          headers.append("X-EdgeDB-User", config.user);
        }
        if (token !== void 0) {
          headers.append("Authorization", `Bearer ${token}`);
        }
        return fetch(url, {
          ...init3,
          headers
        });
      };
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/pgvector.js
var require_pgvector = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/pgvector.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SparseVector = void 0;
    var SparseVector = class {
      constructor(length, indexesOrMap, values2) {
        __publicField(this, "length");
        __publicField(this, "indexes");
        __publicField(this, "values");
        this.length = length;
        if (indexesOrMap instanceof Uint32Array) {
          if (indexesOrMap.length !== values2?.length) {
            throw new Error("indexes array must be the same length as the data array");
          }
          if (indexesOrMap.length > length) {
            throw new Error("length of data cannot be larger than length of sparse vector");
          }
          this.values = values2;
          this.indexes = indexesOrMap;
        } else {
          const entries = Object.entries(indexesOrMap);
          if (entries.length > length) {
            throw new Error("length of data cannot be larger than length of sparse vector");
          }
          this.indexes = new Uint32Array(entries.length);
          this.values = new Float32Array(entries.length);
          for (let i8 = 0; i8 < entries.length; i8++) {
            const index7 = parseInt(entries[i8][0], 10);
            const val2 = entries[i8][1];
            if (Number.isNaN(index7)) {
              throw new Error(`key ${entries[i8][0]} in data map is not an integer`);
            }
            if (index7 < 0 || index7 >= length) {
              throw new Error(`index ${index7} is out of range of sparse vector length`);
            }
            this.indexes[i8] = index7;
            if (typeof val2 !== "number") {
              throw new Error(`expected value at index ${index7} to be number, got ${typeof val2} ${val2}`);
            }
            if (val2 === 0) {
              throw new Error("elements in sparse vector cannot be 0");
            }
            this.values[i8] = val2;
          }
        }
        return new Proxy(this, {
          get(target, p11) {
            const index7 = typeof p11 === "string" ? parseInt(p11, 10) : NaN;
            if (!Number.isNaN(index7)) {
              if (index7 < 0 || index7 >= target.length)
                return void 0;
              const dataIndex = target.indexes.indexOf(index7);
              return dataIndex === -1 ? 0 : target.values[dataIndex];
            }
            return target[p11];
          }
        });
      }
      *[Symbol.iterator]() {
        let nextIndex = 0;
        for (let i8 = 0; i8 < this.length; i8++) {
          yield this.indexes[nextIndex] === i8 ? this.values[nextIndex++] : 0;
        }
      }
    };
    exports2.SparseVector = SparseVector;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/pgvector.js
var require_pgvector2 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/pgvector.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PgVectorSparseVecCodec = exports2.PgVectorHalfVecCodec = exports2.PgVectorCodec = exports2.PG_VECTOR_MAX_DIM = void 0;
    var ifaces_1 = require_ifaces();
    var errors_1 = require_errors();
    var utils_1 = require_utils4();
    var pgvector_1 = require_pgvector();
    exports2.PG_VECTOR_MAX_DIM = (1 << 16) - 1;
    var PgVectorCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "Float32Array");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (!(object2 instanceof Float32Array || Array.isArray(object2))) {
          throw new errors_1.InvalidArgumentError(`a Float32Array or array of numbers was expected, got "${object2}"`);
        }
        if (object2.length > exports2.PG_VECTOR_MAX_DIM) {
          throw new errors_1.InvalidArgumentError("too many elements in array to encode into pgvector");
        }
        buf.writeInt32(4 + object2.length * 4).writeUInt16(object2.length).writeUInt16(0);
        if (object2 instanceof Float32Array) {
          for (const el of object2) {
            buf.writeFloat32(el);
          }
        } else {
          for (const el of object2) {
            if (typeof el !== "number") {
              throw new errors_1.InvalidArgumentError(`elements of vector array expected to be a numbers, got "${el}"`);
            }
            buf.writeFloat32(el);
          }
        }
      }
      decode(buf, ctx) {
        const dim = buf.readUInt16();
        buf.discard(2);
        const vecBuf = buf.readBuffer(dim * 4);
        const data = new DataView(vecBuf.buffer, vecBuf.byteOffset, vecBuf.byteLength);
        const vec = new Float32Array(dim);
        for (let i8 = 0; i8 < dim; i8++) {
          vec[i8] = data.getFloat32(i8 * 4);
        }
        return ctx.postDecode(this, vec);
      }
    };
    exports2.PgVectorCodec = PgVectorCodec;
    var PgVectorHalfVecCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "Float16Array");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        object2 = ctx.preEncode(this, object2);
        if (!((0, utils_1.isFloat16Array)(object2) || Array.isArray(object2))) {
          throw new errors_1.InvalidArgumentError(`a Float16Array or array of numbers was expected, got "${object2}"`);
        }
        if (object2.length > exports2.PG_VECTOR_MAX_DIM) {
          throw new errors_1.InvalidArgumentError("too many elements in array to encode into pgvector");
        }
        buf.writeInt32(4 + object2.length * 2).writeUInt16(object2.length).writeUInt16(0);
        const vecBuf = new Uint8Array(object2.length * 2);
        const data = new DataView(vecBuf.buffer, vecBuf.byteOffset, vecBuf.byteLength);
        if ((0, utils_1.isFloat16Array)(object2)) {
          for (let i8 = 0; i8 < object2.length; i8++) {
            (0, utils_1.setFloat16)(data, i8 * 2, object2[i8]);
          }
        } else {
          for (let i8 = 0; i8 < object2.length; i8++) {
            if (typeof object2[i8] !== "number") {
              throw new errors_1.InvalidArgumentError(`elements of vector array expected to be a numbers, got "${object2[i8]}"`);
            }
            (0, utils_1.setFloat16)(data, i8 * 2, object2[i8]);
          }
        }
        buf.writeBuffer(vecBuf);
      }
      decode(buf, ctx) {
        const dim = buf.readUInt16();
        buf.discard(2);
        const vecBuf = buf.readBuffer(dim * 2);
        const data = new DataView(vecBuf.buffer, vecBuf.byteOffset, vecBuf.byteLength);
        const vec = new utils_1.Float16Array(dim);
        for (let i8 = 0; i8 < dim; i8++) {
          vec[i8] = (0, utils_1.getFloat16)(data, i8 * 2);
        }
        return ctx.postDecode(this, vec);
      }
    };
    exports2.PgVectorHalfVecCodec = PgVectorHalfVecCodec;
    var PgVectorSparseVecCodec = class extends ifaces_1.ScalarCodec {
      constructor() {
        super(...arguments);
        __publicField(this, "tsType", "SparseVector");
        __publicField(this, "tsModule", "gel");
      }
      encode(buf, object2, ctx) {
        let dims;
        let indexes;
        let values2;
        if (ctx.hasOverload(this)) {
          [dims, indexes, values2] = ctx.preEncode(this, object2);
        } else {
          if (!(object2 instanceof pgvector_1.SparseVector)) {
            throw new errors_1.InvalidArgumentError(`a SparseVector was expected, got "${object2}"`);
          }
          dims = object2.length;
          indexes = object2.indexes;
          values2 = object2.values;
        }
        const indexesLength = indexes.length;
        if (indexesLength > exports2.PG_VECTOR_MAX_DIM || indexesLength > dims) {
          throw new errors_1.InvalidArgumentError("too many elements in sparse vector value");
        }
        buf.writeUInt32(4 * (3 + indexesLength * 2)).writeUInt32(dims).writeUInt32(indexesLength).writeUInt32(0);
        const vecBuf = new Uint8Array(indexesLength * 8);
        const data = new DataView(vecBuf.buffer, vecBuf.byteOffset, vecBuf.byteLength);
        for (let i8 = 0; i8 < indexesLength; i8++) {
          data.setUint32(i8 * 4, indexes[i8]);
        }
        for (let i8 = 0; i8 < indexesLength; i8++) {
          data.setFloat32((indexesLength + i8) * 4, values2[i8]);
        }
        buf.writeBuffer(vecBuf);
      }
      decode(buf, ctx) {
        const dim = buf.readUInt32();
        const nnz = buf.readUInt32();
        buf.discard(4);
        const vecBuf = buf.readBuffer(nnz * 8);
        const data = new DataView(vecBuf.buffer, vecBuf.byteOffset, vecBuf.byteLength);
        const indexes = new Uint32Array(nnz);
        for (let i8 = 0; i8 < nnz; i8++) {
          indexes[i8] = data.getUint32(i8 * 4);
        }
        const vecData = new Float32Array(nnz);
        for (let i8 = 0; i8 < nnz; i8++) {
          vecData[i8] = data.getFloat32((i8 + nnz) * 4);
        }
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, [
            dim,
            indexes,
            vecData
          ]);
        }
        return new pgvector_1.SparseVector(dim, indexes, vecData);
      }
    };
    exports2.PgVectorSparseVecCodec = PgVectorSparseVecCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/postgis.js
var require_postgis = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/postgis.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Box3D = exports2.Box2D = exports2.GeometryCollection = exports2.MultiSurface = exports2.TriangulatedIrregularNetwork = exports2.PolyhedralSurface = exports2.MultiPolygon = exports2.CurvePolygon = exports2.Triangle = exports2.Polygon = exports2.MultiCurve = exports2.CompoundCurve = exports2.MultiLineString = exports2.CircularString = exports2.LineString = exports2.MultiPoint = exports2.Point = exports2.Geometry = void 0;
    var Geometry = class {
    };
    exports2.Geometry = Geometry;
    function _pointToWKT(p11) {
      return `${p11.x} ${p11.y}${p11.z !== null ? ` ${p11.z}` : ""}${p11.m !== null ? ` ${p11.m}` : ""}`;
    }
    function _flagsToWKT(z6, m12) {
      return (z6 || m12 ? " " : "") + (z6 ? "Z" : "") + (m12 ? "M" : "");
    }
    function _sridWKTPrefix(srid, depth) {
      return srid !== null && depth === 0 ? `SRID=${srid}; ` : "";
    }
    function _indent(indent, depth) {
      if (!indent)
        return "";
      return "\n" + " ".repeat(indent * depth);
    }
    var Point = class extends Geometry {
      constructor(x11, y7, z6 = null, m12 = null, srid = null) {
        super();
        __publicField(this, "x");
        __publicField(this, "y");
        __publicField(this, "z");
        __publicField(this, "m");
        __publicField(this, "srid");
        this.x = x11;
        this.y = y7;
        this.z = z6;
        this.m = m12;
        this.srid = srid;
      }
      get hasZ() {
        return this.z !== null;
      }
      get hasM() {
        return this.m !== null;
      }
      toWKT(_indent2, _truncate = Infinity, depth = 0) {
        return `${_sridWKTPrefix(this.srid, depth)}POINT${_flagsToWKT(this.z !== null, this.m !== null)} ${Number.isNaN(this.x) ? "EMPTY" : "(" + _pointToWKT(this) + ")"}`;
      }
      equals(other) {
        return this.srid === other.srid && (Number.isNaN(this.x) ? this.hasZ === other.hasZ && this.hasM === other.hasM : this.x === other.x && this.y === other.y && this.z === other.z && this.m === other.m);
      }
    };
    exports2.Point = Point;
    var MultiPoint = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        let wkt = `${_sridWKTPrefix(this.srid, depth)}MULTIPOINT${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        wkt += `(`;
        let i8 = 0;
        while (i8 < this.geometries.length && wkt.length < truncate) {
          wkt += _indent(indent, depth + 1) + "(" + _pointToWKT(this.geometries[i8++]) + (i8 < this.geometries.length ? "), " : ")");
        }
        return wkt + _indent(indent, depth) + ")";
      }
    };
    exports2.MultiPoint = MultiPoint;
    function _linestringToWKT(points, indent, truncate = Infinity, depth = 0) {
      let wkt = `(`;
      let i8 = 0;
      while (i8 < points.length && wkt.length < truncate) {
        wkt += _indent(indent, depth + 1) + _pointToWKT(points[i8++]) + (i8 < points.length ? ", " : "");
      }
      return wkt + _indent(indent, depth) + ")";
    }
    var LineString = class extends Geometry {
      constructor(points, hasZ, hasM, srid) {
        super();
        __publicField(this, "points");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.points = points;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
        this._validate();
      }
      _validate() {
        if (this.points.length === 1) {
          throw new Error(`expected zero, or 2 or more points in LineString`);
        }
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        const wkt = `${_sridWKTPrefix(this.srid, depth)}${this.constructor._wktName}${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.points.length === 0) {
          return wkt + "EMPTY";
        }
        return wkt + _linestringToWKT(this.points, indent, truncate - wkt.length, depth);
      }
    };
    __publicField(LineString, "_wktName", "LINESTRING");
    exports2.LineString = LineString;
    var CircularString = class extends LineString {
      _validate() {
        if (this.points.length !== 0 && (this.points.length <= 1 || this.points.length % 2 !== 1)) {
          throw new Error(`expected zero points, or odd number of points greater than 1 in CircularString`);
        }
      }
    };
    __publicField(CircularString, "_wktName", "CIRCULARSTRING");
    exports2.CircularString = CircularString;
    function _multilinestringToWKT(lineStrings, indent, truncate = Infinity, depth = 0) {
      let wkt = `(`;
      let i8 = 0;
      while (i8 < lineStrings.length && wkt.length < truncate) {
        wkt += _indent(indent, depth + 1) + _linestringToWKT(lineStrings[i8++].points, indent, truncate - wkt.length, depth + 1) + (i8 < lineStrings.length ? ", " : "");
      }
      return wkt + _indent(indent, depth) + ")";
    }
    var MultiLineString = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        const wkt = `${_sridWKTPrefix(this.srid, depth)}MULTILINESTRING${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        return wkt + _multilinestringToWKT(this.geometries, indent, truncate - wkt.length, depth);
      }
    };
    exports2.MultiLineString = MultiLineString;
    var CompoundCurve = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
        let lastPoint = null;
        for (const segment of geometries) {
          if (lastPoint && !segment.points[0].equals(lastPoint)) {
            throw new Error("segments in CompoundCurve do not join");
          }
          lastPoint = segment.points[segment.points.length - 1];
        }
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        let wkt = `${_sridWKTPrefix(this.srid, depth)}COMPOUNDCURVE${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        wkt += "(";
        let i8 = 0;
        while (i8 < this.geometries.length && wkt.length < truncate) {
          wkt += _indent(indent, depth + 1) + (this.geometries[i8] instanceof CircularString ? "CIRCULARSTRING " : "LINESTRING ") + _linestringToWKT(this.geometries[i8++].points, indent, truncate - wkt.length, depth + 1) + (i8 < this.geometries.length ? ", " : "");
        }
        return wkt + _indent(indent, depth) + ")";
      }
    };
    exports2.CompoundCurve = CompoundCurve;
    var MultiCurve = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        let wkt = `${_sridWKTPrefix(this.srid, depth)}MULTICURVE${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        wkt += `(`;
        let i8 = 0;
        while (i8 < this.geometries.length && wkt.length < truncate) {
          wkt += _indent(indent, depth + 1) + this.geometries[i8++].toWKT(indent, truncate - wkt.length, depth + 1) + (i8 < this.geometries.length ? ", " : "");
        }
        return wkt + _indent(indent, depth) + ")";
      }
    };
    exports2.MultiCurve = MultiCurve;
    var Polygon = class extends Geometry {
      constructor(rings, hasZ, hasM, srid) {
        super();
        __publicField(this, "rings");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.rings = rings;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
        this._validate();
      }
      _validate() {
        if (this.rings.some((ring) => ring.points.length < 4 || !ring.points[0].equals(ring.points[ring.points.length - 1]))) {
          throw new Error("expected rings in Polygon to be closed and to have at least 4 points");
        }
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        const wkt = `${_sridWKTPrefix(this.srid, depth)}${this.constructor._wktName}${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.rings.length === 0) {
          return wkt + "EMPTY";
        }
        return wkt + _multilinestringToWKT(this.rings, indent, truncate - wkt.length, depth);
      }
    };
    __publicField(Polygon, "_wktName", "POLYGON");
    exports2.Polygon = Polygon;
    var Triangle = class extends Polygon {
      _validate() {
        if (this.rings.length > 1) {
          throw new Error("Triangle can only contain a single ring");
        }
        if (this.rings.some((ring) => ring.points.length !== 4 || !ring.points[0].equals(ring.points[ring.points.length - 1]))) {
          throw new Error("expected Triangle to be closed and to have exactly 4 points");
        }
      }
    };
    __publicField(Triangle, "_wktName", "TRIANGLE");
    exports2.Triangle = Triangle;
    var CurvePolygon = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
        if (this.geometries.some((ring) => ring instanceof LineString && ring.points.length < 4 || (ring instanceof CompoundCurve ? !ring.geometries[0].points[0].equals(ring.geometries[ring.geometries.length - 1].points[ring.geometries[ring.geometries.length - 1].points.length - 1]) : !ring.points[0].equals(ring.points[ring.points.length - 1])))) {
          throw new Error("expected rings in CurvePolygon to be closed and LinearRings to have at least 4 points");
        }
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        let wkt = `${_sridWKTPrefix(this.srid, depth)}CURVEPOLYGON${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        wkt += `(`;
        let i8 = 0;
        while (i8 < this.geometries.length && wkt.length < truncate) {
          wkt += _indent(indent, depth + 1) + this.geometries[i8++].toWKT(indent, truncate - wkt.length, depth + 1) + (i8 < this.geometries.length ? ", " : "");
        }
        return wkt + _indent(indent, depth) + ")";
      }
    };
    exports2.CurvePolygon = CurvePolygon;
    var MultiPolygon = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        let wkt = `${_sridWKTPrefix(this.srid, depth)}${this.constructor._wktName}${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        wkt += `(`;
        let i8 = 0;
        while (i8 < this.geometries.length && wkt.length < truncate) {
          wkt += _indent(indent, depth + 1) + _multilinestringToWKT(this.geometries[i8++].rings, indent, truncate - wkt.length, depth + 1) + (i8 < this.geometries.length ? ", " : "");
        }
        return wkt + _indent(indent, depth) + ")";
      }
    };
    __publicField(MultiPolygon, "_wktName", "MULTIPOLYGON");
    exports2.MultiPolygon = MultiPolygon;
    var PolyhedralSurface = class extends MultiPolygon {
    };
    __publicField(PolyhedralSurface, "_wktName", "POLYHEDRALSURFACE");
    exports2.PolyhedralSurface = PolyhedralSurface;
    var TriangulatedIrregularNetwork = class extends MultiPolygon {
    };
    __publicField(TriangulatedIrregularNetwork, "_wktName", "TIN");
    exports2.TriangulatedIrregularNetwork = TriangulatedIrregularNetwork;
    var MultiSurface = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        let wkt = `${_sridWKTPrefix(this.srid, depth)}MULTISURFACE${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        wkt += `(`;
        let i8 = 0;
        while (i8 < this.geometries.length && wkt.length < truncate) {
          wkt += _indent(indent, depth + 1) + this.geometries[i8++].toWKT(indent, truncate - wkt.length, depth + 1) + (i8 < this.geometries.length ? ", " : "");
        }
        return wkt + _indent(indent, depth) + ")";
      }
    };
    exports2.MultiSurface = MultiSurface;
    var GeometryCollection = class extends Geometry {
      constructor(geometries, hasZ, hasM, srid) {
        super();
        __publicField(this, "geometries");
        __publicField(this, "hasZ");
        __publicField(this, "hasM");
        __publicField(this, "srid");
        this.geometries = geometries;
        this.hasZ = hasZ;
        this.hasM = hasM;
        this.srid = srid;
      }
      toWKT(indent, truncate = Infinity, depth = 0) {
        let wkt = `${_sridWKTPrefix(this.srid, depth)}GEOMETRYCOLLECTION${_flagsToWKT(this.hasZ, this.hasM)} `;
        if (this.geometries.length === 0) {
          return wkt + "EMPTY";
        }
        wkt += `(`;
        let i8 = 0;
        while (i8 < this.geometries.length && wkt.length < truncate) {
          wkt += _indent(indent, depth + 1) + this.geometries[i8++].toWKT(indent, truncate - wkt.length, depth + 1) + (i8 < this.geometries.length ? ", " : "");
        }
        return wkt + _indent(indent, depth) + ")";
      }
    };
    exports2.GeometryCollection = GeometryCollection;
    var Box2D = class {
      constructor(min2, max2) {
        __publicField(this, "min");
        __publicField(this, "max");
        this.min = min2;
        this.max = max2;
      }
      toString() {
        return `BOX(${this.min[0]} ${this.min[1]}, ${this.max[0]} ${this.max[1]})`;
      }
    };
    exports2.Box2D = Box2D;
    var Box3D = class {
      constructor(min2, max2) {
        __publicField(this, "min");
        __publicField(this, "max");
        this.min = min2;
        this.max = max2;
      }
      toString() {
        return `BOX3D(${this.min[0]} ${this.min[1]} ${this.min[2]}, ${this.max[0]} ${this.max[1]} ${this.max[2]})`;
      }
    };
    exports2.Box3D = Box3D;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/postgis.js
var require_postgis2 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/postgis.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.PostgisBox3dCodec = exports2.PostgisBox2dCodec = exports2.PostgisGeometryCodec = void 0;
    var postgis_1 = require_postgis();
    var errors_1 = require_errors();
    var ifaces_1 = require_ifaces();
    var PostgisGeometryCodec = class extends ifaces_1.ScalarCodec {
      encode(buf, object2, ctx) {
        if (ctx.hasOverload(this)) {
          const geomBuf = ctx.preEncode(this, object2);
          buf.writeBytes(geomBuf);
        } else {
          if (!(object2 instanceof postgis_1.Geometry)) {
            throw new errors_1.InvalidArgumentError(`a Geometry object was expected, got "${object2}"`);
          }
          const finalise = buf.writeDeferredSize();
          _encodeGeometry(buf, object2);
          finalise();
        }
      }
      decode(buf, ctx) {
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, buf.consumeAsBuffer());
        }
        return _parseGeometry(buf);
      }
    };
    exports2.PostgisGeometryCodec = PostgisGeometryCodec;
    var PostgisBox2dCodec = class extends ifaces_1.ScalarCodec {
      encode(buf, object2, ctx) {
        let min2;
        let max2;
        if (ctx.hasOverload(this)) {
          [min2, max2] = ctx.preEncode(this, object2);
        } else {
          if (!(object2 instanceof postgis_1.Box2D)) {
            throw new errors_1.InvalidArgumentError(`a Box2D object was expected, got "${object2}"`);
          }
          min2 = object2.min;
          max2 = object2.max;
        }
        const finalise = buf.writeDeferredSize();
        _encodeGeometry(buf, new postgis_1.Polygon([
          new postgis_1.LineString([
            new postgis_1.Point(min2[0], min2[1]),
            new postgis_1.Point(min2[0], max2[1]),
            new postgis_1.Point(max2[0], max2[1]),
            new postgis_1.Point(min2[0], min2[1])
          ], false, false, null)
        ], false, false, null));
        finalise();
      }
      decode(buf, ctx) {
        const poly = _parseGeometry(buf);
        if (poly.constructor !== postgis_1.Polygon || poly.hasZ || poly.rings.length !== 1 || poly.rings[0].points.length !== 5) {
          throw new errors_1.InternalClientError(`failed to decode ext::postgis::box2d type`);
        }
        const points = poly.rings[0].points;
        const min2 = [points[0].x, points[0].y];
        const max2 = [points[2].x, points[2].y];
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, [min2, max2]);
        }
        return new postgis_1.Box2D(min2, max2);
      }
    };
    exports2.PostgisBox2dCodec = PostgisBox2dCodec;
    var PostgisBox3dCodec = class extends ifaces_1.ScalarCodec {
      encode(buf, object2, ctx) {
        let min2;
        let max2;
        if (ctx.hasOverload(this)) {
          [min2, max2] = ctx.preEncode(this, object2);
        } else {
          if (!(object2 instanceof postgis_1.Box3D)) {
            throw new errors_1.InvalidArgumentError(`a Box3D object was expected, got "${object2}"`);
          }
          min2 = object2.min;
          max2 = object2.max;
        }
        const finalise = buf.writeDeferredSize();
        _encodeGeometry(buf, new postgis_1.Polygon([
          new postgis_1.LineString([
            new postgis_1.Point(min2[0], min2[1], min2[2]),
            new postgis_1.Point(min2[0], max2[1], max2[2]),
            new postgis_1.Point(max2[0], max2[1], max2[2]),
            new postgis_1.Point(min2[0], min2[1], min2[2])
          ], true, false, null)
        ], true, false, null));
        finalise();
      }
      decode(buf, ctx) {
        const poly = _parseGeometry(buf);
        let min2;
        let max2;
        if (poly.constructor === postgis_1.Polygon && poly.rings.length === 1 && poly.rings[0].points.length === 5) {
          const points = poly.rings[0].points;
          min2 = points[0];
          max2 = points[2];
        } else if (poly.constructor === postgis_1.PolyhedralSurface && poly.geometries.length === 6 && poly.geometries[0].rings.length === 1 && poly.geometries[0].rings[0].points.length === 5) {
          min2 = poly.geometries[0].rings[0].points[0];
          max2 = poly.geometries[5].rings[0].points[2];
        } else {
          throw new errors_1.InternalClientError(`failed to decode ext::postgis::box3d type`);
        }
        if (ctx.hasOverload(this)) {
          return ctx.postDecode(this, [
            [min2.x, min2.y, min2.z ?? 0],
            [max2.x, max2.y, max2.z ?? 0]
          ]);
        }
        return new postgis_1.Box3D([min2.x, min2.y, min2.z ?? 0], [max2.x, max2.y, max2.z ?? 0]);
      }
    };
    exports2.PostgisBox3dCodec = PostgisBox3dCodec;
    var zFlag = 2147483648;
    var mFlag = 1073741824;
    var sridFlag = 536870912;
    var allFlags = zFlag | mFlag | sridFlag;
    function _parseGeometry(buf, srid = null) {
      const le2 = buf.readUInt8() === 1;
      let type = buf.readUInt32(le2);
      const z6 = (type & zFlag) !== 0;
      const m12 = (type & mFlag) !== 0;
      if ((type & sridFlag) !== 0) {
        srid = buf.readUInt32(le2);
      }
      type = type & ~allFlags;
      switch (type) {
        case 1:
          return _parsePoint(buf, le2, z6, m12, srid);
        case 2:
          return _parseLineString(buf, postgis_1.LineString, le2, z6, m12, srid);
        case 3:
          return _parsePolygon(buf, postgis_1.Polygon, le2, z6, m12, srid);
        case 4:
          return _parseMultiPoint(buf, le2, z6, m12, srid);
        case 5:
          return _parseMultiLineString(buf, le2, z6, m12, srid);
        case 6:
          return _parseMultiPolygon(buf, postgis_1.MultiPolygon, le2, z6, m12, srid);
        case 7:
          return _parseGeometryCollection(buf, le2, z6, m12, srid);
        case 8:
          return _parseLineString(buf, postgis_1.CircularString, le2, z6, m12, srid);
        case 9:
          return _parseCompoundCurve(buf, le2, z6, m12, srid);
        case 10:
          return _parseMultiCurve(buf, postgis_1.CurvePolygon, le2, z6, m12, srid);
        case 11:
          return _parseMultiCurve(buf, postgis_1.MultiCurve, le2, z6, m12, srid);
        case 12:
          return _parseMultiSurface(buf, le2, z6, m12, srid);
        case 15:
          return _parseMultiPolygon(buf, postgis_1.PolyhedralSurface, le2, z6, m12, srid);
        case 16:
          return _parseMultiPolygon(buf, postgis_1.TriangulatedIrregularNetwork, le2, z6, m12, srid);
        case 17:
          return _parsePolygon(buf, postgis_1.Triangle, le2, z6, m12, srid);
        default:
          throw new Error(`unsupported wkb type: ${type}`);
      }
    }
    function _parsePoint(buf, le2, z6, m12, srid) {
      return new postgis_1.Point(buf.readFloat64(le2), buf.readFloat64(le2), z6 ? buf.readFloat64(le2) : null, m12 ? buf.readFloat64(le2) : null, srid);
    }
    function _parseLineString(buf, cls, le2, z6, m12, srid) {
      const pointCount = buf.readUInt32(le2);
      const points = new Array(pointCount);
      for (let i8 = 0; i8 < pointCount; i8++) {
        points[i8] = _parsePoint(buf, le2, z6, m12, srid);
      }
      return new cls(points, z6, m12, srid);
    }
    function _parsePolygon(buf, cls, le2, z6, m12, srid) {
      const ringCount = buf.readUInt32(le2);
      const rings = new Array(ringCount);
      for (let i8 = 0; i8 < ringCount; i8++) {
        rings[i8] = _parseLineString(buf, postgis_1.LineString, le2, z6, m12, srid);
      }
      return new cls(rings, z6, m12, srid);
    }
    function _parseMultiPoint(buf, le2, z6, m12, srid) {
      const pointCount = buf.readUInt32(le2);
      const points = new Array(pointCount);
      for (let i8 = 0; i8 < pointCount; i8++) {
        buf.discard(5);
        points[i8] = _parsePoint(buf, le2, z6, m12, srid);
      }
      return new postgis_1.MultiPoint(points, z6, m12, srid);
    }
    function _parseMultiLineString(buf, le2, z6, m12, srid) {
      const lineStringCount = buf.readUInt32(le2);
      const lineStrings = new Array(lineStringCount);
      for (let i8 = 0; i8 < lineStringCount; i8++) {
        buf.discard(5);
        lineStrings[i8] = _parseLineString(buf, postgis_1.LineString, le2, z6, m12, srid);
      }
      return new postgis_1.MultiLineString(lineStrings, z6, m12, srid);
    }
    function _parseCompoundCurve(buf, le2, z6, m12, srid) {
      const curveCount = buf.readUInt32(le2);
      const curves = new Array(curveCount);
      for (let i8 = 0; i8 < curveCount; i8++) {
        buf.discard(1);
        const type = buf.readUInt32(le2) & ~allFlags;
        switch (type) {
          case 2:
            curves[i8] = _parseLineString(buf, postgis_1.LineString, le2, z6, m12, srid);
            break;
          case 8:
            curves[i8] = _parseLineString(buf, postgis_1.CircularString, le2, z6, m12, srid);
            break;
          default:
            throw new Error(`unexpected type ${type} in CompoundCurve`);
        }
      }
      return new postgis_1.CompoundCurve(curves, z6, m12, srid);
    }
    function _parseMultiCurve(buf, cls, le2, z6, m12, srid) {
      const curveCount = buf.readUInt32(le2);
      const curves = new Array(curveCount);
      for (let i8 = 0; i8 < curveCount; i8++) {
        buf.discard(1);
        const type = buf.readUInt32(le2) & ~allFlags;
        switch (type) {
          case 2:
            curves[i8] = _parseLineString(buf, postgis_1.LineString, le2, z6, m12, srid);
            break;
          case 8:
            curves[i8] = _parseLineString(buf, postgis_1.CircularString, le2, z6, m12, srid);
            break;
          case 9:
            curves[i8] = _parseCompoundCurve(buf, le2, z6, m12, srid);
            break;
          default:
            throw new Error(`unexpected type ${type} in MultiCurve/CurvePolygon`);
        }
      }
      return new cls(curves, z6, m12, srid);
    }
    function _parseMultiPolygon(buf, cls, le2, z6, m12, srid) {
      const polyCls = cls === postgis_1.TriangulatedIrregularNetwork ? postgis_1.Triangle : postgis_1.Polygon;
      const polyCount = buf.readUInt32(le2);
      const polys = new Array(polyCount);
      for (let i8 = 0; i8 < polyCount; i8++) {
        buf.discard(5);
        polys[i8] = _parsePolygon(buf, polyCls, le2, z6, m12, srid);
      }
      return new cls(polys, z6, m12, srid);
    }
    function _parseMultiSurface(buf, le2, z6, m12, srid) {
      const surfaceCount = buf.readUInt32(le2);
      const surfaces = new Array(surfaceCount);
      for (let i8 = 0; i8 < surfaceCount; i8++) {
        buf.discard(1);
        const type = buf.readUInt32(le2) & ~allFlags;
        switch (type) {
          case 3:
            surfaces[i8] = _parsePolygon(buf, postgis_1.Polygon, le2, z6, m12, srid);
            break;
          case 10:
            surfaces[i8] = _parseMultiCurve(buf, postgis_1.CurvePolygon, le2, z6, m12, srid);
            break;
          default:
            throw new Error(`unexpected type ${type} in MultiSurface`);
        }
      }
      return new postgis_1.MultiSurface(surfaces, z6, m12, srid);
    }
    function _parseGeometryCollection(buf, le2, z6, m12, srid) {
      const geometryCount = buf.readUInt32(le2);
      const geometries = new Array(geometryCount);
      for (let i8 = 0; i8 < geometryCount; i8++) {
        geometries[i8] = _parseGeometry(buf, srid);
      }
      return new postgis_1.GeometryCollection(geometries, z6, m12, srid);
    }
    var geomTypes = /* @__PURE__ */ new Map([
      [postgis_1.Point, 1],
      [postgis_1.LineString, 2],
      [postgis_1.Polygon, 3],
      [postgis_1.MultiPoint, 4],
      [postgis_1.MultiLineString, 5],
      [postgis_1.MultiPolygon, 6],
      [postgis_1.GeometryCollection, 7],
      [postgis_1.CircularString, 8],
      [postgis_1.CompoundCurve, 9],
      [postgis_1.CurvePolygon, 10],
      [postgis_1.MultiCurve, 11],
      [postgis_1.MultiSurface, 12],
      [postgis_1.PolyhedralSurface, 15],
      [postgis_1.TriangulatedIrregularNetwork, 16],
      [postgis_1.Triangle, 17]
    ]);
    function _encodeGeometry(buf, geom) {
      buf.writeUInt8(0);
      const type = geomTypes.get(geom.constructor);
      if (!type) {
        throw new Error(`unknown geometry type ${geom}`);
      }
      buf.writeUInt32(type | (geom.hasZ ? zFlag : 0) | (geom.hasM ? mFlag : 0) | (geom.srid !== null ? sridFlag : 0));
      if (geom.srid !== null) {
        buf.writeUInt32(geom.srid);
      }
      if (geom instanceof postgis_1.Point) {
        _encodePoint(buf, geom);
        return;
      }
      if (geom instanceof postgis_1.LineString) {
        _encodeLineString(buf, geom);
        return;
      }
      if (geom instanceof postgis_1.Polygon) {
        buf.writeUInt32(geom.rings.length);
        for (const ring of geom.rings) {
          _encodeLineString(buf, ring);
        }
        return;
      }
      buf.writeUInt32(geom.geometries.length);
      for (const point2 of geom.geometries) {
        _encodeGeometry(buf, point2);
      }
    }
    function _encodePoint(buf, point2) {
      buf.writeFloat64(point2.x);
      buf.writeFloat64(point2.y);
      if (point2.z !== null)
        buf.writeFloat64(point2.z);
      if (point2.m !== null)
        buf.writeFloat64(point2.m);
    }
    function _encodeLineString(buf, linestring) {
      buf.writeUInt32(linestring.points.length);
      for (const point2 of linestring.points) {
        _encodePoint(buf, point2);
      }
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/codecs.js
var require_codecs = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/codecs.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.INVALID_CODEC = exports2.NULL_CODEC = exports2.SCALAR_CODECS = exports2.NullCodec = void 0;
    var buffer_1 = require_buffer();
    var boolean_1 = require_boolean();
    var ifaces_1 = require_ifaces();
    var numbers_1 = require_numbers();
    var numerics_1 = require_numerics();
    var text_1 = require_text();
    var uuid_1 = require_uuid();
    var bytes_1 = require_bytes();
    var json_1 = require_json();
    var datetime_1 = require_datetime2();
    var memory_1 = require_memory2();
    var pgvector_1 = require_pgvector2();
    var postgis_1 = require_postgis2();
    var errors_1 = require_errors();
    var consts_1 = require_consts();
    var NullCodec = class extends ifaces_1.Codec {
      encode(_buf2, _object) {
        throw new errors_1.InternalClientError("null codec cannot used to encode data");
      }
      decode(_buf2, _ctx) {
        throw new errors_1.InternalClientError("null codec cannot used to decode data");
      }
      getSubcodecs() {
        return [];
      }
      getKind() {
        return "scalar";
      }
    };
    __publicField(NullCodec, "BUFFER", new buffer_1.WriteBuffer().writeInt32(0).unwrap());
    exports2.NullCodec = NullCodec;
    exports2.SCALAR_CODECS = /* @__PURE__ */ new Map();
    exports2.NULL_CODEC = new NullCodec(consts_1.NULL_CODEC_ID);
    exports2.INVALID_CODEC = new NullCodec(consts_1.INVALID_CODEC_ID);
    function registerScalarCodecs(codecs) {
      for (const [typename, type] of Object.entries(codecs)) {
        const id = consts_1.KNOWN_TYPENAMES.get(typename);
        if (id == null) {
          throw new errors_1.InternalClientError("unknown type name");
        }
        exports2.SCALAR_CODECS.set(id, new type(id, typename));
      }
    }
    registerScalarCodecs({
      "std::int16": numbers_1.Int16Codec,
      "std::int32": numbers_1.Int32Codec,
      "std::int64": numbers_1.Int64Codec,
      "std::float32": numbers_1.Float32Codec,
      "std::float64": numbers_1.Float64Codec,
      "std::bigint": numerics_1.BigIntCodec,
      "std::decimal": numerics_1.DecimalStringCodec,
      "std::bool": boolean_1.BoolCodec,
      "std::json": json_1.JSONCodec,
      "std::str": text_1.StrCodec,
      "std::bytes": bytes_1.BytesCodec,
      "std::uuid": uuid_1.UUIDCodec,
      "cal::local_date": datetime_1.LocalDateCodec,
      "cal::local_time": datetime_1.LocalTimeCodec,
      "cal::local_datetime": datetime_1.LocalDateTimeCodec,
      "std::datetime": datetime_1.DateTimeCodec,
      "std::duration": datetime_1.DurationCodec,
      "cal::relative_duration": datetime_1.RelativeDurationCodec,
      "cal::date_duration": datetime_1.DateDurationCodec,
      "cfg::memory": memory_1.ConfigMemoryCodec,
      "std::pg::json": json_1.PgTextJSONCodec,
      "std::pg::timestamptz": datetime_1.DateTimeCodec,
      "std::pg::timestamp": datetime_1.LocalDateTimeCodec,
      "std::pg::date": datetime_1.LocalDateCodec,
      "std::pg::interval": datetime_1.RelativeDurationCodec,
      "ext::pgvector::vector": pgvector_1.PgVectorCodec,
      "ext::pgvector::halfvec": pgvector_1.PgVectorHalfVecCodec,
      "ext::pgvector::sparsevec": pgvector_1.PgVectorSparseVecCodec,
      "ext::postgis::geometry": postgis_1.PostgisGeometryCodec,
      "ext::postgis::geography": postgis_1.PostgisGeometryCodec,
      "ext::postgis::box2d": postgis_1.PostgisBox2dCodec,
      "ext::postgis::box3d": postgis_1.PostgisBox3dCodec
    });
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/tuple.js
var require_tuple = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/tuple.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.EMPTY_TUPLE_CODEC = exports2.EMPTY_TUPLE_CODEC_ID = exports2.EmptyTupleCodec = exports2.TupleCodec = void 0;
    var consts_1 = require_consts();
    var ifaces_1 = require_ifaces();
    var buffer_1 = require_buffer();
    var errors_1 = require_errors();
    var TupleCodec = class extends ifaces_1.Codec {
      constructor(tid, typeName, codecs) {
        super(tid);
        __publicField(this, "subCodecs");
        __publicField(this, "typeName");
        this.subCodecs = codecs;
        this.typeName = typeName;
      }
      encode(buf, object2, ctx) {
        if (!Array.isArray(object2)) {
          throw new errors_1.InvalidArgumentError(`an array was expected, got "${object2}"`);
        }
        const codecs = this.subCodecs;
        const codecsLen = codecs.length;
        if (object2.length !== codecsLen) {
          throw new errors_1.InvalidArgumentError(`expected ${codecsLen} tuple item${codecsLen === 1 ? "" : "s"}, got ${object2.length}`);
        }
        if (!codecsLen) {
          buf.writeBuffer(EmptyTupleCodec.BUFFER);
        }
        const elemData = new buffer_1.WriteBuffer();
        for (let i8 = 0; i8 < codecsLen; i8++) {
          const elem = object2[i8];
          elemData.writeInt32(0);
          if (elem == null) {
            throw new errors_1.MissingArgumentError(`element at index ${i8} in tuple cannot be 'null'`);
          } else {
            try {
              codecs[i8].encode(elemData, elem, ctx);
            } catch (e6) {
              if (e6 instanceof errors_1.QueryArgumentError) {
                throw new errors_1.InvalidArgumentError(`invalid element at index ${i8} in tuple: ${e6.message}`);
              } else {
                throw e6;
              }
            }
          }
        }
        const elemBuf = elemData.unwrap();
        buf.writeInt32(4 + elemBuf.length);
        buf.writeInt32(codecsLen);
        buf.writeBuffer(elemBuf);
      }
      decode(buf, ctx) {
        const els = buf.readUInt32();
        const subCodecs = this.subCodecs;
        if (els !== subCodecs.length) {
          throw new errors_1.ProtocolError(`cannot decode Tuple: expected ${subCodecs.length} elements, got ${els}`);
        }
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const result = new Array(els);
        for (let i8 = 0; i8 < els; i8++) {
          buf.discard(4);
          const elemLen = buf.readInt32();
          if (elemLen === -1) {
            result[i8] = null;
          } else {
            buf.sliceInto(elemBuf, elemLen);
            result[i8] = subCodecs[i8].decode(elemBuf, ctx);
            elemBuf.finish();
          }
        }
        return result;
      }
      getSubcodecs() {
        return Array.from(this.subCodecs);
      }
      getKind() {
        return "tuple";
      }
    };
    exports2.TupleCodec = TupleCodec;
    var EmptyTupleCodec = class extends ifaces_1.Codec {
      encode(buf, object2, _ctx) {
        if (!Array.isArray(object2)) {
          throw new errors_1.InvalidArgumentError("cannot encode empty Tuple: expected an array");
        }
        if (object2.length) {
          throw new errors_1.InvalidArgumentError(`cannot encode empty Tuple: expected 0 elements got ${object2.length}`);
        }
        buf.writeInt32(4);
        buf.writeInt32(0);
      }
      decode(buf) {
        const els = buf.readInt32();
        if (els !== 0) {
          throw new errors_1.ProtocolError(`cannot decode empty Tuple: expected 0 elements, received ${els}`);
        }
        return [];
      }
      getSubcodecs() {
        return [];
      }
      getKind() {
        return "tuple";
      }
    };
    __publicField(EmptyTupleCodec, "BUFFER", new buffer_1.WriteBuffer().writeInt32(4).writeInt32(0).unwrap());
    exports2.EmptyTupleCodec = EmptyTupleCodec;
    exports2.EMPTY_TUPLE_CODEC_ID = consts_1.KNOWN_TYPENAMES.get("empty-tuple");
    exports2.EMPTY_TUPLE_CODEC = new EmptyTupleCodec(exports2.EMPTY_TUPLE_CODEC_ID);
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/range.js
var require_range2 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/range.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.MultiRange = exports2.Range = void 0;
    var Range = class _Range {
      constructor(_lower, _upper, _incLower = _lower != null, _incUpper = false) {
        __publicField(this, "_lower");
        __publicField(this, "_upper");
        __publicField(this, "_incLower");
        __publicField(this, "_incUpper");
        __publicField(this, "_isEmpty", false);
        this._lower = _lower;
        this._upper = _upper;
        this._incLower = _incLower;
        this._incUpper = _incUpper;
      }
      get lower() {
        return this._lower;
      }
      get upper() {
        return this._upper;
      }
      get incLower() {
        return this._incLower;
      }
      get incUpper() {
        return this._incUpper;
      }
      get isEmpty() {
        return this._isEmpty;
      }
      static empty() {
        const range = new _Range(null, null);
        range._isEmpty = true;
        return range;
      }
      toJSON() {
        return this.isEmpty ? { empty: true } : {
          lower: this._lower,
          upper: this._upper,
          inc_lower: this._incLower,
          inc_upper: this._incUpper
        };
      }
    };
    exports2.Range = Range;
    var MultiRange = class {
      constructor(ranges = []) {
        __publicField(this, "_ranges");
        this._ranges = [...ranges];
      }
      get length() {
        return this._ranges.length;
      }
      *[Symbol.iterator]() {
        for (const range of this._ranges) {
          yield range;
        }
      }
      toJSON() {
        return [...this._ranges];
      }
    };
    exports2.MultiRange = MultiRange;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/range.js
var require_range3 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/range.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.MultiRangeCodec = exports2.RangeCodec = void 0;
    var ifaces_1 = require_ifaces();
    var buffer_1 = require_buffer();
    var range_1 = require_range2();
    var errors_1 = require_errors();
    var RangeFlags;
    (function(RangeFlags2) {
      RangeFlags2[RangeFlags2["EMPTY"] = 1] = "EMPTY";
      RangeFlags2[RangeFlags2["INC_LOWER"] = 2] = "INC_LOWER";
      RangeFlags2[RangeFlags2["INC_UPPER"] = 4] = "INC_UPPER";
      RangeFlags2[RangeFlags2["EMPTY_LOWER"] = 8] = "EMPTY_LOWER";
      RangeFlags2[RangeFlags2["EMPTY_UPPER"] = 16] = "EMPTY_UPPER";
    })(RangeFlags || (RangeFlags = {}));
    var MAXINT32 = 2147483647;
    function encodeRange(buf, obj, subCodec, ctx) {
      if (!(obj instanceof range_1.Range)) {
        throw new errors_1.InvalidArgumentError("a Range was expected");
      }
      const elemData = new buffer_1.WriteBuffer();
      if (obj.lower !== null) {
        subCodec.encode(elemData, obj.lower, ctx);
      }
      if (obj.upper !== null) {
        subCodec.encode(elemData, obj.upper, ctx);
      }
      const elemBuf = elemData.unwrap();
      buf.writeInt32(1 + elemBuf.length);
      buf.writeUInt8(obj.isEmpty ? RangeFlags.EMPTY : (obj.incLower ? RangeFlags.INC_LOWER : 0) | (obj.incUpper ? RangeFlags.INC_UPPER : 0) | (obj.lower === null ? RangeFlags.EMPTY_LOWER : 0) | (obj.upper === null ? RangeFlags.EMPTY_UPPER : 0));
      buf.writeBuffer(elemBuf);
    }
    function decodeRange(buf, subCodec, ctx) {
      const flags2 = buf.readUInt8();
      if (flags2 & RangeFlags.EMPTY) {
        return range_1.Range.empty();
      }
      const elemBuf = buffer_1.ReadBuffer.alloc();
      let lower2 = null;
      let upper = null;
      if (!(flags2 & RangeFlags.EMPTY_LOWER)) {
        buf.sliceInto(elemBuf, buf.readInt32());
        lower2 = subCodec.decode(elemBuf, ctx);
        elemBuf.finish();
      }
      if (!(flags2 & RangeFlags.EMPTY_UPPER)) {
        buf.sliceInto(elemBuf, buf.readInt32());
        upper = subCodec.decode(elemBuf, ctx);
        elemBuf.finish();
      }
      return new range_1.Range(lower2, upper, !!(flags2 & RangeFlags.INC_LOWER), !!(flags2 & RangeFlags.INC_UPPER));
    }
    var RangeCodec = class extends ifaces_1.Codec {
      constructor(tid, typeName, subCodec) {
        super(tid);
        __publicField(this, "tsType", "Range");
        __publicField(this, "tsModule", "gel");
        __publicField(this, "subCodec");
        __publicField(this, "typeName");
        this.subCodec = subCodec;
        this.typeName = typeName;
      }
      encode(buf, obj, ctx) {
        return encodeRange(buf, obj, this.subCodec, ctx);
      }
      decode(buf, ctx) {
        return decodeRange(buf, this.subCodec, ctx);
      }
      getSubcodecs() {
        return [this.subCodec];
      }
      getKind() {
        return "range";
      }
    };
    exports2.RangeCodec = RangeCodec;
    var MultiRangeCodec = class extends ifaces_1.Codec {
      constructor(tid, typeName, subCodec) {
        super(tid);
        __publicField(this, "tsType", "MultiRange");
        __publicField(this, "tsModule", "gel");
        __publicField(this, "subCodec");
        __publicField(this, "typeName");
        this.subCodec = subCodec;
        this.typeName = typeName;
      }
      encode(buf, obj, ctx) {
        if (!(obj instanceof range_1.MultiRange)) {
          throw new TypeError(`a MultiRange expected (got type ${obj.constructor.name})`);
        }
        const objLen = obj.length;
        if (objLen > MAXINT32) {
          throw new errors_1.InvalidArgumentError("too many elements in array");
        }
        const elemData = new buffer_1.WriteBuffer();
        for (const item of obj) {
          try {
            encodeRange(elemData, item, this.subCodec, ctx);
          } catch (e6) {
            if (e6 instanceof errors_1.InvalidArgumentError) {
              throw new errors_1.InvalidArgumentError(`invalid multirange element: ${e6.message}`);
            } else {
              throw e6;
            }
          }
        }
        const elemBuf = elemData.unwrap();
        const elemDataLen = elemBuf.length;
        if (elemDataLen > MAXINT32 - 4) {
          throw new errors_1.InvalidArgumentError(`size of encoded multirange datum exceeds the maximum allowed ${MAXINT32 - 4} bytes`);
        }
        buf.writeInt32(4 + elemDataLen);
        buf.writeInt32(objLen);
        buf.writeBuffer(elemBuf);
      }
      decode(buf, ctx) {
        const elemCount = buf.readInt32();
        const result = new Array(elemCount);
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const subCodec = this.subCodec;
        for (let i8 = 0; i8 < elemCount; i8++) {
          const elemLen = buf.readInt32();
          if (elemLen === -1) {
            throw new errors_1.ProtocolError("unexpected NULL element in multirange value");
          } else {
            buf.sliceInto(elemBuf, elemLen);
            const elem = decodeRange(elemBuf, subCodec, ctx);
            if (elemBuf.length) {
              throw new errors_1.ProtocolError(`unexpected trailing data in buffer after multirange element decoding: ${elemBuf.length}`);
            }
            result[i8] = elem;
            elemBuf.finish();
          }
        }
        return new range_1.MultiRange(result);
      }
      getSubcodecs() {
        return [this.subCodec];
      }
      getKind() {
        return "multirange";
      }
    };
    exports2.MultiRangeCodec = MultiRangeCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/namedtuple.js
var require_namedtuple = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/namedtuple.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.NamedTupleCodec = void 0;
    var ifaces_1 = require_ifaces();
    var buffer_1 = require_buffer();
    var errors_1 = require_errors();
    var NamedTupleCodec = class extends ifaces_1.Codec {
      constructor(tid, typeName, codecs, names) {
        super(tid);
        __publicField(this, "subCodecs");
        __publicField(this, "names");
        __publicField(this, "typeName");
        this.subCodecs = codecs;
        this.names = names;
        this.typeName = typeName;
      }
      encode(buf, object2, ctx) {
        if (typeof object2 !== "object" || Array.isArray(object2)) {
          throw new errors_1.InvalidArgumentError(`an object was expected, got "${object2}"`);
        }
        const codecsLen = this.subCodecs.length;
        if (Object.keys(object2).length !== codecsLen) {
          throw new errors_1.QueryArgumentError(`expected ${codecsLen} element${codecsLen === 1 ? "" : "s"} in named tuple, got ${Object.keys(object2).length}`);
        }
        const elemData = new buffer_1.WriteBuffer();
        for (let i8 = 0; i8 < codecsLen; i8++) {
          const key = this.names[i8];
          const val2 = object2[key];
          if (val2 == null) {
            throw new errors_1.MissingArgumentError(`element '${key}' in named tuple cannot be 'null'`);
          } else {
            elemData.writeInt32(0);
            try {
              this.subCodecs[i8].encode(elemData, val2, ctx);
            } catch (e6) {
              if (e6 instanceof errors_1.QueryArgumentError) {
                throw new errors_1.InvalidArgumentError(`invalid element '${key}' in named tuple: ${e6.message}`);
              } else {
                throw e6;
              }
            }
          }
        }
        const elemBuf = elemData.unwrap();
        buf.writeInt32(4 + elemBuf.length);
        buf.writeInt32(codecsLen);
        buf.writeBuffer(elemBuf);
      }
      decode(buf, ctx) {
        const els = buf.readUInt32();
        const subCodecs = this.subCodecs;
        if (els !== subCodecs.length) {
          throw new errors_1.ProtocolError(`cannot decode NamedTuple: expected ${subCodecs.length} elements, got ${els}`);
        }
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const names = this.names;
        const result = {};
        for (let i8 = 0; i8 < els; i8++) {
          buf.discard(4);
          const elemLen = buf.readInt32();
          let val2 = null;
          if (elemLen !== -1) {
            buf.sliceInto(elemBuf, elemLen);
            val2 = subCodecs[i8].decode(elemBuf, ctx);
            elemBuf.finish();
          }
          result[names[i8]] = val2;
        }
        return result;
      }
      getSubcodecs() {
        return Array.from(this.subCodecs);
      }
      getNames() {
        return Array.from(this.names);
      }
      getKind() {
        return "namedtuple";
      }
    };
    exports2.NamedTupleCodec = NamedTupleCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/array.js
var require_array = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/array.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ArrayCodec = void 0;
    var ifaces_1 = require_ifaces();
    var buffer_1 = require_buffer();
    var tuple_1 = require_tuple();
    var range_1 = require_range3();
    var errors_1 = require_errors();
    var namedtuple_1 = require_namedtuple();
    var ArrayCodec = class extends ifaces_1.Codec {
      constructor(tid, typeName, subCodec, len) {
        super(tid);
        __publicField(this, "subCodec");
        __publicField(this, "len");
        __publicField(this, "typeName");
        this.subCodec = subCodec;
        this.len = len;
        this.typeName = typeName;
      }
      encode(buf, obj, ctx) {
        if (!(this.subCodec instanceof ifaces_1.ScalarCodec || this.subCodec instanceof tuple_1.TupleCodec || this.subCodec instanceof namedtuple_1.NamedTupleCodec || this.subCodec instanceof range_1.RangeCodec || this.subCodec instanceof range_1.MultiRangeCodec)) {
          throw new errors_1.InvalidArgumentError("only arrays of scalars or tuples are supported");
        }
        if (!Array.isArray(obj) && !isTypedArray(obj)) {
          throw new errors_1.InvalidArgumentError(`an array was expected (got type ${obj.constructor.name})`);
        }
        const subCodec = this.subCodec;
        const elemData = new buffer_1.WriteBuffer();
        const objLen = obj.length;
        if (objLen > 2147483647) {
          throw new errors_1.InvalidArgumentError("too many elements in array");
        }
        for (let i8 = 0; i8 < objLen; i8++) {
          const item = obj[i8];
          if (item == null) {
            elemData.writeInt32(-1);
          } else {
            subCodec.encode(elemData, item, ctx);
          }
        }
        const elemBuf = elemData.unwrap();
        buf.writeInt32(12 + 8 + elemBuf.length);
        buf.writeInt32(1);
        buf.writeInt32(0);
        buf.writeInt32(0);
        buf.writeInt32(objLen);
        buf.writeInt32(1);
        buf.writeBuffer(elemBuf);
      }
      decode(buf, ctx) {
        const ndims = buf.readInt32();
        buf.discard(4);
        buf.discard(4);
        if (ndims === 0) {
          return [];
        }
        if (ndims !== 1) {
          throw new errors_1.ProtocolError("only 1-dimensional arrays are supported");
        }
        const len = buf.readUInt32();
        if (this.len !== -1 && len !== this.len) {
          throw new errors_1.ProtocolError(`invalid array size: received ${len}, expected ${this.len}`);
        }
        buf.discard(4);
        const result = new Array(len);
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const subCodec = this.subCodec;
        for (let i8 = 0; i8 < len; i8++) {
          const elemLen = buf.readInt32();
          if (elemLen === -1) {
            result[i8] = null;
          } else {
            buf.sliceInto(elemBuf, elemLen);
            result[i8] = subCodec.decode(elemBuf, ctx);
            elemBuf.finish();
          }
        }
        return result;
      }
      getSubcodecs() {
        return [this.subCodec];
      }
      getKind() {
        return "array";
      }
    };
    exports2.ArrayCodec = ArrayCodec;
    function isTypedArray(obj) {
      return !!(obj.buffer instanceof ArrayBuffer && obj.BYTES_PER_ELEMENT);
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/enum.js
var require_enum = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/enum.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.EnumCodec = void 0;
    var text_1 = require_text();
    var EnumCodec = class extends text_1.StrCodec {
      constructor(tid, typeName, values2) {
        super(tid, typeName);
        __publicField(this, "values");
        this.values = values2;
      }
    };
    exports2.EnumCodec = EnumCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/ifaces.js
var require_ifaces2 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/ifaces.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Language = exports2.Cardinality = exports2.OutputFormat = void 0;
    var chars = __importStar(require_chars());
    var OutputFormat;
    (function(OutputFormat2) {
      OutputFormat2[OutputFormat2["BINARY"] = chars.$b] = "BINARY";
      OutputFormat2[OutputFormat2["JSON"] = chars.$j] = "JSON";
      OutputFormat2[OutputFormat2["NONE"] = chars.$n] = "NONE";
    })(OutputFormat || (exports2.OutputFormat = OutputFormat = {}));
    var Cardinality;
    (function(Cardinality2) {
      Cardinality2[Cardinality2["NO_RESULT"] = chars.$n] = "NO_RESULT";
      Cardinality2[Cardinality2["AT_MOST_ONE"] = chars.$o] = "AT_MOST_ONE";
      Cardinality2[Cardinality2["ONE"] = chars.$A] = "ONE";
      Cardinality2[Cardinality2["MANY"] = chars.$m] = "MANY";
      Cardinality2[Cardinality2["AT_LEAST_ONE"] = chars.$M] = "AT_LEAST_ONE";
    })(Cardinality || (exports2.Cardinality = Cardinality = {}));
    var Language;
    (function(Language2) {
      Language2[Language2["EDGEQL"] = chars.$E] = "EDGEQL";
      Language2[Language2["SQL"] = chars.$S] = "SQL";
    })(Language || (exports2.Language = Language = {}));
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/object.js
var require_object = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/object.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ObjectCodec = void 0;
    var ifaces_1 = require_ifaces2();
    var ifaces_2 = require_ifaces();
    var buffer_1 = require_buffer();
    var errors_1 = require_errors();
    var EDGE_POINTER_IS_IMPLICIT = 1 << 0;
    var EDGE_POINTER_IS_LINKPROP = 1 << 1;
    var ObjectCodec = class extends ifaces_2.Codec {
      constructor(tid, codecs, names, flags2, cards) {
        super(tid);
        __publicField(this, "codecs");
        __publicField(this, "fields");
        __publicField(this, "namesSet");
        __publicField(this, "cardinalities");
        this.codecs = codecs;
        this.fields = new Array(names.length);
        this.namesSet = /* @__PURE__ */ new Set();
        this.cardinalities = cards;
        for (let i8 = 0; i8 < names.length; i8++) {
          const isLinkprop = !!(flags2[i8] & EDGE_POINTER_IS_LINKPROP);
          const name3 = isLinkprop ? `@${names[i8]}` : names[i8];
          this.fields[i8] = {
            name: name3,
            implicit: !!(flags2[i8] & EDGE_POINTER_IS_IMPLICIT),
            linkprop: isLinkprop,
            cardinality: cards[i8]
          };
          this.namesSet.add(name3);
        }
      }
      encode(_buf2, _object) {
        throw new errors_1.InvalidArgumentError("Objects cannot be passed as arguments");
      }
      encodeArgs(args2, ctx) {
        if (this.fields[0].name === "0" || this.fields[0].name === "1") {
          return this._encodePositionalArgs(args2, ctx);
        }
        return this._encodeNamedArgs(args2, ctx);
      }
      _encodePositionalArgs(args2, ctx) {
        if (!Array.isArray(args2)) {
          throw new errors_1.InvalidArgumentError("an array of arguments was expected");
        }
        const codecs = this.codecs;
        const codecsLen = codecs.length;
        if (args2.length !== codecsLen) {
          throw new errors_1.QueryArgumentError(`expected ${codecsLen} argument${codecsLen === 1 ? "" : "s"}, got ${args2.length}`);
        }
        const elemData = new buffer_1.WriteBuffer();
        for (let i8 = 0; i8 < codecsLen; i8++) {
          elemData.writeInt32(0);
          const arg = args2[i8];
          if (arg == null) {
            const card = this.cardinalities[i8];
            if (card === ifaces_1.Cardinality.ONE || card === ifaces_1.Cardinality.AT_LEAST_ONE) {
              throw new errors_1.MissingArgumentError(`argument ${this.fields[i8].name} is required, but received ${arg}`);
            }
            elemData.writeInt32(-1);
          } else {
            const codec = codecs[i8];
            codec.encode(elemData, arg, ctx);
          }
        }
        const elemBuf = elemData.unwrap();
        const buf = new buffer_1.WriteBuffer();
        buf.writeInt32(4 + elemBuf.length);
        buf.writeInt32(codecsLen);
        buf.writeBuffer(elemBuf);
        return buf.unwrap();
      }
      _encodeNamedArgs(args2, ctx) {
        if (args2 == null) {
          throw new errors_1.MissingArgumentError("One or more named arguments expected, received null");
        }
        const keys = Object.keys(args2);
        const fields = this.fields;
        const namesSet = this.namesSet;
        const codecs = this.codecs;
        const codecsLen = codecs.length;
        if (keys.length > codecsLen) {
          const extraKeys = keys.filter((key) => !namesSet.has(key));
          throw new errors_1.UnknownArgumentError(`Unused named argument${extraKeys.length === 1 ? "" : "s"}: "${extraKeys.join('", "')}"`);
        }
        const elemData = new buffer_1.WriteBuffer();
        for (let i8 = 0; i8 < codecsLen; i8++) {
          const key = fields[i8].name;
          const val2 = args2[key];
          elemData.writeInt32(0);
          if (val2 == null) {
            const card = this.cardinalities[i8];
            if (card === ifaces_1.Cardinality.ONE || card === ifaces_1.Cardinality.AT_LEAST_ONE) {
              throw new errors_1.MissingArgumentError(`argument ${this.fields[i8].name} is required, but received ${val2}`);
            }
            elemData.writeInt32(-1);
          } else {
            const codec = codecs[i8];
            codec.encode(elemData, val2, ctx);
          }
        }
        const elemBuf = elemData.unwrap();
        const buf = new buffer_1.WriteBuffer();
        buf.writeInt32(4 + elemBuf.length);
        buf.writeInt32(codecsLen);
        buf.writeBuffer(elemBuf);
        return buf.unwrap();
      }
      decode(buf, ctx) {
        const codecs = this.codecs;
        const fields = this.fields;
        const els = buf.readUInt32();
        if (els !== codecs.length) {
          throw new errors_1.ProtocolError(`cannot decode Object: expected ${codecs.length} elements, got ${els}`);
        }
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const result = {};
        for (let i8 = 0; i8 < els; i8++) {
          buf.discard(4);
          const elemLen = buf.readInt32();
          const name3 = fields[i8].name;
          let val2 = null;
          if (elemLen !== -1) {
            buf.sliceInto(elemBuf, elemLen);
            val2 = codecs[i8].decode(elemBuf, ctx);
            elemBuf.finish();
          }
          result[name3] = val2;
        }
        return result;
      }
      getSubcodecs() {
        return Array.from(this.codecs);
      }
      getFields() {
        return Array.from(this.fields);
      }
      getKind() {
        return "object";
      }
    };
    exports2.ObjectCodec = ObjectCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/set.js
var require_set = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/set.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SetCodec = void 0;
    var ifaces_1 = require_ifaces();
    var buffer_1 = require_buffer();
    var array_1 = require_array();
    var errors_1 = require_errors();
    var SetCodec = class extends ifaces_1.Codec {
      constructor(tid, subCodec) {
        super(tid);
        __publicField(this, "subCodec");
        this.subCodec = subCodec;
      }
      encode(_buf2, _obj) {
        throw new errors_1.InvalidArgumentError("Sets cannot be passed in query arguments");
      }
      decode(buf, ctx) {
        if (this.subCodec instanceof array_1.ArrayCodec) {
          return this.decodeSetOfArrays(buf, ctx);
        } else {
          return this.decodeSet(buf, ctx);
        }
      }
      decodeSetOfArrays(buf, ctx) {
        const ndims = buf.readInt32();
        buf.discard(4);
        buf.discard(4);
        if (ndims === 0) {
          return [];
        }
        if (ndims !== 1) {
          throw new errors_1.ProtocolError(`expected 1-dimensional array of records of arrays`);
        }
        const len = buf.readUInt32();
        buf.discard(4);
        const result = new Array(len);
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const subCodec = this.subCodec;
        for (let i8 = 0; i8 < len; i8++) {
          buf.discard(4);
          const recSize = buf.readUInt32();
          if (recSize !== 1) {
            throw new errors_1.ProtocolError("expected a record with a single element as an array set element envelope");
          }
          buf.discard(4);
          const elemLen = buf.readInt32();
          if (elemLen === -1) {
            throw new errors_1.ProtocolError("unexpected NULL value in array set element");
          }
          buf.sliceInto(elemBuf, elemLen);
          result[i8] = subCodec.decode(elemBuf, ctx);
          elemBuf.finish();
        }
        return result;
      }
      decodeSet(buf, ctx) {
        const ndims = buf.readInt32();
        buf.discard(4);
        buf.discard(4);
        if (ndims === 0) {
          return [];
        }
        if (ndims !== 1) {
          throw new errors_1.ProtocolError(`invalid set dimensinality: ${ndims}`);
        }
        const len = buf.readUInt32();
        buf.discard(4);
        const result = new Array(len);
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const subCodec = this.subCodec;
        for (let i8 = 0; i8 < len; i8++) {
          const elemLen = buf.readInt32();
          if (elemLen === -1) {
            result[i8] = null;
          } else {
            buf.sliceInto(elemBuf, elemLen);
            result[i8] = subCodec.decode(elemBuf, ctx);
            elemBuf.finish();
          }
        }
        return result;
      }
      getSubcodecs() {
        return [this.subCodec];
      }
      getKind() {
        return "set";
      }
    };
    exports2.SetCodec = SetCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/record.js
var require_record = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/record.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.RecordCodec = exports2.SQLRowModeObject = exports2.SQLRowModeArray = void 0;
    var ifaces_1 = require_ifaces();
    var buffer_1 = require_buffer();
    var errors_1 = require_errors();
    var SQLRowArrayCodec = {
      fromDatabase(values2, _desc) {
        return values2;
      },
      toDatabase() {
        throw new errors_1.InternalClientError("cannot encode SQL record as a query argument");
      }
    };
    var SQLRowObjectCodec = {
      fromDatabase(values2, { names }) {
        return Object.fromEntries(names.map((key, index7) => [key, values2[index7]]));
      },
      toDatabase() {
        throw new errors_1.InternalClientError("cannot encode SQL record as a query argument");
      }
    };
    exports2.SQLRowModeArray = {
      _private_sql_row: SQLRowArrayCodec
    };
    exports2.SQLRowModeObject = {
      _private_sql_row: SQLRowObjectCodec
    };
    var RecordCodec = class extends ifaces_1.Codec {
      constructor(tid, codecs, names) {
        super(tid);
        __publicField(this, "subCodecs");
        __publicField(this, "names");
        this.subCodecs = codecs;
        this.names = names;
      }
      encode(_buf2, _object) {
        throw new errors_1.InvalidArgumentError("SQL records cannot be passed as arguments");
      }
      decode(buf, ctx) {
        const els = buf.readUInt32();
        const subCodecs = this.subCodecs;
        if (els !== subCodecs.length) {
          throw new errors_1.ProtocolError(`cannot decode Record: expected ${subCodecs.length} elements, got ${els}`);
        }
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const overload = ctx.getContainerOverload("_private_sql_row");
        if (overload != null && overload !== SQLRowObjectCodec) {
          const result = new Array(els);
          for (let i8 = 0; i8 < els; i8++) {
            buf.discard(4);
            const elemLen = buf.readInt32();
            let val2 = null;
            if (elemLen !== -1) {
              buf.sliceInto(elemBuf, elemLen);
              val2 = subCodecs[i8].decode(elemBuf, ctx);
              elemBuf.finish();
            }
            result[i8] = val2;
          }
          if (overload !== SQLRowArrayCodec) {
            return overload.fromDatabase(result, { names: this.names });
          }
          return result;
        } else {
          const names = this.names;
          const result = {};
          for (let i8 = 0; i8 < els; i8++) {
            buf.discard(4);
            const elemLen = buf.readInt32();
            let val2 = null;
            if (elemLen !== -1) {
              buf.sliceInto(elemBuf, elemLen);
              val2 = subCodecs[i8].decode(elemBuf, ctx);
              elemBuf.finish();
            }
            result[names[i8]] = val2;
          }
          return result;
        }
      }
      getSubcodecs() {
        return Array.from(this.subCodecs);
      }
      getNames() {
        return Array.from(this.names);
      }
      getKind() {
        return "record";
      }
    };
    exports2.RecordCodec = RecordCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/sparseObject.js
var require_sparseObject = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/sparseObject.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.SparseObjectCodec = void 0;
    var ifaces_1 = require_ifaces();
    var buffer_1 = require_buffer();
    var errors_1 = require_errors();
    var SparseObjectCodec = class extends ifaces_1.Codec {
      constructor(tid, codecs, names) {
        super(tid);
        __publicField(this, "codecs");
        __publicField(this, "names");
        this.codecs = codecs;
        this.names = names;
      }
      encode(buf, object2, ctx) {
        const elemBuf = new buffer_1.WriteBuffer();
        let objLen = 0;
        for (const [key, val2] of Object.entries(object2)) {
          if (val2 !== void 0) {
            const i8 = this.names.indexOf(key);
            if (i8 === -1) {
              throw new errors_1.UnknownArgumentError(this.names.length ? `invalid global '${key}', valid globals are ${this.names.map((n7) => `'${n7}'`).join(", ")}` : `invalid global '${key}', no valid globals exist`);
            }
            objLen += 1;
            elemBuf.writeInt32(i8);
            if (val2 === null) {
              elemBuf.writeInt32(-1);
            } else {
              this.codecs[i8].encode(elemBuf, val2, ctx);
            }
          }
        }
        const elemData = elemBuf.unwrap();
        buf.writeInt32(4 + elemData.length);
        buf.writeInt32(objLen);
        buf.writeBuffer(elemData);
      }
      decode(buf, ctx) {
        const codecs = this.codecs;
        const names = this.names;
        const els = buf.readUInt32();
        const elemBuf = buffer_1.ReadBuffer.alloc();
        const result = {};
        for (let _7 = 0; _7 < els; _7++) {
          const i8 = buf.readUInt32();
          const elemLen = buf.readInt32();
          const name3 = names[i8];
          let val2 = null;
          if (elemLen !== -1) {
            buf.sliceInto(elemBuf, elemLen);
            val2 = codecs[i8].decode(elemBuf, ctx);
            elemBuf.finish();
          }
          result[name3] = val2;
        }
        return result;
      }
      getSubcodecs() {
        return Array.from(this.codecs);
      }
      getKind() {
        return "sparse_object";
      }
    };
    exports2.SparseObjectCodec = SparseObjectCodec;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/registry.js
var require_registry = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/registry.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.CodecsRegistry = void 0;
    var buffer_1 = require_buffer();
    var lru_1 = __importDefault(require_lru());
    var ifaces_1 = require_ifaces();
    var codecs_1 = require_codecs();
    var consts_1 = require_consts();
    var tuple_1 = require_tuple();
    var array_1 = require_array();
    var namedtuple_1 = require_namedtuple();
    var enum_1 = require_enum();
    var object_1 = require_object();
    var set_1 = require_set();
    var record_1 = require_record();
    var range_1 = require_range3();
    var utils_1 = require_utils4();
    var sparseObject_1 = require_sparseObject();
    var errors_1 = require_errors();
    var CODECS_CACHE_SIZE = 1e3;
    var CODECS_BUILD_CACHE_SIZE = 200;
    var CTYPE_SET = 0;
    var CTYPE_SHAPE = 1;
    var CTYPE_BASE_SCALAR = 2;
    var CTYPE_SCALAR = 3;
    var CTYPE_TUPLE = 4;
    var CTYPE_NAMEDTUPLE = 5;
    var CTYPE_ARRAY = 6;
    var CTYPE_ENUM = 7;
    var CTYPE_INPUT_SHAPE = 8;
    var CTYPE_RANGE = 9;
    var CTYPE_OBJECT = 10;
    var CTYPE_COMPOUND = 11;
    var CTYPE_MULTIRANGE = 12;
    var CTYPE_RECORD = 13;
    var CodecsRegistry = class {
      constructor() {
        __publicField(this, "codecsBuildCache");
        __publicField(this, "codecs");
        this.codecs = new lru_1.default({ capacity: CODECS_CACHE_SIZE });
        this.codecsBuildCache = new lru_1.default({ capacity: CODECS_BUILD_CACHE_SIZE });
      }
      hasCodec(typeId) {
        if (this.codecs.has(typeId)) {
          return true;
        }
        return typeId === consts_1.NULL_CODEC_ID || typeId === tuple_1.EMPTY_TUPLE_CODEC_ID;
      }
      getCodec(typeId) {
        const codec = this.codecs.get(typeId);
        if (codec != null) {
          return codec;
        }
        if (typeId === tuple_1.EMPTY_TUPLE_CODEC_ID) {
          return tuple_1.EMPTY_TUPLE_CODEC;
        }
        if (typeId === consts_1.NULL_CODEC_ID) {
          return codecs_1.NULL_CODEC;
        }
        return null;
      }
      buildCodec(spec, protocolVersion) {
        if (!(0, utils_1.versionGreaterThanOrEqual)(protocolVersion, [2, 0])) {
          throw new errors_1.UnsupportedProtocolVersionError("unsupported old protocol version v1; downgrade to the previous version of gel-js");
        }
        const frb = new buffer_1.ReadBuffer(spec);
        const codecsList = [];
        let codec = null;
        while (frb.length) {
          const descLen = frb.readInt32();
          const descBuf = buffer_1.ReadBuffer.alloc();
          frb.sliceInto(descBuf, descLen);
          codec = this._buildCodec(descBuf, codecsList);
          descBuf.finish("unexpected trailing data in type descriptor buffer");
          if (codec == null) {
            continue;
          }
          codecsList.push(codec);
          this.codecs.set(codec.tid, codec);
        }
        if (!codecsList.length) {
          throw new errors_1.InternalClientError("could not build a codec");
        }
        return codecsList[codecsList.length - 1];
      }
      _buildCodec(frb, cl) {
        const t6 = frb.readUInt8();
        const tid = frb.readUUID();
        let res = this.codecs.get(tid);
        if (res == null) {
          res = this.codecsBuildCache.get(tid);
        }
        if (res != null) {
          frb.discard(frb.length);
          return res;
        }
        switch (t6) {
          case CTYPE_BASE_SCALAR: {
            res = codecs_1.SCALAR_CODECS.get(tid);
            if (!res) {
              if (consts_1.KNOWN_TYPES.has(tid)) {
                throw new errors_1.InternalClientError(`no JS codec for ${consts_1.KNOWN_TYPES.get(tid)}`);
              }
              throw new errors_1.InternalClientError(`no JS codec for the type with ID ${tid}`);
            }
            if (!(res instanceof ifaces_1.ScalarCodec)) {
              throw new errors_1.ProtocolError("could not build scalar codec: base scalar is a non-scalar codec");
            }
            break;
          }
          case CTYPE_SHAPE:
          case CTYPE_INPUT_SHAPE: {
            if (t6 === CTYPE_SHAPE) {
              frb.readBoolean();
              frb.readUInt16();
            }
            const els = frb.readUInt16();
            const codecs = new Array(els);
            const names = new Array(els);
            const flags2 = new Array(els);
            const cards = new Array(els);
            for (let i8 = 0; i8 < els; i8++) {
              const flag = frb.readUInt32();
              const card = frb.readUInt8();
              const name3 = frb.readString();
              const pos = frb.readUInt16();
              const subCodec = cl[pos];
              if (subCodec == null) {
                throw new errors_1.ProtocolError("could not build object codec: missing subcodec");
              }
              codecs[i8] = subCodec;
              names[i8] = name3;
              flags2[i8] = flag;
              cards[i8] = card;
              if (t6 === CTYPE_SHAPE) {
                frb.readUInt16();
              }
            }
            res = t6 === CTYPE_INPUT_SHAPE ? new sparseObject_1.SparseObjectCodec(tid, codecs, names) : new object_1.ObjectCodec(tid, codecs, names, flags2, cards);
            break;
          }
          case CTYPE_SET: {
            const pos = frb.readUInt16();
            const subCodec = cl[pos];
            if (subCodec == null) {
              throw new errors_1.ProtocolError("could not build set codec: missing subcodec");
            }
            res = new set_1.SetCodec(tid, subCodec);
            break;
          }
          case CTYPE_SCALAR: {
            const typeName = frb.readString();
            frb.readBoolean();
            const ancestorCount = frb.readUInt16();
            const ancestors = [];
            for (let i8 = 0; i8 < ancestorCount; i8++) {
              const ancestorPos = frb.readUInt16();
              const ancestorCodec = cl[ancestorPos];
              if (ancestorCodec == null) {
                throw new errors_1.ProtocolError("could not build scalar codec: missing a codec for base scalar");
              }
              if (!(ancestorCodec instanceof ifaces_1.ScalarCodec)) {
                throw new errors_1.ProtocolError(`a scalar codec expected for base scalar type, got ${ancestorCodec}`);
              }
              ancestors.push(ancestorCodec);
            }
            if (ancestorCount === 0) {
              res = codecs_1.SCALAR_CODECS.get(tid);
              if (res == null) {
                if (consts_1.KNOWN_TYPES.has(tid)) {
                  throw new errors_1.InternalClientError(`no JS codec for ${consts_1.KNOWN_TYPES.get(tid)}`);
                }
                throw new errors_1.InternalClientError(`no JS codec for the type with ID ${tid}`);
              }
            } else {
              const baseCodec = ancestors[ancestors.length - 1];
              res = baseCodec.derive(tid, typeName, ancestors);
            }
            break;
          }
          case CTYPE_ARRAY: {
            const typeName = frb.readString();
            frb.readBoolean();
            const ancestorCount = frb.readUInt16();
            for (let i8 = 0; i8 < ancestorCount; i8++) {
              frb.readUInt16();
            }
            const pos = frb.readUInt16();
            const els = frb.readUInt16();
            if (els !== 1) {
              throw new errors_1.ProtocolError("cannot handle arrays with more than one dimension");
            }
            const dimLen = frb.readInt32();
            const subCodec = cl[pos];
            if (subCodec == null) {
              throw new errors_1.ProtocolError("could not build array codec: missing subcodec");
            }
            res = new array_1.ArrayCodec(tid, typeName, subCodec, dimLen);
            break;
          }
          case CTYPE_TUPLE: {
            const typeName = frb.readString();
            frb.readBoolean();
            const ancestorCount = frb.readUInt16();
            for (let i8 = 0; i8 < ancestorCount; i8++) {
              frb.readUInt16();
            }
            const els = frb.readUInt16();
            if (els === 0) {
              res = tuple_1.EMPTY_TUPLE_CODEC;
            } else {
              const codecs = new Array(els);
              for (let i8 = 0; i8 < els; i8++) {
                const pos = frb.readUInt16();
                const subCodec = cl[pos];
                if (subCodec == null) {
                  throw new errors_1.ProtocolError("could not build tuple codec: missing subcodec");
                }
                codecs[i8] = subCodec;
              }
              res = new tuple_1.TupleCodec(tid, typeName, codecs);
            }
            break;
          }
          case CTYPE_NAMEDTUPLE: {
            const typeName = frb.readString();
            frb.readBoolean();
            const ancestorCount = frb.readUInt16();
            for (let i8 = 0; i8 < ancestorCount; i8++) {
              frb.readUInt16();
            }
            const els = frb.readUInt16();
            const codecs = new Array(els);
            const names = new Array(els);
            for (let i8 = 0; i8 < els; i8++) {
              names[i8] = frb.readString();
              const pos = frb.readUInt16();
              const subCodec = cl[pos];
              if (subCodec == null) {
                throw new errors_1.ProtocolError("could not build namedtuple codec: missing subcodec");
              }
              codecs[i8] = subCodec;
            }
            res = new namedtuple_1.NamedTupleCodec(tid, typeName, codecs, names);
            break;
          }
          case CTYPE_RECORD: {
            const els = frb.readUInt16();
            const codecs = new Array(els);
            const names = new Array(els);
            for (let i8 = 0; i8 < els; i8++) {
              names[i8] = frb.readString();
              const pos = frb.readUInt16();
              const subCodec = cl[pos];
              if (subCodec == null) {
                throw new errors_1.ProtocolError("could not build record codec: missing subcodec");
              }
              codecs[i8] = subCodec;
            }
            res = new record_1.RecordCodec(tid, codecs, names);
            break;
          }
          case CTYPE_ENUM: {
            const typeName = frb.readString();
            frb.readBoolean();
            const ancestorCount = frb.readUInt16();
            for (let i8 = 0; i8 < ancestorCount; i8++) {
              frb.readUInt16();
            }
            const els = frb.readUInt16();
            const values2 = [];
            for (let i8 = 0; i8 < els; i8++) {
              values2.push(frb.readString());
            }
            res = new enum_1.EnumCodec(tid, typeName, values2);
            break;
          }
          case CTYPE_RANGE: {
            const typeName = frb.readString();
            frb.readBoolean();
            const ancestorCount = frb.readUInt16();
            for (let i8 = 0; i8 < ancestorCount; i8++) {
              frb.readUInt16();
            }
            const pos = frb.readUInt16();
            const subCodec = cl[pos];
            if (subCodec == null) {
              throw new errors_1.ProtocolError("could not build range codec: missing subcodec");
            }
            res = new range_1.RangeCodec(tid, typeName, subCodec);
            break;
          }
          case CTYPE_OBJECT: {
            frb.discard(frb.length);
            res = codecs_1.NULL_CODEC;
            break;
          }
          case CTYPE_COMPOUND: {
            frb.discard(frb.length);
            res = codecs_1.NULL_CODEC;
            break;
          }
          case CTYPE_MULTIRANGE: {
            const typeName = frb.readString();
            frb.readBoolean();
            const ancestorCount = frb.readUInt16();
            for (let i8 = 0; i8 < ancestorCount; i8++) {
              frb.readUInt16();
            }
            const pos = frb.readUInt16();
            const subCodec = cl[pos];
            if (subCodec == null) {
              throw new errors_1.ProtocolError("could not build range codec: missing subcodec");
            }
            res = new range_1.MultiRangeCodec(tid, typeName, subCodec);
            break;
          }
        }
        if (res == null) {
          if (consts_1.KNOWN_TYPES.has(tid)) {
            throw new errors_1.InternalClientError(`could not build a codec for ${consts_1.KNOWN_TYPES.get(tid)} type`);
          } else {
            throw new errors_1.InternalClientError(`could not build a codec for ${tid} type`);
          }
        }
        this.codecsBuildCache.set(tid, res);
        return res;
      }
    };
    exports2.CodecsRegistry = CodecsRegistry;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/context.js
var require_context = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/codecs/context.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.NOOP_CODEC_CONTEXT = exports2.CodecContext = void 0;
    var NOOP = {
      toDatabase(data) {
        return data;
      },
      fromDatabase(data) {
        return data;
      }
    };
    var CodecContext = class {
      constructor(spec) {
        __publicField(this, "spec");
        __publicField(this, "map");
        if (spec === null || spec.size === 0) {
          this.spec = null;
        } else {
          this.spec = spec;
        }
        this.map = /* @__PURE__ */ new Map();
      }
      initCodec(codec) {
        const specMap = this.spec;
        const targetTypeName = codec.typeName;
        const s10 = specMap.get(targetTypeName);
        if (s10 != null) {
          this.map.set(targetTypeName, s10);
          return s10;
        }
        const ancestors = codec.ancestors;
        if (ancestors == null) {
          this.map.set(targetTypeName, NOOP);
          return NOOP;
        }
        for (let i8 = 0; i8 < ancestors.length; i8++) {
          const parent = ancestors[i8];
          const s11 = specMap.get(parent.typeName);
          if (s11 != null) {
            this.map.set(targetTypeName, s11);
            return s11;
          }
        }
        this.map.set(targetTypeName, NOOP);
        return NOOP;
      }
      getContainerOverload(kind) {
        if (this.spec === null || !this.spec.size) {
          return;
        }
        return this.spec.get(kind);
      }
      hasOverload(codec) {
        if (this.spec === null || !this.spec.size) {
          return false;
        }
        const op = this.map.get(codec.typeName);
        if (op === NOOP) {
          return false;
        }
        if (op != null) {
          return true;
        }
        return this.initCodec(codec) !== NOOP;
      }
      postDecode(codec, value) {
        if (this.spec === null || !this.spec.size) {
          return value;
        }
        let op = this.map.get(codec.typeName);
        if (op === NOOP) {
          return value;
        }
        if (op == null) {
          op = this.initCodec(codec);
        }
        return op.fromDatabase(value);
      }
      preEncode(codec, value) {
        if (this.spec === null || !this.spec.size) {
          return value;
        }
        let op = this.map.get(codec.typeName);
        if (op === NOOP) {
          return value;
        }
        if (op == null) {
          op = this.initCodec(codec);
        }
        return op.toDatabase(value);
      }
    };
    exports2.CodecContext = CodecContext;
    exports2.NOOP_CODEC_CONTEXT = new CodecContext(null);
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/options.js
var require_options = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/options.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Options = exports2.TransactionOptions = exports2.RetryOptions = exports2.logWarnings = exports2.throwWarnings = exports2.RetryCondition = exports2.IsolationLevel = void 0;
    exports2.defaultBackoff = defaultBackoff;
    var errors = __importStar(require_errors());
    var buffer_1 = require_buffer();
    var record_1 = require_record();
    var context_1 = require_context();
    function defaultBackoff(attempt) {
      return 2 ** attempt * 100 + Math.random() * 100;
    }
    var IsolationLevel;
    (function(IsolationLevel2) {
      IsolationLevel2["Serializable"] = "Serializable";
      IsolationLevel2["RepeatableRead"] = "RepeatableRead";
      IsolationLevel2["PreferRepeatableRead"] = "PreferRepeatableRead";
    })(IsolationLevel || (exports2.IsolationLevel = IsolationLevel = {}));
    var RetryCondition;
    (function(RetryCondition2) {
      RetryCondition2[RetryCondition2["TransactionConflict"] = 0] = "TransactionConflict";
      RetryCondition2[RetryCondition2["NetworkError"] = 1] = "NetworkError";
    })(RetryCondition || (exports2.RetryCondition = RetryCondition = {}));
    var RetryRule = class {
      constructor(attempts, backoff2) {
        __publicField(this, "attempts");
        __publicField(this, "backoff");
        this.attempts = attempts;
        this.backoff = backoff2;
      }
    };
    var throwWarnings = (warnings) => {
      throw new AggregateError(warnings, formatWarnings(warnings));
    };
    exports2.throwWarnings = throwWarnings;
    var logWarnings = (warnings) => {
      const merged = new Error(formatWarnings(warnings));
      console.warn(Object.assign(merged, { name: "" }));
    };
    exports2.logWarnings = logWarnings;
    var formatWarnings = (warnings) => `warnings occurred while running query:
${warnings.map((warn) => warn.message).join("\n")}`;
    var RetryOptions = class _RetryOptions {
      constructor(attempts = 3, backoff2 = defaultBackoff) {
        __publicField(this, "default");
        __publicField(this, "overrides");
        this.default = new RetryRule(attempts, backoff2);
        this.overrides = /* @__PURE__ */ new Map();
      }
      withRule(condition, attempts, backoff2) {
        const def = this.default;
        const overrides = new Map(this.overrides);
        overrides.set(condition, new RetryRule(attempts ?? def.attempts, backoff2 ?? def.backoff));
        const result = Object.create(_RetryOptions.prototype);
        result.default = def;
        result.overrides = overrides;
        return result;
      }
      getRuleForException(err3) {
        let result;
        if (err3 instanceof errors.TransactionConflictError) {
          result = this.overrides.get(RetryCondition.TransactionConflict);
        } else if (err3 instanceof errors.ClientError) {
          result = this.overrides.get(RetryCondition.NetworkError);
        }
        return result ?? this.default;
      }
      static defaults() {
        return _retryOptionsDefault;
      }
    };
    exports2.RetryOptions = RetryOptions;
    var _retryOptionsDefault = new RetryOptions();
    var TransactionOptions = class {
      constructor({ isolation, readonly, deferrable } = {}) {
        __publicField(this, "isolation");
        __publicField(this, "readonly");
        __publicField(this, "deferrable");
        this.isolation = isolation;
        this.readonly = readonly;
        this.deferrable = deferrable;
      }
      isDefault() {
        return this.isolation === void 0 && this.readonly === void 0 && this.deferrable === void 0;
      }
      static defaults() {
        return _defaultTransactionOptions;
      }
    };
    exports2.TransactionOptions = TransactionOptions;
    var _defaultTransactionOptions = new TransactionOptions();
    var TAG_ANNOTATION_KEY = "tag";
    var _Options = class _Options {
      constructor({ retryOptions = RetryOptions.defaults(), transactionOptions = TransactionOptions.defaults(), warningHandler = exports2.logWarnings, module: module3 = "default", moduleAliases = {}, config = {}, globals = {}, codecs = {} } = {}) {
        __publicField(this, "module");
        __publicField(this, "moduleAliases");
        __publicField(this, "config");
        __publicField(this, "globals");
        __publicField(this, "retryOptions");
        __publicField(this, "transactionOptions");
        __publicField(this, "codecs");
        __publicField(this, "warningHandler");
        __publicField(this, "annotations", /* @__PURE__ */ new Map());
        __publicField(this, "cachedCodecContext", null);
        __publicField(this, "cachedCodecContextVer", -1);
        this.retryOptions = retryOptions;
        this.transactionOptions = transactionOptions;
        this.warningHandler = warningHandler;
        this.module = module3;
        this.moduleAliases = new Map(Object.entries(moduleAliases));
        this.config = new Map(Object.entries(config));
        this.globals = new Map(Object.entries(globals));
        this.codecs = new Map(Object.entries(codecs));
      }
      get tag() {
        return this.annotations.get(TAG_ANNOTATION_KEY) ?? null;
      }
      static signalSchemaChange() {
        this.schemaVersion += 1;
      }
      makeCodecContext() {
        if (this.codecs.size === 0) {
          return context_1.NOOP_CODEC_CONTEXT;
        }
        if (this.cachedCodecContextVer === _Options.schemaVersion) {
          return this.cachedCodecContext;
        }
        const ctx = new context_1.CodecContext(this.codecs);
        this.cachedCodecContext = ctx;
        this.cachedCodecContextVer = _Options.schemaVersion;
        return ctx;
      }
      _cloneWith(mergeOptions) {
        const clone2 = Object.create(_Options.prototype);
        clone2.annotations = this.annotations;
        clone2.retryOptions = mergeOptions.retryOptions ?? this.retryOptions;
        clone2.transactionOptions = mergeOptions.transactionOptions ?? this.transactionOptions;
        clone2.warningHandler = mergeOptions.warningHandler ?? this.warningHandler;
        if (mergeOptions.config != null) {
          clone2.config = new Map([
            ...this.config,
            ...Object.entries(mergeOptions.config)
          ]);
        } else {
          clone2.config = this.config;
        }
        if (mergeOptions.globals != null) {
          clone2.globals = new Map([
            ...this.globals,
            ...Object.entries(mergeOptions.globals)
          ]);
        } else {
          clone2.globals = this.globals;
        }
        if (mergeOptions.moduleAliases != null) {
          clone2.moduleAliases = new Map([
            ...this.moduleAliases,
            ...Object.entries(mergeOptions.moduleAliases)
          ]);
        } else {
          clone2.moduleAliases = this.moduleAliases;
        }
        if (mergeOptions.codecs != null) {
          clone2.codecs = new Map([
            ...this.codecs,
            ...Object.entries(mergeOptions.codecs)
          ]);
        } else {
          clone2.codecs = this.codecs;
          clone2.cachedCodecContext = this.cachedCodecContext;
          clone2.cachedCodecContextVer = this.cachedCodecContextVer;
        }
        if (mergeOptions._dropSQLRowCodec && clone2.codecs.has("_private_sql_row")) {
          if (clone2.codecs === this.codecs) {
            clone2.codecs = new Map(clone2.codecs);
            clone2.cachedCodecContext = null;
            clone2.cachedCodecContextVer = -1;
          }
          clone2.codecs.delete("_private_sql_row");
        }
        clone2.module = mergeOptions.module ?? this.module;
        return clone2;
      }
      _serialise() {
        const state2 = {};
        if (this.module !== "default") {
          state2.module = this.module;
        }
        if (this.moduleAliases.size) {
          state2.aliases = Array.from(this.moduleAliases.entries());
        }
        if (this.config.size) {
          state2.config = Object.fromEntries(this.config.entries());
        }
        if (this.globals.size) {
          const globs = {};
          for (const [key, val2] of this.globals.entries()) {
            globs[key.includes("::") ? key : `${this.module}::${key}`] = val2;
          }
          state2.globals = globs;
        }
        return state2;
      }
      withModuleAliases({ module: module3, ...aliases }) {
        return this._cloneWith({
          module: module3 ?? this.module,
          moduleAliases: aliases
        });
      }
      withConfig(config) {
        return this._cloneWith({ config });
      }
      withCodecs(codecs) {
        return this._cloneWith({ codecs });
      }
      withSQLRowMode(mode) {
        if (mode === "object") {
          return this._cloneWith({ _dropSQLRowCodec: true });
        } else if (mode === "array") {
          return this._cloneWith({ codecs: record_1.SQLRowModeArray });
        } else {
          throw new errors.InterfaceError(`invalid mode=${mode}`);
        }
      }
      withGlobals(globals) {
        return this._cloneWith({
          globals: { ...this.globals, ...globals }
        });
      }
      withQueryTag(tag) {
        const annos = new Map(this.annotations);
        if (tag != null) {
          if (tag.startsWith("edgedb/")) {
            throw new errors.InterfaceError("reserved tag: edgedb/*");
          }
          if (tag.startsWith("gel/")) {
            throw new errors.InterfaceError("reserved tag: gel/*");
          }
          if (buffer_1.utf8Encoder.encode(tag).length > 128) {
            throw new errors.InterfaceError("tag too long (> 128 bytes)");
          }
          annos.set(TAG_ANNOTATION_KEY, tag);
        } else {
          annos.delete(TAG_ANNOTATION_KEY);
        }
        const clone2 = this._cloneWith({});
        clone2.annotations = annos;
        return clone2;
      }
      withTransactionOptions(opt) {
        return this._cloneWith({
          transactionOptions: opt instanceof TransactionOptions ? opt : new TransactionOptions(opt)
        });
      }
      withRetryOptions(opt) {
        return this._cloneWith({
          retryOptions: opt instanceof RetryOptions ? opt : new RetryOptions(opt.attempts, opt.backoff)
        });
      }
      withWarningHandler(handler) {
        return this._cloneWith({ warningHandler: handler });
      }
      isDefaultSession() {
        return this.config.size === 0 && this.globals.size === 0 && this.moduleAliases.size === 0 && this.module === "default" && this.transactionOptions.isDefault();
      }
      static defaults() {
        return _defaultOptions;
      }
    };
    __publicField(_Options, "schemaVersion", 0);
    var Options = _Options;
    exports2.Options = Options;
    var _defaultOptions = new Options();
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/event.js
var require_event = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/event.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var errors_1 = require_errors();
    var Event = class {
      constructor() {
        __publicField(this, "_promise");
        __publicField(this, "_resolve");
        __publicField(this, "_reject");
        __publicField(this, "_done");
        this._done = false;
        let futReject = null;
        let futResolve = null;
        this._promise = new Promise((resolve2, reject) => {
          futReject = (reason) => {
            this._done = true;
            reject(reason);
          };
          futResolve = (value) => {
            this._done = true;
            resolve2(value);
          };
        });
        if (!futReject || !futResolve) {
          throw new errors_1.InternalClientError("Promise executor was not called synchronously");
        }
        this._reject = futReject;
        this._resolve = futResolve;
      }
      async wait() {
        await this._promise;
      }
      then(..._args) {
        throw new errors_1.InternalClientError("Event objects cannot be awaited on directly; use Event.wait()");
      }
      get done() {
        return this._done;
      }
      set() {
        if (this._done) {
          throw new errors_1.InternalClientError("emit(): the Event is already set");
        }
        this._resolve(true);
      }
      setError(reason) {
        if (this._done) {
          throw new errors_1.InternalClientError("emitError(): the Event is already set");
        }
        this._reject(reason);
      }
    };
    exports2.default = Event;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/queues.js
var require_queues = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/queues.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.LifoQueue = void 0;
    var errors_1 = require_errors();
    var LifoQueue = class {
      constructor() {
        __publicField(this, "_promises");
        __publicField(this, "_resolvers");
        __publicField(this, "_rejecters");
        this._resolvers = [];
        this._rejecters = [];
        this._promises = [];
      }
      _add() {
        this._promises.push(new Promise((resolve2, reject) => {
          this._resolvers.push(resolve2);
          this._rejecters.push(reject);
        }));
      }
      push(item) {
        if (!this._resolvers.length) {
          this._add();
        }
        const resolve2 = this._resolvers.shift();
        this._rejecters.shift();
        if (!resolve2) {
          throw new errors_1.InternalClientError("resolve function was null or undefined when attempting to push.");
        }
        resolve2(item);
      }
      get() {
        if (!this._promises.length) {
          this._add();
        }
        const promise = this._promises.pop();
        if (!promise) {
          throw new errors_1.InternalClientError("promise was null or undefined when attempting to get.");
        }
        return promise;
      }
      cancelAllPending(err3) {
        const rejecters = this._rejecters;
        this._rejecters = [];
        this._resolvers = [];
        for (const reject of rejecters) {
          reject(err3);
        }
      }
      get length() {
        return this._promises.length - this._resolvers.length;
      }
      get pending() {
        return Math.max(0, this._resolvers.length - this._promises.length);
      }
    };
    exports2.LifoQueue = LifoQueue;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/retry.js
var require_retry = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/retry.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.retryingConnect = retryingConnect;
    var errors = __importStar(require_errors());
    var utils_1 = require_utils4();
    var lastLoggingAt = 0;
    async function retryingConnect(connectWithTimeout, config, registry) {
      const maxTime = config.connectionParams.waitUntilAvailable === 0 ? 0 : Date.now() + config.connectionParams.waitUntilAvailable;
      while (true) {
        try {
          return await connectWithTimeout(config, registry);
        } catch (e6) {
          if (e6 instanceof errors.ClientConnectionError) {
            if (e6.hasTag(errors.SHOULD_RECONNECT)) {
              const now = Date.now();
              if (now > maxTime) {
                throw e6;
              }
              if (config.logging && (!lastLoggingAt || now - lastLoggingAt > 5e3)) {
                lastLoggingAt = now;
                const logMsg = [
                  `A client connection error occurred; reconnecting because of "waitUntilAvailable=${config.connectionParams.waitUntilAvailable}".`,
                  e6
                ];
                if (!config.fromProject && !config.fromEnv && await config.inProject()) {
                  logMsg.push(`


Hint: it looks like the program is running from a directory initialized with "gel project init". Consider calling "gel.connect()" without arguments.
`);
                }
                console.warn(...logMsg);
              }
            } else {
              throw e6;
            }
          } else {
            console.error("Unexpected connection error:", e6);
            throw e6;
          }
        }
        await (0, utils_1.sleep)(Math.trunc(10 + Math.random() * 200));
      }
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/enums.js
var require_enums = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/enums.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.OperatorKind = exports2.SelectModifierKind = exports2.ExpressionKind = exports2.TypeKind = exports2.Cardinality = void 0;
    var Cardinality;
    (function(Cardinality2) {
      Cardinality2["AtMostOne"] = "AtMostOne";
      Cardinality2["One"] = "One";
      Cardinality2["Many"] = "Many";
      Cardinality2["AtLeastOne"] = "AtLeastOne";
      Cardinality2["Empty"] = "Empty";
    })(Cardinality || (exports2.Cardinality = Cardinality = {}));
    var TypeKind;
    (function(TypeKind2) {
      TypeKind2["scalar"] = "scalar";
      TypeKind2["enum"] = "enum";
      TypeKind2["object"] = "object";
      TypeKind2["namedtuple"] = "namedtuple";
      TypeKind2["tuple"] = "tuple";
      TypeKind2["array"] = "array";
      TypeKind2["range"] = "range";
      TypeKind2["multirange"] = "multirange";
    })(TypeKind || (exports2.TypeKind = TypeKind = {}));
    var ExpressionKind;
    (function(ExpressionKind2) {
      ExpressionKind2["Set"] = "Set";
      ExpressionKind2["Array"] = "Array";
      ExpressionKind2["Tuple"] = "Tuple";
      ExpressionKind2["NamedTuple"] = "NamedTuple";
      ExpressionKind2["TuplePath"] = "TuplePath";
      ExpressionKind2["PathNode"] = "PathNode";
      ExpressionKind2["PathLeaf"] = "PathLeaf";
      ExpressionKind2["Literal"] = "Literal";
      ExpressionKind2["Cast"] = "Cast";
      ExpressionKind2["Select"] = "Select";
      ExpressionKind2["Update"] = "Update";
      ExpressionKind2["Delete"] = "Delete";
      ExpressionKind2["Insert"] = "Insert";
      ExpressionKind2["InsertUnlessConflict"] = "InsertUnlessConflict";
      ExpressionKind2["Function"] = "Function";
      ExpressionKind2["Operator"] = "Operator";
      ExpressionKind2["For"] = "For";
      ExpressionKind2["ForVar"] = "ForVar";
      ExpressionKind2["TypeIntersection"] = "TypeIntersection";
      ExpressionKind2["Alias"] = "Alias";
      ExpressionKind2["With"] = "With";
      ExpressionKind2["WithParams"] = "WithParams";
      ExpressionKind2["Param"] = "Param";
      ExpressionKind2["OptionalParam"] = "OptionalParam";
      ExpressionKind2["Detached"] = "Detached";
      ExpressionKind2["Global"] = "Global";
      ExpressionKind2["PolyShapeElement"] = "PolyShapeElement";
      ExpressionKind2["Group"] = "Group";
    })(ExpressionKind || (exports2.ExpressionKind = ExpressionKind = {}));
    var SelectModifierKind;
    (function(SelectModifierKind2) {
      SelectModifierKind2["filter"] = "filter";
      SelectModifierKind2["order_by"] = "order_by";
      SelectModifierKind2["offset"] = "offset";
      SelectModifierKind2["limit"] = "limit";
    })(SelectModifierKind || (exports2.SelectModifierKind = SelectModifierKind = {}));
    var OperatorKind;
    (function(OperatorKind2) {
      OperatorKind2["Infix"] = "Infix";
      OperatorKind2["Postfix"] = "Postfix";
      OperatorKind2["Prefix"] = "Prefix";
      OperatorKind2["Ternary"] = "Ternary";
    })(OperatorKind || (exports2.OperatorKind = OperatorKind = {}));
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/util.js
var require_util3 = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/util.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.util = void 0;
    var ifaces_1 = require_ifaces2();
    var enums_1 = require_enums();
    var util2;
    (function(util3) {
      function assertNever(arg, error2) {
        throw error2 ?? new Error(`${arg} is supposed to be of "never" type`);
      }
      util3.assertNever = assertNever;
      function splitName(name3) {
        if (!name3.includes("::"))
          throw new Error(`Invalid FQN ${name3}`);
        const parts2 = name3.split("::");
        return {
          mod: parts2.slice(0, -1).join("::"),
          name: parts2[parts2.length - 1]
        };
      }
      util3.splitName = splitName;
      function toIdent(name3) {
        if (name3.includes("::")) {
          throw new Error(`toIdent: invalid name ${name3}`);
        }
        return name3.replace(/([^a-zA-Z0-9_]+)/g, "_");
      }
      util3.toIdent = toIdent;
      util3.deduplicate = (args2) => [...new Set(args2)];
      util3.getFromArrayMap = (map2, id) => {
        return map2[id] || [];
      };
      util3.defineProperty = (obj, name3, def) => {
        return Object.defineProperty(obj, name3, def);
      };
      util3.defineGetter = (obj, name3, getter) => {
        return Object.defineProperty(obj, name3, {
          get: getter,
          enumerable: true
        });
      };
      util3.defineMethod = (obj, name3, method) => {
        obj[name3] = method.bind(obj);
        return obj;
      };
      function flatMap(array3, callbackfn) {
        return Array.prototype.concat(...array3.map(callbackfn));
      }
      util3.flatMap = flatMap;
      function omitDollarPrefixed(object2) {
        const obj = {};
        for (const key of Object.keys(object2)) {
          if (!key.startsWith("$")) {
            obj[key] = object2[key];
          }
        }
        return obj;
      }
      util3.omitDollarPrefixed = omitDollarPrefixed;
      util3.parseCardinality = (cardinality) => {
        switch (cardinality) {
          case ifaces_1.Cardinality.MANY:
            return enums_1.Cardinality.Many;
          case ifaces_1.Cardinality.ONE:
            return enums_1.Cardinality.One;
          case ifaces_1.Cardinality.AT_MOST_ONE:
            return enums_1.Cardinality.AtMostOne;
          case ifaces_1.Cardinality.AT_LEAST_ONE:
            return enums_1.Cardinality.AtLeastOne;
          case ifaces_1.Cardinality.NO_RESULT:
            return enums_1.Cardinality.Empty;
        }
        throw new Error(`Unexpected cardinality: ${cardinality}`);
      };
    })(util2 || (exports2.util = util2 = {}));
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/transaction.js
var require_transaction = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/transaction.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Transaction = exports2.TransactionImpl = exports2.TransactionState = void 0;
    var errors = __importStar(require_errors());
    var ifaces_1 = require_ifaces2();
    var options_1 = require_options();
    var TransactionState;
    (function(TransactionState2) {
      TransactionState2[TransactionState2["ACTIVE"] = 0] = "ACTIVE";
      TransactionState2[TransactionState2["COMMITTED"] = 1] = "COMMITTED";
      TransactionState2[TransactionState2["ROLLEDBACK"] = 2] = "ROLLEDBACK";
      TransactionState2[TransactionState2["FAILED"] = 3] = "FAILED";
    })(TransactionState || (exports2.TransactionState = TransactionState = {}));
    var TransactionImpl = class _TransactionImpl {
      constructor(holder, rawConn) {
        __publicField(this, "_holder");
        __publicField(this, "_rawConn");
        __publicField(this, "_state");
        __publicField(this, "_opInProgress");
        this._holder = holder;
        this._rawConn = rawConn;
        this._state = TransactionState.ACTIVE;
        this._opInProgress = false;
      }
      static async _startTransaction(holder, optimisticRepeatableRead) {
        const rawConn = await holder._getConnection();
        await rawConn.resetState();
        const options = holder.options.transactionOptions;
        const txOptions = [];
        if (options.isolation === options_1.IsolationLevel.RepeatableRead) {
          txOptions.push(`ISOLATION REPEATABLE READ`);
        } else if (options.isolation === options_1.IsolationLevel.Serializable) {
          txOptions.push(`ISOLATION SERIALIZABLE`);
        } else if (options.isolation === options_1.IsolationLevel.PreferRepeatableRead) {
          if (optimisticRepeatableRead) {
            txOptions.push(`ISOLATION REPEATABLE READ`);
          } else {
            txOptions.push(`ISOLATION SERIALIZABLE`);
          }
        } else if (options.isolation != null) {
          throw new errors.InterfaceError(`Invalid isolation level: ${options.isolation}`);
        }
        if (options.readonly !== void 0) {
          txOptions.push(options.readonly ? "READ ONLY" : "READ WRITE");
        }
        if (options.deferrable !== void 0) {
          txOptions.push(options.deferrable ? "DEFERRABLE" : "NOT DEFERRABLE");
        }
        await rawConn.fetch(`START TRANSACTION ${txOptions.join(", ")};`, void 0, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT, holder.options, true);
        return new _TransactionImpl(holder, rawConn);
      }
      async _waitForConnAbort() {
        await this._rawConn.connAbortWaiter.wait();
        const abortError = this._rawConn.getConnAbortError();
        if (abortError instanceof errors.GelError && abortError.cause instanceof errors.TransactionTimeoutError) {
          throw abortError.cause;
        } else {
          throw abortError;
        }
      }
      async _runOp(opname, op, errMessage) {
        if (this._opInProgress) {
          throw new errors.InterfaceError(errMessage ?? "Another query is in progress. Use the query methods on 'Client' to run queries concurrently.");
        }
        if (this._state !== TransactionState.ACTIVE) {
          throw new errors.InterfaceError(`cannot ${opname}; the transaction is ${this._state === TransactionState.COMMITTED ? "already committed" : this._state === TransactionState.ROLLEDBACK ? "already rolled back" : "in error state"}`);
        }
        this._opInProgress = true;
        try {
          return await op();
        } finally {
          this._opInProgress = false;
        }
      }
      async _runFetchOp(opName, ...args2) {
        const { result, warnings } = await this._runOp(opName, () => this._rawConn.fetch(...args2));
        if (warnings.length) {
          this._holder.options.warningHandler(warnings);
        }
        return result;
      }
      async _commit() {
        await this._runOp("commit", async () => {
          await this._rawConn.fetch("COMMIT", void 0, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT, this._holder.options, true);
          this._state = TransactionState.COMMITTED;
        }, "A query is still in progress after transaction block has returned.");
      }
      async _rollback() {
        await this._runOp("rollback", async () => {
          await this._rawConn.fetch("ROLLBACK", void 0, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT, this._holder.options, true);
          this._state = TransactionState.ROLLEDBACK;
        }, "A query is still in progress after transaction block has returned.");
      }
    };
    exports2.TransactionImpl = TransactionImpl;
    var Transaction = class _Transaction {
      constructor(impl, options) {
        __publicField(this, "impl");
        __publicField(this, "options");
        this.impl = impl;
        this.options = options;
      }
      withSQLRowMode(mode) {
        return new _Transaction(this.impl, this.options.withSQLRowMode(mode));
      }
      async execute(query, args2) {
        await this.impl._runFetchOp("execute", query, args2, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT, this.options);
      }
      async executeSQL(query, args2) {
        await this.impl._runFetchOp("execute", query, args2, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT, this.options, false, ifaces_1.Language.SQL);
      }
      async query(query, args2) {
        return this.impl._runFetchOp("query", query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.MANY, this.options);
      }
      async querySQL(query, args2) {
        return this.impl._runFetchOp("query", query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.MANY, this.options, false, ifaces_1.Language.SQL);
      }
      async queryJSON(query, args2) {
        return this.impl._runFetchOp("queryJSON", query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.MANY, this.options);
      }
      async querySingle(query, args2) {
        return this.impl._runFetchOp("querySingle", query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.AT_MOST_ONE, this.options);
      }
      async querySingleJSON(query, args2) {
        return this.impl._runFetchOp("querySingleJSON", query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.AT_MOST_ONE, this.options);
      }
      async queryRequired(query, args2) {
        return this.impl._runFetchOp("queryRequired", query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.AT_LEAST_ONE, this.options);
      }
      async queryRequiredJSON(query, args2) {
        return this.impl._runFetchOp("queryRequiredJSON", query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.AT_LEAST_ONE, this.options);
      }
      async queryRequiredSingle(query, args2) {
        return this.impl._runFetchOp("queryRequiredSingle", query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.ONE, this.options);
      }
      async queryRequiredSingleJSON(query, args2) {
        return this.impl._runFetchOp("queryRequiredSingleJSON", query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.ONE, this.options);
      }
    };
    exports2.Transaction = Transaction;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/baseClient.js
var require_baseClient = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/baseClient.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Client = exports2.BaseClientPool = exports2.ClientConnectionHolder = void 0;
    var registry_1 = require_registry();
    var errors = __importStar(require_errors());
    var ifaces_1 = require_ifaces2();
    var options_1 = require_options();
    var event_1 = __importDefault(require_event());
    var queues_1 = require_queues();
    var retry_1 = require_retry();
    var util_1 = require_util3();
    var transaction_1 = require_transaction();
    var utils_1 = require_utils4();
    var ClientConnectionHolder = class {
      constructor(pool2) {
        __publicField(this, "_pool");
        __publicField(this, "_connection");
        __publicField(this, "_options");
        __publicField(this, "_inUse");
        this._pool = pool2;
        this._connection = null;
        this._options = null;
        this._inUse = null;
      }
      get options() {
        return this._options ?? options_1.Options.defaults();
      }
      async _getConnection() {
        if (!this._connection || this._connection.isClosed()) {
          this._connection = await this._pool.getNewConnection();
        }
        return this._connection;
      }
      get connectionOpen() {
        return this._connection !== null && !this._connection.isClosed();
      }
      async acquire(options) {
        if (this._inUse) {
          throw new errors.InternalClientError("ClientConnectionHolder cannot be acquired, already in use");
        }
        this._options = options;
        this._inUse = new event_1.default();
        return this;
      }
      async release() {
        if (this._inUse === null) {
          throw new errors.ClientError("ClientConnectionHolder.release() called on a free connection holder");
        }
        this._options = null;
        await this._connection?.resetState();
        if (!this._inUse.done) {
          this._inUse.set();
        }
        this._inUse = null;
        this._pool.enqueue(this);
      }
      async _waitUntilReleasedAndClose() {
        if (this._inUse) {
          await this._inUse.wait();
        }
        await this._connection?.close();
      }
      terminate() {
        this._connection?.close();
      }
      async transaction(action) {
        let result;
        let optimisticRepeatableRead = true;
        for (let iteration = 0; ; ++iteration) {
          const transaction = await transaction_1.TransactionImpl._startTransaction(this, optimisticRepeatableRead);
          const clientTx = new transaction_1.Transaction(transaction, this.options);
          let commitFailed = false;
          try {
            result = await Promise.race([
              action(clientTx),
              transaction._waitForConnAbort()
            ]);
            try {
              await transaction._commit();
            } catch (err3) {
              commitFailed = true;
              throw err3;
            }
          } catch (err3) {
            try {
              if (!commitFailed) {
                await transaction._rollback();
              }
            } catch (rollback_err) {
              if (!(rollback_err instanceof errors.GelError)) {
                throw rollback_err;
              }
            }
            if (err3 instanceof errors.CapabilityError && err3.message && err3.message.includes("REPEATABLE READ") && optimisticRepeatableRead) {
              optimisticRepeatableRead = false;
              iteration--;
              continue;
            }
            if (err3 instanceof errors.GelError && err3.hasTag(errors.SHOULD_RETRY) && !(commitFailed && err3 instanceof errors.ClientConnectionError)) {
              const rule = this.options.retryOptions.getRuleForException(err3);
              if (iteration + 1 >= rule.attempts) {
                throw err3;
              }
              await (0, utils_1.sleep)(rule.backoff(iteration + 1));
              continue;
            }
            throw err3;
          }
          return result;
        }
      }
      async retryingFetch(query, args2, outputFormat, expectedCardinality, language = ifaces_1.Language.EDGEQL) {
        for (let iteration = 0; ; ++iteration) {
          const conn = await this._getConnection();
          try {
            const { result, warnings } = await conn.fetch(query, args2, outputFormat, expectedCardinality, this.options, false, language);
            if (warnings.length) {
              this.options.warningHandler(warnings);
            }
            return result;
          } catch (err3) {
            if (err3 instanceof errors.GelError && err3.hasTag(errors.SHOULD_RETRY) && (conn.getQueryCapabilities(query, outputFormat, expectedCardinality) === 0 || err3 instanceof errors.TransactionConflictError)) {
              const rule = this.options.retryOptions.getRuleForException(err3);
              if (iteration + 1 >= rule.attempts) {
                throw err3;
              }
              await (0, utils_1.sleep)(rule.backoff(iteration + 1));
              continue;
            }
            throw err3;
          }
        }
      }
      async execute(query, args2) {
        await this.retryingFetch(query, args2, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT);
      }
      async executeSQL(query, args2) {
        await this.retryingFetch(query, args2, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT, ifaces_1.Language.SQL);
      }
      async query(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.MANY);
      }
      async querySQL(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.MANY, ifaces_1.Language.SQL);
      }
      async queryJSON(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.MANY);
      }
      async querySingle(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.AT_MOST_ONE);
      }
      async querySingleJSON(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.AT_MOST_ONE);
      }
      async queryRequired(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.AT_LEAST_ONE);
      }
      async queryRequiredJSON(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.AT_LEAST_ONE);
      }
      async queryRequiredSingle(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.ONE);
      }
      async queryRequiredSingleJSON(query, args2) {
        return this.retryingFetch(query, args2, ifaces_1.OutputFormat.JSON, ifaces_1.Cardinality.ONE);
      }
    };
    exports2.ClientConnectionHolder = ClientConnectionHolder;
    var BaseClientPool = class {
      constructor(_parseConnectArguments, options) {
        __publicField(this, "_parseConnectArguments");
        __publicField(this, "_closing");
        __publicField(this, "_queue");
        __publicField(this, "_holders");
        __publicField(this, "_userConcurrency");
        __publicField(this, "_suggestedConcurrency");
        __publicField(this, "_connectConfig");
        __publicField(this, "_codecsRegistry");
        __publicField(this, "__normalizedConnectConfig", null);
        this._parseConnectArguments = _parseConnectArguments;
        this.validateClientOptions(options);
        this._codecsRegistry = new registry_1.CodecsRegistry();
        this._queue = new queues_1.LifoQueue();
        this._holders = [];
        this._userConcurrency = options.concurrency ?? null;
        this._suggestedConcurrency = null;
        this._closing = null;
        this._connectConfig = { ...options };
        this._resizeHolderPool();
      }
      validateClientOptions(opts) {
        if (opts.concurrency != null && (typeof opts.concurrency !== "number" || !Number.isInteger(opts.concurrency) || opts.concurrency < 0)) {
          throw new errors.InterfaceError(`invalid 'concurrency' value: expected integer greater than 0 (got ${JSON.stringify(opts.concurrency)})`);
        }
      }
      _getStats() {
        return {
          queueLength: this._queue.pending,
          openConnections: this._holders.filter((holder) => holder.connectionOpen).length
        };
      }
      async ensureConnected() {
        if (this._closing) {
          throw new errors.InterfaceError(this._closing.done ? "The client is closed" : "The client is closing");
        }
        if (this._getStats().openConnections > 0) {
          return;
        }
        const connHolder = await this._queue.get();
        try {
          await connHolder._getConnection();
        } finally {
          this._queue.push(connHolder);
        }
      }
      get _concurrency() {
        return this._userConcurrency ?? this._suggestedConcurrency ?? 1;
      }
      _resizeHolderPool() {
        const holdersDiff = this._concurrency - this._holders.length;
        if (holdersDiff > 0) {
          for (let i8 = 0; i8 < holdersDiff; i8++) {
            const connectionHolder = new ClientConnectionHolder(this);
            this._holders.push(connectionHolder);
            this._queue.push(connectionHolder);
          }
        } else if (holdersDiff < 0) {
        }
      }
      _getNormalizedConnectConfig() {
        return this.__normalizedConnectConfig ?? (this.__normalizedConnectConfig = this._parseConnectArguments(this._connectConfig));
      }
      async resolveConnectionParams() {
        const config = await this._getNormalizedConnectConfig();
        return config.connectionParams;
      }
      async getNewConnection() {
        if (this._closing?.done) {
          throw new errors.InterfaceError("The client is closed");
        }
        const config = await this._getNormalizedConnectConfig();
        const connection2 = await (0, retry_1.retryingConnect)(this._connectWithTimeout, config, this._codecsRegistry);
        const suggestedConcurrency = connection2.serverSettings.suggested_pool_concurrency;
        if (suggestedConcurrency && suggestedConcurrency !== this._suggestedConcurrency) {
          this._suggestedConcurrency = suggestedConcurrency;
          this._resizeHolderPool();
        }
        return connection2;
      }
      async acquireHolder(options) {
        if (this._closing) {
          throw new errors.InterfaceError(this._closing.done ? "The client is closed" : "The client is closing");
        }
        const connectionHolder = await this._queue.get();
        try {
          return await connectionHolder.acquire(options);
        } catch (error2) {
          this._queue.push(connectionHolder);
          throw error2;
        }
      }
      enqueue(holder) {
        this._queue.push(holder);
      }
      async close() {
        if (this._closing) {
          return await this._closing.wait();
        }
        this._closing = new event_1.default();
        this._queue.cancelAllPending(new errors.InterfaceError(`The client is closing`));
        const warningTimeoutId = setTimeout(() => {
          console.warn("Client.close() is taking over 60 seconds to complete. Check if you have any unreleased connections left.");
        }, 6e4);
        try {
          await Promise.all(this._holders.map((connectionHolder) => connectionHolder._waitUntilReleasedAndClose()));
        } catch (err3) {
          this._terminate();
          this._closing.setError(err3);
          throw err3;
        } finally {
          clearTimeout(warningTimeoutId);
        }
        this._closing.set();
      }
      _terminate() {
        for (const connectionHolder of this._holders) {
          connectionHolder.terminate();
        }
      }
      terminate() {
        if (this._closing?.done) {
          return;
        }
        this._queue.cancelAllPending(new errors.InterfaceError(`The client is closed`));
        this._terminate();
        if (!this._closing) {
          this._closing = new event_1.default();
          this._closing.set();
        }
      }
      isClosed() {
        return !!this._closing;
      }
    };
    exports2.BaseClientPool = BaseClientPool;
    var Client6 = class _Client {
      constructor(pool2, options) {
        __publicField(this, "pool");
        __publicField(this, "options");
        this.pool = pool2;
        this.options = options;
      }
      withTransactionOptions(opts) {
        return new _Client(this.pool, this.options.withTransactionOptions(opts));
      }
      withRetryOptions(opts) {
        return new _Client(this.pool, this.options.withRetryOptions(opts));
      }
      withModuleAliases(aliases) {
        return new _Client(this.pool, this.options.withModuleAliases(aliases));
      }
      withConfig(config) {
        return new _Client(this.pool, this.options.withConfig(config));
      }
      withCodecs(codecs) {
        return new _Client(this.pool, this.options.withCodecs(codecs));
      }
      withSQLRowMode(mode) {
        return new _Client(this.pool, this.options.withSQLRowMode(mode));
      }
      withGlobals(globals) {
        return new _Client(this.pool, this.options.withGlobals(globals));
      }
      withQueryTag(tag) {
        return new _Client(this.pool, this.options.withQueryTag(tag));
      }
      withWarningHandler(handler) {
        return new _Client(this.pool, this.options.withWarningHandler(handler));
      }
      async ensureConnected() {
        await this.pool.ensureConnected();
        return this;
      }
      async resolveConnectionParams() {
        return this.pool.resolveConnectionParams();
      }
      isClosed() {
        return this.pool.isClosed();
      }
      async close() {
        await this.pool.close();
      }
      terminate() {
        this.pool.terminate();
      }
      async transaction(action) {
        if (this.pool.isStateless) {
          throw new errors.GelError(`cannot use 'transaction()' API on HTTP client`);
        }
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.transaction(action);
        } finally {
          await holder.release();
        }
      }
      async execute(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.execute(query, args2);
        } finally {
          await holder.release();
        }
      }
      async executeSQL(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.executeSQL(query, args2);
        } finally {
          await holder.release();
        }
      }
      async query(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.query(query, args2);
        } finally {
          await holder.release();
        }
      }
      async querySQL(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.querySQL(query, args2);
        } finally {
          await holder.release();
        }
      }
      async queryJSON(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.queryJSON(query, args2);
        } finally {
          await holder.release();
        }
      }
      async querySingle(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.querySingle(query, args2);
        } finally {
          await holder.release();
        }
      }
      async querySingleJSON(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.querySingleJSON(query, args2);
        } finally {
          await holder.release();
        }
      }
      async queryRequired(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.queryRequired(query, args2);
        } finally {
          await holder.release();
        }
      }
      async queryRequiredJSON(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.queryRequiredJSON(query, args2);
        } finally {
          await holder.release();
        }
      }
      async queryRequiredSingle(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.queryRequiredSingle(query, args2);
        } finally {
          await holder.release();
        }
      }
      async queryRequiredSingleJSON(query, args2) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          return await holder.queryRequiredSingleJSON(query, args2);
        } finally {
          await holder.release();
        }
      }
      async describe(query) {
        const holder = await this.pool.acquireHolder(this.options);
        try {
          const cxn = await holder._getConnection();
          const result = await cxn._parse(ifaces_1.Language.EDGEQL, query, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.MANY, this.options);
          const cardinality = util_1.util.parseCardinality(result[0]);
          return {
            in: result[1],
            out: result[2],
            cardinality,
            capabilities: result[3]
          };
        } finally {
          await holder.release();
        }
      }
      async parse(query) {
        return await this.describe(query);
      }
    };
    exports2.Client = Client6;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/systemUtils.js
var require_systemUtils = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/systemUtils.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.readFileUtf8 = readFileUtf8;
    exports2.hasFSReadPermission = hasFSReadPermission;
    exports2.hashSHA1toHex = hashSHA1toHex;
    exports2.walk = walk;
    exports2.exists = exists2;
    exports2.input = input;
    var crypto7 = __importStar(require("crypto"));
    var node_fs_1 = require("fs");
    var node_path_1 = __importDefault(require("path"));
    var node_process_1 = __importDefault(require("process"));
    var readline = __importStar(require("readline"));
    var node_stream_1 = require("stream");
    async function readFileUtf8(...pathParts) {
      return await node_fs_1.promises.readFile(node_path_1.default.join(...pathParts), { encoding: "utf8" });
    }
    function hasFSReadPermission() {
      if (typeof Deno !== "undefined") {
        return Deno.permissions.querySync({ name: "read" }).state === "granted";
      }
      return true;
    }
    function hashSHA1toHex(msg) {
      return crypto7.createHash("sha1").update(msg).digest("hex");
    }
    async function walk(dir, params) {
      const { match: match2, skip = [] } = params || {};
      try {
        await node_fs_1.promises.access(dir);
      } catch (_err) {
        return [];
      }
      const dirents = await node_fs_1.promises.readdir(dir, { withFileTypes: true });
      const files = await Promise.all(dirents.map((dirent) => {
        const fspath = node_path_1.default.resolve(dir, dirent.name);
        if (skip) {
          if (skip.some((re3) => re3.test(fspath))) {
            return [];
          }
        }
        if (dirent.isDirectory()) {
          return walk(fspath, params);
        }
        if (match2) {
          if (!match2.some((re3) => re3.test(fspath))) {
            return [];
          }
        }
        return [fspath];
      }));
      return Array.prototype.concat(...files);
    }
    async function exists2(filepath) {
      try {
        await node_fs_1.promises.access(filepath);
        return true;
      } catch {
        return false;
      }
    }
    async function input(message, params) {
      let silent = false;
      const output = params?.silent ? new node_stream_1.Writable({
        write(chunk, encoding, callback) {
          if (!silent)
            node_process_1.default.stdout.write(chunk, encoding);
          callback();
        }
      }) : node_process_1.default.stdout;
      const rl = readline.createInterface({
        input: node_process_1.default.stdin,
        output
      });
      return new Promise((resolve2) => {
        rl.question(message, (val2) => {
          rl.close();
          resolve2(val2);
        });
        silent = true;
      });
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/platform.js
var require_platform = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/platform.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.isWindows = void 0;
    exports2.searchConfigDir = searchConfigDir;
    var node_path_1 = __importDefault(require("path"));
    var node_os_1 = __importDefault(require("os"));
    var systemUtils_1 = require_systemUtils();
    exports2.isWindows = process.platform === "win32";
    var homeDir = node_os_1.default.homedir;
    var _configDir;
    if (process.platform === "darwin") {
      _configDir = () => {
        return node_path_1.default.join(homeDir(), "Library", "Application Support", "edgedb");
      };
    } else if (process.platform === "win32") {
      _configDir = () => {
        const localAppDataDir = process.env.LOCALAPPDATA ?? node_path_1.default.join(homeDir(), "AppData", "Local");
        return node_path_1.default.join(localAppDataDir, "EdgeDB", "config");
      };
    } else {
      _configDir = () => {
        let xdgConfigDir = process.env.XDG_CONFIG_HOME;
        if (!xdgConfigDir || !node_path_1.default.isAbsolute(xdgConfigDir)) {
          xdgConfigDir = node_path_1.default.join(homeDir(), ".config");
        }
        return node_path_1.default.join(xdgConfigDir, "edgedb");
      };
    }
    async function searchConfigDir(...configPath) {
      const filePath = node_path_1.default.join(_configDir(), ...configPath);
      if (await (0, systemUtils_1.exists)(filePath)) {
        return filePath;
      }
      const fallbackPath = node_path_1.default.join(homeDir(), ".edgedb", ...configPath);
      if (await (0, systemUtils_1.exists)(fallbackPath)) {
        return fallbackPath;
      }
      return filePath;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/credentials.js
var require_credentials = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/credentials.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getCredentialsPath = getCredentialsPath;
    exports2.readCredentialsFile = readCredentialsFile;
    exports2.validateCredentials = validateCredentials;
    var conUtils_1 = require_conUtils();
    var errors_1 = require_errors();
    async function getCredentialsPath(instanceName, serverUtils) {
      return serverUtils.searchConfigDir("credentials", instanceName + ".json");
    }
    async function readCredentialsFile(file, serverUtils) {
      try {
        const data = await serverUtils.readFileUtf8(file);
        return validateCredentials(JSON.parse(data));
      } catch (e6) {
        throw new errors_1.InterfaceError(`cannot read credentials file ${file}: ${e6}`);
      }
    }
    function validateCredentials(data) {
      const port = data.port;
      if (port != null && (typeof port !== "number" || port < 1 || port > 65535)) {
        throw new errors_1.InterfaceError("invalid `port` value");
      }
      const user = data.user;
      if (user == null) {
        throw new errors_1.InterfaceError("`user` key is required");
      }
      if (typeof user !== "string") {
        throw new errors_1.InterfaceError("`user` must be string");
      }
      const result = { user, port };
      const host = data.host;
      if (host != null) {
        if (typeof host !== "string") {
          throw new errors_1.InterfaceError("`host` must be string");
        }
        result.host = host;
      }
      const database = data.database;
      if (database != null) {
        if (typeof database !== "string") {
          throw new errors_1.InterfaceError("`database` must be string");
        }
        result.database = database;
      }
      const branch = data.branch;
      if (branch != null) {
        if (typeof branch !== "string") {
          throw new errors_1.InterfaceError("`branch` must be string");
        }
        if (database != null && branch !== database) {
          throw new errors_1.InterfaceError("`database` and `branch` cannot both be set");
        }
        result.branch = branch;
      }
      const password = data.password;
      if (password != null) {
        if (typeof password !== "string") {
          throw new errors_1.InterfaceError("`password` must be string");
        }
        result.password = password;
      }
      const caData = data.tls_ca;
      if (caData != null) {
        if (typeof caData !== "string") {
          throw new errors_1.InterfaceError("`tls_ca` must be string");
        }
        result.tlsCAData = caData;
      }
      const certData = data.tls_cert_data;
      if (certData != null) {
        if (typeof certData !== "string") {
          throw new errors_1.InterfaceError("`tls_cert_data` must be string");
        }
        if (caData != null && certData !== caData) {
          throw new errors_1.InterfaceError(`both 'tls_ca' and 'tls_cert_data' are defined, and are not in agreement`);
        }
        result.tlsCAData = certData;
      }
      let verifyHostname = data.tls_verify_hostname;
      const tlsSecurity = data.tls_security;
      if (verifyHostname != null) {
        if (typeof verifyHostname === "boolean") {
          verifyHostname = verifyHostname ? "strict" : "no_host_verification";
        } else {
          throw new errors_1.InterfaceError("`tls_verify_hostname` must be boolean");
        }
      }
      if (tlsSecurity != null && (typeof tlsSecurity !== "string" || !conUtils_1.validTlsSecurityValues.includes(tlsSecurity))) {
        throw new errors_1.InterfaceError(`\`tls_security\` must be one of ${conUtils_1.validTlsSecurityValues.map((val2) => `"${val2}"`).join(", ")}`);
      }
      if (verifyHostname && tlsSecurity && verifyHostname !== tlsSecurity && !(verifyHostname === "no_host_verification" && tlsSecurity === "insecure")) {
        throw new errors_1.InterfaceError(`both 'tls_security' and 'tls_verify_hostname' are defined, and are not in agreement`);
      }
      if (tlsSecurity || verifyHostname) {
        result.tlsSecurity = tlsSecurity ?? verifyHostname;
      }
      return result;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/crcHqx.js
var require_crcHqx = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/primitives/crcHqx.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.crcHqx = crcHqx;
    var crctabHqx = new Uint16Array([
      0,
      4129,
      8258,
      12387,
      16516,
      20645,
      24774,
      28903,
      33032,
      37161,
      41290,
      45419,
      49548,
      53677,
      57806,
      61935,
      4657,
      528,
      12915,
      8786,
      21173,
      17044,
      29431,
      25302,
      37689,
      33560,
      45947,
      41818,
      54205,
      50076,
      62463,
      58334,
      9314,
      13379,
      1056,
      5121,
      25830,
      29895,
      17572,
      21637,
      42346,
      46411,
      34088,
      38153,
      58862,
      62927,
      50604,
      54669,
      13907,
      9842,
      5649,
      1584,
      30423,
      26358,
      22165,
      18100,
      46939,
      42874,
      38681,
      34616,
      63455,
      59390,
      55197,
      51132,
      18628,
      22757,
      26758,
      30887,
      2112,
      6241,
      10242,
      14371,
      51660,
      55789,
      59790,
      63919,
      35144,
      39273,
      43274,
      47403,
      23285,
      19156,
      31415,
      27286,
      6769,
      2640,
      14899,
      10770,
      56317,
      52188,
      64447,
      60318,
      39801,
      35672,
      47931,
      43802,
      27814,
      31879,
      19684,
      23749,
      11298,
      15363,
      3168,
      7233,
      60846,
      64911,
      52716,
      56781,
      44330,
      48395,
      36200,
      40265,
      32407,
      28342,
      24277,
      20212,
      15891,
      11826,
      7761,
      3696,
      65439,
      61374,
      57309,
      53244,
      48923,
      44858,
      40793,
      36728,
      37256,
      33193,
      45514,
      41451,
      53516,
      49453,
      61774,
      57711,
      4224,
      161,
      12482,
      8419,
      20484,
      16421,
      28742,
      24679,
      33721,
      37784,
      41979,
      46042,
      49981,
      54044,
      58239,
      62302,
      689,
      4752,
      8947,
      13010,
      16949,
      21012,
      25207,
      29270,
      46570,
      42443,
      38312,
      34185,
      62830,
      58703,
      54572,
      50445,
      13538,
      9411,
      5280,
      1153,
      29798,
      25671,
      21540,
      17413,
      42971,
      47098,
      34713,
      38840,
      59231,
      63358,
      50973,
      55100,
      9939,
      14066,
      1681,
      5808,
      26199,
      30326,
      17941,
      22068,
      55628,
      51565,
      63758,
      59695,
      39368,
      35305,
      47498,
      43435,
      22596,
      18533,
      30726,
      26663,
      6336,
      2273,
      14466,
      10403,
      52093,
      56156,
      60223,
      64286,
      35833,
      39896,
      43963,
      48026,
      19061,
      23124,
      27191,
      31254,
      2801,
      6864,
      10931,
      14994,
      64814,
      60687,
      56684,
      52557,
      48554,
      44427,
      40424,
      36297,
      31782,
      27655,
      23652,
      19525,
      15522,
      11395,
      7392,
      3265,
      61215,
      65342,
      53085,
      57212,
      44955,
      49082,
      36825,
      40952,
      28183,
      32310,
      20053,
      24180,
      11923,
      16050,
      3793,
      7920
    ]);
    function crcHqx(data, crc) {
      crc &= 65535;
      const len = data.length;
      let i8 = 0;
      while (i8 < len) {
        crc = crc << 8 & 65280 ^ crctabHqx[crc >> 8 ^ data[i8++]];
      }
      return crc;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/conUtils.js
var require_conUtils = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/conUtils.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ResolvedConnectConfig = exports2.validTlsSecurityValues = void 0;
    exports2.isValidTlsSecurityValue = isValidTlsSecurityValue;
    exports2.getConnectArgumentsParser = getConnectArgumentsParser;
    exports2.parseDuration = parseDuration;
    var errors = __importStar(require_errors());
    var credentials_1 = require_credentials();
    var datetime_1 = require_datetime();
    var datetime_2 = require_datetime2();
    var errors_1 = require_errors();
    var buffer_1 = require_buffer();
    var crcHqx_1 = require_crcHqx();
    var DOMAIN_NAME_MAX_LEN = 63;
    exports2.validTlsSecurityValues = [
      "insecure",
      "no_host_verification",
      "strict",
      "default"
    ];
    function isValidTlsSecurityValue(candidate) {
      return typeof candidate === "string" && exports2.validTlsSecurityValues.includes(candidate);
    }
    function getConnectArgumentsParser(utils) {
      return async (opts) => {
        return {
          ...await parseConnectDsnAndArgs(opts, utils),
          connectTimeout: opts.timeout,
          logging: opts.logging ?? true
        };
      };
    }
    function getEnv(envName, _required = false) {
      const gelEnv = envName;
      const edgedbEnv = envName.replace(/^GEL_/, "EDGEDB_");
      const gelValue = process.env[gelEnv];
      const edgedbValue = process.env[edgedbEnv];
      if (gelValue !== void 0 && edgedbValue !== void 0) {
        console.warn(`Both GEL_w+ and EDGEDB_w+ are set; EDGEDB_w+ will be ignored`);
      }
      return gelValue ?? edgedbValue;
    }
    var ResolvedConnectConfig = class {
      constructor() {
        __publicField(this, "_host", null);
        __publicField(this, "_hostSource", null);
        __publicField(this, "_port", null);
        __publicField(this, "_portSource", null);
        __publicField(this, "_database", null);
        __publicField(this, "_databaseSource", null);
        __publicField(this, "_branch", null);
        __publicField(this, "_branchSource", null);
        __publicField(this, "_user", null);
        __publicField(this, "_userSource", null);
        __publicField(this, "_password", null);
        __publicField(this, "_passwordSource", null);
        __publicField(this, "_secretKey", null);
        __publicField(this, "_secretKeySource", null);
        __publicField(this, "_cloudProfile", null);
        __publicField(this, "_cloudProfileSource", null);
        __publicField(this, "_tlsCAData", null);
        __publicField(this, "_tlsCADataSource", null);
        __publicField(this, "_tlsSecurity", null);
        __publicField(this, "_tlsSecuritySource", null);
        __publicField(this, "_tlsServerName", null);
        __publicField(this, "_tlsServerNameSource", null);
        __publicField(this, "_waitUntilAvailable", null);
        __publicField(this, "_waitUntilAvailableSource", null);
        __publicField(this, "serverSettings", {});
        this.setHost = this.setHost.bind(this);
        this.setPort = this.setPort.bind(this);
        this.setDatabase = this.setDatabase.bind(this);
        this.setBranch = this.setBranch.bind(this);
        this.setUser = this.setUser.bind(this);
        this.setPassword = this.setPassword.bind(this);
        this.setSecretKey = this.setSecretKey.bind(this);
        this.setTlsCAData = this.setTlsCAData.bind(this);
        this.setTlsCAFile = this.setTlsCAFile.bind(this);
        this.setTlsServerName = this.setTlsServerName.bind(this);
        this.setTlsSecurity = this.setTlsSecurity.bind(this);
        this.setWaitUntilAvailable = this.setWaitUntilAvailable.bind(this);
      }
      _setParam(param2, value, source, validator2) {
        if (this[`_${param2}`] === null) {
          this[`_${param2}Source`] = source;
          if (value !== null) {
            this[`_${param2}`] = validator2 ? validator2(value) : value;
            return true;
          }
        }
        return false;
      }
      async _setParamAsync(param2, value, source, validator2) {
        if (this[`_${param2}`] === null) {
          this[`_${param2}Source`] = source;
          if (value !== null) {
            this[`_${param2}`] = validator2 ? await validator2(value) : value;
            return true;
          }
        }
        return false;
      }
      setHost(host, source) {
        return this._setParam("host", host, source, validateHost);
      }
      setPort(port, source) {
        return this._setParam("port", port, source, parseValidatePort);
      }
      setDatabase(database, source) {
        return this._setParam("database", database, source, (db2) => {
          if (db2 === "") {
            throw new errors_1.InterfaceError(`invalid database name: '${db2}'`);
          }
          return db2;
        });
      }
      setBranch(branch, source) {
        return this._setParam("branch", branch, source, (branchName) => {
          if (branchName === "") {
            throw new errors_1.InterfaceError(`invalid branch name: '${branchName}'`);
          }
          return branchName;
        });
      }
      setUser(user, source) {
        return this._setParam("user", user, source, (_user) => {
          if (_user === "") {
            throw new errors_1.InterfaceError(`invalid user name: '${_user}'`);
          }
          return _user;
        });
      }
      setPassword(password, source) {
        return this._setParam("password", password, source);
      }
      setSecretKey(secretKey, source) {
        return this._setParam("secretKey", secretKey, source);
      }
      setCloudProfile(cloudProfile, source) {
        return this._setParam("cloudProfile", cloudProfile, source);
      }
      setTlsCAData(caData, source) {
        return this._setParam("tlsCAData", caData, source);
      }
      setTlsCAFile(caFile, source, readFile4) {
        return this._setParamAsync("tlsCAData", caFile, source, (caFilePath) => readFile4(caFilePath));
      }
      setTlsServerName(serverName, source) {
        return this._setParam("tlsServerName", serverName, source, validateHost);
      }
      setTlsSecurity(tlsSecurity, source) {
        return this._setParam("tlsSecurity", tlsSecurity, source, (_tlsSecurity) => {
          if (!exports2.validTlsSecurityValues.includes(_tlsSecurity)) {
            throw new errors_1.InterfaceError(`invalid 'tlsSecurity' value: '${_tlsSecurity}', must be one of ${exports2.validTlsSecurityValues.map((val2) => `'${val2}'`).join(", ")}`);
          }
          const clientSecurity = getEnv("GEL_CLIENT_SECURITY");
          if (clientSecurity !== void 0) {
            if (!["default", "insecure_dev_mode", "strict"].includes(clientSecurity)) {
              throw new errors_1.InterfaceError(`invalid GEL_CLIENT_SECURITY value: '${clientSecurity}', must be one of 'default', 'insecure_dev_mode' or 'strict'`);
            }
            if (clientSecurity === "insecure_dev_mode") {
              if (_tlsSecurity === "default") {
                _tlsSecurity = "insecure";
              }
            } else if (clientSecurity === "strict") {
              if (_tlsSecurity === "insecure" || _tlsSecurity === "no_host_verification") {
                throw new errors_1.InterfaceError(`'tlsSecurity' value (${_tlsSecurity}) conflicts with GEL_CLIENT_SECURITY value (${clientSecurity}), 'tlsSecurity' value cannot be lower than security level set by GEL_CLIENT_SECURITY`);
              }
              _tlsSecurity = "strict";
            }
          }
          return _tlsSecurity;
        });
      }
      setWaitUntilAvailable(duration, source) {
        return this._setParam("waitUntilAvailable", duration, source, parseDuration);
      }
      addServerSettings(settings) {
        this.serverSettings = {
          ...settings,
          ...this.serverSettings
        };
      }
      get address() {
        return [this._host ?? "localhost", this._port ?? 5656];
      }
      get database() {
        return this._database ?? this._branch ?? "edgedb";
      }
      get branch() {
        return this._branch ?? this._database ?? "__default__";
      }
      get user() {
        return this._user ?? "edgedb";
      }
      get password() {
        return this._password ?? void 0;
      }
      get secretKey() {
        return this._secretKey ?? void 0;
      }
      get cloudProfile() {
        return this._cloudProfile ?? "default";
      }
      get tlsServerName() {
        return this._tlsServerName ?? void 0;
      }
      get tlsSecurity() {
        return this._tlsSecurity && this._tlsSecurity !== "default" ? this._tlsSecurity : this._tlsCAData !== null ? "no_host_verification" : "strict";
      }
      get waitUntilAvailable() {
        return this._waitUntilAvailable ?? 3e4;
      }
      explainConfig() {
        const output = [
          `Parameter          Value                                    Source`,
          `---------          -----                                    ------`
        ];
        const outputLine = (param2, val2, rawVal, source) => {
          const isDefault = rawVal === null;
          const maxValLength = 40 - (isDefault ? 10 : 0);
          let value = String(val2);
          if (value.length > maxValLength) {
            value = value.slice(0, maxValLength - 3) + "...";
          }
          output.push(param2.padEnd(19, " ") + (value + (isDefault ? " (default)" : "")).padEnd(42, " ") + (source ?? "default"));
        };
        outputLine("host", this.address[0], this._host, this._hostSource);
        outputLine("port", this.address[1], this._port, this._portSource);
        outputLine("database", this.database, this._database, this._databaseSource);
        outputLine("branch", this.branch, this._branch, this._branchSource);
        outputLine("user", this.user, this._user, this._userSource);
        outputLine("password", this.password && this.password.slice(0, 3).padEnd(this.password.length, "*"), this._password, this._passwordSource);
        outputLine("tlsCAData", this._tlsCAData && this._tlsCAData.replace(/\r\n?|\n/, ""), this._tlsCAData, this._tlsCADataSource);
        outputLine("tlsSecurity", this.tlsSecurity, this._tlsSecurity, this._tlsSecuritySource);
        outputLine("tlsServerName", this.tlsServerName, this._tlsServerName, this._tlsServerNameSource);
        outputLine("waitUntilAvailable", this.waitUntilAvailable, this._waitUntilAvailable, this._waitUntilAvailableSource);
        return output.join("\n");
      }
    };
    exports2.ResolvedConnectConfig = ResolvedConnectConfig;
    function parseValidatePort(port) {
      let parsedPort;
      if (typeof port === "string") {
        if (!/^\d*$/.test(port)) {
          throw new errors_1.InterfaceError(`invalid port: ${port}`);
        }
        parsedPort = parseInt(port, 10);
        if (Number.isNaN(parsedPort)) {
          throw new errors_1.InterfaceError(`invalid port: ${port}`);
        }
      } else {
        parsedPort = port;
      }
      if (!Number.isInteger(parsedPort) || parsedPort < 1 || parsedPort > 65535) {
        throw new errors_1.InterfaceError(`invalid port: ${port}`);
      }
      return parsedPort;
    }
    function validateHost(host) {
      if (host.includes("/")) {
        throw new errors_1.InterfaceError(`unix socket paths not supported`);
      }
      if (!host.length || host.includes(",")) {
        throw new errors_1.InterfaceError(`invalid host: '${host}'`);
      }
      return host;
    }
    function parseDuration(duration) {
      if (typeof duration === "number") {
        if (duration < 0) {
          throw new errors_1.InterfaceError("invalid waitUntilAvailable duration, must be >= 0");
        }
        return duration;
      }
      if (typeof duration === "string") {
        if (duration.startsWith("P")) {
          duration = datetime_1.Duration.from(duration);
        } else {
          return (0, datetime_1.parseHumanDurationString)(duration);
        }
      }
      if (duration instanceof datetime_1.Duration) {
        const invalidField = (0, datetime_2.checkValidGelDuration)(duration);
        if (invalidField) {
          throw new errors_1.InterfaceError(`invalid waitUntilAvailable duration, cannot have a '${invalidField}' value`);
        }
        if (duration.sign < 0) {
          throw new errors_1.InterfaceError("invalid waitUntilAvailable duration, must be >= 0");
        }
        return duration.milliseconds + duration.seconds * 1e3 + duration.minutes * 6e4 + duration.hours * 36e5;
      }
      throw new errors_1.InterfaceError(`invalid duration`);
    }
    async function parseConnectDsnAndArgs(config, serverUtils) {
      const resolvedConfig = new ResolvedConnectConfig();
      let fromEnv3 = false;
      let fromProject = false;
      const [dsn, instanceName] = config.instanceName == null && config.dsn != null && !/^[a-z]+:\/\//i.test(config.dsn) ? [void 0, config.dsn] : [config.dsn, config.instanceName];
      let { hasCompoundOptions } = await resolveConfigOptions(resolvedConfig, {
        dsn,
        instanceName,
        credentials: config.credentials,
        credentialsFile: config.credentialsFile,
        host: config.host,
        port: config.port,
        database: config.database,
        branch: config.branch,
        user: config.user,
        password: config.password,
        secretKey: config.secretKey,
        cloudProfile: getEnv("GEL_CLOUD_PROFILE"),
        tlsCA: config.tlsCA,
        tlsCAFile: config.tlsCAFile,
        tlsServerName: config.tlsServerName,
        tlsSecurity: config.tlsSecurity,
        serverSettings: config.serverSettings,
        waitUntilAvailable: config.waitUntilAvailable
      }, {
        dsn: `'dsnOrInstanceName' option (parsed as dsn)`,
        instanceName: config.instanceName != null ? `'instanceName' option` : `'dsnOrInstanceName' option (parsed as instance name)`,
        credentials: `'credentials' option`,
        credentialsFile: `'credentialsFile' option`,
        host: `'host' option`,
        port: `'port' option`,
        database: `'database' option`,
        branch: `'branch' option`,
        user: `'user' option`,
        password: `'password' option`,
        secretKey: `'secretKey' option`,
        cloudProfile: `'GEL_CLOUD_PROFILE' environment variable`,
        tlsCA: `'tlsCA' option`,
        tlsCAFile: `'tlsCAFile' option`,
        tlsSecurity: `'tlsSecurity' option`,
        tlsServerName: `'tlsServerName' option`,
        serverSettings: `'serverSettings' option`,
        waitUntilAvailable: `'waitUntilAvailable' option`
      }, `Cannot have more than one of the following connection options: 'dsn', 'instanceName', 'credentials', 'credentialsFile' or 'host'/'port'`, serverUtils);
      if (!hasCompoundOptions) {
        let port = getEnv("GEL_PORT");
        if (resolvedConfig._port === null && port?.startsWith("tcp://")) {
          console.warn(`GEL_PORT in 'tcp://host:port' format, so will be ignored`);
          port = void 0;
        }
        ({ hasCompoundOptions, anyOptionsUsed: fromEnv3 } = await resolveConfigOptions(resolvedConfig, {
          dsn: getEnv("GEL_DSN"),
          instanceName: getEnv("GEL_INSTANCE"),
          credentials: getEnv("GEL_CREDENTIALS"),
          credentialsFile: getEnv("GEL_CREDENTIALS_FILE"),
          host: getEnv("GEL_HOST"),
          port,
          database: getEnv("GEL_DATABASE"),
          branch: getEnv("GEL_BRANCH"),
          user: getEnv("GEL_USER"),
          password: getEnv("GEL_PASSWORD"),
          secretKey: getEnv("GEL_SECRET_KEY"),
          tlsCA: getEnv("GEL_TLS_CA"),
          tlsCAFile: getEnv("GEL_TLS_CA_FILE"),
          tlsServerName: getEnv("GEL_TLS_SERVER_NAME"),
          tlsSecurity: getEnv("GEL_CLIENT_TLS_SECURITY"),
          waitUntilAvailable: getEnv("GEL_WAIT_UNTIL_AVAILABLE")
        }, {
          dsn: `'GEL_DSN' environment variable`,
          instanceName: `'GEL_INSTANCE' environment variable`,
          credentials: `'GEL_CREDENTIALS' environment variable`,
          credentialsFile: `'GEL_CREDENTIALS_FILE' environment variable`,
          host: `'GEL_HOST' environment variable`,
          port: `'GEL_PORT' environment variable`,
          database: `'GEL_DATABASE' environment variable`,
          branch: `'GEL_BRANCH' environment variable`,
          user: `'GEL_USER' environment variable`,
          password: `'GEL_PASSWORD' environment variable`,
          secretKey: `'GEL_SECRET_KEY' environment variable`,
          tlsCA: `'GEL_TLS_CA' environment variable`,
          tlsCAFile: `'GEL_TLS_CA_FILE' environment variable`,
          tlsServerName: `'GEL_TLS_SERVER_NAME' environment variable`,
          tlsSecurity: `'GEL_CLIENT_TLS_SECURITY' environment variable`,
          waitUntilAvailable: `'GEL_WAIT_UNTIL_AVAILABLE' environment variable`
        }, `Cannot have more than one of the following connection environment variables: 'GEL_DSN', 'GEL_INSTANCE', 'GEL_CREDENTIALS', 'GEL_CREDENTIALS_FILE' or 'GEL_HOST'`, serverUtils));
      }
      if (!hasCompoundOptions) {
        if (!serverUtils) {
          throw new errors.ClientConnectionError("no connection options specified either by arguments to `createClient` API or environment variables; also cannot resolve from project config file in browser (or edge runtime) environment");
        }
        const projectDir = await serverUtils?.findProjectDir();
        if (!projectDir) {
          throw new errors.ClientConnectionError("no project config file found and no connection options specified either via arguments to `createClient()` API or via environment variables GEL_HOST, GEL_INSTANCE, GEL_DSN, GEL_CREDENTIALS or GEL_CREDENTIALS_FILE");
        }
        const stashDir = await serverUtils.findStashPath(projectDir);
        const instName = await serverUtils.readFileUtf8(stashDir, "instance-name").then((name3) => name3.trim()).catch(() => null);
        if (instName !== null) {
          const [cloudProfile, _database2, branch] = await Promise.all([
            serverUtils.readFileUtf8(stashDir, "cloud-profile").then((name3) => name3.trim()).catch(() => void 0),
            serverUtils.readFileUtf8(stashDir, "database").then((name3) => name3.trim()).catch(() => void 0),
            serverUtils.readFileUtf8(stashDir, "branch").then((name3) => name3.trim()).catch(() => void 0)
          ]);
          let database = _database2;
          if (database !== void 0 && branch !== void 0) {
            if (database !== branch) {
              throw new errors_1.InterfaceError("Both database and branch exist in the config dir and don't match.");
            } else {
              database = void 0;
            }
          }
          await resolveConfigOptions(resolvedConfig, { instanceName: instName, cloudProfile, database, branch }, {
            instanceName: `project linked instance ('${instName}')`,
            cloudProfile: `project defined cloud instance ('${cloudProfile}')`,
            database: `project default database`,
            branch: `project default branch`
          }, "", serverUtils);
          fromProject = true;
        } else {
          throw new errors.ClientConnectionError("Found project config file but the project is not initialized. Run 'gel project init'.");
        }
      }
      resolvedConfig.setTlsSecurity("default", "default");
      return {
        connectionParams: resolvedConfig,
        inProject: async () => await serverUtils?.findProjectDir(false) != null,
        fromEnv: fromEnv3,
        fromProject
      };
    }
    async function resolveConfigOptions(resolvedConfig, config, sources, compoundParamsError, serverUtils) {
      let anyOptionsUsed = false;
      const readFile4 = serverUtils?.readFileUtf8 ?? ((fn3) => {
        throw new errors_1.InterfaceError(`cannot read file "${fn3}" in browser (or edge runtime) environment`);
      });
      if (config.tlsCA != null && config.tlsCAFile != null) {
        throw new errors_1.InterfaceError(`Cannot specify both ${sources.tlsCA} and ${sources.tlsCAFile}`);
      }
      if (config.database != null) {
        if (config.branch != null) {
          throw new errors_1.InterfaceError(`${sources.database} and ${sources.branch} are mutually exclusive`);
        }
        if (resolvedConfig._branch == null) {
          anyOptionsUsed = resolvedConfig.setDatabase(config.database ?? null, sources.database) || anyOptionsUsed;
        }
      }
      if (config.branch != null) {
        if (resolvedConfig._database == null) {
          anyOptionsUsed = resolvedConfig.setBranch(config.branch ?? null, sources.branch) || anyOptionsUsed;
        }
      }
      anyOptionsUsed = resolvedConfig.setUser(config.user ?? null, sources.user) || anyOptionsUsed;
      anyOptionsUsed = resolvedConfig.setPassword(config.password ?? null, sources.password) || anyOptionsUsed;
      anyOptionsUsed = resolvedConfig.setSecretKey(config.secretKey ?? null, sources.secretKey) || anyOptionsUsed;
      anyOptionsUsed = resolvedConfig.setCloudProfile(config.cloudProfile ?? null, sources.cloudProfile) || anyOptionsUsed;
      anyOptionsUsed = resolvedConfig.setTlsCAData(config.tlsCA ?? null, sources.tlsCA) || anyOptionsUsed;
      anyOptionsUsed = await resolvedConfig.setTlsCAFile(config.tlsCAFile ?? null, sources.tlsCAFile, readFile4) || anyOptionsUsed;
      anyOptionsUsed = resolvedConfig.setTlsServerName(config.tlsServerName ?? null, sources.tlsServerName) || anyOptionsUsed;
      anyOptionsUsed = resolvedConfig.setTlsSecurity(config.tlsSecurity ?? null, sources.tlsSecurity) || anyOptionsUsed;
      anyOptionsUsed = resolvedConfig.setWaitUntilAvailable(config.waitUntilAvailable ?? null, sources.waitUntilAvailable) || anyOptionsUsed;
      resolvedConfig.addServerSettings(config.serverSettings ?? {});
      const compoundParamsCount = [
        config.dsn,
        config.instanceName,
        config.credentials,
        config.credentialsFile,
        config.host ?? config.port
      ].filter((param2) => param2 !== void 0).length;
      if (compoundParamsCount > 1) {
        throw new errors_1.InterfaceError(compoundParamsError);
      }
      if (compoundParamsCount === 1) {
        if (config.dsn !== void 0 || config.host !== void 0 || config.port !== void 0) {
          let dsn = config.dsn;
          if (dsn === void 0) {
            if (config.port !== void 0) {
              resolvedConfig.setPort(config.port, sources.port);
            }
            const host = config.host != null ? validateHost(config.host) : "";
            dsn = `edgedb://${host.includes(":") ? `[${encodeURI(host)}]` : host}`;
          }
          await parseDSNIntoConfig(dsn, resolvedConfig, config.dsn ? sources.dsn : config.host !== void 0 ? sources.host : sources.port, readFile4);
        } else {
          let creds;
          let source;
          if (config.credentials != null) {
            creds = (0, credentials_1.validateCredentials)(JSON.parse(config.credentials));
            source = sources.credentials;
          } else {
            if (!serverUtils && !config.instanceName?.includes("/")) {
              throw new errors_1.InterfaceError(`cannot ${config.credentialsFile ? `read credentials file "${config.credentialsFile}"` : `resolve instance name "${config.instanceName}"`} in browser (or edge runtime) environment`);
            }
            let credentialsFile = config.credentialsFile;
            if (credentialsFile === void 0) {
              if (/^\w(-?\w)*$/.test(config.instanceName)) {
                credentialsFile = await (0, credentials_1.getCredentialsPath)(config.instanceName, serverUtils);
                source = sources.instanceName;
              } else {
                if (!/^([A-Za-z0-9_-](-?[A-Za-z0-9_])*)\/([A-Za-z0-9](-?[A-Za-z0-9])*)$/.test(config.instanceName)) {
                  throw new errors_1.InterfaceError(`invalid DSN or instance name: '${config.instanceName}'`);
                }
                await parseCloudInstanceNameIntoConfig(resolvedConfig, config.instanceName, sources.instanceName, serverUtils);
                return { hasCompoundOptions: true, anyOptionsUsed: true };
              }
            } else {
              source = sources.credentialsFile;
            }
            creds = await (0, credentials_1.readCredentialsFile)(credentialsFile, serverUtils);
          }
          resolvedConfig.setHost(creds.host ?? null, source);
          resolvedConfig.setPort(creds.port ?? null, source);
          if (creds.database != null) {
            if (resolvedConfig._branch == null) {
              resolvedConfig.setDatabase(creds.database ?? null, source);
            }
          } else if (creds.branch != null) {
            if (resolvedConfig._database == null) {
              resolvedConfig.setBranch(creds.branch ?? null, source);
            }
          }
          resolvedConfig.setUser(creds.user ?? null, source);
          resolvedConfig.setPassword(creds.password ?? null, source);
          resolvedConfig.setTlsCAData(creds.tlsCAData ?? null, source);
          resolvedConfig.setTlsSecurity(creds.tlsSecurity ?? null, source);
        }
        return { hasCompoundOptions: true, anyOptionsUsed: true };
      }
      return { hasCompoundOptions: false, anyOptionsUsed };
    }
    async function parseDSNIntoConfig(_dsnString, config, source, readFile4) {
      let dsnString = _dsnString;
      let regexHostname = null;
      let zoneId = "";
      const regexResult = /\[(.*?)(%25.+?)\]/.exec(_dsnString);
      if (regexResult) {
        regexHostname = regexResult[1];
        zoneId = decodeURI(regexResult[2]);
        dsnString = dsnString.slice(0, regexResult.index + regexHostname.length + 1) + dsnString.slice(regexResult.index + regexHostname.length + regexResult[2].length + 1);
      }
      let parsed;
      try {
        parsed = new URL(dsnString);
        if (regexHostname !== null && parsed.hostname !== `[${regexHostname}]`) {
          throw new Error();
        }
      } catch (_7) {
        throw new errors_1.InterfaceError(`invalid DSN or instance name: '${_dsnString}'`);
      }
      if (parsed.protocol !== "edgedb:" && parsed.protocol !== "gel:") {
        throw new errors_1.InterfaceError(`invalid DSN: scheme is expected to be 'gel', got '${parsed.protocol.slice(0, -1)}'`);
      }
      const searchParams = /* @__PURE__ */ new Map();
      for (const [key, value] of parsed.searchParams) {
        if (searchParams.has(key)) {
          throw new errors_1.InterfaceError(`invalid DSN: duplicate query parameter '${key}'`);
        }
        searchParams.set(key, value);
      }
      async function handleDSNPart(paramName, value, currentValue, setter, formatter = (val2) => val2) {
        if ([
          value || null,
          searchParams.get(paramName),
          searchParams.get(`${paramName}_env`),
          searchParams.get(`${paramName}_file`)
        ].filter((param2) => param2 != null).length > 1) {
          throw new errors_1.InterfaceError(`invalid DSN: more than one of ${value !== null ? `'${paramName}', ` : ""}'?${paramName}=', '?${paramName}_env=' or '?${paramName}_file=' was specified ${dsnString}`);
        }
        if (currentValue === null) {
          let param2 = value || (searchParams.get(paramName) ?? null);
          let paramSource = source;
          if (param2 === null) {
            const env4 = searchParams.get(`${paramName}_env`);
            if (env4 != null) {
              param2 = getEnv(env4, true) ?? null;
              if (param2 === null) {
                throw new errors_1.InterfaceError(`'${paramName}_env' environment variable '${env4}' doesn't exist`);
              }
              paramSource += ` (${paramName}_env: ${env4})`;
            }
          }
          if (param2 === null) {
            const file = searchParams.get(`${paramName}_file`);
            if (file != null) {
              param2 = await readFile4(file);
              paramSource += ` (${paramName}_file: ${file})`;
            }
          }
          param2 = param2 !== null ? formatter(param2) : null;
          await setter(param2, paramSource);
        }
        searchParams.delete(paramName);
        searchParams.delete(`${paramName}_env`);
        searchParams.delete(`${paramName}_file`);
      }
      const hostname = /^\[.*\]$/.test(parsed.hostname) ? parsed.hostname.slice(1, -1) + zoneId : parsed.hostname;
      await handleDSNPart("host", hostname, config._host, config.setHost);
      await handleDSNPart("port", parsed.port, config._port, config.setPort);
      const stripLeadingSlash = (str) => str.replace(/^\//, "");
      const searchParamsContainsDatabase = searchParams.has("database") || searchParams.has("database_env") || searchParams.has("database_file");
      const searchParamsContainsBranch = searchParams.has("branch") || searchParams.has("branch_env") || searchParams.has("branch_file");
      if (searchParamsContainsBranch) {
        if (searchParamsContainsDatabase) {
          throw new errors_1.InterfaceError(`invalid DSN: cannot specify both 'database' and 'branch'`);
        }
        if (config._database === null) {
          await handleDSNPart("branch", stripLeadingSlash(parsed.pathname), config._branch, config.setBranch, stripLeadingSlash);
        } else {
          searchParams.delete("branch");
          searchParams.delete("branch_env");
          searchParams.delete("branch_file");
        }
      } else {
        if (config._branch === null) {
          await handleDSNPart("database", stripLeadingSlash(parsed.pathname), config._database, config.setDatabase, stripLeadingSlash);
        } else {
          searchParams.delete("database");
          searchParams.delete("database_env");
          searchParams.delete("database_file");
        }
      }
      await handleDSNPart("user", parsed.username, config._user, config.setUser);
      await handleDSNPart("password", parsed.password, config._password, config.setPassword);
      await handleDSNPart("secret_key", null, config._secretKey, config.setSecretKey);
      await handleDSNPart("tls_ca", null, config._tlsCAData, config.setTlsCAData);
      await handleDSNPart("tls_ca_file", null, config._tlsCAData, (val2, _source) => config.setTlsCAFile(val2, _source, readFile4));
      await handleDSNPart("tls_server_name", null, config._tlsServerName, config.setTlsServerName);
      await handleDSNPart("tls_security", null, config._tlsSecurity, config.setTlsSecurity);
      await handleDSNPart("wait_until_available", null, config._waitUntilAvailable, config.setWaitUntilAvailable);
      const serverSettings = {};
      for (const [key, value] of searchParams) {
        serverSettings[key] = value;
      }
      config.addServerSettings(serverSettings);
    }
    async function parseCloudInstanceNameIntoConfig(config, cloudInstanceName, source, serverUtils) {
      const normInstanceName = cloudInstanceName.toLowerCase();
      const [org, instanceName] = normInstanceName.split("/");
      const domainName = `${instanceName}--${org}`;
      if (domainName.length > DOMAIN_NAME_MAX_LEN) {
        throw new errors_1.InterfaceError(`invalid instance name: cloud instance name length cannot exceed ${DOMAIN_NAME_MAX_LEN - 1} characters: ${cloudInstanceName}`);
      }
      let secretKey = config.secretKey;
      if (secretKey == null) {
        try {
          if (!serverUtils) {
            throw new errors_1.InterfaceError(`Cannot get secret key from cloud profile in browser (or edge runtime) environment`);
          }
          const profile = config.cloudProfile;
          const profilePath = await serverUtils.searchConfigDir("cloud-credentials", `${profile}.json`);
          const fileData = await serverUtils.readFileUtf8(profilePath);
          secretKey = JSON.parse(fileData)["secret_key"];
          if (!secretKey) {
            throw new errors_1.InterfaceError(`Cloud profile '${profile}' doesn't contain a secret key`);
          }
          config.setSecretKey(secretKey, `cloud-credentials/${profile}.json`);
        } catch (e6) {
          throw new errors_1.InterfaceError(`Cannot connect to cloud instances without a secret key: ${e6}`);
        }
      }
      try {
        const keyParts = secretKey.split(".");
        if (keyParts.length < 2) {
          throw new errors_1.InterfaceError("Invalid secret key: does not contain payload");
        }
        const dnsZone = _jwtBase64Decode(keyParts[1])["iss"];
        if (!dnsZone) {
          throw new errors_1.InterfaceError("Invalid secret key: payload does not contain 'iss' value");
        }
        const dnsBucket = ((0, crcHqx_1.crcHqx)(buffer_1.utf8Encoder.encode(normInstanceName), 0) % 100).toString(10).padStart(2, "0");
        const host = `${domainName}.c-${dnsBucket}.i.${dnsZone}`;
        config.setHost(host, `resolved from 'secretKey' and ${source}`);
      } catch (e6) {
        if (e6 instanceof errors.GelError) {
          throw e6;
        } else {
          throw new errors_1.InterfaceError(`Invalid secret key: ${e6}`);
        }
      }
    }
    function _jwtBase64Decode(payload) {
      return JSON.parse(buffer_1.utf8Decoder.decode((0, buffer_1.decodeB64)(payload.padEnd(Math.ceil(payload.length / 4) * 4, "="))));
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/conUtils.server.js
var require_conUtils_server = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/conUtils.server.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.parseConnectArguments = exports2.serverUtils = void 0;
    exports2.findStashPath = findStashPath;
    var platform2 = __importStar(require_platform());
    var node_fs_1 = require("fs");
    var node_path_1 = __importDefault(require("path"));
    var systemUtils_1 = require_systemUtils();
    var conUtils_1 = require_conUtils();
    var projectDirCache = /* @__PURE__ */ new Map();
    async function findProjectDir(required = true) {
      if (!required && !(0, systemUtils_1.hasFSReadPermission)()) {
        return null;
      }
      const workingDir = process.cwd();
      if (projectDirCache.has(workingDir)) {
        return projectDirCache.get(workingDir);
      }
      let dir = workingDir;
      const cwdDev = (await node_fs_1.promises.stat(dir)).dev;
      while (true) {
        if (await (0, systemUtils_1.exists)(node_path_1.default.join(dir, "edgedb.toml")) || await (0, systemUtils_1.exists)(node_path_1.default.join(dir, "gel.toml"))) {
          projectDirCache.set(workingDir, dir);
          return dir;
        }
        const parentDir = node_path_1.default.join(dir, "..");
        if (parentDir === dir || (await node_fs_1.promises.stat(parentDir)).dev !== cwdDev) {
          projectDirCache.set(workingDir, null);
          return null;
        }
        dir = parentDir;
      }
    }
    async function findStashPath(projectDir) {
      let projectPath = await node_fs_1.promises.realpath(projectDir);
      if (platform2.isWindows && !projectPath.startsWith("\\\\")) {
        projectPath = "\\\\?\\" + projectPath;
      }
      const hash = (0, systemUtils_1.hashSHA1toHex)(projectPath);
      const baseName = node_path_1.default.basename(projectPath);
      const dirName = baseName + "-" + hash;
      return platform2.searchConfigDir("projects", dirName);
    }
    exports2.serverUtils = {
      findProjectDir,
      findStashPath,
      readFileUtf8: systemUtils_1.readFileUtf8,
      searchConfigDir: platform2.searchConfigDir
    };
    exports2.parseConnectArguments = (0, conUtils_1.getConnectArgumentsParser)(exports2.serverUtils);
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/map.js
var require_map = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/map.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.errorMapping = void 0;
    var errors = __importStar(require_errors());
    exports2.errorMapping = /* @__PURE__ */ new Map();
    exports2.errorMapping.set(16777216, errors.InternalServerError);
    exports2.errorMapping.set(33554432, errors.UnsupportedFeatureError);
    exports2.errorMapping.set(50331648, errors.ProtocolError);
    exports2.errorMapping.set(50397184, errors.BinaryProtocolError);
    exports2.errorMapping.set(50397185, errors.UnsupportedProtocolVersionError);
    exports2.errorMapping.set(50397186, errors.TypeSpecNotFoundError);
    exports2.errorMapping.set(50397187, errors.UnexpectedMessageError);
    exports2.errorMapping.set(50462720, errors.InputDataError);
    exports2.errorMapping.set(50462976, errors.ParameterTypeMismatchError);
    exports2.errorMapping.set(50463232, errors.StateMismatchError);
    exports2.errorMapping.set(50528256, errors.ResultCardinalityMismatchError);
    exports2.errorMapping.set(50593792, errors.CapabilityError);
    exports2.errorMapping.set(50594048, errors.UnsupportedCapabilityError);
    exports2.errorMapping.set(50594304, errors.DisabledCapabilityError);
    exports2.errorMapping.set(50594560, errors.UnsafeIsolationLevelError);
    exports2.errorMapping.set(67108864, errors.QueryError);
    exports2.errorMapping.set(67174400, errors.InvalidSyntaxError);
    exports2.errorMapping.set(67174656, errors.EdgeQLSyntaxError);
    exports2.errorMapping.set(67174912, errors.SchemaSyntaxError);
    exports2.errorMapping.set(67175168, errors.GraphQLSyntaxError);
    exports2.errorMapping.set(67239936, errors.InvalidTypeError);
    exports2.errorMapping.set(67240192, errors.InvalidTargetError);
    exports2.errorMapping.set(67240193, errors.InvalidLinkTargetError);
    exports2.errorMapping.set(67240194, errors.InvalidPropertyTargetError);
    exports2.errorMapping.set(67305472, errors.InvalidReferenceError);
    exports2.errorMapping.set(67305473, errors.UnknownModuleError);
    exports2.errorMapping.set(67305474, errors.UnknownLinkError);
    exports2.errorMapping.set(67305475, errors.UnknownPropertyError);
    exports2.errorMapping.set(67305476, errors.UnknownUserError);
    exports2.errorMapping.set(67305477, errors.UnknownDatabaseError);
    exports2.errorMapping.set(67305478, errors.UnknownParameterError);
    exports2.errorMapping.set(67305479, errors.DeprecatedScopingError);
    exports2.errorMapping.set(67371008, errors.SchemaError);
    exports2.errorMapping.set(67436544, errors.SchemaDefinitionError);
    exports2.errorMapping.set(67436800, errors.InvalidDefinitionError);
    exports2.errorMapping.set(67436801, errors.InvalidModuleDefinitionError);
    exports2.errorMapping.set(67436802, errors.InvalidLinkDefinitionError);
    exports2.errorMapping.set(67436803, errors.InvalidPropertyDefinitionError);
    exports2.errorMapping.set(67436804, errors.InvalidUserDefinitionError);
    exports2.errorMapping.set(67436805, errors.InvalidDatabaseDefinitionError);
    exports2.errorMapping.set(67436806, errors.InvalidOperatorDefinitionError);
    exports2.errorMapping.set(67436807, errors.InvalidAliasDefinitionError);
    exports2.errorMapping.set(67436808, errors.InvalidFunctionDefinitionError);
    exports2.errorMapping.set(67436809, errors.InvalidConstraintDefinitionError);
    exports2.errorMapping.set(67436810, errors.InvalidCastDefinitionError);
    exports2.errorMapping.set(67437056, errors.DuplicateDefinitionError);
    exports2.errorMapping.set(67437057, errors.DuplicateModuleDefinitionError);
    exports2.errorMapping.set(67437058, errors.DuplicateLinkDefinitionError);
    exports2.errorMapping.set(67437059, errors.DuplicatePropertyDefinitionError);
    exports2.errorMapping.set(67437060, errors.DuplicateUserDefinitionError);
    exports2.errorMapping.set(67437061, errors.DuplicateDatabaseDefinitionError);
    exports2.errorMapping.set(67437062, errors.DuplicateOperatorDefinitionError);
    exports2.errorMapping.set(67437063, errors.DuplicateViewDefinitionError);
    exports2.errorMapping.set(67437064, errors.DuplicateFunctionDefinitionError);
    exports2.errorMapping.set(67437065, errors.DuplicateConstraintDefinitionError);
    exports2.errorMapping.set(67437066, errors.DuplicateCastDefinitionError);
    exports2.errorMapping.set(67437067, errors.DuplicateMigrationError);
    exports2.errorMapping.set(67502080, errors.SessionTimeoutError);
    exports2.errorMapping.set(67502336, errors.IdleSessionTimeoutError);
    exports2.errorMapping.set(67502592, errors.QueryTimeoutError);
    exports2.errorMapping.set(67504640, errors.TransactionTimeoutError);
    exports2.errorMapping.set(67504641, errors.IdleTransactionTimeoutError);
    exports2.errorMapping.set(83886080, errors.ExecutionError);
    exports2.errorMapping.set(83951616, errors.InvalidValueError);
    exports2.errorMapping.set(83951617, errors.DivisionByZeroError);
    exports2.errorMapping.set(83951618, errors.NumericOutOfRangeError);
    exports2.errorMapping.set(83951619, errors.AccessPolicyError);
    exports2.errorMapping.set(83951620, errors.QueryAssertionError);
    exports2.errorMapping.set(84017152, errors.IntegrityError);
    exports2.errorMapping.set(84017153, errors.ConstraintViolationError);
    exports2.errorMapping.set(84017154, errors.CardinalityViolationError);
    exports2.errorMapping.set(84017155, errors.MissingRequiredError);
    exports2.errorMapping.set(84082688, errors.TransactionError);
    exports2.errorMapping.set(84082944, errors.TransactionConflictError);
    exports2.errorMapping.set(84082945, errors.TransactionSerializationError);
    exports2.errorMapping.set(84082946, errors.TransactionDeadlockError);
    exports2.errorMapping.set(84148224, errors.WatchError);
    exports2.errorMapping.set(100663296, errors.ConfigurationError);
    exports2.errorMapping.set(117440512, errors.AccessError);
    exports2.errorMapping.set(117506048, errors.AuthenticationError);
    exports2.errorMapping.set(134217728, errors.AvailabilityError);
    exports2.errorMapping.set(134217729, errors.BackendUnavailableError);
    exports2.errorMapping.set(134217730, errors.ServerOfflineError);
    exports2.errorMapping.set(134217731, errors.UnknownTenantError);
    exports2.errorMapping.set(134217732, errors.ServerBlockedError);
    exports2.errorMapping.set(150994944, errors.BackendError);
    exports2.errorMapping.set(150995200, errors.UnsupportedBackendFeatureError);
    exports2.errorMapping.set(4026531840, errors.LogMessage);
    exports2.errorMapping.set(4026597376, errors.WarningMessage);
    exports2.errorMapping.set(4026662912, errors.StatusMessage);
    exports2.errorMapping.set(4026662913, errors.MigrationStatusMessage);
    exports2.errorMapping.set(4278190080, errors.ClientError);
    exports2.errorMapping.set(4278255616, errors.ClientConnectionError);
    exports2.errorMapping.set(4278255872, errors.ClientConnectionFailedError);
    exports2.errorMapping.set(4278255873, errors.ClientConnectionFailedTemporarilyError);
    exports2.errorMapping.set(4278256128, errors.ClientConnectionTimeoutError);
    exports2.errorMapping.set(4278256384, errors.ClientConnectionClosedError);
    exports2.errorMapping.set(4278321152, errors.InterfaceError);
    exports2.errorMapping.set(4278321408, errors.QueryArgumentError);
    exports2.errorMapping.set(4278321409, errors.MissingArgumentError);
    exports2.errorMapping.set(4278321410, errors.UnknownArgumentError);
    exports2.errorMapping.set(4278321411, errors.InvalidArgumentError);
    exports2.errorMapping.set(4278386688, errors.NoDataError);
    exports2.errorMapping.set(4278452224, errors.InternalClientError);
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/resolve.js
var require_resolve = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/errors/resolve.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.resolveErrorCode = resolveErrorCode;
    exports2.errorFromJSON = errorFromJSON;
    var errors = __importStar(require_errors());
    var base_1 = require_base();
    var map_1 = require_map();
    function resolveErrorCode(code) {
      let result;
      result = map_1.errorMapping.get(code);
      if (result) {
        return result;
      }
      code = code & 4294967040;
      result = map_1.errorMapping.get(code);
      if (result) {
        return result;
      }
      code = code & 4294901760;
      result = map_1.errorMapping.get(code);
      if (result) {
        return result;
      }
      code = code & 4278190080;
      result = map_1.errorMapping.get(code);
      if (result) {
        return result;
      }
      return errors.GelError;
    }
    var _JSON_FIELDS = {
      hint: base_1.ErrorAttr.hint,
      details: base_1.ErrorAttr.details,
      start: base_1.ErrorAttr.characterStart,
      end: base_1.ErrorAttr.characterEnd,
      line: base_1.ErrorAttr.lineStart,
      col: base_1.ErrorAttr.columnStart
    };
    function errorFromJSON(data) {
      const errType = resolveErrorCode(data.code);
      const err3 = new errType(data.message);
      const attrs = /* @__PURE__ */ new Map();
      for (const [name3, field] of Object.entries(_JSON_FIELDS)) {
        if (data[name3] != null) {
          attrs.set(field, data[name3]);
        }
      }
      err3._attrs = attrs;
      return err3;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/baseConn.js
var require_baseConn = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/baseConn.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.BaseRawConnection = exports2.RESTRICTED_CAPABILITIES = exports2.Capabilities = exports2.PROTO_VER_MIN = exports2.PROTO_VER = void 0;
    var codecs_1 = require_codecs();
    var object_1 = require_object();
    var utils_1 = require_utils4();
    var errors = __importStar(require_errors());
    var resolve_1 = require_resolve();
    var context_1 = require_context();
    var ifaces_1 = require_ifaces2();
    var buffer_1 = require_buffer();
    var chars = __importStar(require_chars());
    var event_1 = __importDefault(require_event());
    var lru_1 = __importDefault(require_lru());
    var options_1 = require_options();
    exports2.PROTO_VER = [3, 0];
    exports2.PROTO_VER_MIN = [0, 9];
    var TransactionStatus;
    (function(TransactionStatus2) {
      TransactionStatus2[TransactionStatus2["TRANS_IDLE"] = 0] = "TRANS_IDLE";
      TransactionStatus2[TransactionStatus2["TRANS_ACTIVE"] = 1] = "TRANS_ACTIVE";
      TransactionStatus2[TransactionStatus2["TRANS_INTRANS"] = 2] = "TRANS_INTRANS";
      TransactionStatus2[TransactionStatus2["TRANS_INERROR"] = 3] = "TRANS_INERROR";
      TransactionStatus2[TransactionStatus2["TRANS_UNKNOWN"] = 4] = "TRANS_UNKNOWN";
    })(TransactionStatus || (TransactionStatus = {}));
    var Capabilities;
    (function(Capabilities2) {
      Capabilities2[Capabilities2["NONE"] = 0] = "NONE";
      Capabilities2[Capabilities2["MODIFICATONS"] = 1] = "MODIFICATONS";
      Capabilities2[Capabilities2["SESSION_CONFIG"] = 2] = "SESSION_CONFIG";
      Capabilities2[Capabilities2["TRANSACTION"] = 4] = "TRANSACTION";
      Capabilities2[Capabilities2["DDL"] = 8] = "DDL";
      Capabilities2[Capabilities2["PERSISTENT_CONFIG"] = 16] = "PERSISTENT_CONFIG";
      Capabilities2[Capabilities2["SET_GLOBAL"] = 32] = "SET_GLOBAL";
      Capabilities2[Capabilities2["ALL"] = 4294967295] = "ALL";
    })(Capabilities || (exports2.Capabilities = Capabilities = {}));
    var NO_TRANSACTION_CAPABILITIES = (Capabilities.ALL & ~Capabilities.TRANSACTION) >>> 0;
    var NO_TRANSACTION_CAPABILITIES_BYTES = new Uint8Array(Array(8).fill(255));
    new DataView(NO_TRANSACTION_CAPABILITIES_BYTES.buffer).setUint32(4, NO_TRANSACTION_CAPABILITIES);
    exports2.RESTRICTED_CAPABILITIES = (Capabilities.ALL & ~Capabilities.TRANSACTION & ~Capabilities.SESSION_CONFIG & ~Capabilities.SET_GLOBAL) >>> 0;
    var CompilationFlag;
    (function(CompilationFlag2) {
      CompilationFlag2[CompilationFlag2["INJECT_OUTPUT_TYPE_IDS"] = 1] = "INJECT_OUTPUT_TYPE_IDS";
      CompilationFlag2[CompilationFlag2["INJECT_OUTPUT_TYPE_NAMES"] = 2] = "INJECT_OUTPUT_TYPE_NAMES";
      CompilationFlag2[CompilationFlag2["INJECT_OUTPUT_OBJECT_IDS"] = 4] = "INJECT_OUTPUT_OBJECT_IDS";
    })(CompilationFlag || (CompilationFlag = {}));
    var OLD_ERROR_CODES = /* @__PURE__ */ new Map([
      [84082689, 84082945],
      [84082690, 84082946]
    ]);
    var BaseRawConnection = class {
      constructor(registry) {
        __publicField(this, "connected", false);
        __publicField(this, "lastStatus");
        __publicField(this, "codecsRegistry");
        __publicField(this, "queryCodecCache");
        __publicField(this, "serverSecret");
        __publicField(this, "serverSettings");
        __publicField(this, "serverXactStatus");
        __publicField(this, "buffer");
        __publicField(this, "messageWaiter");
        __publicField(this, "connWaiter");
        __publicField(this, "connAbortWaiter");
        __publicField(this, "_abortedWith", null);
        __publicField(this, "protocolVersion", exports2.PROTO_VER);
        __publicField(this, "stateCodec", codecs_1.INVALID_CODEC);
        __publicField(this, "stateCache", /* @__PURE__ */ new WeakMap());
        __publicField(this, "lastStateUpdate", null);
        __publicField(this, "adminUIMode", false);
        this.buffer = new buffer_1.ReadMessageBuffer();
        this.codecsRegistry = registry;
        this.queryCodecCache = new lru_1.default({ capacity: 1e3 });
        this.lastStatus = null;
        this.serverSecret = null;
        this.serverSettings = {};
        this.serverXactStatus = TransactionStatus.TRANS_UNKNOWN;
        this.messageWaiter = null;
        this.connWaiter = new event_1.default();
        this.connAbortWaiter = new event_1.default();
      }
      throwNotImplemented(method) {
        throw new errors.InternalClientError(`method ${method} is not implemented`);
      }
      async _waitForMessage() {
        this.throwNotImplemented("_waitForMessage");
      }
      _sendData(_data5) {
        this.throwNotImplemented("_sendData");
      }
      getConnAbortError() {
        return this._abortedWith ?? new errors.InterfaceError(`client has been closed`);
      }
      _checkState() {
        if (this.isClosed()) {
          throw this.getConnAbortError();
        }
      }
      _abortWithError(err3) {
        this._abortedWith = err3;
        this._abort();
      }
      _ignoreHeaders() {
        let numFields = this.buffer.readInt16();
        while (numFields) {
          this.buffer.readInt16();
          this.buffer.readLenPrefixedBuffer();
          numFields--;
        }
      }
      _readHeaders() {
        const numFields = this.buffer.readInt16();
        const headers = {};
        for (let i8 = 0; i8 < numFields; i8++) {
          const key = this.buffer.readString();
          const value = this.buffer.readString();
          headers[key] = value;
        }
        return headers;
      }
      _abortWaiters(err3) {
        if (!this.connWaiter.done) {
          this.connWaiter.setError(err3);
        }
        this.messageWaiter?.setError(err3);
        this.messageWaiter = null;
      }
      _parseHeaders() {
        const ret = /* @__PURE__ */ new Map();
        let numFields = this.buffer.readInt16();
        while (numFields) {
          const key = this.buffer.readInt16();
          const value = this.buffer.readLenPrefixedBuffer();
          ret.set(key, value);
          numFields--;
        }
        return ret;
      }
      _parseDescribeTypeMessage(query) {
        let capabilities = -1;
        let warnings = [];
        let unsafeIsolationDangers = [];
        const headers = this._readHeaders();
        if (headers.warnings != null) {
          warnings = JSON.parse(headers.warnings).map((warning3) => {
            const err3 = (0, resolve_1.errorFromJSON)(warning3);
            err3._query = query;
            return err3;
          });
        }
        if (headers.unsafe_isolation_dangers != null) {
          unsafeIsolationDangers = JSON.parse(headers.unsafe_isolation_dangers).map((danger) => {
            const err3 = (0, resolve_1.errorFromJSON)(danger);
            err3._query = query;
            return err3;
          });
        }
        capabilities = Number(this.buffer.readBigInt64());
        const cardinality = this.buffer.readChar();
        const inTypeId = this.buffer.readUUID();
        const inTypeData = this.buffer.readLenPrefixedBuffer();
        const outTypeId = this.buffer.readUUID();
        const outTypeData = this.buffer.readLenPrefixedBuffer();
        this.buffer.finishMessage();
        let inCodec = this.codecsRegistry.getCodec(inTypeId);
        if (inCodec == null) {
          inCodec = this.codecsRegistry.buildCodec(inTypeData, this.protocolVersion);
        }
        let outCodec = this.codecsRegistry.getCodec(outTypeId);
        if (outCodec == null) {
          outCodec = this.codecsRegistry.buildCodec(outTypeData, this.protocolVersion);
        }
        return [
          cardinality,
          inCodec,
          outCodec,
          capabilities,
          inTypeData,
          outTypeData,
          warnings,
          unsafeIsolationDangers
        ];
      }
      _parseCommandCompleteMessage() {
        this._ignoreHeaders();
        this.buffer.readBigInt64();
        const status = this.buffer.readString();
        const stateTypeId = this.buffer.readUUID();
        const stateData = this.buffer.readLenPrefixedBuffer();
        if (this.adminUIMode && stateTypeId === this.stateCodec.tid) {
          this.lastStateUpdate = this.stateCodec.decode(new buffer_1.ReadBuffer(stateData), context_1.NOOP_CODEC_CONTEXT);
        }
        this.buffer.finishMessage();
        return status;
      }
      _parseErrorMessage() {
        this.buffer.readChar();
        const code = this.buffer.readUInt32();
        const message = this.buffer.readString();
        const errorType = (0, resolve_1.resolveErrorCode)(OLD_ERROR_CODES.get(code) ?? code);
        const err3 = new errorType(message);
        err3._attrs = this._parseHeaders();
        this.buffer.finishMessage();
        if (err3 instanceof errors.AuthenticationError) {
          throw err3;
        }
        return err3;
      }
      _parseSyncMessage() {
        this._parseHeaders();
        const status = this.buffer.readChar();
        switch (status) {
          case chars.$I:
            this.serverXactStatus = TransactionStatus.TRANS_IDLE;
            break;
          case chars.$T:
            this.serverXactStatus = TransactionStatus.TRANS_INTRANS;
            break;
          case chars.$E:
            this.serverXactStatus = TransactionStatus.TRANS_INERROR;
            break;
          default:
            this.serverXactStatus = TransactionStatus.TRANS_UNKNOWN;
        }
        this.buffer.finishMessage();
      }
      _redirectDataMessages(result) {
        const $D = chars.$D;
        const buffer2 = this.buffer;
        while (buffer2.takeMessageType($D)) {
          const msg = buffer2.consumeMessage();
          result.writeChar($D);
          result.writeInt32(msg.length + 4);
          result.writeBuffer(msg);
        }
      }
      _parseDataMessages(codec, result, ctx) {
        const frb = buffer_1.ReadBuffer.alloc();
        const $D = chars.$D;
        const buffer2 = this.buffer;
        if (Array.isArray(result)) {
          while (buffer2.takeMessageType($D)) {
            buffer2.consumeMessageInto(frb);
            frb.discard(6);
            result.push(codec.decode(frb, ctx));
            frb.finish();
          }
        } else {
          this._redirectDataMessages(result);
        }
      }
      _parseServerSettings(name3, value) {
        switch (name3) {
          case "suggested_pool_concurrency": {
            this.serverSettings.suggested_pool_concurrency = parseInt(buffer_1.utf8Decoder.decode(value), 10);
            break;
          }
          case "system_config": {
            const buf = new buffer_1.ReadBuffer(value);
            const typedescLen = buf.readInt32() - 16;
            const typedescId = buf.readUUID();
            const typedesc = buf.readBuffer(typedescLen);
            let codec = this.codecsRegistry.getCodec(typedescId);
            if (codec === null) {
              codec = this.codecsRegistry.buildCodec(typedesc, this.protocolVersion);
            }
            buf.discard(4);
            const data = codec.decode(buf, context_1.NOOP_CODEC_CONTEXT);
            buf.finish();
            this.serverSettings.system_config = data;
            break;
          }
          default:
            this.serverSettings[name3] = value;
            break;
        }
      }
      _parseDescribeStateMessage() {
        const typedescId = this.buffer.readUUID();
        const typedesc = this.buffer.readBuffer(this.buffer.readInt32());
        let codec = this.codecsRegistry.getCodec(typedescId);
        if (codec === null) {
          codec = this.codecsRegistry.buildCodec(typedesc, this.protocolVersion);
        }
        this.stateCodec = codec;
        this.stateCache = /* @__PURE__ */ new WeakMap();
        this.buffer.finishMessage();
      }
      _fallthrough() {
        const mtype = this.buffer.getMessageType();
        switch (mtype) {
          case chars.$S: {
            const name3 = this.buffer.readString();
            const value = this.buffer.readLenPrefixedBuffer();
            this._parseServerSettings(name3, value);
            this.buffer.finishMessage();
            break;
          }
          case chars.$L: {
            const severity = this.buffer.readChar();
            const code = this.buffer.readUInt32();
            const message = this.buffer.readString();
            this._parseHeaders();
            this.buffer.finishMessage();
            console.info("SERVER MESSAGE", severity, code, message);
            break;
          }
          default:
            throw new errors.UnexpectedMessageError(`unexpected message type ${mtype} ("${chars.chr(mtype)}")`);
        }
      }
      _encodeArgs(args2, inCodec, ctx) {
        if (inCodec === codecs_1.NULL_CODEC) {
          if (args2 != null) {
            throw new errors.QueryArgumentError(`This query does not contain any query parameters, but query arguments were provided to the 'query*()' method`);
          }
          return codecs_1.NullCodec.BUFFER;
        }
        if (inCodec instanceof object_1.ObjectCodec) {
          return inCodec.encodeArgs(args2, ctx);
        }
        throw new errors.ProtocolError("invalid input codec");
      }
      _isInTransaction() {
        return this.serverXactStatus === TransactionStatus.TRANS_INTRANS || this.serverXactStatus === TransactionStatus.TRANS_ACTIVE;
      }
      _setStateCodec(state2) {
        let encodedState = this.stateCache.get(state2);
        if (encodedState) {
          return encodedState;
        }
        const buf = new buffer_1.WriteBuffer();
        this.stateCodec.encode(buf, state2._serialise(), context_1.NOOP_CODEC_CONTEXT);
        encodedState = buf.unwrap();
        this.stateCache.set(state2, encodedState);
        return encodedState;
      }
      _encodeParseParams(wb, query, outputFormat, expectedCardinality, state2, capabilitiesFlags, options, language, isExecute, unsafeIsolationDangers) {
        if ((0, utils_1.versionGreaterThanOrEqual)(this.protocolVersion, [3, 0])) {
          if (state2.annotations.size >= 1 << 16) {
            throw new errors.InternalClientError("too many annotations");
          }
          wb.writeUInt16(state2.annotations.size);
          for (const [name3, value] of state2.annotations) {
            wb.writeString(name3);
            wb.writeString(value);
          }
        } else {
          wb.writeUInt16(0);
        }
        wb.writeFlags(4294967295, capabilitiesFlags);
        wb.writeFlags(0, 0 | (options?.injectObjectids ? CompilationFlag.INJECT_OUTPUT_OBJECT_IDS : 0) | (options?.injectTypeids ? CompilationFlag.INJECT_OUTPUT_TYPE_IDS : 0) | (options?.injectTypenames ? CompilationFlag.INJECT_OUTPUT_TYPE_NAMES : 0));
        wb.writeBigInt64(options?.implicitLimit ?? BigInt(0));
        if ((0, utils_1.versionGreaterThanOrEqual)(this.protocolVersion, [3, 0])) {
          wb.writeChar(language);
        }
        wb.writeChar(outputFormat);
        wb.writeChar(expectedCardinality === ifaces_1.Cardinality.ONE || expectedCardinality === ifaces_1.Cardinality.AT_MOST_ONE ? ifaces_1.Cardinality.AT_MOST_ONE : ifaces_1.Cardinality.MANY);
        wb.writeString(query);
        if (!this.adminUIMode && state2.isDefaultSession()) {
          wb.writeBuffer(codecs_1.NULL_CODEC.tidBuffer);
          wb.writeInt32(0);
        } else {
          wb.writeBuffer(this.stateCodec.tidBuffer);
          if (this.stateCodec === codecs_1.INVALID_CODEC || this.stateCodec === codecs_1.NULL_CODEC) {
            wb.writeInt32(0);
          } else {
            if ((0, utils_1.versionGreaterThanOrEqual)(this.protocolVersion, [3, 0]) && isExecute && !this._isInTransaction()) {
              const isolation = state2.transactionOptions.isolation === options_1.IsolationLevel.PreferRepeatableRead ? unsafeIsolationDangers.length === 0 ? options_1.IsolationLevel.RepeatableRead : options_1.IsolationLevel.Serializable : state2.transactionOptions.isolation;
              if (isolation !== state2.config.get("default_transaction_isolation")) {
                state2 = state2.withConfig({
                  default_transaction_isolation: isolation
                }).withTransactionOptions({
                  isolation
                });
              }
              if (state2.transactionOptions.readonly !== state2.config.get("default_transaction_access_mode")) {
                state2 = state2.withConfig({
                  default_transaction_access_mode: state2.transactionOptions.readonly ? "ReadOnly" : "ReadWrite"
                });
              }
            }
            const encodedState = this._setStateCodec(state2);
            wb.writeBuffer(encodedState);
          }
        }
      }
      async _parse(language, query, outputFormat, expectedCardinality, state2, capabilitiesFlags = exports2.RESTRICTED_CAPABILITIES, options, unsafeIsolationDangers = []) {
        const wb = new buffer_1.WriteMessageBuffer();
        wb.beginMessage(chars.$P);
        this._encodeParseParams(wb, query, outputFormat, expectedCardinality, state2, capabilitiesFlags, options, language, false, unsafeIsolationDangers);
        wb.endMessage();
        wb.writeSync();
        this._sendData(wb.unwrap());
        let parsing = true;
        let error2 = null;
        let newCard = null;
        let capabilities = -1;
        let inCodec = null;
        let outCodec = null;
        let inCodecBuf = null;
        let outCodecBuf = null;
        let warnings = [];
        while (parsing) {
          if (!this.buffer.takeMessage()) {
            await this._waitForMessage();
          }
          const mtype = this.buffer.getMessageType();
          switch (mtype) {
            case chars.$T: {
              try {
                [
                  newCard,
                  inCodec,
                  outCodec,
                  capabilities,
                  inCodecBuf,
                  outCodecBuf,
                  warnings,
                  unsafeIsolationDangers
                ] = this._parseDescribeTypeMessage(query);
                const key = this._getQueryCacheKey(query, outputFormat, expectedCardinality);
                this.queryCodecCache.set(key, [
                  newCard,
                  inCodec,
                  outCodec,
                  capabilities,
                  unsafeIsolationDangers
                ]);
              } catch (e6) {
                error2 = e6;
              }
              break;
            }
            case chars.$E: {
              error2 = this._parseErrorMessage();
              error2._query = query;
              break;
            }
            case chars.$s: {
              options_1.Options.signalSchemaChange();
              this._parseDescribeStateMessage();
              break;
            }
            case chars.$Z: {
              this._parseSyncMessage();
              parsing = false;
              break;
            }
            default:
              this._fallthrough();
          }
        }
        if (error2 !== null) {
          if (error2 instanceof errors.StateMismatchError) {
            return this._parse(language, query, outputFormat, expectedCardinality, state2, capabilitiesFlags, options, unsafeIsolationDangers);
          }
          throw error2;
        }
        return [
          newCard,
          inCodec,
          outCodec,
          capabilities,
          inCodecBuf,
          outCodecBuf,
          warnings,
          unsafeIsolationDangers
        ];
      }
      async _executeFlow(language, query, args2, outputFormat, expectedCardinality, state2, inCodec, outCodec, result, capabilitiesFlags = exports2.RESTRICTED_CAPABILITIES, options, unsafeIsolationDangers = []) {
        let currentUnsafeIsolationDangers = unsafeIsolationDangers;
        let ctx = state2.makeCodecContext();
        const wb = new buffer_1.WriteMessageBuffer();
        wb.beginMessage(chars.$O);
        this._encodeParseParams(wb, query, outputFormat, expectedCardinality, state2, capabilitiesFlags, options, language, true, currentUnsafeIsolationDangers);
        wb.writeBuffer(inCodec.tidBuffer);
        wb.writeBuffer(outCodec.tidBuffer);
        if (inCodec) {
          wb.writeBuffer(this._encodeArgs(args2, inCodec, ctx));
        } else {
          wb.writeInt32(0);
        }
        wb.endMessage();
        wb.writeSync();
        this._sendData(wb.unwrap());
        let error2 = null;
        let parsing = true;
        let currentWarnings = [];
        while (parsing) {
          if (!this.buffer.takeMessage()) {
            await this._waitForMessage();
          }
          const mtype = this.buffer.getMessageType();
          switch (mtype) {
            case chars.$D: {
              if (error2 == null) {
                try {
                  this._parseDataMessages(outCodec, result, ctx);
                } catch (e6) {
                  error2 = e6;
                  this.buffer.finishMessage();
                }
              } else {
                this.buffer.discardMessage();
              }
              break;
            }
            case chars.$C: {
              this.lastStatus = this._parseCommandCompleteMessage();
              break;
            }
            case chars.$Z: {
              this._parseSyncMessage();
              parsing = false;
              break;
            }
            case chars.$T: {
              try {
                ctx = state2.makeCodecContext();
                const [newCard, newInCodec, newOutCodec, capabilities, _7, __, _warnings, _dangers] = this._parseDescribeTypeMessage(query);
                if (outCodec !== codecs_1.NULL_CODEC && outCodec.tid !== newOutCodec.tid || inCodec !== codecs_1.NULL_CODEC && inCodec.tid !== newInCodec.tid) {
                  options_1.Options.signalSchemaChange();
                  ctx = state2.makeCodecContext();
                }
                const key = this._getQueryCacheKey(query, outputFormat, expectedCardinality);
                this.queryCodecCache.set(key, [
                  newCard,
                  newInCodec,
                  newOutCodec,
                  capabilities,
                  _dangers
                ]);
                outCodec = newOutCodec;
                currentWarnings = _warnings;
                currentUnsafeIsolationDangers = _dangers;
              } catch (e6) {
                options_1.Options.signalSchemaChange();
                error2 = e6;
              }
              break;
            }
            case chars.$s: {
              options_1.Options.signalSchemaChange();
              this._parseDescribeStateMessage();
              break;
            }
            case chars.$E: {
              error2 = this._parseErrorMessage();
              error2._query = query;
              break;
            }
            default:
              this._fallthrough();
          }
        }
        if (error2 != null) {
          if (error2 instanceof errors.StateMismatchError) {
            return this._executeFlow(language, query, args2, outputFormat, expectedCardinality, state2, inCodec, outCodec, result, capabilitiesFlags, options, currentUnsafeIsolationDangers);
          }
          throw error2;
        }
        return [currentWarnings, currentUnsafeIsolationDangers];
      }
      _getQueryCacheKey(query, outputFormat, expectedCardinality, language = ifaces_1.Language.EDGEQL) {
        const expectOne = expectedCardinality === ifaces_1.Cardinality.ONE || expectedCardinality === ifaces_1.Cardinality.AT_MOST_ONE;
        return [language, outputFormat, expectOne, query.length, query].join(";");
      }
      _validateFetchCardinality(card, outputFormat, expectedCardinality) {
        if (expectedCardinality === ifaces_1.Cardinality.ONE && card === ifaces_1.Cardinality.NO_RESULT) {
          throw new errors.NoDataError(`query executed via queryRequiredSingle${outputFormat === ifaces_1.OutputFormat.JSON ? "JSON" : ""}() returned no data`);
        }
      }
      async fetch(query, args2 = null, outputFormat, expectedCardinality, state2, privilegedMode = false, language = ifaces_1.Language.EDGEQL) {
        if (language !== ifaces_1.Language.EDGEQL && (0, utils_1.versionGreaterThan)([3, 0], this.protocolVersion)) {
          throw new errors.UnsupportedFeatureError(`the server does not support SQL queries, upgrade to 6.0 or newer`);
        }
        this._checkState();
        const requiredOne = expectedCardinality === ifaces_1.Cardinality.ONE;
        const expectOne = requiredOne || expectedCardinality === ifaces_1.Cardinality.AT_MOST_ONE;
        const asJson = outputFormat === ifaces_1.OutputFormat.JSON;
        const key = this._getQueryCacheKey(query, outputFormat, expectedCardinality, language);
        const ret = [];
        let warnings = [];
        let [card, inCodec, outCodec, , unsafeIsolationDangers] = this.queryCodecCache.get(key) ?? [];
        if (card) {
          this._validateFetchCardinality(card, outputFormat, expectedCardinality);
        }
        if (!inCodec && args2 !== null || this.stateCodec === codecs_1.INVALID_CODEC && !state2.isDefaultSession()) {
          [card, inCodec, outCodec, , , , warnings, unsafeIsolationDangers] = await this._parse(language, query, outputFormat, expectedCardinality, state2, privilegedMode ? Capabilities.ALL : void 0, void 0, unsafeIsolationDangers);
          this._validateFetchCardinality(card, outputFormat, expectedCardinality);
        }
        try {
          [warnings, unsafeIsolationDangers] = await this._executeFlow(language, query, args2, outputFormat, expectedCardinality, state2, inCodec ?? codecs_1.NULL_CODEC, outCodec ?? codecs_1.NULL_CODEC, ret, privilegedMode ? Capabilities.ALL : void 0, void 0, unsafeIsolationDangers);
        } catch (e6) {
          if (e6 instanceof errors.ParameterTypeMismatchError) {
            [card, inCodec, outCodec, , unsafeIsolationDangers] = this.queryCodecCache.get(key);
            [warnings, unsafeIsolationDangers] = await this._executeFlow(language, query, args2, outputFormat, expectedCardinality, state2, inCodec ?? codecs_1.NULL_CODEC, outCodec ?? codecs_1.NULL_CODEC, ret, privilegedMode ? Capabilities.ALL : void 0);
          } else {
            throw e6;
          }
        }
        if (outputFormat === ifaces_1.OutputFormat.NONE) {
          return { result: null, warnings, unsafeIsolationDangers };
        }
        if (expectOne) {
          if (requiredOne && !ret.length) {
            throw new errors.NoDataError("query returned no data");
          } else {
            return {
              result: ret[0] ?? (asJson ? "null" : null),
              warnings,
              unsafeIsolationDangers
            };
          }
        } else {
          if (ret && ret.length) {
            if (asJson) {
              return { result: ret[0], warnings, unsafeIsolationDangers };
            } else {
              return { result: ret, warnings, unsafeIsolationDangers };
            }
          } else {
            if (asJson) {
              return { result: "[]", warnings, unsafeIsolationDangers };
            } else {
              return { result: ret, warnings, unsafeIsolationDangers };
            }
          }
        }
      }
      getQueryCapabilities(query, outputFormat, expectedCardinality) {
        const key = this._getQueryCacheKey(query, outputFormat, expectedCardinality);
        return this.queryCodecCache.get(key)?.[3] ?? null;
      }
      async resetState() {
        if (this.connected && this.serverXactStatus !== TransactionStatus.TRANS_IDLE) {
          try {
            await this.fetch(`rollback`, void 0, ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.NO_RESULT, options_1.Options.defaults(), true);
          } catch {
            this._abortWithError(new errors.ClientConnectionClosedError("failed to reset state"));
          }
        }
      }
      _abort() {
        this.connected = false;
        this._abortWaiters(this.getConnAbortError());
        if (!this.connAbortWaiter.done) {
          this.connAbortWaiter.set();
        }
      }
      isClosed() {
        return !this.connected;
      }
      async close() {
        this._abort();
      }
    };
    exports2.BaseRawConnection = BaseRawConnection;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/scram.js
var require_scram = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/scram.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.saslprep = saslprep;
    exports2.getSCRAM = getSCRAM;
    var buffer_1 = require_buffer();
    var errors_1 = require_errors();
    var RAW_NONCE_LENGTH = 18;
    function saslprep(str) {
      return str.normalize("NFKC");
    }
    function getSCRAM({ randomBytes, H: H5, HMAC, makeKey }) {
      function bufferEquals(a9, b9) {
        if (a9.length !== b9.length) {
          return false;
        }
        for (let i8 = 0, len = a9.length; i8 < len; i8++) {
          if (a9[i8] !== b9[i8]) {
            return false;
          }
        }
        return true;
      }
      function generateNonce(length = RAW_NONCE_LENGTH) {
        return randomBytes(length);
      }
      function buildClientFirstMessage(clientNonce, username) {
        const bare = `n=${saslprep(username)},r=${(0, buffer_1.encodeB64)(clientNonce)}`;
        return [`n,,${bare}`, bare];
      }
      function parseServerFirstMessage(msg) {
        const attrs = msg.split(",");
        if (attrs.length < 3) {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const nonceAttr = attrs[0];
        if (!nonceAttr || nonceAttr[0] !== "r") {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const nonceB64 = nonceAttr.split("=", 2)[1];
        if (!nonceB64) {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const nonce = (0, buffer_1.decodeB64)(nonceB64);
        const saltAttr = attrs[1];
        if (!saltAttr || saltAttr[0] !== "s") {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const saltB64 = saltAttr.split("=", 2)[1];
        if (!saltB64) {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const salt = (0, buffer_1.decodeB64)(saltB64);
        const iterAttr = attrs[2];
        if (!iterAttr || iterAttr[0] !== "i") {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const iter = iterAttr.split("=", 2)[1];
        if (!iter || !iter.match(/^[0-9]*$/)) {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const iterCount = parseInt(iter, 10);
        if (iterCount <= 0) {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        return [nonce, salt, iterCount];
      }
      function parseServerFinalMessage(msg) {
        const attrs = msg.split(",");
        if (attrs.length < 1) {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const nonceAttr = attrs[0];
        if (!nonceAttr || nonceAttr[0] !== "v") {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        const signatureB64 = nonceAttr.split("=", 2)[1];
        if (!signatureB64) {
          throw new errors_1.ProtocolError("malformed SCRAM message");
        }
        return (0, buffer_1.decodeB64)(signatureB64);
      }
      async function buildClientFinalMessage(password, salt, iterations, clientFirstBare, serverFirst, serverNonce) {
        const clientFinal = `c=biws,r=${(0, buffer_1.encodeB64)(serverNonce)}`;
        const authMessage = buffer_1.utf8Encoder.encode(`${clientFirstBare},${serverFirst},${clientFinal}`);
        const saltedPassword = await _getSaltedPassword(buffer_1.utf8Encoder.encode(saslprep(password)), salt, iterations);
        const clientKey = await _getClientKey(saltedPassword);
        const storedKey = await H5(clientKey);
        const clientSignature = await HMAC(storedKey, authMessage);
        const clientProof = _XOR(clientKey, clientSignature);
        const serverKey = await _getServerKey(saltedPassword);
        const serverProof = await HMAC(serverKey, authMessage);
        return [`${clientFinal},p=${(0, buffer_1.encodeB64)(clientProof)}`, serverProof];
      }
      async function _getSaltedPassword(password, salt, iterations) {
        const msg = new Uint8Array(salt.length + 4);
        msg.set(salt);
        msg.set([0, 0, 0, 1], salt.length);
        const keyFromPassword = await makeKey(password);
        let Hi = await HMAC(keyFromPassword, msg);
        let Ui = Hi;
        for (let _7 = 0; _7 < iterations - 1; _7++) {
          Ui = await HMAC(keyFromPassword, Ui);
          Hi = _XOR(Hi, Ui);
        }
        return Hi;
      }
      function _getClientKey(saltedPassword) {
        return HMAC(saltedPassword, buffer_1.utf8Encoder.encode("Client Key"));
      }
      function _getServerKey(saltedPassword) {
        return HMAC(saltedPassword, buffer_1.utf8Encoder.encode("Server Key"));
      }
      function _XOR(a9, b9) {
        const len = a9.length;
        if (len !== b9.length) {
          throw new errors_1.ProtocolError("scram.XOR: buffers are of different lengths");
        }
        const res = new Uint8Array(len);
        for (let i8 = 0; i8 < len; i8++) {
          res[i8] = a9[i8] ^ b9[i8];
        }
        return res;
      }
      return {
        bufferEquals,
        generateNonce,
        buildClientFirstMessage,
        parseServerFirstMessage,
        parseServerFinalMessage,
        buildClientFinalMessage,
        _getSaltedPassword,
        _getClientKey,
        _getServerKey,
        _XOR
      };
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/browserCrypto.js
var require_browserCrypto = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/browserCrypto.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.cryptoUtils = void 0;
    async function makeKey(key) {
      return await crypto.subtle.importKey("raw", key, {
        name: "HMAC",
        hash: { name: "SHA-256" }
      }, false, ["sign"]);
    }
    function randomBytes(size2) {
      return crypto.getRandomValues(new Uint8Array(size2));
    }
    async function H5(msg) {
      return new Uint8Array(await crypto.subtle.digest("SHA-256", msg));
    }
    async function HMAC(key, msg) {
      const cryptoKey = key instanceof Uint8Array ? await makeKey(key) : key;
      return new Uint8Array(await crypto.subtle.sign("HMAC", cryptoKey, msg));
    }
    exports2.cryptoUtils = {
      makeKey,
      randomBytes,
      H: H5,
      HMAC
    };
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/nodeCrypto.js
var require_nodeCrypto = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/nodeCrypto.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.cryptoUtils = void 0;
    var node_crypto_1 = __importDefault(require("crypto"));
    function makeKey(keyBytes) {
      return Promise.resolve(keyBytes);
    }
    function randomBytes(size2) {
      return node_crypto_1.default.randomBytes(size2);
    }
    async function H5(msg) {
      const sign = node_crypto_1.default.createHash("sha256");
      sign.update(msg);
      return sign.digest();
    }
    async function HMAC(key, msg) {
      const cryptoKey = key instanceof Uint8Array ? key : node_crypto_1.default.KeyObject.from(key);
      const hm = node_crypto_1.default.createHmac("sha256", cryptoKey);
      hm.update(msg);
      return hm.digest();
    }
    exports2.cryptoUtils = {
      makeKey,
      randomBytes,
      H: H5,
      HMAC
    };
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/cryptoUtils.js
var require_cryptoUtils = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/cryptoUtils.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var browserCrypto_1 = require_browserCrypto();
    var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
    var cryptoUtils;
    function loadCrypto() {
      if (isNode) {
        try {
          require("crypto");
          cryptoUtils = require_nodeCrypto().cryptoUtils;
        } catch (_7) {
          if (typeof globalThis.crypto !== "undefined") {
            cryptoUtils = browserCrypto_1.cryptoUtils;
          } else {
            throw new Error("No crypto implementation found");
          }
        }
      } else {
        cryptoUtils = browserCrypto_1.cryptoUtils;
      }
    }
    loadCrypto();
    exports2.default = cryptoUtils;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/rawConn.js
var require_rawConn = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/rawConn.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.RawConnection = void 0;
    var node_net_1 = __importDefault(require("net"));
    var tls2 = __importStar(require("tls"));
    var baseConn_1 = require_baseConn();
    var utils_1 = require_utils4();
    var buffer_1 = require_buffer();
    var event_1 = __importDefault(require_event());
    var chars = __importStar(require_chars());
    var scram_1 = require_scram();
    var errors = __importStar(require_errors());
    var cryptoUtils_1 = __importDefault(require_cryptoUtils());
    var AuthenticationStatuses;
    (function(AuthenticationStatuses2) {
      AuthenticationStatuses2[AuthenticationStatuses2["AUTH_OK"] = 0] = "AUTH_OK";
      AuthenticationStatuses2[AuthenticationStatuses2["AUTH_SASL"] = 10] = "AUTH_SASL";
      AuthenticationStatuses2[AuthenticationStatuses2["AUTH_SASL_CONTINUE"] = 11] = "AUTH_SASL_CONTINUE";
      AuthenticationStatuses2[AuthenticationStatuses2["AUTH_SASL_FINAL"] = 12] = "AUTH_SASL_FINAL";
    })(AuthenticationStatuses || (AuthenticationStatuses = {}));
    var scram = (0, scram_1.getSCRAM)(cryptoUtils_1.default);
    var _tlsOptions = /* @__PURE__ */ new WeakMap();
    function getTlsOptions(config) {
      if (_tlsOptions.has(config)) {
        return _tlsOptions.get(config);
      }
      const tlsSecurity = config.tlsSecurity;
      const tlsOptions = {
        ALPNProtocols: ["edgedb-binary"],
        rejectUnauthorized: tlsSecurity !== "insecure"
      };
      const isIPAddress = node_net_1.default.isIP(config.address[0]) !== 0;
      if (!isIPAddress) {
        tlsOptions.servername = config.tlsServerName || config.address[0];
      }
      _tlsOptions.set(config, tlsOptions);
      if (config._tlsCAData !== null) {
        tlsOptions.ca = config._tlsCAData;
      }
      if (tlsSecurity === "no_host_verification") {
        tlsOptions.checkServerIdentity = (hostname, cert) => {
          const err3 = tls2.checkServerIdentity(hostname, cert);
          if (err3 === void 0) {
            return void 0;
          }
          if (err3.message.startsWith("Hostname/IP does not match certificate")) {
            return void 0;
          }
          return err3;
        };
      }
      return tlsOptions;
    }
    var RawConnection = class extends baseConn_1.BaseRawConnection {
      constructor(sock, config, registry) {
        super(registry);
        __publicField(this, "config");
        __publicField(this, "sock");
        __publicField(this, "paused");
        this.config = config;
        this.paused = false;
        this.sock = sock;
        this.sock.setNoDelay();
        this.sock.on("error", this._onError.bind(this));
        this.sock.on("data", this._onData.bind(this));
        if (tls2.TLSSocket && this.sock instanceof tls2.TLSSocket) {
          this.sock.on("secureConnect", this._onConnect.bind(this));
        } else {
          this.sock.on("connect", this._onConnect.bind(this));
        }
        this.sock.on("close", this._onClose.bind(this));
      }
      _onConnect() {
        this.connWaiter.set();
      }
      _onClose() {
        if (!this.connected) {
          return;
        }
        const newErr = new errors.ClientConnectionClosedError(`the connection has been aborted`);
        if (!this.connWaiter.done || this.messageWaiter) {
          this._abortWaiters(newErr);
        }
        if (this.buffer.takeMessage() && this.buffer.getMessageType() === chars.$E) {
          Object.defineProperty(newErr, "cause", {
            enumerable: false,
            value: this._parseErrorMessage()
          });
        }
        this._abortWithError(newErr);
      }
      _onError(err3) {
        const newErr = new errors.ClientConnectionClosedError(`network error: ${err3}`, { cause: err3 });
        try {
          this._abortWaiters(newErr);
        } finally {
          this._abortWithError(newErr);
        }
      }
      _onData(data) {
        try {
          this.buffer.feed(data);
        } catch (e6) {
          if (this.messageWaiter) {
            this.messageWaiter.setError(e6);
            this.messageWaiter = null;
          }
          this._abortWithError(e6);
        }
        if (this.messageWaiter) {
          if (this.buffer.takeMessage()) {
            this.messageWaiter.set();
            this.messageWaiter = null;
          }
        }
      }
      async _waitForMessage() {
        if (this.buffer.takeMessage()) {
          return;
        }
        if (this.paused) {
          this.paused = false;
          this.sock.resume();
        }
        this.sock.ref();
        this.messageWaiter = new event_1.default();
        try {
          await this.messageWaiter.wait();
        } finally {
          this.sock.unref();
        }
      }
      _sendData(data) {
        this.sock.write(data);
      }
      static newSock(addr2, options) {
        if (typeof addr2 === "string") {
          return node_net_1.default.createConnection(addr2);
        }
        const [host, port] = addr2;
        if (options == null) {
          return node_net_1.default.createConnection(port, host);
        }
        const opts = { ...options, host, port };
        return tls2.connect(opts);
      }
      _abort() {
        if (this.sock && this.connected) {
          this.sock.destroy();
        }
        super._abort();
      }
      async close() {
        if (this.sock && this.connected) {
          this.sock.write(new buffer_1.WriteMessageBuffer().beginMessage(chars.$X).endMessage().unwrap());
        }
        return await super.close();
      }
      static async connectWithTimeout(config, registry, useTls = true) {
        const sock = this.newSock(config.connectionParams.address, useTls ? getTlsOptions(config.connectionParams) : void 0);
        const conn = new this(sock, config, registry);
        const connPromise = conn.connect();
        let timeoutCb = null;
        let timeoutHappened = false;
        if (config.connectTimeout) {
          timeoutCb = setTimeout(() => {
            if (!conn.connected) {
              timeoutHappened = true;
              conn.sock.destroy(new errors.ClientConnectionTimeoutError(`connection timed out (${config.connectTimeout}ms)`));
            }
          }, config.connectTimeout);
        }
        try {
          await connPromise;
        } catch (e6) {
          conn._abort();
          if (timeoutHappened && e6 instanceof errors.ClientConnectionClosedError) {
            throw new errors.ClientConnectionTimeoutError(`connection timed out (${config.connectTimeout}ms)`);
          }
          if (e6 instanceof errors.GelError) {
            throw e6;
          } else {
            let err3;
            switch (e6.code) {
              case "EPROTO":
                if (useTls === true) {
                  try {
                    return this.connectWithTimeout(config, registry, false);
                  } catch {
                  }
                }
                err3 = new errors.ClientConnectionFailedError(`${e6.message}
Attempted to connect using the following credentials:
${config.connectionParams.explainConfig()}
`, { cause: e6 });
                break;
              case "ECONNREFUSED":
              case "ECONNABORTED":
              case "ECONNRESET":
              case "ENOTFOUND":
              case "ENOENT":
                err3 = new errors.ClientConnectionFailedTemporarilyError(`${e6.message}
Attempted to connect using the following credentials:
${config.connectionParams.explainConfig()}
`, { cause: e6 });
                break;
              default:
                err3 = new errors.ClientConnectionFailedError(`${e6.message}
Attempted to connect using the following credentials:
${config.connectionParams.explainConfig()}
`, { cause: e6 });
                break;
            }
            throw err3;
          }
        } finally {
          if (timeoutCb != null) {
            clearTimeout(timeoutCb);
          }
        }
        return conn;
      }
      async connect() {
        await this.connWaiter.wait();
        if (this.sock instanceof tls2.TLSSocket) {
          if (this.sock.alpnProtocol !== "edgedb-binary") {
            throw new errors.ClientConnectionFailedError("The server doesn't support the edgedb-binary protocol.");
          }
        }
        const handshake = new buffer_1.WriteMessageBuffer();
        handshake.beginMessage(chars.$V).writeInt16(this.protocolVersion[0]).writeInt16(this.protocolVersion[1]);
        const clientHandshakeOptions = {
          user: this.config.connectionParams.user,
          database: this.config.connectionParams.database
        };
        if (this.config.connectionParams.secretKey != null) {
          clientHandshakeOptions.secret_key = this.config.connectionParams.secretKey;
        }
        handshake.writeInt16(Object.keys(clientHandshakeOptions).length);
        for (const [key, value] of Object.entries(clientHandshakeOptions)) {
          handshake.writeString(key).writeString(value);
        }
        handshake.writeInt16(0);
        handshake.endMessage();
        this.sock.write(handshake.unwrap());
        while (true) {
          if (!this.buffer.takeMessage()) {
            await this._waitForMessage();
          }
          const mtype = this.buffer.getMessageType();
          switch (mtype) {
            case chars.$v: {
              const hi3 = this.buffer.readInt16();
              const lo = this.buffer.readInt16();
              this._parseHeaders();
              this.buffer.finishMessage();
              const proposed = [hi3, lo];
              if ((0, utils_1.versionGreaterThan)(proposed, baseConn_1.PROTO_VER) || (0, utils_1.versionGreaterThan)(baseConn_1.PROTO_VER_MIN, proposed)) {
                throw new errors.UnsupportedProtocolVersionError(`the server requested an unsupported version of the protocol ${hi3}.${lo}`);
              }
              this.protocolVersion = [hi3, lo];
              break;
            }
            case chars.$R: {
              const status = this.buffer.readInt32();
              if (status === AuthenticationStatuses.AUTH_OK) {
                this.buffer.finishMessage();
              } else if (status === AuthenticationStatuses.AUTH_SASL) {
                await this._authSasl();
              } else {
                throw new errors.ProtocolError(`unsupported authentication method requested by the server: ${status}`);
              }
              break;
            }
            case chars.$K: {
              this.serverSecret = this.buffer.readBuffer(32);
              this.buffer.finishMessage();
              break;
            }
            case chars.$E: {
              throw this._parseErrorMessage();
            }
            case chars.$s: {
              this._parseDescribeStateMessage();
              break;
            }
            case chars.$Z: {
              this._parseSyncMessage();
              if (!(this.sock instanceof tls2.TLSSocket) && typeof Deno === "undefined") {
                const [major, minor] = this.protocolVersion;
                throw new errors.ProtocolError(`the protocol version requires TLS: ${major}.${minor}`);
              }
              this.connected = true;
              return;
            }
            default:
              this._fallthrough();
          }
        }
      }
      async _authSasl() {
        const numMethods = this.buffer.readInt32();
        if (numMethods <= 0) {
          throw new errors.ProtocolError("the server requested SASL authentication but did not offer any methods");
        }
        const methods = [];
        let foundScram256 = false;
        for (let _7 = 0; _7 < numMethods; _7++) {
          const method = this.buffer.readString();
          if (method === "SCRAM-SHA-256") {
            foundScram256 = true;
          }
          methods.push(method);
        }
        this.buffer.finishMessage();
        if (!foundScram256) {
          throw new errors.ProtocolError(`the server offered the following SASL authentication methods: ${methods.join(", ")}, neither are supported.`);
        }
        const clientNonce = scram.generateNonce();
        const [clientFirst, clientFirstBare] = scram.buildClientFirstMessage(clientNonce, this.config.connectionParams.user);
        const wb = new buffer_1.WriteMessageBuffer();
        wb.beginMessage(chars.$p).writeString("SCRAM-SHA-256").writeString(clientFirst).endMessage();
        this.sock.write(wb.unwrap());
        await this._ensureMessage(chars.$R, "SASLContinue");
        let status = this.buffer.readInt32();
        if (status !== AuthenticationStatuses.AUTH_SASL_CONTINUE) {
          throw new errors.ProtocolError(`expected SASLContinue from the server, received ${status}`);
        }
        const serverFirst = this.buffer.readString();
        this.buffer.finishMessage();
        const [serverNonce, salt, itercount] = scram.parseServerFirstMessage(serverFirst);
        const [clientFinal, expectedServerSig] = await scram.buildClientFinalMessage(this.config.connectionParams.password || "", salt, itercount, clientFirstBare, serverFirst, serverNonce);
        wb.reset().beginMessage(chars.$r).writeString(clientFinal).endMessage();
        this.sock.write(wb.unwrap());
        await this._ensureMessage(chars.$R, "SASLFinal");
        status = this.buffer.readInt32();
        if (status !== AuthenticationStatuses.AUTH_SASL_FINAL) {
          throw new errors.ProtocolError(`expected SASLFinal from the server, received ${status}`);
        }
        const serverFinal = this.buffer.readString();
        this.buffer.finishMessage();
        const serverSig = scram.parseServerFinalMessage(serverFinal);
        if (!scram.bufferEquals(serverSig, expectedServerSig)) {
          throw new errors.ProtocolError("server SCRAM proof does not match");
        }
      }
      async _ensureMessage(expectedMtype, err3) {
        if (!this.buffer.takeMessage()) {
          await this._waitForMessage();
        }
        const mtype = this.buffer.getMessageType();
        switch (mtype) {
          case chars.$E: {
            throw this._parseErrorMessage();
          }
          case expectedMtype: {
            return;
          }
          default: {
            throw new errors.UnexpectedMessageError(`expected ${err3} from the server, received ${chars.chr(mtype)}`);
          }
        }
      }
    };
    exports2.RawConnection = RawConnection;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/fetchConn.js
var require_fetchConn = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/fetchConn.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.FetchConnection = exports2.AdminUIFetchConnection = void 0;
    var baseConn_1 = require_baseConn();
    var codecs_1 = require_codecs();
    var errors_1 = require_errors();
    var ifaces_1 = require_ifaces2();
    var buffer_1 = require_buffer();
    var chars = __importStar(require_chars());
    var event_1 = __importDefault(require_event());
    var utils_1 = require_utils4();
    var PROTO_MIME = `application/x.edgedb.v_${baseConn_1.PROTO_VER[0]}_${baseConn_1.PROTO_VER[1]}.binary'`;
    var PROTO_MIME_RE = /application\/x\.edgedb\.v_(\d+)_(\d+)\.binary/;
    var STUDIO_CAPABILITIES = (baseConn_1.RESTRICTED_CAPABILITIES | baseConn_1.Capabilities.SESSION_CONFIG | baseConn_1.Capabilities.SET_GLOBAL) >>> 0;
    var BaseFetchConnection = class extends baseConn_1.BaseRawConnection {
      constructor(fetch3, registry) {
        super(registry);
        __publicField(this, "authenticatedFetch");
        __publicField(this, "abortSignal", null);
        this.authenticatedFetch = fetch3;
      }
      async _waitForMessage() {
        if (this.buffer.takeMessage()) {
          return;
        }
        if (this.messageWaiter == null || this.messageWaiter.done) {
          throw new errors_1.InternalClientError(`message waiter was not initialized before waiting for response`);
        }
        await this.messageWaiter.wait();
      }
      async __sendData(data) {
        if (this.buffer.takeMessage()) {
          const mtype = this.buffer.getMessageType();
          throw new errors_1.InternalClientError(`sending request before reading all data of the previous one: ${chars.chr(mtype)}`);
        }
        if (this.messageWaiter != null && !this.messageWaiter.done) {
          throw new errors_1.InternalClientError(`sending request before waiting for completion of the previous one`);
        }
        this.messageWaiter = new event_1.default();
        try {
          const resp = await this.authenticatedFetch("", {
            method: "post",
            body: data,
            headers: {
              "Content-Type": PROTO_MIME
            },
            signal: this.abortSignal
          });
          if (!resp.ok) {
            throw new errors_1.ProtocolError(`fetch failed with status code ${resp.status}: ${resp.statusText}`);
          }
          const contentType = resp.headers.get("content-type");
          const matchProtoVer = contentType?.match(PROTO_MIME_RE);
          if (matchProtoVer) {
            this.protocolVersion = [+matchProtoVer[1], +matchProtoVer[2]];
          }
          const respData = await resp.arrayBuffer();
          const buf = new Uint8Array(respData);
          try {
            this.buffer.feed(buf);
          } catch (e6) {
            this.messageWaiter.setError(e6);
          }
          if (!this.buffer.takeMessage()) {
            throw new errors_1.ProtocolError("no binary protocol messages in the response");
          }
          this.messageWaiter.set();
        } catch (e6) {
          this.messageWaiter.setError(e6);
        } finally {
          this.messageWaiter = null;
        }
      }
      _sendData(data) {
        this.__sendData(data);
      }
      async fetch(...args2) {
        const protoVer = this.protocolVersion;
        try {
          return await super.fetch(...args2);
        } catch (err3) {
          if (err3 instanceof errors_1.BinaryProtocolError && !(0, utils_1.versionEqual)(protoVer, this.protocolVersion)) {
            return await super.fetch(...args2);
          }
          throw err3;
        }
      }
      static create(fetch3, registry) {
        const conn = new this(fetch3, registry);
        conn.connected = true;
        conn.connWaiter.set();
        return conn;
      }
    };
    var AdminUIFetchConnection = class extends BaseFetchConnection {
      constructor() {
        super(...arguments);
        __publicField(this, "adminUIMode", true);
      }
      static create(fetch3, registry, knownServerVersion) {
        const conn = super.create(fetch3, registry);
        if (knownServerVersion && knownServerVersion[0] < 6) {
          conn.protocolVersion = [2, 0];
        }
        return conn;
      }
      async rawParse(language, query, state2, options, abortSignal) {
        this.abortSignal = abortSignal ?? null;
        const result = await this._parse(language, query, ifaces_1.OutputFormat.BINARY, ifaces_1.Cardinality.MANY, state2, STUDIO_CAPABILITIES, options);
        return [this.protocolVersion, ...result];
      }
      async rawExecute(language, query, state2, outCodec, options, inCodec, args2 = null, abortSignal) {
        this.abortSignal = abortSignal ?? null;
        const result = new buffer_1.WriteBuffer();
        const [warnings] = await this._executeFlow(language, query, args2, outCodec ? ifaces_1.OutputFormat.BINARY : ifaces_1.OutputFormat.NONE, ifaces_1.Cardinality.MANY, state2, inCodec ?? codecs_1.NULL_CODEC, outCodec ?? codecs_1.NULL_CODEC, result, STUDIO_CAPABILITIES, options);
        return [result.unwrap(), warnings];
      }
    };
    exports2.AdminUIFetchConnection = AdminUIFetchConnection;
    var FetchConnection = class _FetchConnection extends BaseFetchConnection {
      static createConnectWithTimeout(httpSCRAMAuth) {
        return async function connectWithTimeout(config, registry) {
          const fetch3 = await (0, utils_1.getAuthenticatedFetch)(config.connectionParams, httpSCRAMAuth);
          const conn = new _FetchConnection(fetch3, registry);
          conn.connected = true;
          conn.connWaiter.set();
          return conn;
        };
      }
    };
    exports2.FetchConnection = FetchConnection;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/httpScram.js
var require_httpScram = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/httpScram.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.getHTTPSCRAMAuth = getHTTPSCRAMAuth;
    var errors_1 = require_errors();
    var buffer_1 = require_buffer();
    var scram_1 = require_scram();
    var AUTH_ENDPOINT = "/auth/token";
    function getHTTPSCRAMAuth(cryptoUtils) {
      const { bufferEquals, generateNonce, buildClientFirstMessage, buildClientFinalMessage, parseServerFirstMessage, parseServerFinalMessage } = (0, scram_1.getSCRAM)(cryptoUtils);
      return async function HTTPSCRAMAuth(baseUrl, username, password) {
        const authUrl = baseUrl + AUTH_ENDPOINT;
        const clientNonce = generateNonce();
        const [clientFirst, clientFirstBare] = buildClientFirstMessage(clientNonce, username);
        const serverFirstRes = await fetch(authUrl, {
          headers: {
            Authorization: `SCRAM-SHA-256 data=${utf8ToB64(clientFirst)}`
          }
        });
        const authenticateHeader = serverFirstRes.headers.get("WWW-Authenticate");
        if (serverFirstRes.status !== 401 || !authenticateHeader) {
          const body2 = await serverFirstRes.text();
          throw new errors_1.ProtocolError(`authentication failed: ${body2}`);
        }
        if (!authenticateHeader.startsWith("SCRAM-SHA-256")) {
          throw new errors_1.ProtocolError(`unsupported authentication scheme: ${authenticateHeader}`);
        }
        const authParams = authenticateHeader.split(/ (.+)?/, 2)[1] ?? "";
        if (authParams.length === 0) {
          const body2 = await serverFirstRes.text();
          throw new errors_1.ProtocolError(`authentication failed: ${body2}`);
        }
        const { sid, data: serverFirst } = parseScramAttrs(authParams);
        if (!sid || !serverFirst) {
          throw new errors_1.ProtocolError(`authentication challenge missing attributes: expected "sid" and "data", got '${authParams}'`);
        }
        const [serverNonce, salt, iterCount] = parseServerFirstMessage(serverFirst);
        const [clientFinal, expectedServerSig] = await buildClientFinalMessage(password, salt, iterCount, clientFirstBare, serverFirst, serverNonce);
        const serverFinalRes = await fetch(authUrl, {
          headers: {
            Authorization: `SCRAM-SHA-256 sid=${sid}, data=${utf8ToB64(clientFinal)}`
          }
        });
        const authInfoHeader = serverFinalRes.headers.get("Authentication-Info");
        if (!serverFinalRes.ok || !authInfoHeader) {
          const body2 = await serverFinalRes.text();
          throw new errors_1.ProtocolError(`authentication failed: ${body2}`);
        }
        const { data: serverFinal, sid: sidFinal } = parseScramAttrs(authInfoHeader);
        if (!sidFinal || !serverFinal) {
          throw new errors_1.ProtocolError(`authentication info missing attributes: expected "sid" and "data", got '${authInfoHeader}'`);
        }
        if (sidFinal !== sid) {
          throw new errors_1.ProtocolError("SCRAM session id does not match");
        }
        const serverSig = parseServerFinalMessage(serverFinal);
        if (!bufferEquals(serverSig, expectedServerSig)) {
          throw new errors_1.ProtocolError("server SCRAM proof does not match");
        }
        const authToken = await serverFinalRes.text();
        return authToken;
      };
    }
    function utf8ToB64(str) {
      return (0, buffer_1.encodeB64)(buffer_1.utf8Encoder.encode(str));
    }
    function b64ToUtf8(str) {
      return buffer_1.utf8Decoder.decode((0, buffer_1.decodeB64)(str));
    }
    function parseScramAttrs(paramsStr) {
      const params = new Map(paramsStr.length > 0 ? paramsStr.split(",").map((attr) => attr.split(/=(.+)?/, 2)).map(([key, val2]) => [key.trim(), val2.trim()]) : []);
      const sid = params.get("sid") ?? null;
      const rawData = params.get("data");
      const data = rawData ? b64ToUtf8(rawData) : null;
      return { sid, data };
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/nodeClient.js
var require_nodeClient = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/nodeClient.js"(exports2) {
    "use strict";
    var __importDefault = exports2 && exports2.__importDefault || function(mod) {
      return mod && mod.__esModule ? mod : { "default": mod };
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createClient = createClient3;
    exports2.createHttpClient = createHttpClient;
    var baseClient_1 = require_baseClient();
    var conUtils_server_1 = require_conUtils_server();
    var options_1 = require_options();
    var rawConn_1 = require_rawConn();
    var fetchConn_1 = require_fetchConn();
    var httpScram_1 = require_httpScram();
    var cryptoUtils_1 = __importDefault(require_cryptoUtils());
    var ClientPool = class extends baseClient_1.BaseClientPool {
      constructor() {
        super(...arguments);
        __publicField(this, "isStateless", false);
        __publicField(this, "_connectWithTimeout", rawConn_1.RawConnection.connectWithTimeout.bind(rawConn_1.RawConnection));
      }
    };
    function createClient3(options) {
      return new baseClient_1.Client(new ClientPool(conUtils_server_1.parseConnectArguments, typeof options === "string" ? { dsn: options } : options ?? {}), options_1.Options.defaults());
    }
    var httpSCRAMAuth = (0, httpScram_1.getHTTPSCRAMAuth)(cryptoUtils_1.default);
    var FetchClientPool = class extends baseClient_1.BaseClientPool {
      constructor() {
        super(...arguments);
        __publicField(this, "isStateless", true);
        __publicField(this, "_connectWithTimeout", fetchConn_1.FetchConnection.createConnectWithTimeout(httpSCRAMAuth));
      }
    };
    function createHttpClient(options) {
      return new baseClient_1.Client(new FetchClientPool(conUtils_server_1.parseConnectArguments, typeof options === "string" ? { dsn: options } : options ?? {}), options_1.Options.defaults());
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/wkt.js
var require_wkt = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/datatypes/wkt.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.parseWKT = parseWKT;
    var postgis_1 = require_postgis();
    var sridRegex = /\s*SRID=([0-9]+)\s*;/iy;
    var endRegex = /\s*$/y;
    var geomTypes = [
      "POINT",
      "LINESTRING",
      "POLYGON",
      "MULTIPOINT",
      "MULTILINESTRING",
      "MULTIPOLYGON",
      "GEOMETRYCOLLECTION",
      "POLYHEDRALSURFACE",
      "TRIANGLE",
      "TIN",
      "CIRCULARSTRING",
      "COMPOUNDCURVE",
      "CURVEPOLYGON",
      "MULTICURVE",
      "MULTISURFACE"
    ];
    var geomTypeRegex = new RegExp(`\\s*(${geomTypes.join("|")})`, "iy");
    var zmFlagsRegex = /\s+(ZM|Z|M)/iy;
    var emptyOrOpenRegex = /\s+(EMPTY)|\s*\(/iy;
    var openRegex = /\s*\(/y;
    var closeRegex = /\s*\)/y;
    var commaRegex = /\s*,/y;
    var _num = "-?[0-9]+(?:\\.[0-9]+)?";
    var pointRegex = new RegExp(`\\s*(${_num})\\s+(${_num})(?:\\s+(${_num}))?(?:\\s+(${_num}))?`, "y");
    function parseWKT(wkt) {
      let i8 = 0;
      let hasZ = null;
      let hasM = null;
      let srid = null;
      sridRegex.lastIndex = i8;
      const _srid = sridRegex.exec(wkt);
      if (_srid) {
        srid = parseInt(_srid[1], 10);
        i8 += _srid[0].length;
      }
      const geom = _parseGeom();
      endRegex.lastIndex = i8;
      if (endRegex.exec(wkt) === null) {
        throw createParseError(wkt, i8, "expected end of wkt");
      }
      return geom;
      function _parseGeom(unnamedGeom = null, allowedGeoms = null) {
        geomTypeRegex.lastIndex = i8;
        const _geomType = geomTypeRegex.exec(wkt);
        const type = _geomType?.[1].toUpperCase() ?? unnamedGeom;
        if (!type || allowedGeoms && !allowedGeoms.includes(type)) {
          throw createParseError(wkt, i8, `expected one of ${(allowedGeoms ? ["(", ...allowedGeoms] : geomTypes).join(", ")}`);
        }
        i8 += _geomType?.[0].length ?? 0;
        if (_geomType !== null) {
          zmFlagsRegex.lastIndex = i8;
          const _zmFlags = zmFlagsRegex.exec(wkt);
          if (_zmFlags !== null) {
            const zm = _zmFlags[1].toLowerCase();
            hasZ = zm === "zm" || zm === "z";
            hasM = zm === "zm" || zm === "m";
            i8 += _zmFlags[0].length;
          } else {
            hasZ = null;
            hasM = null;
          }
        }
        const open = _geomType === null ? openRegex : emptyOrOpenRegex;
        open.lastIndex = i8;
        const _emptyOrOpen = open.exec(wkt);
        if (_emptyOrOpen === null) {
          throw createParseError(wkt, i8, _geomType === null ? `expected (` : `expected EMPTY or (`);
        }
        i8 += _emptyOrOpen[0].length;
        const empty = _emptyOrOpen[1] != null;
        let geom2;
        switch (type) {
          case "POINT":
            geom2 = _parsePoint(empty);
            break;
          case "LINESTRING":
          case "CIRCULARSTRING":
            geom2 = _parseLineString(empty, type === "CIRCULARSTRING" ? postgis_1.CircularString : postgis_1.LineString);
            break;
          case "POLYGON":
          case "TRIANGLE":
            geom2 = _parsePolygon(empty, type === "TRIANGLE" ? postgis_1.Triangle : postgis_1.Polygon);
            break;
          case "MULTIPOINT":
            geom2 = new postgis_1.MultiPoint(empty ? [] : _parseCommaSep(() => _parseBracketedGeom(_parsePoint)), hasZ ?? false, hasM ?? false, srid);
            break;
          case "MULTILINESTRING":
            geom2 = new postgis_1.MultiLineString(empty ? [] : _parseCommaSep(() => _parseBracketedGeom(_parseLineString)), hasZ ?? false, hasM ?? false, srid);
            break;
          case "MULTIPOLYGON":
          case "POLYHEDRALSURFACE":
          case "TIN":
            {
              const Geom = type === "TIN" ? postgis_1.TriangulatedIrregularNetwork : type === "POLYHEDRALSURFACE" ? postgis_1.PolyhedralSurface : postgis_1.MultiPolygon;
              geom2 = new Geom(empty ? [] : _parseCommaSep(() => _parseBracketedGeom(() => _parsePolygon(false, type === "TIN" ? postgis_1.Triangle : postgis_1.Polygon))), hasZ ?? false, hasM ?? false, srid);
            }
            break;
          case "GEOMETRYCOLLECTION": {
            geom2 = new postgis_1.GeometryCollection(empty ? [] : _checkDimensions(() => _parseCommaSep(_parseGeom)), hasZ ?? false, hasM ?? false, srid);
            break;
          }
          case "COMPOUNDCURVE":
            {
              const segments = empty ? [] : _checkDimensions(() => _parseCommaSep(() => _parseGeom("LINESTRING", ["LINESTRING", "CIRCULARSTRING"])));
              geom2 = new postgis_1.CompoundCurve(segments, hasZ ?? false, hasM ?? false, srid);
            }
            break;
          case "CURVEPOLYGON":
          case "MULTICURVE":
            {
              const rings = empty ? [] : _checkDimensions(() => _parseCommaSep(() => _parseGeom("LINESTRING", [
                "LINESTRING",
                "CIRCULARSTRING",
                "COMPOUNDCURVE"
              ])));
              const Geom = type === "MULTICURVE" ? postgis_1.MultiCurve : postgis_1.CurvePolygon;
              geom2 = new Geom(rings, hasZ ?? false, hasM ?? false, srid);
            }
            break;
          case "MULTISURFACE":
            {
              const surfaces = empty ? [] : _checkDimensions(() => _parseCommaSep(() => _parseGeom("POLYGON", ["POLYGON", "CURVEPOLYGON"])));
              geom2 = new postgis_1.MultiSurface(surfaces, hasZ ?? false, hasM ?? false, srid);
            }
            break;
          default:
            assertNever(type, `unknown geometry type ${type}`);
        }
        if (!empty) {
          closeRegex.lastIndex = i8;
          const _close2 = closeRegex.exec(wkt);
          if (_close2 === null) {
            throw createParseError(wkt, i8, `expected )`);
          }
          i8 += _close2[0].length;
        }
        return geom2;
      }
      function _parsePoint(empty = false) {
        if (empty) {
          return new postgis_1.Point(NaN, NaN, hasZ ? NaN : null, hasM ? NaN : null, srid);
        }
        pointRegex.lastIndex = i8;
        const coords = pointRegex.exec(wkt);
        if (coords === null) {
          throw createParseError(wkt, i8, `expected between 2 to 4 coordinates`);
        }
        const x11 = parseFloat(coords[1]);
        const y7 = parseFloat(coords[2]);
        const z6 = coords[3] ? parseFloat(coords[3]) : null;
        const m12 = coords[4] ? parseFloat(coords[4]) : null;
        if (hasZ === null) {
          hasZ = z6 !== null;
          hasM = m12 !== null;
        } else {
          if (m12 === null) {
            if (hasZ && hasM) {
              throw createParseError(wkt, i8, `expected M coordinate`);
            }
          } else {
            if (!hasM) {
              throw createParseError(wkt, i8, `unexpected M coordinate`);
            }
          }
          if (z6 === null) {
            if (hasZ || hasM) {
              throw createParseError(wkt, i8, `expected ${hasZ ? "Z" : "M"} coordinate`);
            }
          } else {
            if (!hasZ && (!hasM || m12 !== null)) {
              throw createParseError(wkt, i8, `unexpected Z coordinate`);
            }
          }
        }
        i8 += coords[0].length;
        return new postgis_1.Point(x11, y7, hasZ ? z6 : null, hasZ ? m12 : z6, srid);
      }
      function _parseLineString(empty = false, Geom = postgis_1.LineString) {
        return new Geom(empty ? [] : _parseCommaSep(_parsePoint), hasZ ?? false, hasM ?? false, srid);
      }
      function _parsePolygon(empty = false, Geom = postgis_1.Polygon) {
        return new Geom(empty ? [] : _parseCommaSep(() => _parseBracketedGeom(_parseLineString)), hasZ ?? false, hasM ?? false, srid);
      }
      function _parseCommaSep(parseGeom) {
        const geoms = [parseGeom()];
        while (true) {
          commaRegex.lastIndex = i8;
          const comma = commaRegex.exec(wkt);
          if (comma === null) {
            break;
          }
          i8 += comma[0].length;
          geoms.push(parseGeom());
        }
        return geoms;
      }
      function _parseBracketedGeom(parseGeom) {
        openRegex.lastIndex = i8;
        const open = openRegex.exec(wkt);
        if (open === null) {
          throw createParseError(wkt, i8, `expected (`);
        }
        i8 += open[0].length;
        const geom2 = parseGeom();
        closeRegex.lastIndex = i8;
        const close = closeRegex.exec(wkt);
        if (close === null) {
          throw createParseError(wkt, i8, `expected )`);
        }
        i8 += close[0].length;
        return geom2;
      }
      function _checkDimensions(parseChildren) {
        const parentZ = hasZ;
        const parentM = hasM;
        const geoms = parseChildren();
        hasZ = parentZ ?? geoms[0].hasZ ?? false;
        hasM = parentM ?? geoms[0].hasM ?? false;
        if (geoms.some((geom2) => geom2.hasZ !== hasZ || geom2.hasM !== hasM)) {
          throw createParseError(wkt, i8, `child geometries have mixed dimensions`);
        }
        return geoms;
      }
    }
    function createParseError(_wkt, index7, error2) {
      return new Error(`${error2} at position ${index7}`);
    }
    function assertNever(_type2, message) {
      throw new Error(message);
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/index.shared.js
var require_index_shared = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/index.shared.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m12, exports3) {
      for (var p11 in m12) if (p11 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p11)) __createBinding(exports3, m12, p11);
    };
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2._ReadBuffer = exports2._CodecsRegistry = exports2.throwWarnings = exports2.logWarnings = exports2.defaultBackoff = exports2.Options = exports2.RetryOptions = exports2.RetryCondition = exports2.IsolationLevel = exports2.parseWKT = exports2.Float16Array = exports2.SparseVector = exports2.MultiRange = exports2.Range = exports2.ConfigMemory = exports2.DateDuration = exports2.RelativeDuration = exports2.Duration = exports2.LocalTime = exports2.LocalDate = exports2.LocalDateTime = void 0;
    var datetime_1 = require_datetime();
    Object.defineProperty(exports2, "LocalDateTime", { enumerable: true, get: function() {
      return datetime_1.LocalDateTime;
    } });
    Object.defineProperty(exports2, "LocalDate", { enumerable: true, get: function() {
      return datetime_1.LocalDate;
    } });
    Object.defineProperty(exports2, "LocalTime", { enumerable: true, get: function() {
      return datetime_1.LocalTime;
    } });
    Object.defineProperty(exports2, "Duration", { enumerable: true, get: function() {
      return datetime_1.Duration;
    } });
    Object.defineProperty(exports2, "RelativeDuration", { enumerable: true, get: function() {
      return datetime_1.RelativeDuration;
    } });
    Object.defineProperty(exports2, "DateDuration", { enumerable: true, get: function() {
      return datetime_1.DateDuration;
    } });
    var memory_1 = require_memory();
    Object.defineProperty(exports2, "ConfigMemory", { enumerable: true, get: function() {
      return memory_1.ConfigMemory;
    } });
    var range_1 = require_range2();
    Object.defineProperty(exports2, "Range", { enumerable: true, get: function() {
      return range_1.Range;
    } });
    Object.defineProperty(exports2, "MultiRange", { enumerable: true, get: function() {
      return range_1.MultiRange;
    } });
    var pgvector_1 = require_pgvector();
    Object.defineProperty(exports2, "SparseVector", { enumerable: true, get: function() {
      return pgvector_1.SparseVector;
    } });
    var utils_1 = require_utils4();
    Object.defineProperty(exports2, "Float16Array", { enumerable: true, get: function() {
      return utils_1.Float16Array;
    } });
    __exportStar(require_postgis(), exports2);
    var wkt_1 = require_wkt();
    Object.defineProperty(exports2, "parseWKT", { enumerable: true, get: function() {
      return wkt_1.parseWKT;
    } });
    var options_1 = require_options();
    Object.defineProperty(exports2, "IsolationLevel", { enumerable: true, get: function() {
      return options_1.IsolationLevel;
    } });
    Object.defineProperty(exports2, "RetryCondition", { enumerable: true, get: function() {
      return options_1.RetryCondition;
    } });
    Object.defineProperty(exports2, "RetryOptions", { enumerable: true, get: function() {
      return options_1.RetryOptions;
    } });
    Object.defineProperty(exports2, "Options", { enumerable: true, get: function() {
      return options_1.Options;
    } });
    Object.defineProperty(exports2, "defaultBackoff", { enumerable: true, get: function() {
      return options_1.defaultBackoff;
    } });
    Object.defineProperty(exports2, "logWarnings", { enumerable: true, get: function() {
      return options_1.logWarnings;
    } });
    Object.defineProperty(exports2, "throwWarnings", { enumerable: true, get: function() {
      return options_1.throwWarnings;
    } });
    __exportStar(require_errors(), exports2);
    var reg = __importStar(require_registry());
    var buf = __importStar(require_buffer());
    exports2._CodecsRegistry = reg.CodecsRegistry;
    exports2._ReadBuffer = buf.ReadBuffer;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/typeutil.js
var require_typeutil = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/typeutil.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/strictMap.js
var require_strictMap = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/strictMap.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.StrictMapSet = exports2.StrictMap = void 0;
    var StrictMap = class extends Map {
      get(key) {
        if (!this.has(key)) {
          throw new Error(`key "${key}" is not found`);
        }
        return super.get(key);
      }
    };
    exports2.StrictMap = StrictMap;
    var StrictMapSet = class extends StrictMap {
      appendAt(key, value) {
        const set = this.has(key) ? this.get(key) : /* @__PURE__ */ new Set();
        set.add(value);
        this.set(key, set);
      }
    };
    exports2.StrictMapSet = StrictMapSet;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/reservedKeywords.js
var require_reservedKeywords = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/reservedKeywords.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.reservedKeywords = void 0;
    exports2.reservedKeywords = /* @__PURE__ */ new Set([
      "__edgedbsys__",
      "__edgedbtpl__",
      "__source__",
      "__std__",
      "__subject__",
      "__type__",
      "abort",
      "alter",
      "analyze",
      "and",
      "anyarray",
      "anytuple",
      "anytype",
      "anyobject",
      "begin",
      "case",
      "check",
      "commit",
      "configure",
      "create",
      "deallocate",
      "declare",
      "delete",
      "describe",
      "detached",
      "discard",
      "distinct",
      "do",
      "drop",
      "else",
      "empty",
      "end",
      "execute",
      "exists",
      "explain",
      "extending",
      "fetch",
      "filter",
      "for",
      "get",
      "global",
      "grant",
      "group",
      "if",
      "ilike",
      "import",
      "in",
      "insert",
      "introspect",
      "is",
      "like",
      "limit",
      "listen",
      "load",
      "lock",
      "match",
      "module",
      "move",
      "not",
      "notify",
      "offset",
      "optional",
      "or",
      "order",
      "over",
      "partition",
      "policy",
      "populate",
      "prepare",
      "raise",
      "refresh",
      "reindex",
      "release",
      "reset",
      "revoke",
      "rollback",
      "select",
      "set",
      "single",
      "start",
      "typeof",
      "union",
      "update",
      "variadic",
      "when",
      "window",
      "with"
    ]);
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/types.js
var require_types = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/types.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.typeMapping = void 0;
    exports2.getTypes = getTypes;
    exports2.types = getTypes;
    exports2.topoSort = topoSort;
    exports2.getTypes = getTypes;
    exports2.types = getTypes;
    var strictMap_1 = require_strictMap();
    var numberType2 = {
      id: "00000000-0000-0000-0000-0000000001ff",
      name: "std::number",
      is_abstract: false,
      is_seq: false,
      kind: "scalar",
      enum_values: null,
      material_id: null,
      bases: []
    };
    exports2.typeMapping = /* @__PURE__ */ new Map([
      [
        "00000000-0000-0000-0000-000000000103",
        numberType2
      ],
      [
        "00000000-0000-0000-0000-000000000104",
        numberType2
      ],
      [
        "00000000-0000-0000-0000-000000000105",
        numberType2
      ],
      [
        "00000000-0000-0000-0000-000000000106",
        numberType2
      ],
      [
        "00000000-0000-0000-0000-000000000107",
        numberType2
      ]
    ]);
    async function getTypes(cxn, params) {
      const debug = params?.debug === true;
      const version3 = await cxn.queryRequiredSingle(`select sys::get_version().major;`);
      const v2Plus = version3 >= 2;
      const v4Plus = version3 >= 4;
      const QUERY = `
    WITH
      MODULE schema,

      material_scalars := (
        SELECT ScalarType
        FILTER NOT .abstract
           AND NOT EXISTS .enum_values
           AND NOT EXISTS (SELECT .ancestors FILTER NOT .abstract)
      )

    SELECT Type {
      id,
      name :=
        array_join(array_agg([IS ObjectType].union_of.name), ' | ')
        IF EXISTS [IS ObjectType].union_of
        ELSE .name,
      is_abstract := .abstract,

      kind := 'object' IF Type IS ObjectType ELSE
              'scalar' IF Type IS ScalarType ELSE
              'array' IF Type IS Array ELSE
              'tuple' IF Type IS Tuple ELSE
              ${v2Plus ? `'range' IF Type IS Range ELSE` : ``}
              ${v4Plus ? `'multirange' IF Type IS MultiRange ELSE` : ``}
              'unknown',

      [IS ScalarType].enum_values,
      is_seq := 'std::sequence' in [IS ScalarType].ancestors.name,
      # for sequence (abstract type that has non-abstract ancestor)
      single material_id := (
        SELECT x := Type[IS ScalarType].ancestors
        FILTER x IN material_scalars
        LIMIT 1
      ).id,

      [IS InheritingObject].bases: {
        id
      } ORDER BY @index ASC,

      [IS ObjectType].union_of,
      [IS ObjectType].intersection_of,
      [IS ObjectType].pointers: {
        card := ("One" IF .required ELSE "AtMostOne") IF <str>.cardinality = "One" ELSE ("AtLeastOne" IF .required ELSE "Many"),
        name,
        target_id := .target.id,
        kind := 'link' IF .__type__.name = 'schema::Link' ELSE 'property',
        is_exclusive := exists (select .constraints filter .name = 'std::exclusive'),
        is_computed := len(.computed_fields) != 0,
        is_readonly := .readonly,
        has_default := EXISTS .default or ("std::sequence" in .target[IS ScalarType].ancestors.name),
        [IS Link].pointers: {
          card := ("One" IF .required ELSE "AtMostOne") IF <str>.cardinality = "One" ELSE ("AtLeastOne" IF .required ELSE "Many"),
          name := '@' ++ .name,
          target_id := .target.id,
          kind := 'link' IF .__type__.name = 'schema::Link' ELSE 'property',
          is_computed := len(.computed_fields) != 0,
          is_readonly := .readonly
        } filter .name != '@source' and .name != '@target',
      } FILTER any(@is_owned),
      exclusives := assert_distinct((
        [is schema::ObjectType].constraints
        union
        [is schema::ObjectType].pointers.constraints
      ) {
        target := (.subject[is schema::Property].name ?? .subject[is schema::Link].name ?? .subjectexpr)
      } filter .name = 'std::exclusive'),
      backlinks := (
         SELECT DETACHED Link
         FILTER .target = Type
           AND NOT EXISTS .source[IS ObjectType].union_of
        ) {
        card := "AtMostOne"
          IF
          EXISTS (select .constraints filter .name = 'std::exclusive')
          ELSE
          "Many",
        name := '<' ++ .name ++ '[is ' ++ assert_exists(.source.name) ++ ']',
        stub := .name,
        target_id := .source.id,
        kind := 'link',
        is_exclusive := (EXISTS (select .constraints filter .name = 'std::exclusive')) AND <str>.cardinality = "One",
      },
      backlink_stubs := array_agg((
        WITH
          stubs := DISTINCT (SELECT DETACHED Link FILTER .target = Type).name,
          baseObjectId := (SELECT DETACHED ObjectType FILTER .name = 'std::BaseObject' LIMIT 1).id
        FOR stub in { stubs }
        UNION (
          SELECT {
            card := "Many",
            name := '<' ++ stub,
            target_id := baseObjectId,
            kind := 'link',
            is_exclusive := false,
          }
        )
      )),
      array_element_id := [IS Array].element_type.id,

      tuple_elements := (SELECT [IS Tuple].element_types {
        target_id := .type.id,
        name
      } ORDER BY @index ASC),
      ${v2Plus ? `range_element_id := [IS Range].element_type.id,` : ``}
      ${v4Plus ? `multirange_element_id := [IS MultiRange].element_type.id,` : ``}
    }
    ORDER BY .name;
  `;
      const _types = JSON.parse(await cxn.queryJSON(QUERY));
      if (debug)
        console.log(JSON.stringify(_types, null, 2));
      for (const type of _types) {
        if (Array.isArray(type.backlinks)) {
          for (const backlink of type.backlinks) {
            const isName = backlink.name.match(/\[is (.+)\]/)[1];
            if (isName.split("::").length === 2 && isName.startsWith("default::")) {
              backlink.name = backlink.name.replace(/\[is (.+)\]/, `[is ${isName.slice(9)}]`);
            }
          }
        }
        switch (type.kind) {
          case "scalar":
            if (exports2.typeMapping.has(type.id)) {
              type.cast_type = exports2.typeMapping.get(type.id).id;
            }
            if (type.is_seq) {
              type.cast_type = numberType2.id;
            }
            if (type.name !== "std::sequence" && type.bases[0]?.id === type.material_id) {
              type.cast_type = exports2.typeMapping.get(type.material_id)?.id ?? type.material_id;
            }
            break;
          case "multirange":
            type.multirange_element_id = exports2.typeMapping.get(type.multirange_element_id)?.id ?? type.multirange_element_id;
            break;
          case "range":
            type.range_element_id = exports2.typeMapping.get(type.range_element_id)?.id ?? type.range_element_id;
            break;
          case "object": {
            const ptrs = {};
            for (const ptr of type.pointers) {
              ptrs[ptr.name] = ptr;
            }
            const rawExclusives = type.exclusives;
            const exclusives = [];
            for (const ex of rawExclusives) {
              const target = ex.target;
              if (target in ptrs) {
                exclusives.push({ [ex.target]: ptrs[ex.target] });
              }
              if (target[0] === "(" && target[target.length - 1] === ")") {
                const targets = target.slice(1, -1).split(" ").map((t6) => {
                  t6 = t6.trim();
                  if (t6[0] === ".")
                    t6 = t6.slice(1);
                  if (t6[t6.length - 1] === ",")
                    t6 = t6.slice(0, -1);
                  return t6;
                });
                const newEx = {};
                if (!targets.every((t6) => t6 in ptrs)) {
                  continue;
                }
                for (const t6 of targets) {
                  newEx[t6] = ptrs[t6];
                }
                exclusives.push(newEx);
              }
            }
            type.exclusives = exclusives;
            break;
          }
        }
      }
      _types.push(numberType2);
      const types6 = topoSort(_types);
      for (const [_7, type] of types6) {
        if (type.kind === "object" && type.union_of.length) {
          const unionTypes = type.union_of.map(({ id }) => {
            const t6 = types6.get(id);
            if (t6.kind !== "object") {
              throw new Error(`type '${t6.name}' of union '${type.name}' is not an object type`);
            }
            return t6;
          });
          const [first, ...rest] = unionTypes;
          const restPointerNames = rest.map((t6) => new Set(t6.pointers.map((p11) => p11.name)));
          for (const pointer of first.pointers) {
            if (restPointerNames.every((names) => names.has(pointer.name))) {
              type.pointers.push(pointer);
            }
          }
          type.backlinks = [];
          type.backlink_stubs = [];
        }
      }
      return types6;
    }
    function topoSort(types6) {
      const graph = new strictMap_1.StrictMap();
      const adj = new strictMap_1.StrictMap();
      for (const type of types6) {
        graph.set(type.id, type);
      }
      for (const type of types6) {
        if (type.kind !== "object" && type.kind !== "scalar") {
          continue;
        }
        for (const { id: base } of type.bases) {
          if (!graph.has(base)) {
            throw new Error(`reference to an unknown object type: ${base}`);
          }
          if (!adj.has(type.id)) {
            adj.set(type.id, /* @__PURE__ */ new Set());
          }
          adj.get(type.id).add(base);
        }
      }
      const visiting = /* @__PURE__ */ new Set();
      const visited = /* @__PURE__ */ new Set();
      const sorted = new strictMap_1.StrictMap();
      const visit = (type) => {
        if (visiting.has(type.name)) {
          const last = Array.from(visiting).slice(1, 2);
          throw new Error(`dependency cycle between ${type.name} and ${last}`);
        }
        if (!visited.has(type.id)) {
          visiting.add(type.name);
          if (adj.has(type.id)) {
            for (const adjId of adj.get(type.id).values()) {
              visit(graph.get(adjId));
            }
          }
          sorted.set(type.id, type);
          visited.add(type.id);
          visiting.delete(type.name);
        }
      };
      for (const type of types6) {
        visit(type);
      }
      return sorted;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/casts.js
var require_casts = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/casts.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.casts = void 0;
    var types_1 = require_types();
    var reachableFrom = (source, adj, seen = /* @__PURE__ */ new Set()) => {
      const reachable = /* @__PURE__ */ new Set();
      if (seen.has(source))
        return [];
      seen.add(source);
      (adj[source] || []).map((cast2) => {
        reachable.add(cast2);
        for (const item of reachableFrom(cast2, adj, seen)) {
          reachable.add(item);
        }
      });
      return [...reachable];
    };
    var casts = async (cxn, params) => {
      const allCastsRaw = await cxn.queryJSON(`WITH MODULE schema
        SELECT Cast {
            id,
            source := .from_type { id, name },
            target := .to_type { id, name },
            allow_assignment,
            allow_implicit,
        }
        FILTER .from_type IS ScalarType
        AND .to_type IS ScalarType
        # AND .from_type.is_abstract = false
        # AND .to_type.is_abstract = false
        `);
      const allCasts = JSON.parse(allCastsRaw);
      const types6 = /* @__PURE__ */ new Set();
      const typesById = {};
      const castsById = {};
      const castsBySource = {};
      const implicitCastsBySource = {};
      const implicitCastsByTarget = {};
      const assignmentCastsBySource = {};
      const assignmentCastsByTarget = {};
      for (const cast2 of allCasts) {
        if (types_1.typeMapping.has(cast2.source.id) || types_1.typeMapping.has(cast2.target.id)) {
          cast2.allow_implicit = false;
          cast2.allow_assignment = false;
        }
        typesById[cast2.source.id] = cast2.source;
        typesById[cast2.target.id] = cast2.target;
        types6.add(cast2.source.id);
        types6.add(cast2.target.id);
        castsById[cast2.id] = cast2;
        castsBySource[cast2.source.id] = castsBySource[cast2.source.id] || [];
        castsBySource[cast2.source.id].push(cast2.target.id);
        if (cast2.allow_assignment || cast2.allow_implicit) {
          assignmentCastsBySource[cast2.source.id] ??= [];
          assignmentCastsBySource[cast2.source.id].push(cast2.target.id);
          assignmentCastsByTarget[cast2.target.id] ??= [];
          assignmentCastsByTarget[cast2.target.id].push(cast2.source.id);
        }
        if (cast2.allow_implicit) {
          implicitCastsBySource[cast2.source.id] ??= [];
          implicitCastsBySource[cast2.source.id].push(cast2.target.id);
          implicitCastsByTarget[cast2.target.id] ??= [];
          implicitCastsByTarget[cast2.target.id].push(cast2.source.id);
        }
      }
      const castMap = {};
      const implicitCastMap = {};
      const implicitCastFromMap = {};
      const assignmentCastMap = {};
      const assignableByMap = {};
      for (const type of [...types6]) {
        castMap[type] = castsBySource[type] || [];
        implicitCastMap[type] = reachableFrom(type, implicitCastsBySource);
        implicitCastFromMap[type] = reachableFrom(type, implicitCastsByTarget);
        assignmentCastMap[type] = reachableFrom(type, assignmentCastsBySource);
        assignableByMap[type] = reachableFrom(type, assignmentCastsByTarget);
      }
      if (params?.debug === true) {
        console.log(`
IMPLICIT`);
        for (const [fromId, castArr] of Object.entries(implicitCastMap)) {
          console.log(`${typesById[fromId].name} implicitly castable to: [${castArr.map((id) => typesById[id].name).join(", ")}]`);
        }
        console.log("");
        for (const [fromId, castArr] of Object.entries(implicitCastFromMap)) {
          console.log(`${typesById[fromId].name} implicitly castable from: [${castArr.map((id) => typesById[id].name).join(", ")}]`);
        }
        console.log(`
ASSIGNABLE TO`);
        for (const [fromId, castArr] of Object.entries(assignmentCastMap)) {
          console.log(`${typesById[fromId].name} assignable to: [${castArr.map((id) => typesById[id].name).join(", ")}]`);
        }
        console.log(`
ASSIGNABLE BY`);
        for (const [fromId, castArr] of Object.entries(assignableByMap)) {
          console.log(`${typesById[fromId].name} assignable by: [${castArr.map((id) => typesById[id].name).join(", ")}]`);
        }
        console.log(`
EXPLICIT`);
        for (const [fromId, castArr] of Object.entries(castMap)) {
          console.log(`${typesById[fromId].name} castable to: [${castArr.map((id) => {
            return typesById[id].name;
          }).join(", ")}]`);
        }
      }
      return {
        castsById,
        typesById,
        castMap,
        implicitCastMap,
        implicitCastFromMap,
        assignmentCastMap,
        assignableByMap
      };
    };
    exports2.casts = casts;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/functions.js
var require_functions = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/functions.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.functions = void 0;
    exports2.replaceNumberTypes = replaceNumberTypes;
    var strictMap_1 = require_strictMap();
    var types_1 = require_types();
    var functions = async (cxn) => {
      const functionsJson = await cxn.queryJSON(`
    with module schema
    select Function {
      id,
      name,
      annotations: {
        name,
        @value
      } filter .name = 'std::description',
      return_type: {id, name},
      return_typemod,
      params: {
        name,
        type: {id, name},
        kind,
        typemod,
        hasDefault := exists .default,
      } order by @index,
      preserves_optionality,
    } filter .internal = false
  `);
      const functionMap = new strictMap_1.StrictMap();
      const seenFuncDefHashes = /* @__PURE__ */ new Set();
      for (const func2 of JSON.parse(functionsJson)) {
        const { name: name3 } = func2;
        const funcDef = {
          ...func2,
          description: func2.annotations[0]?.["@value"]
        };
        replaceNumberTypes(funcDef);
        const hash = hashFuncDef(funcDef);
        if (!seenFuncDefHashes.has(hash)) {
          if (!functionMap.has(name3)) {
            functionMap.set(name3, [funcDef]);
          } else {
            functionMap.get(name3).push(funcDef);
          }
          seenFuncDefHashes.add(hash);
        }
      }
      return functionMap;
    };
    exports2.functions = functions;
    function replaceNumberTypes(def) {
      if (types_1.typeMapping.has(def.return_type.id)) {
        const type = types_1.typeMapping.get(def.return_type.id);
        def.return_type = {
          id: type.id,
          name: type.name
        };
      }
      for (const param2 of def.params) {
        if (types_1.typeMapping.has(param2.type.id)) {
          const type = types_1.typeMapping.get(param2.type.id);
          param2.type = {
            id: type.id,
            name: type.name
          };
        }
      }
    }
    function hashFuncDef(def) {
      return JSON.stringify({
        name: def.name,
        return_type: def.return_type.id,
        return_typemod: def.return_typemod,
        params: def.params.map((param2) => JSON.stringify({
          kind: param2.kind,
          type: param2.type.id,
          typemod: param2.typemod,
          hasDefault: !!param2.hasDefault
        })).sort(),
        preserves_optionality: def.preserves_optionality
      });
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/globals.js
var require_globals = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/globals.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.globals = globals;
    async function globals(cxn) {
      const globalsMap = /* @__PURE__ */ new Map();
      const version3 = await cxn.queryRequiredSingle(`select sys::get_version().major;`);
      if (version3 === 1) {
        return globalsMap;
      }
      const QUERY = `
    WITH
      MODULE schema
    SELECT schema::Global {
      id,
      name,
      target_id := .target.id,
      card := ("One" IF .required ELSE "One" IF EXISTS .default ELSE "AtMostOne")
        IF <str>.cardinality = "One" ELSE
        ("AtLeastOne" IF .required ELSE "Many"),
      has_default := exists .default,
    }
    ORDER BY .name;
  `;
      const allGlobals = JSON.parse(await cxn.queryJSON(QUERY));
      for (const g10 of allGlobals) {
        globalsMap.set(g10.id, g10);
      }
      return globalsMap;
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/operators.js
var require_operators = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/operators.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.operators = void 0;
    var strictMap_1 = require_strictMap();
    var functions_1 = require_functions();
    var util_1 = require_util3();
    var _operators = async (cxn) => {
      const operatorsJson = await cxn.queryJSON(`
    with module schema
    select Operator {
      id,
      name,
      annotations: {
        name,
        @value
      } filter .name in {'std::identifier', 'std::description'},
      operator_kind,
      return_type: {id, name},
      return_typemod,
      params: {
        name,
        type: {id, name},
        kind,
        typemod,
      } order by @index,
    } filter not .internal and not .abstract
  `);
      const operators = new strictMap_1.StrictMap();
      const seenOpDefHashes = /* @__PURE__ */ new Set();
      for (const op of JSON.parse(operatorsJson)) {
        const identifier = op.annotations.find((anno) => anno.name === "std::identifier")?.["@value"];
        if (!identifier) {
          continue;
        }
        const { mod } = util_1.util.splitName(op.name);
        const name3 = `${mod}::${identifier}`;
        const opDef = {
          ...op,
          name: name3,
          kind: op.operator_kind,
          originalName: op.name,
          description: op.annotations.find((anno) => anno.name === "std::description")?.["@value"],
          annotations: void 0
        };
        (0, functions_1.replaceNumberTypes)(opDef);
        const hash = hashOpDef(opDef);
        if (!seenOpDefHashes.has(hash)) {
          if (!operators.has(name3)) {
            operators.set(name3, [opDef]);
          } else {
            operators.get(name3).push(opDef);
          }
          seenOpDefHashes.add(hash);
        }
      }
      return operators;
    };
    exports2.operators = _operators;
    function hashOpDef(def) {
      return JSON.stringify({
        name: def.name,
        return_type: def.return_type.id,
        return_typemod: def.return_typemod,
        params: def.params.map((param2) => JSON.stringify({
          kind: param2.kind,
          type: param2.type.id,
          typemod: param2.typemod,
          hasDefault: !!param2.hasDefault
        })).sort(),
        operator_kind: def.operator_kind
      });
    }
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/scalars.js
var require_scalars = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries/scalars.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.scalars = void 0;
    var strictMap_1 = require_strictMap();
    var _scalars = async (cxn) => {
      const scalarArray = await cxn.queryJSON(`with module schema
select InheritingObject {
  id,
  name,
  is_abstract,
  bases: { id, name },
  ancestors: { id, name },
  children := .<bases[IS Type] { id, name },
  descendants := .<ancestors[IS Type] { id, name }
}
FILTER
  InheritingObject IS ScalarType OR
  InheritingObject IS ObjectType;
`);
      const scalars = new strictMap_1.StrictMap();
      for (const type of JSON.parse(scalarArray)) {
        scalars.set(type.id, type);
      }
      return scalars;
    };
    exports2.scalars = _scalars;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries.js
var require_queries = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/queries.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m12, exports3) {
      for (var p11 in m12) if (p11 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p11)) __createBinding(exports3, m12, p11);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    __exportStar(require_casts(), exports2);
    __exportStar(require_functions(), exports2);
    __exportStar(require_globals(), exports2);
    __exportStar(require_operators(), exports2);
    __exportStar(require_scalars(), exports2);
    __exportStar(require_types(), exports2);
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/analyzeQuery.js
var require_analyzeQuery = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/analyzeQuery.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.ImportMap = exports2.defaultApplyCardinalityToTsType = exports2.generateTsObjectField = exports2.generateTsObject = exports2.defaultCodecGenerators = exports2.defineCodecGeneratorTuple = exports2.generateTSTypeFromCodec = void 0;
    exports2.analyzeQuery = analyzeQuery;
    var array_1 = require_array();
    var enum_1 = require_enum();
    var ifaces_1 = require_ifaces();
    var namedtuple_1 = require_namedtuple();
    var object_1 = require_object();
    var range_1 = require_range3();
    var codecs_1 = require_codecs();
    var set_1 = require_set();
    var tuple_1 = require_tuple();
    var enums_1 = require_enums();
    var util_1 = require_util3();
    async function analyzeQuery(client, query) {
      const { cardinality, capabilities, in: inCodec, out: outCodec } = await client.describe(query);
      const args2 = (0, exports2.generateTSTypeFromCodec)(inCodec, enums_1.Cardinality.One, {
        optionalNulls: true,
        readonly: true
      });
      const result = (0, exports2.generateTSTypeFromCodec)(outCodec, cardinality);
      const imports = args2.imports.merge(result.imports);
      return {
        result: result.type,
        args: args2.type,
        cardinality,
        capabilities,
        query,
        importMap: imports,
        imports: imports.get("gel") ?? /* @__PURE__ */ new Set()
      };
    }
    var generateTSTypeFromCodec = (codec, cardinality = enums_1.Cardinality.One, options = {}) => {
      const optionsWithDefaults = {
        indent: "",
        optionalNulls: false,
        readonly: false,
        ...options
      };
      const context = {
        ...optionsWithDefaults,
        generators: exports2.defaultCodecGenerators,
        applyCardinality: (0, exports2.defaultApplyCardinalityToTsType)(optionsWithDefaults),
        ...options,
        imports: new ImportMap(),
        walk: (codec2, innerContext) => {
          innerContext ??= context;
          for (const [type2, generator] of innerContext.generators) {
            if (codec2 instanceof type2) {
              return generator(codec2, innerContext);
            }
          }
          throw new Error(`Unexpected codec kind: ${codec2.getKind()}`);
        }
      };
      const type = context.applyCardinality(context.walk(codec, context), cardinality);
      return {
        type,
        imports: context.imports
      };
    };
    exports2.generateTSTypeFromCodec = generateTSTypeFromCodec;
    var genDef = (codecType, generator) => [codecType, generator];
    exports2.defineCodecGeneratorTuple = genDef;
    exports2.defaultCodecGenerators = new Map([
      genDef(codecs_1.NullCodec, () => "null"),
      genDef(enum_1.EnumCodec, (codec) => {
        return `(${codec.values.map((val2) => JSON.stringify(val2)).join(" | ")})`;
      }),
      genDef(ifaces_1.ScalarCodec, (codec, ctx) => {
        if (codec.tsModule) {
          ctx.imports.add(codec.tsModule, codec.tsType);
        }
        return codec.tsType;
      }),
      genDef(object_1.ObjectCodec, (codec, ctx) => {
        const subCodecs = codec.getSubcodecs();
        const fields = codec.getFields().map((field, i8) => ({
          name: field.name,
          codec: subCodecs[i8],
          cardinality: util_1.util.parseCardinality(field.cardinality)
        }));
        return (0, exports2.generateTsObject)(fields, ctx);
      }),
      genDef(namedtuple_1.NamedTupleCodec, (codec, ctx) => {
        const subCodecs = codec.getSubcodecs();
        const fields = codec.getNames().map((name3, i8) => ({
          name: name3,
          codec: subCodecs[i8],
          cardinality: enums_1.Cardinality.One
        }));
        return (0, exports2.generateTsObject)(fields, ctx);
      }),
      genDef(tuple_1.TupleCodec, (codec, ctx) => {
        const subCodecs = codec.getSubcodecs().map((subCodec) => ctx.walk(subCodec));
        const tuple = `[${subCodecs.join(", ")}]`;
        return ctx.readonly ? `(readonly ${tuple})` : tuple;
      }),
      genDef(array_1.ArrayCodec, (codec, ctx) => ctx.applyCardinality(ctx.walk(codec.getSubcodecs()[0]), enums_1.Cardinality.Many)),
      genDef(range_1.RangeCodec, (codec, ctx) => {
        const subCodec = codec.getSubcodecs()[0];
        if (!(subCodec instanceof ifaces_1.ScalarCodec)) {
          throw Error("expected range subtype to be scalar type");
        }
        ctx.imports.add(codec.tsModule, codec.tsType);
        return `${codec.tsType}<${ctx.walk(subCodec)}>`;
      }),
      genDef(range_1.MultiRangeCodec, (codec, ctx) => {
        const subCodec = codec.getSubcodecs()[0];
        if (!(subCodec instanceof ifaces_1.ScalarCodec)) {
          throw Error("expected multirange subtype to be scalar type");
        }
        ctx.imports.add(codec.tsModule, codec.tsType);
        return `${codec.tsType}<${ctx.walk(subCodec)}>`;
      })
    ]);
    var generateTsObject = (fields, ctx) => {
      const properties = fields.map((field) => (0, exports2.generateTsObjectField)(field, ctx));
      return `{
${properties.join("\n")}
${ctx.indent}}`;
    };
    exports2.generateTsObject = generateTsObject;
    var generateTsObjectField = (field, ctx) => {
      const codec = unwrapSetCodec(field.codec, field.cardinality);
      const name3 = JSON.stringify(field.name);
      const value = ctx.applyCardinality(ctx.walk(codec, { ...ctx, indent: ctx.indent + "  " }), field.cardinality);
      const optional = ctx.optionalNulls && field.cardinality === enums_1.Cardinality.AtMostOne;
      const questionMark = optional ? "?" : "";
      const isReadonly = ctx.readonly ? "readonly " : "";
      return `${ctx.indent}  ${isReadonly}${name3}${questionMark}: ${value};`;
    };
    exports2.generateTsObjectField = generateTsObjectField;
    function unwrapSetCodec(codec, cardinality) {
      if (!(codec instanceof set_1.SetCodec)) {
        return codec;
      }
      if (cardinality === enums_1.Cardinality.Many || cardinality === enums_1.Cardinality.AtLeastOne) {
        return codec.getSubcodecs()[0];
      }
      throw new Error("Sub-codec is SetCodec, but upper cardinality is one");
    }
    var defaultApplyCardinalityToTsType = (ctx) => (type, cardinality) => {
      switch (cardinality) {
        case enums_1.Cardinality.Many:
          return `${ctx.readonly ? "Readonly" : ""}Array<${type}>`;
        case enums_1.Cardinality.One:
          return type;
        case enums_1.Cardinality.AtMostOne:
          return `${type} | null`;
        case enums_1.Cardinality.AtLeastOne: {
          const tuple = `[(${type}), ...(${type})[]]`;
          return ctx.readonly ? `(readonly ${tuple})` : tuple;
        }
      }
      throw new Error(`Unexpected cardinality: ${cardinality}`);
    };
    exports2.defaultApplyCardinalityToTsType = defaultApplyCardinalityToTsType;
    var ImportMap = class _ImportMap extends Map {
      add(module3, specifier) {
        if (!this.has(module3)) {
          this.set(module3, /* @__PURE__ */ new Set());
        }
        this.get(module3).add(specifier);
        return this;
      }
      merge(map2) {
        const out2 = new _ImportMap();
        for (const [mod, specifiers] of [...this, ...map2]) {
          for (const specifier of specifiers) {
            out2.add(mod, specifier);
          }
        }
        return out2;
      }
    };
    exports2.ImportMap = ImportMap;
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/index.js
var require_reflection = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/reflection/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __exportStar = exports2 && exports2.__exportStar || function(m12, exports3) {
      for (var p11 in m12) if (p11 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p11)) __createBinding(exports3, m12, p11);
    };
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.Capabilities = exports2.introspect = void 0;
    __exportStar(require_enums(), exports2);
    __exportStar(require_util3(), exports2);
    __exportStar(require_typeutil(), exports2);
    __exportStar(require_util3(), exports2);
    __exportStar(require_strictMap(), exports2);
    __exportStar(require_reservedKeywords(), exports2);
    exports2.introspect = __importStar(require_queries());
    __exportStar(require_analyzeQuery(), exports2);
    var baseConn_1 = require_baseConn();
    Object.defineProperty(exports2, "Capabilities", { enumerable: true, get: function() {
      return baseConn_1.Capabilities;
    } });
  }
});

// ../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/index.node.js
var require_index_node = __commonJS({
  "../node_modules/.pnpm/gel@2.1.0/node_modules/gel/dist/index.node.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    var __exportStar = exports2 && exports2.__exportStar || function(m12, exports3) {
      for (var p11 in m12) if (p11 !== "default" && !Object.prototype.hasOwnProperty.call(exports3, p11)) __createBinding(exports3, m12, p11);
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.$ = exports2.Client = exports2.ResolvedConnectConfig = exports2._RawConnection = exports2.systemUtils = exports2.createHttpClient = exports2.createClient = void 0;
    var nodeClient_1 = require_nodeClient();
    exports2.default = nodeClient_1.createClient;
    var nodeClient_2 = require_nodeClient();
    Object.defineProperty(exports2, "createClient", { enumerable: true, get: function() {
      return nodeClient_2.createClient;
    } });
    Object.defineProperty(exports2, "createHttpClient", { enumerable: true, get: function() {
      return nodeClient_2.createHttpClient;
    } });
    var systemUtils = __importStar(require_systemUtils());
    exports2.systemUtils = systemUtils;
    var rawConn_1 = require_rawConn();
    Object.defineProperty(exports2, "_RawConnection", { enumerable: true, get: function() {
      return rawConn_1.RawConnection;
    } });
    var conUtils_1 = require_conUtils();
    Object.defineProperty(exports2, "ResolvedConnectConfig", { enumerable: true, get: function() {
      return conUtils_1.ResolvedConnectConfig;
    } });
    var baseClient_1 = require_baseClient();
    Object.defineProperty(exports2, "Client", { enumerable: true, get: function() {
      return baseClient_1.Client;
    } });
    __exportStar(require_index_shared(), exports2);
    exports2.$ = __importStar(require_reflection());
  }
});

// ../node_modules/.pnpm/sqlstring@2.3.3/node_modules/sqlstring/lib/SqlString.js
var require_SqlString = __commonJS({
  "../node_modules/.pnpm/sqlstring@2.3.3/node_modules/sqlstring/lib/SqlString.js"(exports2) {
    "use strict";
    var SqlString = exports2;
    var ID_GLOBAL_REGEXP = /`/g;
    var QUAL_GLOBAL_REGEXP = /\./g;
    var CHARS_GLOBAL_REGEXP = /[\0\b\t\n\r\x1a\"\'\\]/g;
    var CHARS_ESCAPE_MAP = {
      "\0": "\\0",
      "\b": "\\b",
      "	": "\\t",
      "\n": "\\n",
      "\r": "\\r",
      "": "\\Z",
      '"': '\\"',
      "'": "\\'",
      "\\": "\\\\"
    };
    SqlString.escapeId = function escapeId(val2, forbidQualified) {
      if (Array.isArray(val2)) {
        var sql3 = "";
        for (var i8 = 0; i8 < val2.length; i8++) {
          sql3 += (i8 === 0 ? "" : ", ") + SqlString.escapeId(val2[i8], forbidQualified);
        }
        return sql3;
      } else if (forbidQualified) {
        return "`" + String(val2).replace(ID_GLOBAL_REGEXP, "``") + "`";
      } else {
        return "`" + String(val2).replace(ID_GLOBAL_REGEXP, "``").replace(QUAL_GLOBAL_REGEXP, "`.`") + "`";
      }
    };
    SqlString.escape = function escape4(val2, stringifyObjects, timeZone) {
      if (val2 === void 0 || val2 === null) {
        return "NULL";
      }
      switch (typeof val2) {
        case "boolean":
          return val2 ? "true" : "false";
        case "number":
          return val2 + "";
        case "object":
          if (Object.prototype.toString.call(val2) === "[object Date]") {
            return SqlString.dateToString(val2, timeZone || "local");
          } else if (Array.isArray(val2)) {
            return SqlString.arrayToList(val2, timeZone);
          } else if (Buffer.isBuffer(val2)) {
            return SqlString.bufferToString(val2);
          } else if (typeof val2.toSqlString === "function") {
            return String(val2.toSqlString());
          } else if (stringifyObjects) {
            return escapeString(val2.toString());
          } else {
            return SqlString.objectToValues(val2, timeZone);
          }
        default:
          return escapeString(val2);
      }
    };
    SqlString.arrayToList = function arrayToList(array3, timeZone) {
      var sql3 = "";
      for (var i8 = 0; i8 < array3.length; i8++) {
        var val2 = array3[i8];
        if (Array.isArray(val2)) {
          sql3 += (i8 === 0 ? "" : ", ") + "(" + SqlString.arrayToList(val2, timeZone) + ")";
        } else {
          sql3 += (i8 === 0 ? "" : ", ") + SqlString.escape(val2, true, timeZone);
        }
      }
      return sql3;
    };
    SqlString.format = function format2(sql3, values2, stringifyObjects, timeZone) {
      if (values2 == null) {
        return sql3;
      }
      if (!Array.isArray(values2)) {
        values2 = [values2];
      }
      var chunkIndex = 0;
      var placeholdersRegex = /\?+/g;
      var result = "";
      var valuesIndex = 0;
      var match2;
      while (valuesIndex < values2.length && (match2 = placeholdersRegex.exec(sql3))) {
        var len = match2[0].length;
        if (len > 2) {
          continue;
        }
        var value = len === 2 ? SqlString.escapeId(values2[valuesIndex]) : SqlString.escape(values2[valuesIndex], stringifyObjects, timeZone);
        result += sql3.slice(chunkIndex, match2.index) + value;
        chunkIndex = placeholdersRegex.lastIndex;
        valuesIndex++;
      }
      if (chunkIndex === 0) {
        return sql3;
      }
      if (chunkIndex < sql3.length) {
        return result + sql3.slice(chunkIndex);
      }
      return result;
    };
    SqlString.dateToString = function dateToString(date4, timeZone) {
      var dt2 = new Date(date4);
      if (isNaN(dt2.getTime())) {
        return "NULL";
      }
      var year3;
      var month;
      var day;
      var hour;
      var minute;
      var second;
      var millisecond;
      if (timeZone === "local") {
        year3 = dt2.getFullYear();
        month = dt2.getMonth() + 1;
        day = dt2.getDate();
        hour = dt2.getHours();
        minute = dt2.getMinutes();
        second = dt2.getSeconds();
        millisecond = dt2.getMilliseconds();
      } else {
        var tz = convertTimezone(timeZone);
        if (tz !== false && tz !== 0) {
          dt2.setTime(dt2.getTime() + tz * 6e4);
        }
        year3 = dt2.getUTCFullYear();
        month = dt2.getUTCMonth() + 1;
        day = dt2.getUTCDate();
        hour = dt2.getUTCHours();
        minute = dt2.getUTCMinutes();
        second = dt2.getUTCSeconds();
        millisecond = dt2.getUTCMilliseconds();
      }
      var str = zeroPad(year3, 4) + "-" + zeroPad(month, 2) + "-" + zeroPad(day, 2) + " " + zeroPad(hour, 2) + ":" + zeroPad(minute, 2) + ":" + zeroPad(second, 2) + "." + zeroPad(millisecond, 3);
      return escapeString(str);
    };
    SqlString.bufferToString = function bufferToString(buffer2) {
      return "X" + escapeString(buffer2.toString("hex"));
    };
    SqlString.objectToValues = function objectToValues(object2, timeZone) {
      var sql3 = "";
      for (var key in object2) {
        var val2 = object2[key];
        if (typeof val2 === "function") {
          continue;
        }
        sql3 += (sql3.length === 0 ? "" : ", ") + SqlString.escapeId(key) + " = " + SqlString.escape(val2, true, timeZone);
      }
      return sql3;
    };
    SqlString.raw = function raw2(sql3) {
      if (typeof sql3 !== "string") {
        throw new TypeError("argument sql must be a string");
      }
      return {
        toSqlString: function toSqlString() {
          return sql3;
        }
      };
    };
    function escapeString(val2) {
      var chunkIndex = CHARS_GLOBAL_REGEXP.lastIndex = 0;
      var escapedVal = "";
      var match2;
      while (match2 = CHARS_GLOBAL_REGEXP.exec(val2)) {
        escapedVal += val2.slice(chunkIndex, match2.index) + CHARS_ESCAPE_MAP[match2[0]];
        chunkIndex = CHARS_GLOBAL_REGEXP.lastIndex;
      }
      if (chunkIndex === 0) {
        return "'" + val2 + "'";
      }
      if (chunkIndex < val2.length) {
        return "'" + escapedVal + val2.slice(chunkIndex) + "'";
      }
      return "'" + escapedVal + "'";
    }
    function zeroPad(number2, length) {
      number2 = number2.toString();
      while (number2.length < length) {
        number2 = "0" + number2;
      }
      return number2;
    }
    function convertTimezone(tz) {
      if (tz === "Z") {
        return 0;
      }
      var m12 = tz.match(/([\+\-\s])(\d\d):?(\d\d)?/);
      if (m12) {
        return (m12[1] === "-" ? -1 : 1) * (parseInt(m12[2], 10) + (m12[3] ? parseInt(m12[3], 10) : 0) / 60) * 60;
      }
      return false;
    }
  }
});

// ../node_modules/.pnpm/sqlstring@2.3.3/node_modules/sqlstring/index.js
var require_sqlstring = __commonJS({
  "../node_modules/.pnpm/sqlstring@2.3.3/node_modules/sqlstring/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_SqlString();
  }
});

// ../node_modules/.pnpm/lru.min@1.1.2/node_modules/lru.min/lib/index.js
var require_lib5 = __commonJS({
  "../node_modules/.pnpm/lru.min@1.1.2/node_modules/lru.min/lib/index.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.createLRU = void 0;
    var createLRU = (options) => {
      let { max: max2 } = options;
      if (!(Number.isInteger(max2) && max2 > 0))
        throw new TypeError("`max` must be a positive integer");
      let size2 = 0;
      let head = 0;
      let tail = 0;
      let free = [];
      const { onEviction } = options;
      const keyMap = /* @__PURE__ */ new Map();
      const keyList = new Array(max2).fill(void 0);
      const valList = new Array(max2).fill(void 0);
      const next = new Array(max2).fill(0);
      const prev = new Array(max2).fill(0);
      const setTail = (index7, type) => {
        if (index7 === tail)
          return;
        const nextIndex = next[index7];
        const prevIndex = prev[index7];
        if (index7 === head)
          head = nextIndex;
        else if (type === "get" || prevIndex !== 0)
          next[prevIndex] = nextIndex;
        if (nextIndex !== 0)
          prev[nextIndex] = prevIndex;
        next[tail] = index7;
        prev[index7] = tail;
        next[index7] = 0;
        tail = index7;
      };
      const _evict = () => {
        const evictHead = head;
        const key = keyList[evictHead];
        onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[evictHead]);
        keyMap.delete(key);
        keyList[evictHead] = void 0;
        valList[evictHead] = void 0;
        head = next[evictHead];
        if (head !== 0)
          prev[head] = 0;
        size2--;
        if (size2 === 0)
          head = tail = 0;
        free.push(evictHead);
        return evictHead;
      };
      return {
        /** Adds a key-value pair to the cache. Updates the value if the key already exists. */
        set(key, value) {
          if (key === void 0)
            return;
          let index7 = keyMap.get(key);
          if (index7 === void 0) {
            index7 = size2 === max2 ? _evict() : free.length > 0 ? free.pop() : size2;
            keyMap.set(key, index7);
            keyList[index7] = key;
            size2++;
          } else
            onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index7]);
          valList[index7] = value;
          if (size2 === 1)
            head = tail = index7;
          else
            setTail(index7, "set");
        },
        /** Retrieves the value for a given key and moves the key to the most recent position. */
        get(key) {
          const index7 = keyMap.get(key);
          if (index7 === void 0)
            return;
          if (index7 !== tail)
            setTail(index7, "get");
          return valList[index7];
        },
        /** Retrieves the value for a given key without changing its position. */
        peek: (key) => {
          const index7 = keyMap.get(key);
          return index7 !== void 0 ? valList[index7] : void 0;
        },
        /** Checks if a key exists in the cache. */
        has: (key) => keyMap.has(key),
        /** Iterates over all keys in the cache, from most recent to least recent. */
        *keys() {
          let current = tail;
          for (let i8 = 0; i8 < size2; i8++) {
            yield keyList[current];
            current = prev[current];
          }
        },
        /** Iterates over all values in the cache, from most recent to least recent. */
        *values() {
          let current = tail;
          for (let i8 = 0; i8 < size2; i8++) {
            yield valList[current];
            current = prev[current];
          }
        },
        /** Iterates over `[key, value]` pairs in the cache, from most recent to least recent. */
        *entries() {
          let current = tail;
          for (let i8 = 0; i8 < size2; i8++) {
            yield [keyList[current], valList[current]];
            current = prev[current];
          }
        },
        /** Iterates over each value-key pair in the cache, from most recent to least recent. */
        forEach: (callback) => {
          let current = tail;
          for (let i8 = 0; i8 < size2; i8++) {
            const key = keyList[current];
            const value = valList[current];
            callback(value, key);
            current = prev[current];
          }
        },
        /** Deletes a key-value pair from the cache. */
        delete(key) {
          const index7 = keyMap.get(key);
          if (index7 === void 0)
            return false;
          onEviction === null || onEviction === void 0 ? void 0 : onEviction(key, valList[index7]);
          keyMap.delete(key);
          free.push(index7);
          keyList[index7] = void 0;
          valList[index7] = void 0;
          const prevIndex = prev[index7];
          const nextIndex = next[index7];
          if (prevIndex !== 0)
            next[prevIndex] = nextIndex;
          if (nextIndex !== 0)
            prev[nextIndex] = prevIndex;
          if (index7 === head)
            head = nextIndex;
          if (index7 === tail)
            tail = prevIndex;
          size2--;
          return true;
        },
        /** Evicts the oldest item or the specified number of the oldest items from the cache. */
        evict: (number2) => {
          let toPrune = Math.min(number2, size2);
          while (toPrune > 0) {
            _evict();
            toPrune--;
          }
        },
        /** Clears all key-value pairs from the cache. */
        clear() {
          if (typeof onEviction === "function") {
            const iterator = keyMap.values();
            for (let result = iterator.next(); !result.done; result = iterator.next())
              onEviction(keyList[result.value], valList[result.value]);
          }
          keyMap.clear();
          keyList.fill(void 0);
          valList.fill(void 0);
          free = [];
          size2 = 0;
          head = tail = 0;
        },
        /** Resizes the cache to a new maximum size, evicting items if necessary. */
        resize: (newMax) => {
          if (!(Number.isInteger(newMax) && newMax > 0))
            throw new TypeError("`max` must be a positive integer");
          if (newMax === max2)
            return;
          if (newMax < max2) {
            let current = tail;
            const preserve = Math.min(size2, newMax);
            const remove = size2 - preserve;
            const newKeyList = new Array(newMax);
            const newValList = new Array(newMax);
            const newNext = new Array(newMax);
            const newPrev = new Array(newMax);
            for (let i8 = 1; i8 <= remove; i8++)
              onEviction === null || onEviction === void 0 ? void 0 : onEviction(keyList[i8], valList[i8]);
            for (let i8 = preserve - 1; i8 >= 0; i8--) {
              newKeyList[i8] = keyList[current];
              newValList[i8] = valList[current];
              newNext[i8] = i8 + 1;
              newPrev[i8] = i8 - 1;
              keyMap.set(newKeyList[i8], i8);
              current = prev[current];
            }
            head = 0;
            tail = preserve - 1;
            size2 = preserve;
            keyList.length = newMax;
            valList.length = newMax;
            next.length = newMax;
            prev.length = newMax;
            for (let i8 = 0; i8 < preserve; i8++) {
              keyList[i8] = newKeyList[i8];
              valList[i8] = newValList[i8];
              next[i8] = newNext[i8];
              prev[i8] = newPrev[i8];
            }
            free = [];
            for (let i8 = preserve; i8 < newMax; i8++)
              free.push(i8);
          } else {
            const fill = newMax - max2;
            keyList.push(...new Array(fill).fill(void 0));
            valList.push(...new Array(fill).fill(void 0));
            next.push(...new Array(fill).fill(0));
            prev.push(...new Array(fill).fill(0));
          }
          max2 = newMax;
        },
        /** Returns the maximum number of items that can be stored in the cache. */
        get max() {
          return max2;
        },
        /** Returns the number of items currently stored in the cache. */
        get size() {
          return size2;
        },
        /** Returns the number of currently available slots in the cache before reaching the maximum size. */
        get available() {
          return max2 - size2;
        }
      };
    };
    exports2.createLRU = createLRU;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/parser_cache.js
var require_parser_cache = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/parser_cache.js"(exports2, module2) {
    "use strict";
    var { createLRU } = require_lib5();
    var parserCache = createLRU({
      max: 15e3
    });
    function keyFromFields(type, fields, options, config) {
      const res = [
        type,
        typeof options.nestTables,
        options.nestTables,
        Boolean(options.rowsAsArray),
        Boolean(options.supportBigNumbers || config.supportBigNumbers),
        Boolean(options.bigNumberStrings || config.bigNumberStrings),
        typeof options.typeCast,
        options.timezone || config.timezone,
        Boolean(options.decimalNumbers),
        options.dateStrings
      ];
      for (let i8 = 0; i8 < fields.length; ++i8) {
        const field = fields[i8];
        res.push([
          field.name,
          field.columnType,
          field.length,
          field.schema,
          field.table,
          field.flags,
          field.characterSet
        ]);
      }
      return JSON.stringify(res, null, 0);
    }
    function getParser(type, fields, options, config, compiler) {
      const key = keyFromFields(type, fields, options, config);
      let parser = parserCache.get(key);
      if (parser) {
        return parser;
      }
      parser = compiler(fields, options, config);
      parserCache.set(key, parser);
      return parser;
    }
    function setMaxCache(max2) {
      parserCache.resize(max2);
    }
    function clearCache() {
      parserCache.clear();
    }
    module2.exports = {
      getParser,
      setMaxCache,
      clearCache,
      _keyFromFields: keyFromFields
    };
  }
});

// ../node_modules/.pnpm/denque@2.1.0/node_modules/denque/index.js
var require_denque = __commonJS({
  "../node_modules/.pnpm/denque@2.1.0/node_modules/denque/index.js"(exports2, module2) {
    "use strict";
    function Denque(array3, options) {
      var options = options || {};
      this._capacity = options.capacity;
      this._head = 0;
      this._tail = 0;
      if (Array.isArray(array3)) {
        this._fromArray(array3);
      } else {
        this._capacityMask = 3;
        this._list = new Array(4);
      }
    }
    Denque.prototype.peekAt = function peekAt(index7) {
      var i8 = index7;
      if (i8 !== (i8 | 0)) {
        return void 0;
      }
      var len = this.size();
      if (i8 >= len || i8 < -len) return void 0;
      if (i8 < 0) i8 += len;
      i8 = this._head + i8 & this._capacityMask;
      return this._list[i8];
    };
    Denque.prototype.get = function get2(i8) {
      return this.peekAt(i8);
    };
    Denque.prototype.peek = function peek() {
      if (this._head === this._tail) return void 0;
      return this._list[this._head];
    };
    Denque.prototype.peekFront = function peekFront() {
      return this.peek();
    };
    Denque.prototype.peekBack = function peekBack() {
      return this.peekAt(-1);
    };
    Object.defineProperty(Denque.prototype, "length", {
      get: function length() {
        return this.size();
      }
    });
    Denque.prototype.size = function size2() {
      if (this._head === this._tail) return 0;
      if (this._head < this._tail) return this._tail - this._head;
      else return this._capacityMask + 1 - (this._head - this._tail);
    };
    Denque.prototype.unshift = function unshift(item) {
      if (arguments.length === 0) return this.size();
      var len = this._list.length;
      this._head = this._head - 1 + len & this._capacityMask;
      this._list[this._head] = item;
      if (this._tail === this._head) this._growArray();
      if (this._capacity && this.size() > this._capacity) this.pop();
      if (this._head < this._tail) return this._tail - this._head;
      else return this._capacityMask + 1 - (this._head - this._tail);
    };
    Denque.prototype.shift = function shift() {
      var head = this._head;
      if (head === this._tail) return void 0;
      var item = this._list[head];
      this._list[head] = void 0;
      this._head = head + 1 & this._capacityMask;
      if (head < 2 && this._tail > 1e4 && this._tail <= this._list.length >>> 2) this._shrinkArray();
      return item;
    };
    Denque.prototype.push = function push(item) {
      if (arguments.length === 0) return this.size();
      var tail = this._tail;
      this._list[tail] = item;
      this._tail = tail + 1 & this._capacityMask;
      if (this._tail === this._head) {
        this._growArray();
      }
      if (this._capacity && this.size() > this._capacity) {
        this.shift();
      }
      if (this._head < this._tail) return this._tail - this._head;
      else return this._capacityMask + 1 - (this._head - this._tail);
    };
    Denque.prototype.pop = function pop() {
      var tail = this._tail;
      if (tail === this._head) return void 0;
      var len = this._list.length;
      this._tail = tail - 1 + len & this._capacityMask;
      var item = this._list[this._tail];
      this._list[this._tail] = void 0;
      if (this._head < 2 && tail > 1e4 && tail <= len >>> 2) this._shrinkArray();
      return item;
    };
    Denque.prototype.removeOne = function removeOne(index7) {
      var i8 = index7;
      if (i8 !== (i8 | 0)) {
        return void 0;
      }
      if (this._head === this._tail) return void 0;
      var size2 = this.size();
      var len = this._list.length;
      if (i8 >= size2 || i8 < -size2) return void 0;
      if (i8 < 0) i8 += size2;
      i8 = this._head + i8 & this._capacityMask;
      var item = this._list[i8];
      var k9;
      if (index7 < size2 / 2) {
        for (k9 = index7; k9 > 0; k9--) {
          this._list[i8] = this._list[i8 = i8 - 1 + len & this._capacityMask];
        }
        this._list[i8] = void 0;
        this._head = this._head + 1 + len & this._capacityMask;
      } else {
        for (k9 = size2 - 1 - index7; k9 > 0; k9--) {
          this._list[i8] = this._list[i8 = i8 + 1 + len & this._capacityMask];
        }
        this._list[i8] = void 0;
        this._tail = this._tail - 1 + len & this._capacityMask;
      }
      return item;
    };
    Denque.prototype.remove = function remove(index7, count2) {
      var i8 = index7;
      var removed;
      var del_count = count2;
      if (i8 !== (i8 | 0)) {
        return void 0;
      }
      if (this._head === this._tail) return void 0;
      var size2 = this.size();
      var len = this._list.length;
      if (i8 >= size2 || i8 < -size2 || count2 < 1) return void 0;
      if (i8 < 0) i8 += size2;
      if (count2 === 1 || !count2) {
        removed = new Array(1);
        removed[0] = this.removeOne(i8);
        return removed;
      }
      if (i8 === 0 && i8 + count2 >= size2) {
        removed = this.toArray();
        this.clear();
        return removed;
      }
      if (i8 + count2 > size2) count2 = size2 - i8;
      var k9;
      removed = new Array(count2);
      for (k9 = 0; k9 < count2; k9++) {
        removed[k9] = this._list[this._head + i8 + k9 & this._capacityMask];
      }
      i8 = this._head + i8 & this._capacityMask;
      if (index7 + count2 === size2) {
        this._tail = this._tail - count2 + len & this._capacityMask;
        for (k9 = count2; k9 > 0; k9--) {
          this._list[i8 = i8 + 1 + len & this._capacityMask] = void 0;
        }
        return removed;
      }
      if (index7 === 0) {
        this._head = this._head + count2 + len & this._capacityMask;
        for (k9 = count2 - 1; k9 > 0; k9--) {
          this._list[i8 = i8 + 1 + len & this._capacityMask] = void 0;
        }
        return removed;
      }
      if (i8 < size2 / 2) {
        this._head = this._head + index7 + count2 + len & this._capacityMask;
        for (k9 = index7; k9 > 0; k9--) {
          this.unshift(this._list[i8 = i8 - 1 + len & this._capacityMask]);
        }
        i8 = this._head - 1 + len & this._capacityMask;
        while (del_count > 0) {
          this._list[i8 = i8 - 1 + len & this._capacityMask] = void 0;
          del_count--;
        }
        if (index7 < 0) this._tail = i8;
      } else {
        this._tail = i8;
        i8 = i8 + count2 + len & this._capacityMask;
        for (k9 = size2 - (count2 + index7); k9 > 0; k9--) {
          this.push(this._list[i8++]);
        }
        i8 = this._tail;
        while (del_count > 0) {
          this._list[i8 = i8 + 1 + len & this._capacityMask] = void 0;
          del_count--;
        }
      }
      if (this._head < 2 && this._tail > 1e4 && this._tail <= len >>> 2) this._shrinkArray();
      return removed;
    };
    Denque.prototype.splice = function splice(index7, count2) {
      var i8 = index7;
      if (i8 !== (i8 | 0)) {
        return void 0;
      }
      var size2 = this.size();
      if (i8 < 0) i8 += size2;
      if (i8 > size2) return void 0;
      if (arguments.length > 2) {
        var k9;
        var temp;
        var removed;
        var arg_len = arguments.length;
        var len = this._list.length;
        var arguments_index = 2;
        if (!size2 || i8 < size2 / 2) {
          temp = new Array(i8);
          for (k9 = 0; k9 < i8; k9++) {
            temp[k9] = this._list[this._head + k9 & this._capacityMask];
          }
          if (count2 === 0) {
            removed = [];
            if (i8 > 0) {
              this._head = this._head + i8 + len & this._capacityMask;
            }
          } else {
            removed = this.remove(i8, count2);
            this._head = this._head + i8 + len & this._capacityMask;
          }
          while (arg_len > arguments_index) {
            this.unshift(arguments[--arg_len]);
          }
          for (k9 = i8; k9 > 0; k9--) {
            this.unshift(temp[k9 - 1]);
          }
        } else {
          temp = new Array(size2 - (i8 + count2));
          var leng = temp.length;
          for (k9 = 0; k9 < leng; k9++) {
            temp[k9] = this._list[this._head + i8 + count2 + k9 & this._capacityMask];
          }
          if (count2 === 0) {
            removed = [];
            if (i8 != size2) {
              this._tail = this._head + i8 + len & this._capacityMask;
            }
          } else {
            removed = this.remove(i8, count2);
            this._tail = this._tail - leng + len & this._capacityMask;
          }
          while (arguments_index < arg_len) {
            this.push(arguments[arguments_index++]);
          }
          for (k9 = 0; k9 < leng; k9++) {
            this.push(temp[k9]);
          }
        }
        return removed;
      } else {
        return this.remove(i8, count2);
      }
    };
    Denque.prototype.clear = function clear() {
      this._list = new Array(this._list.length);
      this._head = 0;
      this._tail = 0;
    };
    Denque.prototype.isEmpty = function isEmpty() {
      return this._head === this._tail;
    };
    Denque.prototype.toArray = function toArray2() {
      return this._copyArray(false);
    };
    Denque.prototype._fromArray = function _fromArray(array3) {
      var length = array3.length;
      var capacity = this._nextPowerOf2(length);
      this._list = new Array(capacity);
      this._capacityMask = capacity - 1;
      this._tail = length;
      for (var i8 = 0; i8 < length; i8++) this._list[i8] = array3[i8];
    };
    Denque.prototype._copyArray = function _copyArray(fullCopy, size2) {
      var src = this._list;
      var capacity = src.length;
      var length = this.length;
      size2 = size2 | length;
      if (size2 == length && this._head < this._tail) {
        return this._list.slice(this._head, this._tail);
      }
      var dest = new Array(size2);
      var k9 = 0;
      var i8;
      if (fullCopy || this._head > this._tail) {
        for (i8 = this._head; i8 < capacity; i8++) dest[k9++] = src[i8];
        for (i8 = 0; i8 < this._tail; i8++) dest[k9++] = src[i8];
      } else {
        for (i8 = this._head; i8 < this._tail; i8++) dest[k9++] = src[i8];
      }
      return dest;
    };
    Denque.prototype._growArray = function _growArray() {
      if (this._head != 0) {
        var newList = this._copyArray(true, this._list.length << 1);
        this._tail = this._list.length;
        this._head = 0;
        this._list = newList;
      } else {
        this._tail = this._list.length;
        this._list.length <<= 1;
      }
      this._capacityMask = this._capacityMask << 1 | 1;
    };
    Denque.prototype._shrinkArray = function _shrinkArray() {
      this._list.length >>>= 1;
      this._capacityMask >>>= 1;
    };
    Denque.prototype._nextPowerOf2 = function _nextPowerOf2(num) {
      var log2 = Math.log(num) / Math.log(2);
      var nextPow2 = 1 << log2 + 1;
      return Math.max(nextPow2, 4);
    };
    module2.exports = Denque;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/errors.js
var require_errors2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/errors.js"(exports2) {
    "use strict";
    exports2.EE_CANTCREATEFILE = 1;
    exports2.EE_READ = 2;
    exports2.EE_WRITE = 3;
    exports2.EE_BADCLOSE = 4;
    exports2.EE_OUTOFMEMORY = 5;
    exports2.EE_DELETE = 6;
    exports2.EE_LINK = 7;
    exports2.EE_EOFERR = 9;
    exports2.EE_CANTLOCK = 10;
    exports2.EE_CANTUNLOCK = 11;
    exports2.EE_DIR = 12;
    exports2.EE_STAT = 13;
    exports2.EE_CANT_CHSIZE = 14;
    exports2.EE_CANT_OPEN_STREAM = 15;
    exports2.EE_GETWD = 16;
    exports2.EE_SETWD = 17;
    exports2.EE_LINK_WARNING = 18;
    exports2.EE_OPEN_WARNING = 19;
    exports2.EE_DISK_FULL = 20;
    exports2.EE_CANT_MKDIR = 21;
    exports2.EE_UNKNOWN_CHARSET = 22;
    exports2.EE_OUT_OF_FILERESOURCES = 23;
    exports2.EE_CANT_READLINK = 24;
    exports2.EE_CANT_SYMLINK = 25;
    exports2.EE_REALPATH = 26;
    exports2.EE_SYNC = 27;
    exports2.EE_UNKNOWN_COLLATION = 28;
    exports2.EE_FILENOTFOUND = 29;
    exports2.EE_FILE_NOT_CLOSED = 30;
    exports2.EE_CHANGE_OWNERSHIP = 31;
    exports2.EE_CHANGE_PERMISSIONS = 32;
    exports2.EE_CANT_SEEK = 33;
    exports2.EE_CAPACITY_EXCEEDED = 34;
    exports2.EE_DISK_FULL_WITH_RETRY_MSG = 35;
    exports2.EE_FAILED_TO_CREATE_TIMER = 36;
    exports2.EE_FAILED_TO_DELETE_TIMER = 37;
    exports2.EE_FAILED_TO_CREATE_TIMER_QUEUE = 38;
    exports2.EE_FAILED_TO_START_TIMER_NOTIFY_THREAD = 39;
    exports2.EE_FAILED_TO_CREATE_TIMER_NOTIFY_THREAD_INTERRUPT_EVENT = 40;
    exports2.EE_EXITING_TIMER_NOTIFY_THREAD = 41;
    exports2.EE_WIN_LIBRARY_LOAD_FAILED = 42;
    exports2.EE_WIN_RUN_TIME_ERROR_CHECK = 43;
    exports2.EE_FAILED_TO_DETERMINE_LARGE_PAGE_SIZE = 44;
    exports2.EE_FAILED_TO_KILL_ALL_THREADS = 45;
    exports2.EE_FAILED_TO_CREATE_IO_COMPLETION_PORT = 46;
    exports2.EE_FAILED_TO_OPEN_DEFAULTS_FILE = 47;
    exports2.EE_FAILED_TO_HANDLE_DEFAULTS_FILE = 48;
    exports2.EE_WRONG_DIRECTIVE_IN_CONFIG_FILE = 49;
    exports2.EE_SKIPPING_DIRECTIVE_DUE_TO_MAX_INCLUDE_RECURSION = 50;
    exports2.EE_INCORRECT_GRP_DEFINITION_IN_CONFIG_FILE = 51;
    exports2.EE_OPTION_WITHOUT_GRP_IN_CONFIG_FILE = 52;
    exports2.EE_CONFIG_FILE_PERMISSION_ERROR = 53;
    exports2.EE_IGNORE_WORLD_WRITABLE_CONFIG_FILE = 54;
    exports2.EE_USING_DISABLED_OPTION = 55;
    exports2.EE_USING_DISABLED_SHORT_OPTION = 56;
    exports2.EE_USING_PASSWORD_ON_CLI_IS_INSECURE = 57;
    exports2.EE_UNKNOWN_SUFFIX_FOR_VARIABLE = 58;
    exports2.EE_SSL_ERROR_FROM_FILE = 59;
    exports2.EE_SSL_ERROR = 60;
    exports2.EE_NET_SEND_ERROR_IN_BOOTSTRAP = 61;
    exports2.EE_PACKETS_OUT_OF_ORDER = 62;
    exports2.EE_UNKNOWN_PROTOCOL_OPTION = 63;
    exports2.EE_FAILED_TO_LOCATE_SERVER_PUBLIC_KEY = 64;
    exports2.EE_PUBLIC_KEY_NOT_IN_PEM_FORMAT = 65;
    exports2.EE_DEBUG_INFO = 66;
    exports2.EE_UNKNOWN_VARIABLE = 67;
    exports2.EE_UNKNOWN_OPTION = 68;
    exports2.EE_UNKNOWN_SHORT_OPTION = 69;
    exports2.EE_OPTION_WITHOUT_ARGUMENT = 70;
    exports2.EE_OPTION_REQUIRES_ARGUMENT = 71;
    exports2.EE_SHORT_OPTION_REQUIRES_ARGUMENT = 72;
    exports2.EE_OPTION_IGNORED_DUE_TO_INVALID_VALUE = 73;
    exports2.EE_OPTION_WITH_EMPTY_VALUE = 74;
    exports2.EE_FAILED_TO_ASSIGN_MAX_VALUE_TO_OPTION = 75;
    exports2.EE_INCORRECT_BOOLEAN_VALUE_FOR_OPTION = 76;
    exports2.EE_FAILED_TO_SET_OPTION_VALUE = 77;
    exports2.EE_INCORRECT_INT_VALUE_FOR_OPTION = 78;
    exports2.EE_INCORRECT_UINT_VALUE_FOR_OPTION = 79;
    exports2.EE_ADJUSTED_SIGNED_VALUE_FOR_OPTION = 80;
    exports2.EE_ADJUSTED_UNSIGNED_VALUE_FOR_OPTION = 81;
    exports2.EE_ADJUSTED_ULONGLONG_VALUE_FOR_OPTION = 82;
    exports2.EE_ADJUSTED_DOUBLE_VALUE_FOR_OPTION = 83;
    exports2.EE_INVALID_DECIMAL_VALUE_FOR_OPTION = 84;
    exports2.EE_COLLATION_PARSER_ERROR = 85;
    exports2.EE_FAILED_TO_RESET_BEFORE_PRIMARY_IGNORABLE_CHAR = 86;
    exports2.EE_FAILED_TO_RESET_BEFORE_TERTIARY_IGNORABLE_CHAR = 87;
    exports2.EE_SHIFT_CHAR_OUT_OF_RANGE = 88;
    exports2.EE_RESET_CHAR_OUT_OF_RANGE = 89;
    exports2.EE_UNKNOWN_LDML_TAG = 90;
    exports2.EE_FAILED_TO_RESET_BEFORE_SECONDARY_IGNORABLE_CHAR = 91;
    exports2.EE_FAILED_PROCESSING_DIRECTIVE = 92;
    exports2.EE_PTHREAD_KILL_FAILED = 93;
    exports2.HA_ERR_KEY_NOT_FOUND = 120;
    exports2.HA_ERR_FOUND_DUPP_KEY = 121;
    exports2.HA_ERR_INTERNAL_ERROR = 122;
    exports2.HA_ERR_RECORD_CHANGED = 123;
    exports2.HA_ERR_WRONG_INDEX = 124;
    exports2.HA_ERR_ROLLED_BACK = 125;
    exports2.HA_ERR_CRASHED = 126;
    exports2.HA_ERR_WRONG_IN_RECORD = 127;
    exports2.HA_ERR_OUT_OF_MEM = 128;
    exports2.HA_ERR_NOT_A_TABLE = 130;
    exports2.HA_ERR_WRONG_COMMAND = 131;
    exports2.HA_ERR_OLD_FILE = 132;
    exports2.HA_ERR_NO_ACTIVE_RECORD = 133;
    exports2.HA_ERR_RECORD_DELETED = 134;
    exports2.HA_ERR_RECORD_FILE_FULL = 135;
    exports2.HA_ERR_INDEX_FILE_FULL = 136;
    exports2.HA_ERR_END_OF_FILE = 137;
    exports2.HA_ERR_UNSUPPORTED = 138;
    exports2.HA_ERR_TOO_BIG_ROW = 139;
    exports2.HA_WRONG_CREATE_OPTION = 140;
    exports2.HA_ERR_FOUND_DUPP_UNIQUE = 141;
    exports2.HA_ERR_UNKNOWN_CHARSET = 142;
    exports2.HA_ERR_WRONG_MRG_TABLE_DEF = 143;
    exports2.HA_ERR_CRASHED_ON_REPAIR = 144;
    exports2.HA_ERR_CRASHED_ON_USAGE = 145;
    exports2.HA_ERR_LOCK_WAIT_TIMEOUT = 146;
    exports2.HA_ERR_LOCK_TABLE_FULL = 147;
    exports2.HA_ERR_READ_ONLY_TRANSACTION = 148;
    exports2.HA_ERR_LOCK_DEADLOCK = 149;
    exports2.HA_ERR_CANNOT_ADD_FOREIGN = 150;
    exports2.HA_ERR_NO_REFERENCED_ROW = 151;
    exports2.HA_ERR_ROW_IS_REFERENCED = 152;
    exports2.HA_ERR_NO_SAVEPOINT = 153;
    exports2.HA_ERR_NON_UNIQUE_BLOCK_SIZE = 154;
    exports2.HA_ERR_NO_SUCH_TABLE = 155;
    exports2.HA_ERR_TABLE_EXIST = 156;
    exports2.HA_ERR_NO_CONNECTION = 157;
    exports2.HA_ERR_NULL_IN_SPATIAL = 158;
    exports2.HA_ERR_TABLE_DEF_CHANGED = 159;
    exports2.HA_ERR_NO_PARTITION_FOUND = 160;
    exports2.HA_ERR_RBR_LOGGING_FAILED = 161;
    exports2.HA_ERR_DROP_INDEX_FK = 162;
    exports2.HA_ERR_FOREIGN_DUPLICATE_KEY = 163;
    exports2.HA_ERR_TABLE_NEEDS_UPGRADE = 164;
    exports2.HA_ERR_TABLE_READONLY = 165;
    exports2.HA_ERR_AUTOINC_READ_FAILED = 166;
    exports2.HA_ERR_AUTOINC_ERANGE = 167;
    exports2.HA_ERR_GENERIC = 168;
    exports2.HA_ERR_RECORD_IS_THE_SAME = 169;
    exports2.HA_ERR_LOGGING_IMPOSSIBLE = 170;
    exports2.HA_ERR_CORRUPT_EVENT = 171;
    exports2.HA_ERR_NEW_FILE = 172;
    exports2.HA_ERR_ROWS_EVENT_APPLY = 173;
    exports2.HA_ERR_INITIALIZATION = 174;
    exports2.HA_ERR_FILE_TOO_SHORT = 175;
    exports2.HA_ERR_WRONG_CRC = 176;
    exports2.HA_ERR_TOO_MANY_CONCURRENT_TRXS = 177;
    exports2.HA_ERR_NOT_IN_LOCK_PARTITIONS = 178;
    exports2.HA_ERR_INDEX_COL_TOO_LONG = 179;
    exports2.HA_ERR_INDEX_CORRUPT = 180;
    exports2.HA_ERR_UNDO_REC_TOO_BIG = 181;
    exports2.HA_FTS_INVALID_DOCID = 182;
    exports2.HA_ERR_TABLE_IN_FK_CHECK = 183;
    exports2.HA_ERR_TABLESPACE_EXISTS = 184;
    exports2.HA_ERR_TOO_MANY_FIELDS = 185;
    exports2.HA_ERR_ROW_IN_WRONG_PARTITION = 186;
    exports2.HA_ERR_INNODB_READ_ONLY = 187;
    exports2.HA_ERR_FTS_EXCEED_RESULT_CACHE_LIMIT = 188;
    exports2.HA_ERR_TEMP_FILE_WRITE_FAILURE = 189;
    exports2.HA_ERR_INNODB_FORCED_RECOVERY = 190;
    exports2.HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE = 191;
    exports2.HA_ERR_FK_DEPTH_EXCEEDED = 192;
    exports2.HA_MISSING_CREATE_OPTION = 193;
    exports2.HA_ERR_SE_OUT_OF_MEMORY = 194;
    exports2.HA_ERR_TABLE_CORRUPT = 195;
    exports2.HA_ERR_QUERY_INTERRUPTED = 196;
    exports2.HA_ERR_TABLESPACE_MISSING = 197;
    exports2.HA_ERR_TABLESPACE_IS_NOT_EMPTY = 198;
    exports2.HA_ERR_WRONG_FILE_NAME = 199;
    exports2.HA_ERR_NOT_ALLOWED_COMMAND = 200;
    exports2.HA_ERR_COMPUTE_FAILED = 201;
    exports2.HA_ERR_ROW_FORMAT_CHANGED = 202;
    exports2.HA_ERR_NO_WAIT_LOCK = 203;
    exports2.HA_ERR_DISK_FULL_NOWAIT = 204;
    exports2.HA_ERR_NO_SESSION_TEMP = 205;
    exports2.HA_ERR_WRONG_TABLE_NAME = 206;
    exports2.HA_ERR_TOO_LONG_PATH = 207;
    exports2.HA_ERR_SAMPLING_INIT_FAILED = 208;
    exports2.HA_ERR_FTS_TOO_MANY_NESTED_EXP = 209;
    exports2.ER_HASHCHK = 1e3;
    exports2.ER_NISAMCHK = 1001;
    exports2.ER_NO = 1002;
    exports2.ER_YES = 1003;
    exports2.ER_CANT_CREATE_FILE = 1004;
    exports2.ER_CANT_CREATE_TABLE = 1005;
    exports2.ER_CANT_CREATE_DB = 1006;
    exports2.ER_DB_CREATE_EXISTS = 1007;
    exports2.ER_DB_DROP_EXISTS = 1008;
    exports2.ER_DB_DROP_DELETE = 1009;
    exports2.ER_DB_DROP_RMDIR = 1010;
    exports2.ER_CANT_DELETE_FILE = 1011;
    exports2.ER_CANT_FIND_SYSTEM_REC = 1012;
    exports2.ER_CANT_GET_STAT = 1013;
    exports2.ER_CANT_GET_WD = 1014;
    exports2.ER_CANT_LOCK = 1015;
    exports2.ER_CANT_OPEN_FILE = 1016;
    exports2.ER_FILE_NOT_FOUND = 1017;
    exports2.ER_CANT_READ_DIR = 1018;
    exports2.ER_CANT_SET_WD = 1019;
    exports2.ER_CHECKREAD = 1020;
    exports2.ER_DISK_FULL = 1021;
    exports2.ER_DUP_KEY = 1022;
    exports2.ER_ERROR_ON_CLOSE = 1023;
    exports2.ER_ERROR_ON_READ = 1024;
    exports2.ER_ERROR_ON_RENAME = 1025;
    exports2.ER_ERROR_ON_WRITE = 1026;
    exports2.ER_FILE_USED = 1027;
    exports2.ER_FILSORT_ABORT = 1028;
    exports2.ER_FORM_NOT_FOUND = 1029;
    exports2.ER_GET_ERRNO = 1030;
    exports2.ER_ILLEGAL_HA = 1031;
    exports2.ER_KEY_NOT_FOUND = 1032;
    exports2.ER_NOT_FORM_FILE = 1033;
    exports2.ER_NOT_KEYFILE = 1034;
    exports2.ER_OLD_KEYFILE = 1035;
    exports2.ER_OPEN_AS_READONLY = 1036;
    exports2.ER_OUTOFMEMORY = 1037;
    exports2.ER_OUT_OF_SORTMEMORY = 1038;
    exports2.ER_UNEXPECTED_EOF = 1039;
    exports2.ER_CON_COUNT_ERROR = 1040;
    exports2.ER_OUT_OF_RESOURCES = 1041;
    exports2.ER_BAD_HOST_ERROR = 1042;
    exports2.ER_HANDSHAKE_ERROR = 1043;
    exports2.ER_DBACCESS_DENIED_ERROR = 1044;
    exports2.ER_ACCESS_DENIED_ERROR = 1045;
    exports2.ER_NO_DB_ERROR = 1046;
    exports2.ER_UNKNOWN_COM_ERROR = 1047;
    exports2.ER_BAD_NULL_ERROR = 1048;
    exports2.ER_BAD_DB_ERROR = 1049;
    exports2.ER_TABLE_EXISTS_ERROR = 1050;
    exports2.ER_BAD_TABLE_ERROR = 1051;
    exports2.ER_NON_UNIQ_ERROR = 1052;
    exports2.ER_SERVER_SHUTDOWN = 1053;
    exports2.ER_BAD_FIELD_ERROR = 1054;
    exports2.ER_WRONG_FIELD_WITH_GROUP = 1055;
    exports2.ER_WRONG_GROUP_FIELD = 1056;
    exports2.ER_WRONG_SUM_SELECT = 1057;
    exports2.ER_WRONG_VALUE_COUNT = 1058;
    exports2.ER_TOO_LONG_IDENT = 1059;
    exports2.ER_DUP_FIELDNAME = 1060;
    exports2.ER_DUP_KEYNAME = 1061;
    exports2.ER_DUP_ENTRY = 1062;
    exports2.ER_WRONG_FIELD_SPEC = 1063;
    exports2.ER_PARSE_ERROR = 1064;
    exports2.ER_EMPTY_QUERY = 1065;
    exports2.ER_NONUNIQ_TABLE = 1066;
    exports2.ER_INVALID_DEFAULT = 1067;
    exports2.ER_MULTIPLE_PRI_KEY = 1068;
    exports2.ER_TOO_MANY_KEYS = 1069;
    exports2.ER_TOO_MANY_KEY_PARTS = 1070;
    exports2.ER_TOO_LONG_KEY = 1071;
    exports2.ER_KEY_COLUMN_DOES_NOT_EXITS = 1072;
    exports2.ER_BLOB_USED_AS_KEY = 1073;
    exports2.ER_TOO_BIG_FIELDLENGTH = 1074;
    exports2.ER_WRONG_AUTO_KEY = 1075;
    exports2.ER_READY = 1076;
    exports2.ER_NORMAL_SHUTDOWN = 1077;
    exports2.ER_GOT_SIGNAL = 1078;
    exports2.ER_SHUTDOWN_COMPLETE = 1079;
    exports2.ER_FORCING_CLOSE = 1080;
    exports2.ER_IPSOCK_ERROR = 1081;
    exports2.ER_NO_SUCH_INDEX = 1082;
    exports2.ER_WRONG_FIELD_TERMINATORS = 1083;
    exports2.ER_BLOBS_AND_NO_TERMINATED = 1084;
    exports2.ER_TEXTFILE_NOT_READABLE = 1085;
    exports2.ER_FILE_EXISTS_ERROR = 1086;
    exports2.ER_LOAD_INFO = 1087;
    exports2.ER_ALTER_INFO = 1088;
    exports2.ER_WRONG_SUB_KEY = 1089;
    exports2.ER_CANT_REMOVE_ALL_FIELDS = 1090;
    exports2.ER_CANT_DROP_FIELD_OR_KEY = 1091;
    exports2.ER_INSERT_INFO = 1092;
    exports2.ER_UPDATE_TABLE_USED = 1093;
    exports2.ER_NO_SUCH_THREAD = 1094;
    exports2.ER_KILL_DENIED_ERROR = 1095;
    exports2.ER_NO_TABLES_USED = 1096;
    exports2.ER_TOO_BIG_SET = 1097;
    exports2.ER_NO_UNIQUE_LOGFILE = 1098;
    exports2.ER_TABLE_NOT_LOCKED_FOR_WRITE = 1099;
    exports2.ER_TABLE_NOT_LOCKED = 1100;
    exports2.ER_BLOB_CANT_HAVE_DEFAULT = 1101;
    exports2.ER_WRONG_DB_NAME = 1102;
    exports2.ER_WRONG_TABLE_NAME = 1103;
    exports2.ER_TOO_BIG_SELECT = 1104;
    exports2.ER_UNKNOWN_ERROR = 1105;
    exports2.ER_UNKNOWN_PROCEDURE = 1106;
    exports2.ER_WRONG_PARAMCOUNT_TO_PROCEDURE = 1107;
    exports2.ER_WRONG_PARAMETERS_TO_PROCEDURE = 1108;
    exports2.ER_UNKNOWN_TABLE = 1109;
    exports2.ER_FIELD_SPECIFIED_TWICE = 1110;
    exports2.ER_INVALID_GROUP_FUNC_USE = 1111;
    exports2.ER_UNSUPPORTED_EXTENSION = 1112;
    exports2.ER_TABLE_MUST_HAVE_COLUMNS = 1113;
    exports2.ER_RECORD_FILE_FULL = 1114;
    exports2.ER_UNKNOWN_CHARACTER_SET = 1115;
    exports2.ER_TOO_MANY_TABLES = 1116;
    exports2.ER_TOO_MANY_FIELDS = 1117;
    exports2.ER_TOO_BIG_ROWSIZE = 1118;
    exports2.ER_STACK_OVERRUN = 1119;
    exports2.ER_WRONG_OUTER_JOIN = 1120;
    exports2.ER_NULL_COLUMN_IN_INDEX = 1121;
    exports2.ER_CANT_FIND_UDF = 1122;
    exports2.ER_CANT_INITIALIZE_UDF = 1123;
    exports2.ER_UDF_NO_PATHS = 1124;
    exports2.ER_UDF_EXISTS = 1125;
    exports2.ER_CANT_OPEN_LIBRARY = 1126;
    exports2.ER_CANT_FIND_DL_ENTRY = 1127;
    exports2.ER_FUNCTION_NOT_DEFINED = 1128;
    exports2.ER_HOST_IS_BLOCKED = 1129;
    exports2.ER_HOST_NOT_PRIVILEGED = 1130;
    exports2.ER_PASSWORD_ANONYMOUS_USER = 1131;
    exports2.ER_PASSWORD_NOT_ALLOWED = 1132;
    exports2.ER_PASSWORD_NO_MATCH = 1133;
    exports2.ER_UPDATE_INFO = 1134;
    exports2.ER_CANT_CREATE_THREAD = 1135;
    exports2.ER_WRONG_VALUE_COUNT_ON_ROW = 1136;
    exports2.ER_CANT_REOPEN_TABLE = 1137;
    exports2.ER_INVALID_USE_OF_NULL = 1138;
    exports2.ER_REGEXP_ERROR = 1139;
    exports2.ER_MIX_OF_GROUP_FUNC_AND_FIELDS = 1140;
    exports2.ER_NONEXISTING_GRANT = 1141;
    exports2.ER_TABLEACCESS_DENIED_ERROR = 1142;
    exports2.ER_COLUMNACCESS_DENIED_ERROR = 1143;
    exports2.ER_ILLEGAL_GRANT_FOR_TABLE = 1144;
    exports2.ER_GRANT_WRONG_HOST_OR_USER = 1145;
    exports2.ER_NO_SUCH_TABLE = 1146;
    exports2.ER_NONEXISTING_TABLE_GRANT = 1147;
    exports2.ER_NOT_ALLOWED_COMMAND = 1148;
    exports2.ER_SYNTAX_ERROR = 1149;
    exports2.ER_UNUSED1 = 1150;
    exports2.ER_UNUSED2 = 1151;
    exports2.ER_ABORTING_CONNECTION = 1152;
    exports2.ER_NET_PACKET_TOO_LARGE = 1153;
    exports2.ER_NET_READ_ERROR_FROM_PIPE = 1154;
    exports2.ER_NET_FCNTL_ERROR = 1155;
    exports2.ER_NET_PACKETS_OUT_OF_ORDER = 1156;
    exports2.ER_NET_UNCOMPRESS_ERROR = 1157;
    exports2.ER_NET_READ_ERROR = 1158;
    exports2.ER_NET_READ_INTERRUPTED = 1159;
    exports2.ER_NET_ERROR_ON_WRITE = 1160;
    exports2.ER_NET_WRITE_INTERRUPTED = 1161;
    exports2.ER_TOO_LONG_STRING = 1162;
    exports2.ER_TABLE_CANT_HANDLE_BLOB = 1163;
    exports2.ER_TABLE_CANT_HANDLE_AUTO_INCREMENT = 1164;
    exports2.ER_UNUSED3 = 1165;
    exports2.ER_WRONG_COLUMN_NAME = 1166;
    exports2.ER_WRONG_KEY_COLUMN = 1167;
    exports2.ER_WRONG_MRG_TABLE = 1168;
    exports2.ER_DUP_UNIQUE = 1169;
    exports2.ER_BLOB_KEY_WITHOUT_LENGTH = 1170;
    exports2.ER_PRIMARY_CANT_HAVE_NULL = 1171;
    exports2.ER_TOO_MANY_ROWS = 1172;
    exports2.ER_REQUIRES_PRIMARY_KEY = 1173;
    exports2.ER_NO_RAID_COMPILED = 1174;
    exports2.ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE = 1175;
    exports2.ER_KEY_DOES_NOT_EXITS = 1176;
    exports2.ER_CHECK_NO_SUCH_TABLE = 1177;
    exports2.ER_CHECK_NOT_IMPLEMENTED = 1178;
    exports2.ER_CANT_DO_THIS_DURING_AN_TRANSACTION = 1179;
    exports2.ER_ERROR_DURING_COMMIT = 1180;
    exports2.ER_ERROR_DURING_ROLLBACK = 1181;
    exports2.ER_ERROR_DURING_FLUSH_LOGS = 1182;
    exports2.ER_ERROR_DURING_CHECKPOINT = 1183;
    exports2.ER_NEW_ABORTING_CONNECTION = 1184;
    exports2.ER_DUMP_NOT_IMPLEMENTED = 1185;
    exports2.ER_FLUSH_MASTER_BINLOG_CLOSED = 1186;
    exports2.ER_INDEX_REBUILD = 1187;
    exports2.ER_SOURCE = 1188;
    exports2.ER_SOURCE_NET_READ = 1189;
    exports2.ER_SOURCE_NET_WRITE = 1190;
    exports2.ER_FT_MATCHING_KEY_NOT_FOUND = 1191;
    exports2.ER_LOCK_OR_ACTIVE_TRANSACTION = 1192;
    exports2.ER_UNKNOWN_SYSTEM_VARIABLE = 1193;
    exports2.ER_CRASHED_ON_USAGE = 1194;
    exports2.ER_CRASHED_ON_REPAIR = 1195;
    exports2.ER_WARNING_NOT_COMPLETE_ROLLBACK = 1196;
    exports2.ER_TRANS_CACHE_FULL = 1197;
    exports2.ER_SLAVE_MUST_STOP = 1198;
    exports2.ER_REPLICA_NOT_RUNNING = 1199;
    exports2.ER_BAD_REPLICA = 1200;
    exports2.ER_CONNECTION_METADATA = 1201;
    exports2.ER_REPLICA_THREAD = 1202;
    exports2.ER_TOO_MANY_USER_CONNECTIONS = 1203;
    exports2.ER_SET_CONSTANTS_ONLY = 1204;
    exports2.ER_LOCK_WAIT_TIMEOUT = 1205;
    exports2.ER_LOCK_TABLE_FULL = 1206;
    exports2.ER_READ_ONLY_TRANSACTION = 1207;
    exports2.ER_DROP_DB_WITH_READ_LOCK = 1208;
    exports2.ER_CREATE_DB_WITH_READ_LOCK = 1209;
    exports2.ER_WRONG_ARGUMENTS = 1210;
    exports2.ER_NO_PERMISSION_TO_CREATE_USER = 1211;
    exports2.ER_UNION_TABLES_IN_DIFFERENT_DIR = 1212;
    exports2.ER_LOCK_DEADLOCK = 1213;
    exports2.ER_TABLE_CANT_HANDLE_FT = 1214;
    exports2.ER_CANNOT_ADD_FOREIGN = 1215;
    exports2.ER_NO_REFERENCED_ROW = 1216;
    exports2.ER_ROW_IS_REFERENCED = 1217;
    exports2.ER_CONNECT_TO_SOURCE = 1218;
    exports2.ER_QUERY_ON_MASTER = 1219;
    exports2.ER_ERROR_WHEN_EXECUTING_COMMAND = 1220;
    exports2.ER_WRONG_USAGE = 1221;
    exports2.ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT = 1222;
    exports2.ER_CANT_UPDATE_WITH_READLOCK = 1223;
    exports2.ER_MIXING_NOT_ALLOWED = 1224;
    exports2.ER_DUP_ARGUMENT = 1225;
    exports2.ER_USER_LIMIT_REACHED = 1226;
    exports2.ER_SPECIFIC_ACCESS_DENIED_ERROR = 1227;
    exports2.ER_LOCAL_VARIABLE = 1228;
    exports2.ER_GLOBAL_VARIABLE = 1229;
    exports2.ER_NO_DEFAULT = 1230;
    exports2.ER_WRONG_VALUE_FOR_VAR = 1231;
    exports2.ER_WRONG_TYPE_FOR_VAR = 1232;
    exports2.ER_VAR_CANT_BE_READ = 1233;
    exports2.ER_CANT_USE_OPTION_HERE = 1234;
    exports2.ER_NOT_SUPPORTED_YET = 1235;
    exports2.ER_SOURCE_FATAL_ERROR_READING_BINLOG = 1236;
    exports2.ER_REPLICA_IGNORED_TABLE = 1237;
    exports2.ER_INCORRECT_GLOBAL_LOCAL_VAR = 1238;
    exports2.ER_WRONG_FK_DEF = 1239;
    exports2.ER_KEY_REF_DO_NOT_MATCH_TABLE_REF = 1240;
    exports2.ER_OPERAND_COLUMNS = 1241;
    exports2.ER_SUBQUERY_NO_1_ROW = 1242;
    exports2.ER_UNKNOWN_STMT_HANDLER = 1243;
    exports2.ER_CORRUPT_HELP_DB = 1244;
    exports2.ER_CYCLIC_REFERENCE = 1245;
    exports2.ER_AUTO_CONVERT = 1246;
    exports2.ER_ILLEGAL_REFERENCE = 1247;
    exports2.ER_DERIVED_MUST_HAVE_ALIAS = 1248;
    exports2.ER_SELECT_REDUCED = 1249;
    exports2.ER_TABLENAME_NOT_ALLOWED_HERE = 1250;
    exports2.ER_NOT_SUPPORTED_AUTH_MODE = 1251;
    exports2.ER_SPATIAL_CANT_HAVE_NULL = 1252;
    exports2.ER_COLLATION_CHARSET_MISMATCH = 1253;
    exports2.ER_SLAVE_WAS_RUNNING = 1254;
    exports2.ER_SLAVE_WAS_NOT_RUNNING = 1255;
    exports2.ER_TOO_BIG_FOR_UNCOMPRESS = 1256;
    exports2.ER_ZLIB_Z_MEM_ERROR = 1257;
    exports2.ER_ZLIB_Z_BUF_ERROR = 1258;
    exports2.ER_ZLIB_Z_DATA_ERROR = 1259;
    exports2.ER_CUT_VALUE_GROUP_CONCAT = 1260;
    exports2.ER_WARN_TOO_FEW_RECORDS = 1261;
    exports2.ER_WARN_TOO_MANY_RECORDS = 1262;
    exports2.ER_WARN_NULL_TO_NOTNULL = 1263;
    exports2.ER_WARN_DATA_OUT_OF_RANGE = 1264;
    exports2.WARN_DATA_TRUNCATED = 1265;
    exports2.ER_WARN_USING_OTHER_HANDLER = 1266;
    exports2.ER_CANT_AGGREGATE_2COLLATIONS = 1267;
    exports2.ER_DROP_USER = 1268;
    exports2.ER_REVOKE_GRANTS = 1269;
    exports2.ER_CANT_AGGREGATE_3COLLATIONS = 1270;
    exports2.ER_CANT_AGGREGATE_NCOLLATIONS = 1271;
    exports2.ER_VARIABLE_IS_NOT_STRUCT = 1272;
    exports2.ER_UNKNOWN_COLLATION = 1273;
    exports2.ER_REPLICA_IGNORED_SSL_PARAMS = 1274;
    exports2.ER_SERVER_IS_IN_SECURE_AUTH_MODE = 1275;
    exports2.ER_WARN_FIELD_RESOLVED = 1276;
    exports2.ER_BAD_REPLICA_UNTIL_COND = 1277;
    exports2.ER_MISSING_SKIP_REPLICA = 1278;
    exports2.ER_UNTIL_COND_IGNORED = 1279;
    exports2.ER_WRONG_NAME_FOR_INDEX = 1280;
    exports2.ER_WRONG_NAME_FOR_CATALOG = 1281;
    exports2.ER_WARN_QC_RESIZE = 1282;
    exports2.ER_BAD_FT_COLUMN = 1283;
    exports2.ER_UNKNOWN_KEY_CACHE = 1284;
    exports2.ER_WARN_HOSTNAME_WONT_WORK = 1285;
    exports2.ER_UNKNOWN_STORAGE_ENGINE = 1286;
    exports2.ER_WARN_DEPRECATED_SYNTAX = 1287;
    exports2.ER_NON_UPDATABLE_TABLE = 1288;
    exports2.ER_FEATURE_DISABLED = 1289;
    exports2.ER_OPTION_PREVENTS_STATEMENT = 1290;
    exports2.ER_DUPLICATED_VALUE_IN_TYPE = 1291;
    exports2.ER_TRUNCATED_WRONG_VALUE = 1292;
    exports2.ER_TOO_MUCH_AUTO_TIMESTAMP_COLS = 1293;
    exports2.ER_INVALID_ON_UPDATE = 1294;
    exports2.ER_UNSUPPORTED_PS = 1295;
    exports2.ER_GET_ERRMSG = 1296;
    exports2.ER_GET_TEMPORARY_ERRMSG = 1297;
    exports2.ER_UNKNOWN_TIME_ZONE = 1298;
    exports2.ER_WARN_INVALID_TIMESTAMP = 1299;
    exports2.ER_INVALID_CHARACTER_STRING = 1300;
    exports2.ER_WARN_ALLOWED_PACKET_OVERFLOWED = 1301;
    exports2.ER_CONFLICTING_DECLARATIONS = 1302;
    exports2.ER_SP_NO_RECURSIVE_CREATE = 1303;
    exports2.ER_SP_ALREADY_EXISTS = 1304;
    exports2.ER_SP_DOES_NOT_EXIST = 1305;
    exports2.ER_SP_DROP_FAILED = 1306;
    exports2.ER_SP_STORE_FAILED = 1307;
    exports2.ER_SP_LILABEL_MISMATCH = 1308;
    exports2.ER_SP_LABEL_REDEFINE = 1309;
    exports2.ER_SP_LABEL_MISMATCH = 1310;
    exports2.ER_SP_UNINIT_VAR = 1311;
    exports2.ER_SP_BADSELECT = 1312;
    exports2.ER_SP_BADRETURN = 1313;
    exports2.ER_SP_BADSTATEMENT = 1314;
    exports2.ER_UPDATE_LOG_DEPRECATED_IGNORED = 1315;
    exports2.ER_UPDATE_LOG_DEPRECATED_TRANSLATED = 1316;
    exports2.ER_QUERY_INTERRUPTED = 1317;
    exports2.ER_SP_WRONG_NO_OF_ARGS = 1318;
    exports2.ER_SP_COND_MISMATCH = 1319;
    exports2.ER_SP_NORETURN = 1320;
    exports2.ER_SP_NORETURNEND = 1321;
    exports2.ER_SP_BAD_CURSOR_QUERY = 1322;
    exports2.ER_SP_BAD_CURSOR_SELECT = 1323;
    exports2.ER_SP_CURSOR_MISMATCH = 1324;
    exports2.ER_SP_CURSOR_ALREADY_OPEN = 1325;
    exports2.ER_SP_CURSOR_NOT_OPEN = 1326;
    exports2.ER_SP_UNDECLARED_VAR = 1327;
    exports2.ER_SP_WRONG_NO_OF_FETCH_ARGS = 1328;
    exports2.ER_SP_FETCH_NO_DATA = 1329;
    exports2.ER_SP_DUP_PARAM = 1330;
    exports2.ER_SP_DUP_VAR = 1331;
    exports2.ER_SP_DUP_COND = 1332;
    exports2.ER_SP_DUP_CURS = 1333;
    exports2.ER_SP_CANT_ALTER = 1334;
    exports2.ER_SP_SUBSELECT_NYI = 1335;
    exports2.ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG = 1336;
    exports2.ER_SP_VARCOND_AFTER_CURSHNDLR = 1337;
    exports2.ER_SP_CURSOR_AFTER_HANDLER = 1338;
    exports2.ER_SP_CASE_NOT_FOUND = 1339;
    exports2.ER_FPARSER_TOO_BIG_FILE = 1340;
    exports2.ER_FPARSER_BAD_HEADER = 1341;
    exports2.ER_FPARSER_EOF_IN_COMMENT = 1342;
    exports2.ER_FPARSER_ERROR_IN_PARAMETER = 1343;
    exports2.ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER = 1344;
    exports2.ER_VIEW_NO_EXPLAIN = 1345;
    exports2.ER_FRM_UNKNOWN_TYPE = 1346;
    exports2.ER_WRONG_OBJECT = 1347;
    exports2.ER_NONUPDATEABLE_COLUMN = 1348;
    exports2.ER_VIEW_SELECT_DERIVED = 1349;
    exports2.ER_VIEW_SELECT_CLAUSE = 1350;
    exports2.ER_VIEW_SELECT_VARIABLE = 1351;
    exports2.ER_VIEW_SELECT_TMPTABLE = 1352;
    exports2.ER_VIEW_WRONG_LIST = 1353;
    exports2.ER_WARN_VIEW_MERGE = 1354;
    exports2.ER_WARN_VIEW_WITHOUT_KEY = 1355;
    exports2.ER_VIEW_INVALID = 1356;
    exports2.ER_SP_NO_DROP_SP = 1357;
    exports2.ER_SP_GOTO_IN_HNDLR = 1358;
    exports2.ER_TRG_ALREADY_EXISTS = 1359;
    exports2.ER_TRG_DOES_NOT_EXIST = 1360;
    exports2.ER_TRG_ON_VIEW_OR_TEMP_TABLE = 1361;
    exports2.ER_TRG_CANT_CHANGE_ROW = 1362;
    exports2.ER_TRG_NO_SUCH_ROW_IN_TRG = 1363;
    exports2.ER_NO_DEFAULT_FOR_FIELD = 1364;
    exports2.ER_DIVISION_BY_ZERO = 1365;
    exports2.ER_TRUNCATED_WRONG_VALUE_FOR_FIELD = 1366;
    exports2.ER_ILLEGAL_VALUE_FOR_TYPE = 1367;
    exports2.ER_VIEW_NONUPD_CHECK = 1368;
    exports2.ER_VIEW_CHECK_FAILED = 1369;
    exports2.ER_PROCACCESS_DENIED_ERROR = 1370;
    exports2.ER_RELAY_LOG_FAIL = 1371;
    exports2.ER_PASSWD_LENGTH = 1372;
    exports2.ER_UNKNOWN_TARGET_BINLOG = 1373;
    exports2.ER_IO_ERR_LOG_INDEX_READ = 1374;
    exports2.ER_BINLOG_PURGE_PROHIBITED = 1375;
    exports2.ER_FSEEK_FAIL = 1376;
    exports2.ER_BINLOG_PURGE_FATAL_ERR = 1377;
    exports2.ER_LOG_IN_USE = 1378;
    exports2.ER_LOG_PURGE_UNKNOWN_ERR = 1379;
    exports2.ER_RELAY_LOG_INIT = 1380;
    exports2.ER_NO_BINARY_LOGGING = 1381;
    exports2.ER_RESERVED_SYNTAX = 1382;
    exports2.ER_WSAS_FAILED = 1383;
    exports2.ER_DIFF_GROUPS_PROC = 1384;
    exports2.ER_NO_GROUP_FOR_PROC = 1385;
    exports2.ER_ORDER_WITH_PROC = 1386;
    exports2.ER_LOGGING_PROHIBIT_CHANGING_OF = 1387;
    exports2.ER_NO_FILE_MAPPING = 1388;
    exports2.ER_WRONG_MAGIC = 1389;
    exports2.ER_PS_MANY_PARAM = 1390;
    exports2.ER_KEY_PART_0 = 1391;
    exports2.ER_VIEW_CHECKSUM = 1392;
    exports2.ER_VIEW_MULTIUPDATE = 1393;
    exports2.ER_VIEW_NO_INSERT_FIELD_LIST = 1394;
    exports2.ER_VIEW_DELETE_MERGE_VIEW = 1395;
    exports2.ER_CANNOT_USER = 1396;
    exports2.ER_XAER_NOTA = 1397;
    exports2.ER_XAER_INVAL = 1398;
    exports2.ER_XAER_RMFAIL = 1399;
    exports2.ER_XAER_OUTSIDE = 1400;
    exports2.ER_XAER_RMERR = 1401;
    exports2.ER_XA_RBROLLBACK = 1402;
    exports2.ER_NONEXISTING_PROC_GRANT = 1403;
    exports2.ER_PROC_AUTO_GRANT_FAIL = 1404;
    exports2.ER_PROC_AUTO_REVOKE_FAIL = 1405;
    exports2.ER_DATA_TOO_LONG = 1406;
    exports2.ER_SP_BAD_SQLSTATE = 1407;
    exports2.ER_STARTUP = 1408;
    exports2.ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR = 1409;
    exports2.ER_CANT_CREATE_USER_WITH_GRANT = 1410;
    exports2.ER_WRONG_VALUE_FOR_TYPE = 1411;
    exports2.ER_TABLE_DEF_CHANGED = 1412;
    exports2.ER_SP_DUP_HANDLER = 1413;
    exports2.ER_SP_NOT_VAR_ARG = 1414;
    exports2.ER_SP_NO_RETSET = 1415;
    exports2.ER_CANT_CREATE_GEOMETRY_OBJECT = 1416;
    exports2.ER_FAILED_ROUTINE_BREAK_BINLOG = 1417;
    exports2.ER_BINLOG_UNSAFE_ROUTINE = 1418;
    exports2.ER_BINLOG_CREATE_ROUTINE_NEED_SUPER = 1419;
    exports2.ER_EXEC_STMT_WITH_OPEN_CURSOR = 1420;
    exports2.ER_STMT_HAS_NO_OPEN_CURSOR = 1421;
    exports2.ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG = 1422;
    exports2.ER_NO_DEFAULT_FOR_VIEW_FIELD = 1423;
    exports2.ER_SP_NO_RECURSION = 1424;
    exports2.ER_TOO_BIG_SCALE = 1425;
    exports2.ER_TOO_BIG_PRECISION = 1426;
    exports2.ER_M_BIGGER_THAN_D = 1427;
    exports2.ER_WRONG_LOCK_OF_SYSTEM_TABLE = 1428;
    exports2.ER_CONNECT_TO_FOREIGN_DATA_SOURCE = 1429;
    exports2.ER_QUERY_ON_FOREIGN_DATA_SOURCE = 1430;
    exports2.ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST = 1431;
    exports2.ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE = 1432;
    exports2.ER_FOREIGN_DATA_STRING_INVALID = 1433;
    exports2.ER_CANT_CREATE_FEDERATED_TABLE = 1434;
    exports2.ER_TRG_IN_WRONG_SCHEMA = 1435;
    exports2.ER_STACK_OVERRUN_NEED_MORE = 1436;
    exports2.ER_TOO_LONG_BODY = 1437;
    exports2.ER_WARN_CANT_DROP_DEFAULT_KEYCACHE = 1438;
    exports2.ER_TOO_BIG_DISPLAYWIDTH = 1439;
    exports2.ER_XAER_DUPID = 1440;
    exports2.ER_DATETIME_FUNCTION_OVERFLOW = 1441;
    exports2.ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG = 1442;
    exports2.ER_VIEW_PREVENT_UPDATE = 1443;
    exports2.ER_PS_NO_RECURSION = 1444;
    exports2.ER_SP_CANT_SET_AUTOCOMMIT = 1445;
    exports2.ER_MALFORMED_DEFINER = 1446;
    exports2.ER_VIEW_FRM_NO_USER = 1447;
    exports2.ER_VIEW_OTHER_USER = 1448;
    exports2.ER_NO_SUCH_USER = 1449;
    exports2.ER_FORBID_SCHEMA_CHANGE = 1450;
    exports2.ER_ROW_IS_REFERENCED_2 = 1451;
    exports2.ER_NO_REFERENCED_ROW_2 = 1452;
    exports2.ER_SP_BAD_VAR_SHADOW = 1453;
    exports2.ER_TRG_NO_DEFINER = 1454;
    exports2.ER_OLD_FILE_FORMAT = 1455;
    exports2.ER_SP_RECURSION_LIMIT = 1456;
    exports2.ER_SP_PROC_TABLE_CORRUPT = 1457;
    exports2.ER_SP_WRONG_NAME = 1458;
    exports2.ER_TABLE_NEEDS_UPGRADE = 1459;
    exports2.ER_SP_NO_AGGREGATE = 1460;
    exports2.ER_MAX_PREPARED_STMT_COUNT_REACHED = 1461;
    exports2.ER_VIEW_RECURSIVE = 1462;
    exports2.ER_NON_GROUPING_FIELD_USED = 1463;
    exports2.ER_TABLE_CANT_HANDLE_SPKEYS = 1464;
    exports2.ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA = 1465;
    exports2.ER_REMOVED_SPACES = 1466;
    exports2.ER_AUTOINC_READ_FAILED = 1467;
    exports2.ER_USERNAME = 1468;
    exports2.ER_HOSTNAME = 1469;
    exports2.ER_WRONG_STRING_LENGTH = 1470;
    exports2.ER_NON_INSERTABLE_TABLE = 1471;
    exports2.ER_ADMIN_WRONG_MRG_TABLE = 1472;
    exports2.ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT = 1473;
    exports2.ER_NAME_BECOMES_EMPTY = 1474;
    exports2.ER_AMBIGUOUS_FIELD_TERM = 1475;
    exports2.ER_FOREIGN_SERVER_EXISTS = 1476;
    exports2.ER_FOREIGN_SERVER_DOESNT_EXIST = 1477;
    exports2.ER_ILLEGAL_HA_CREATE_OPTION = 1478;
    exports2.ER_PARTITION_REQUIRES_VALUES_ERROR = 1479;
    exports2.ER_PARTITION_WRONG_VALUES_ERROR = 1480;
    exports2.ER_PARTITION_MAXVALUE_ERROR = 1481;
    exports2.ER_PARTITION_SUBPARTITION_ERROR = 1482;
    exports2.ER_PARTITION_SUBPART_MIX_ERROR = 1483;
    exports2.ER_PARTITION_WRONG_NO_PART_ERROR = 1484;
    exports2.ER_PARTITION_WRONG_NO_SUBPART_ERROR = 1485;
    exports2.ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR = 1486;
    exports2.ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR = 1487;
    exports2.ER_FIELD_NOT_FOUND_PART_ERROR = 1488;
    exports2.ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR = 1489;
    exports2.ER_INCONSISTENT_PARTITION_INFO_ERROR = 1490;
    exports2.ER_PARTITION_FUNC_NOT_ALLOWED_ERROR = 1491;
    exports2.ER_PARTITIONS_MUST_BE_DEFINED_ERROR = 1492;
    exports2.ER_RANGE_NOT_INCREASING_ERROR = 1493;
    exports2.ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR = 1494;
    exports2.ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR = 1495;
    exports2.ER_PARTITION_ENTRY_ERROR = 1496;
    exports2.ER_MIX_HANDLER_ERROR = 1497;
    exports2.ER_PARTITION_NOT_DEFINED_ERROR = 1498;
    exports2.ER_TOO_MANY_PARTITIONS_ERROR = 1499;
    exports2.ER_SUBPARTITION_ERROR = 1500;
    exports2.ER_CANT_CREATE_HANDLER_FILE = 1501;
    exports2.ER_BLOB_FIELD_IN_PART_FUNC_ERROR = 1502;
    exports2.ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF = 1503;
    exports2.ER_NO_PARTS_ERROR = 1504;
    exports2.ER_PARTITION_MGMT_ON_NONPARTITIONED = 1505;
    exports2.ER_FOREIGN_KEY_ON_PARTITIONED = 1506;
    exports2.ER_DROP_PARTITION_NON_EXISTENT = 1507;
    exports2.ER_DROP_LAST_PARTITION = 1508;
    exports2.ER_COALESCE_ONLY_ON_HASH_PARTITION = 1509;
    exports2.ER_REORG_HASH_ONLY_ON_SAME_NO = 1510;
    exports2.ER_REORG_NO_PARAM_ERROR = 1511;
    exports2.ER_ONLY_ON_RANGE_LIST_PARTITION = 1512;
    exports2.ER_ADD_PARTITION_SUBPART_ERROR = 1513;
    exports2.ER_ADD_PARTITION_NO_NEW_PARTITION = 1514;
    exports2.ER_COALESCE_PARTITION_NO_PARTITION = 1515;
    exports2.ER_REORG_PARTITION_NOT_EXIST = 1516;
    exports2.ER_SAME_NAME_PARTITION = 1517;
    exports2.ER_NO_BINLOG_ERROR = 1518;
    exports2.ER_CONSECUTIVE_REORG_PARTITIONS = 1519;
    exports2.ER_REORG_OUTSIDE_RANGE = 1520;
    exports2.ER_PARTITION_FUNCTION_FAILURE = 1521;
    exports2.ER_PART_STATE_ERROR = 1522;
    exports2.ER_LIMITED_PART_RANGE = 1523;
    exports2.ER_PLUGIN_IS_NOT_LOADED = 1524;
    exports2.ER_WRONG_VALUE = 1525;
    exports2.ER_NO_PARTITION_FOR_GIVEN_VALUE = 1526;
    exports2.ER_FILEGROUP_OPTION_ONLY_ONCE = 1527;
    exports2.ER_CREATE_FILEGROUP_FAILED = 1528;
    exports2.ER_DROP_FILEGROUP_FAILED = 1529;
    exports2.ER_TABLESPACE_AUTO_EXTEND_ERROR = 1530;
    exports2.ER_WRONG_SIZE_NUMBER = 1531;
    exports2.ER_SIZE_OVERFLOW_ERROR = 1532;
    exports2.ER_ALTER_FILEGROUP_FAILED = 1533;
    exports2.ER_BINLOG_ROW_LOGGING_FAILED = 1534;
    exports2.ER_BINLOG_ROW_WRONG_TABLE_DEF = 1535;
    exports2.ER_BINLOG_ROW_RBR_TO_SBR = 1536;
    exports2.ER_EVENT_ALREADY_EXISTS = 1537;
    exports2.ER_EVENT_STORE_FAILED = 1538;
    exports2.ER_EVENT_DOES_NOT_EXIST = 1539;
    exports2.ER_EVENT_CANT_ALTER = 1540;
    exports2.ER_EVENT_DROP_FAILED = 1541;
    exports2.ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG = 1542;
    exports2.ER_EVENT_ENDS_BEFORE_STARTS = 1543;
    exports2.ER_EVENT_EXEC_TIME_IN_THE_PAST = 1544;
    exports2.ER_EVENT_OPEN_TABLE_FAILED = 1545;
    exports2.ER_EVENT_NEITHER_M_EXPR_NOR_M_AT = 1546;
    exports2.ER_COL_COUNT_DOESNT_MATCH_CORRUPTED = 1547;
    exports2.ER_CANNOT_LOAD_FROM_TABLE = 1548;
    exports2.ER_EVENT_CANNOT_DELETE = 1549;
    exports2.ER_EVENT_COMPILE_ERROR = 1550;
    exports2.ER_EVENT_SAME_NAME = 1551;
    exports2.ER_EVENT_DATA_TOO_LONG = 1552;
    exports2.ER_DROP_INDEX_FK = 1553;
    exports2.ER_WARN_DEPRECATED_SYNTAX_WITH_VER = 1554;
    exports2.ER_CANT_WRITE_LOCK_LOG_TABLE = 1555;
    exports2.ER_CANT_LOCK_LOG_TABLE = 1556;
    exports2.ER_FOREIGN_DUPLICATE_KEY = 1557;
    exports2.ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE = 1558;
    exports2.ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR = 1559;
    exports2.ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1560;
    exports2.ER_NDB_CANT_SWITCH_BINLOG_FORMAT = 1561;
    exports2.ER_PARTITION_NO_TEMPORARY = 1562;
    exports2.ER_PARTITION_CONST_DOMAIN_ERROR = 1563;
    exports2.ER_PARTITION_FUNCTION_IS_NOT_ALLOWED = 1564;
    exports2.ER_DDL_LOG_ERROR = 1565;
    exports2.ER_NULL_IN_VALUES_LESS_THAN = 1566;
    exports2.ER_WRONG_PARTITION_NAME = 1567;
    exports2.ER_CANT_CHANGE_TX_CHARACTERISTICS = 1568;
    exports2.ER_DUP_ENTRY_AUTOINCREMENT_CASE = 1569;
    exports2.ER_EVENT_MODIFY_QUEUE_ERROR = 1570;
    exports2.ER_EVENT_SET_VAR_ERROR = 1571;
    exports2.ER_PARTITION_MERGE_ERROR = 1572;
    exports2.ER_CANT_ACTIVATE_LOG = 1573;
    exports2.ER_RBR_NOT_AVAILABLE = 1574;
    exports2.ER_BASE64_DECODE_ERROR = 1575;
    exports2.ER_EVENT_RECURSION_FORBIDDEN = 1576;
    exports2.ER_EVENTS_DB_ERROR = 1577;
    exports2.ER_ONLY_INTEGERS_ALLOWED = 1578;
    exports2.ER_UNSUPORTED_LOG_ENGINE = 1579;
    exports2.ER_BAD_LOG_STATEMENT = 1580;
    exports2.ER_CANT_RENAME_LOG_TABLE = 1581;
    exports2.ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT = 1582;
    exports2.ER_WRONG_PARAMETERS_TO_NATIVE_FCT = 1583;
    exports2.ER_WRONG_PARAMETERS_TO_STORED_FCT = 1584;
    exports2.ER_NATIVE_FCT_NAME_COLLISION = 1585;
    exports2.ER_DUP_ENTRY_WITH_KEY_NAME = 1586;
    exports2.ER_BINLOG_PURGE_EMFILE = 1587;
    exports2.ER_EVENT_CANNOT_CREATE_IN_THE_PAST = 1588;
    exports2.ER_EVENT_CANNOT_ALTER_IN_THE_PAST = 1589;
    exports2.ER_SLAVE_INCIDENT = 1590;
    exports2.ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT = 1591;
    exports2.ER_BINLOG_UNSAFE_STATEMENT = 1592;
    exports2.ER_BINLOG_FATAL_ERROR = 1593;
    exports2.ER_SLAVE_RELAY_LOG_READ_FAILURE = 1594;
    exports2.ER_SLAVE_RELAY_LOG_WRITE_FAILURE = 1595;
    exports2.ER_SLAVE_CREATE_EVENT_FAILURE = 1596;
    exports2.ER_SLAVE_MASTER_COM_FAILURE = 1597;
    exports2.ER_BINLOG_LOGGING_IMPOSSIBLE = 1598;
    exports2.ER_VIEW_NO_CREATION_CTX = 1599;
    exports2.ER_VIEW_INVALID_CREATION_CTX = 1600;
    exports2.ER_SR_INVALID_CREATION_CTX = 1601;
    exports2.ER_TRG_CORRUPTED_FILE = 1602;
    exports2.ER_TRG_NO_CREATION_CTX = 1603;
    exports2.ER_TRG_INVALID_CREATION_CTX = 1604;
    exports2.ER_EVENT_INVALID_CREATION_CTX = 1605;
    exports2.ER_TRG_CANT_OPEN_TABLE = 1606;
    exports2.ER_CANT_CREATE_SROUTINE = 1607;
    exports2.ER_NEVER_USED = 1608;
    exports2.ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT = 1609;
    exports2.ER_REPLICA_CORRUPT_EVENT = 1610;
    exports2.ER_LOAD_DATA_INVALID_COLUMN = 1611;
    exports2.ER_LOG_PURGE_NO_FILE = 1612;
    exports2.ER_XA_RBTIMEOUT = 1613;
    exports2.ER_XA_RBDEADLOCK = 1614;
    exports2.ER_NEED_REPREPARE = 1615;
    exports2.ER_DELAYED_NOT_SUPPORTED = 1616;
    exports2.WARN_NO_CONNECTION_METADATA = 1617;
    exports2.WARN_OPTION_IGNORED = 1618;
    exports2.ER_PLUGIN_DELETE_BUILTIN = 1619;
    exports2.WARN_PLUGIN_BUSY = 1620;
    exports2.ER_VARIABLE_IS_READONLY = 1621;
    exports2.ER_WARN_ENGINE_TRANSACTION_ROLLBACK = 1622;
    exports2.ER_SLAVE_HEARTBEAT_FAILURE = 1623;
    exports2.ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE = 1624;
    exports2.ER_NDB_REPLICATION_SCHEMA_ERROR = 1625;
    exports2.ER_CONFLICT_FN_PARSE_ERROR = 1626;
    exports2.ER_EXCEPTIONS_WRITE_ERROR = 1627;
    exports2.ER_TOO_LONG_TABLE_COMMENT = 1628;
    exports2.ER_TOO_LONG_FIELD_COMMENT = 1629;
    exports2.ER_FUNC_INEXISTENT_NAME_COLLISION = 1630;
    exports2.ER_DATABASE_NAME = 1631;
    exports2.ER_TABLE_NAME = 1632;
    exports2.ER_PARTITION_NAME = 1633;
    exports2.ER_SUBPARTITION_NAME = 1634;
    exports2.ER_TEMPORARY_NAME = 1635;
    exports2.ER_RENAMED_NAME = 1636;
    exports2.ER_TOO_MANY_CONCURRENT_TRXS = 1637;
    exports2.WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED = 1638;
    exports2.ER_DEBUG_SYNC_TIMEOUT = 1639;
    exports2.ER_DEBUG_SYNC_HIT_LIMIT = 1640;
    exports2.ER_DUP_SIGNAL_SET = 1641;
    exports2.ER_SIGNAL_WARN = 1642;
    exports2.ER_SIGNAL_NOT_FOUND = 1643;
    exports2.ER_SIGNAL_EXCEPTION = 1644;
    exports2.ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER = 1645;
    exports2.ER_SIGNAL_BAD_CONDITION_TYPE = 1646;
    exports2.WARN_COND_ITEM_TRUNCATED = 1647;
    exports2.ER_COND_ITEM_TOO_LONG = 1648;
    exports2.ER_UNKNOWN_LOCALE = 1649;
    exports2.ER_REPLICA_IGNORE_SERVER_IDS = 1650;
    exports2.ER_QUERY_CACHE_DISABLED = 1651;
    exports2.ER_SAME_NAME_PARTITION_FIELD = 1652;
    exports2.ER_PARTITION_COLUMN_LIST_ERROR = 1653;
    exports2.ER_WRONG_TYPE_COLUMN_VALUE_ERROR = 1654;
    exports2.ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR = 1655;
    exports2.ER_MAXVALUE_IN_VALUES_IN = 1656;
    exports2.ER_TOO_MANY_VALUES_ERROR = 1657;
    exports2.ER_ROW_SINGLE_PARTITION_FIELD_ERROR = 1658;
    exports2.ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD = 1659;
    exports2.ER_PARTITION_FIELDS_TOO_LONG = 1660;
    exports2.ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE = 1661;
    exports2.ER_BINLOG_ROW_MODE_AND_STMT_ENGINE = 1662;
    exports2.ER_BINLOG_UNSAFE_AND_STMT_ENGINE = 1663;
    exports2.ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE = 1664;
    exports2.ER_BINLOG_STMT_MODE_AND_ROW_ENGINE = 1665;
    exports2.ER_BINLOG_ROW_INJECTION_AND_STMT_MODE = 1666;
    exports2.ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1667;
    exports2.ER_BINLOG_UNSAFE_LIMIT = 1668;
    exports2.ER_UNUSED4 = 1669;
    exports2.ER_BINLOG_UNSAFE_SYSTEM_TABLE = 1670;
    exports2.ER_BINLOG_UNSAFE_AUTOINC_COLUMNS = 1671;
    exports2.ER_BINLOG_UNSAFE_UDF = 1672;
    exports2.ER_BINLOG_UNSAFE_SYSTEM_VARIABLE = 1673;
    exports2.ER_BINLOG_UNSAFE_SYSTEM_FUNCTION = 1674;
    exports2.ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS = 1675;
    exports2.ER_MESSAGE_AND_STATEMENT = 1676;
    exports2.ER_SLAVE_CONVERSION_FAILED = 1677;
    exports2.ER_REPLICA_CANT_CREATE_CONVERSION = 1678;
    exports2.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT = 1679;
    exports2.ER_PATH_LENGTH = 1680;
    exports2.ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT = 1681;
    exports2.ER_WRONG_NATIVE_TABLE_STRUCTURE = 1682;
    exports2.ER_WRONG_PERFSCHEMA_USAGE = 1683;
    exports2.ER_WARN_I_S_SKIPPED_TABLE = 1684;
    exports2.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1685;
    exports2.ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT = 1686;
    exports2.ER_SPATIAL_MUST_HAVE_GEOM_COL = 1687;
    exports2.ER_TOO_LONG_INDEX_COMMENT = 1688;
    exports2.ER_LOCK_ABORTED = 1689;
    exports2.ER_DATA_OUT_OF_RANGE = 1690;
    exports2.ER_WRONG_SPVAR_TYPE_IN_LIMIT = 1691;
    exports2.ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE = 1692;
    exports2.ER_BINLOG_UNSAFE_MIXED_STATEMENT = 1693;
    exports2.ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1694;
    exports2.ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN = 1695;
    exports2.ER_FAILED_READ_FROM_PAR_FILE = 1696;
    exports2.ER_VALUES_IS_NOT_INT_TYPE_ERROR = 1697;
    exports2.ER_ACCESS_DENIED_NO_PASSWORD_ERROR = 1698;
    exports2.ER_SET_PASSWORD_AUTH_PLUGIN = 1699;
    exports2.ER_GRANT_PLUGIN_USER_EXISTS = 1700;
    exports2.ER_TRUNCATE_ILLEGAL_FK = 1701;
    exports2.ER_PLUGIN_IS_PERMANENT = 1702;
    exports2.ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN = 1703;
    exports2.ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX = 1704;
    exports2.ER_STMT_CACHE_FULL = 1705;
    exports2.ER_MULTI_UPDATE_KEY_CONFLICT = 1706;
    exports2.ER_TABLE_NEEDS_REBUILD = 1707;
    exports2.WARN_OPTION_BELOW_LIMIT = 1708;
    exports2.ER_INDEX_COLUMN_TOO_LONG = 1709;
    exports2.ER_ERROR_IN_TRIGGER_BODY = 1710;
    exports2.ER_ERROR_IN_UNKNOWN_TRIGGER_BODY = 1711;
    exports2.ER_INDEX_CORRUPT = 1712;
    exports2.ER_UNDO_RECORD_TOO_BIG = 1713;
    exports2.ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT = 1714;
    exports2.ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE = 1715;
    exports2.ER_BINLOG_UNSAFE_REPLACE_SELECT = 1716;
    exports2.ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT = 1717;
    exports2.ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT = 1718;
    exports2.ER_BINLOG_UNSAFE_UPDATE_IGNORE = 1719;
    exports2.ER_PLUGIN_NO_UNINSTALL = 1720;
    exports2.ER_PLUGIN_NO_INSTALL = 1721;
    exports2.ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT = 1722;
    exports2.ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC = 1723;
    exports2.ER_BINLOG_UNSAFE_INSERT_TWO_KEYS = 1724;
    exports2.ER_TABLE_IN_FK_CHECK = 1725;
    exports2.ER_UNSUPPORTED_ENGINE = 1726;
    exports2.ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST = 1727;
    exports2.ER_CANNOT_LOAD_FROM_TABLE_V2 = 1728;
    exports2.ER_SOURCE_DELAY_VALUE_OUT_OF_RANGE = 1729;
    exports2.ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT = 1730;
    exports2.ER_PARTITION_EXCHANGE_DIFFERENT_OPTION = 1731;
    exports2.ER_PARTITION_EXCHANGE_PART_TABLE = 1732;
    exports2.ER_PARTITION_EXCHANGE_TEMP_TABLE = 1733;
    exports2.ER_PARTITION_INSTEAD_OF_SUBPARTITION = 1734;
    exports2.ER_UNKNOWN_PARTITION = 1735;
    exports2.ER_TABLES_DIFFERENT_METADATA = 1736;
    exports2.ER_ROW_DOES_NOT_MATCH_PARTITION = 1737;
    exports2.ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX = 1738;
    exports2.ER_WARN_INDEX_NOT_APPLICABLE = 1739;
    exports2.ER_PARTITION_EXCHANGE_FOREIGN_KEY = 1740;
    exports2.ER_NO_SUCH_KEY_VALUE = 1741;
    exports2.ER_RPL_INFO_DATA_TOO_LONG = 1742;
    exports2.ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE = 1743;
    exports2.ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE = 1744;
    exports2.ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX = 1745;
    exports2.ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT = 1746;
    exports2.ER_PARTITION_CLAUSE_ON_NONPARTITIONED = 1747;
    exports2.ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET = 1748;
    exports2.ER_NO_SUCH_PARTITION = 1749;
    exports2.ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE = 1750;
    exports2.ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE = 1751;
    exports2.ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE = 1752;
    exports2.ER_MTA_FEATURE_IS_NOT_SUPPORTED = 1753;
    exports2.ER_MTA_UPDATED_DBS_GREATER_MAX = 1754;
    exports2.ER_MTA_CANT_PARALLEL = 1755;
    exports2.ER_MTA_INCONSISTENT_DATA = 1756;
    exports2.ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING = 1757;
    exports2.ER_DA_INVALID_CONDITION_NUMBER = 1758;
    exports2.ER_INSECURE_PLAIN_TEXT = 1759;
    exports2.ER_INSECURE_CHANGE_SOURCE = 1760;
    exports2.ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO = 1761;
    exports2.ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO = 1762;
    exports2.ER_SQLTHREAD_WITH_SECURE_REPLICA = 1763;
    exports2.ER_TABLE_HAS_NO_FT = 1764;
    exports2.ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER = 1765;
    exports2.ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION = 1766;
    exports2.ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST = 1767;
    exports2.ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION = 1768;
    exports2.ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION = 1769;
    exports2.ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL = 1770;
    exports2.ER_SKIPPING_LOGGED_TRANSACTION = 1771;
    exports2.ER_MALFORMED_GTID_SET_SPECIFICATION = 1772;
    exports2.ER_MALFORMED_GTID_SET_ENCODING = 1773;
    exports2.ER_MALFORMED_GTID_SPECIFICATION = 1774;
    exports2.ER_GNO_EXHAUSTED = 1775;
    exports2.ER_BAD_REPLICA_AUTO_POSITION = 1776;
    exports2.ER_AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF = 1777;
    exports2.ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET = 1778;
    exports2.ER_GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON = 1779;
    exports2.ER_GTID_MODE_REQUIRES_BINLOG = 1780;
    exports2.ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF = 1781;
    exports2.ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON = 1782;
    exports2.ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF = 1783;
    exports2.ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF = 1784;
    exports2.ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE = 1785;
    exports2.ER_GTID_UNSAFE_CREATE_SELECT = 1786;
    exports2.ER_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRANSACTION = 1787;
    exports2.ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME = 1788;
    exports2.ER_SOURCE_HAS_PURGED_REQUIRED_GTIDS = 1789;
    exports2.ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID = 1790;
    exports2.ER_UNKNOWN_EXPLAIN_FORMAT = 1791;
    exports2.ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION = 1792;
    exports2.ER_TOO_LONG_TABLE_PARTITION_COMMENT = 1793;
    exports2.ER_REPLICA_CONFIGURATION = 1794;
    exports2.ER_INNODB_FT_LIMIT = 1795;
    exports2.ER_INNODB_NO_FT_TEMP_TABLE = 1796;
    exports2.ER_INNODB_FT_WRONG_DOCID_COLUMN = 1797;
    exports2.ER_INNODB_FT_WRONG_DOCID_INDEX = 1798;
    exports2.ER_INNODB_ONLINE_LOG_TOO_BIG = 1799;
    exports2.ER_UNKNOWN_ALTER_ALGORITHM = 1800;
    exports2.ER_UNKNOWN_ALTER_LOCK = 1801;
    exports2.ER_MTA_CHANGE_SOURCE_CANT_RUN_WITH_GAPS = 1802;
    exports2.ER_MTA_RECOVERY_FAILURE = 1803;
    exports2.ER_MTA_RESET_WORKERS = 1804;
    exports2.ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2 = 1805;
    exports2.ER_REPLICA_SILENT_RETRY_TRANSACTION = 1806;
    exports2.ER_DISCARD_FK_CHECKS_RUNNING = 1807;
    exports2.ER_TABLE_SCHEMA_MISMATCH = 1808;
    exports2.ER_TABLE_IN_SYSTEM_TABLESPACE = 1809;
    exports2.ER_IO_READ_ERROR = 1810;
    exports2.ER_IO_WRITE_ERROR = 1811;
    exports2.ER_TABLESPACE_MISSING = 1812;
    exports2.ER_TABLESPACE_EXISTS = 1813;
    exports2.ER_TABLESPACE_DISCARDED = 1814;
    exports2.ER_INTERNAL_ERROR = 1815;
    exports2.ER_INNODB_IMPORT_ERROR = 1816;
    exports2.ER_INNODB_INDEX_CORRUPT = 1817;
    exports2.ER_INVALID_YEAR_COLUMN_LENGTH = 1818;
    exports2.ER_NOT_VALID_PASSWORD = 1819;
    exports2.ER_MUST_CHANGE_PASSWORD = 1820;
    exports2.ER_FK_NO_INDEX_CHILD = 1821;
    exports2.ER_FK_NO_INDEX_PARENT = 1822;
    exports2.ER_FK_FAIL_ADD_SYSTEM = 1823;
    exports2.ER_FK_CANNOT_OPEN_PARENT = 1824;
    exports2.ER_FK_INCORRECT_OPTION = 1825;
    exports2.ER_FK_DUP_NAME = 1826;
    exports2.ER_PASSWORD_FORMAT = 1827;
    exports2.ER_FK_COLUMN_CANNOT_DROP = 1828;
    exports2.ER_FK_COLUMN_CANNOT_DROP_CHILD = 1829;
    exports2.ER_FK_COLUMN_NOT_NULL = 1830;
    exports2.ER_DUP_INDEX = 1831;
    exports2.ER_FK_COLUMN_CANNOT_CHANGE = 1832;
    exports2.ER_FK_COLUMN_CANNOT_CHANGE_CHILD = 1833;
    exports2.ER_UNUSED5 = 1834;
    exports2.ER_MALFORMED_PACKET = 1835;
    exports2.ER_READ_ONLY_MODE = 1836;
    exports2.ER_GTID_NEXT_TYPE_UNDEFINED_GTID = 1837;
    exports2.ER_VARIABLE_NOT_SETTABLE_IN_SP = 1838;
    exports2.ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF = 1839;
    exports2.ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY = 1840;
    exports2.ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY = 1841;
    exports2.ER_GTID_PURGED_WAS_CHANGED = 1842;
    exports2.ER_GTID_EXECUTED_WAS_CHANGED = 1843;
    exports2.ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES = 1844;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED = 1845;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON = 1846;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY = 1847;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION = 1848;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME = 1849;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE = 1850;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK = 1851;
    exports2.ER_UNUSED6 = 1852;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK = 1853;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC = 1854;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS = 1855;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS = 1856;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS = 1857;
    exports2.ER_SQL_REPLICA_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE = 1858;
    exports2.ER_DUP_UNKNOWN_IN_INDEX = 1859;
    exports2.ER_IDENT_CAUSES_TOO_LONG_PATH = 1860;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL = 1861;
    exports2.ER_MUST_CHANGE_PASSWORD_LOGIN = 1862;
    exports2.ER_ROW_IN_WRONG_PARTITION = 1863;
    exports2.ER_MTA_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX = 1864;
    exports2.ER_INNODB_NO_FT_USES_PARSER = 1865;
    exports2.ER_BINLOG_LOGICAL_CORRUPTION = 1866;
    exports2.ER_WARN_PURGE_LOG_IN_USE = 1867;
    exports2.ER_WARN_PURGE_LOG_IS_ACTIVE = 1868;
    exports2.ER_AUTO_INCREMENT_CONFLICT = 1869;
    exports2.WARN_ON_BLOCKHOLE_IN_RBR = 1870;
    exports2.ER_REPLICA_CM_INIT_REPOSITORY = 1871;
    exports2.ER_REPLICA_AM_INIT_REPOSITORY = 1872;
    exports2.ER_ACCESS_DENIED_CHANGE_USER_ERROR = 1873;
    exports2.ER_INNODB_READ_ONLY = 1874;
    exports2.ER_STOP_REPLICA_SQL_THREAD_TIMEOUT = 1875;
    exports2.ER_STOP_REPLICA_IO_THREAD_TIMEOUT = 1876;
    exports2.ER_TABLE_CORRUPT = 1877;
    exports2.ER_TEMP_FILE_WRITE_FAILURE = 1878;
    exports2.ER_INNODB_FT_AUX_NOT_HEX_ID = 1879;
    exports2.ER_OLD_TEMPORALS_UPGRADED = 1880;
    exports2.ER_INNODB_FORCED_RECOVERY = 1881;
    exports2.ER_AES_INVALID_IV = 1882;
    exports2.ER_PLUGIN_CANNOT_BE_UNINSTALLED = 1883;
    exports2.ER_GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_ASSIGNED_GTID = 1884;
    exports2.ER_REPLICA_HAS_MORE_GTIDS_THAN_SOURCE = 1885;
    exports2.ER_MISSING_KEY = 1886;
    exports2.WARN_NAMED_PIPE_ACCESS_EVERYONE = 1887;
    exports2.ER_FILE_CORRUPT = 3e3;
    exports2.ER_ERROR_ON_SOURCE = 3001;
    exports2.ER_INCONSISTENT_ERROR = 3002;
    exports2.ER_STORAGE_ENGINE_NOT_LOADED = 3003;
    exports2.ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER = 3004;
    exports2.ER_WARN_LEGACY_SYNTAX_CONVERTED = 3005;
    exports2.ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN = 3006;
    exports2.ER_CANNOT_DISCARD_TEMPORARY_TABLE = 3007;
    exports2.ER_FK_DEPTH_EXCEEDED = 3008;
    exports2.ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2 = 3009;
    exports2.ER_WARN_TRIGGER_DOESNT_HAVE_CREATED = 3010;
    exports2.ER_REFERENCED_TRG_DOES_NOT_EXIST = 3011;
    exports2.ER_EXPLAIN_NOT_SUPPORTED = 3012;
    exports2.ER_INVALID_FIELD_SIZE = 3013;
    exports2.ER_MISSING_HA_CREATE_OPTION = 3014;
    exports2.ER_ENGINE_OUT_OF_MEMORY = 3015;
    exports2.ER_PASSWORD_EXPIRE_ANONYMOUS_USER = 3016;
    exports2.ER_REPLICA_SQL_THREAD_MUST_STOP = 3017;
    exports2.ER_NO_FT_MATERIALIZED_SUBQUERY = 3018;
    exports2.ER_INNODB_UNDO_LOG_FULL = 3019;
    exports2.ER_INVALID_ARGUMENT_FOR_LOGARITHM = 3020;
    exports2.ER_REPLICA_CHANNEL_IO_THREAD_MUST_STOP = 3021;
    exports2.ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO = 3022;
    exports2.ER_WARN_ONLY_SOURCE_LOG_FILE_NO_POS = 3023;
    exports2.ER_QUERY_TIMEOUT = 3024;
    exports2.ER_NON_RO_SELECT_DISABLE_TIMER = 3025;
    exports2.ER_DUP_LIST_ENTRY = 3026;
    exports2.ER_SQL_MODE_NO_EFFECT = 3027;
    exports2.ER_AGGREGATE_ORDER_FOR_UNION = 3028;
    exports2.ER_AGGREGATE_ORDER_NON_AGG_QUERY = 3029;
    exports2.ER_REPLICA_WORKER_STOPPED_PREVIOUS_THD_ERROR = 3030;
    exports2.ER_DONT_SUPPORT_REPLICA_PRESERVE_COMMIT_ORDER = 3031;
    exports2.ER_SERVER_OFFLINE_MODE = 3032;
    exports2.ER_GIS_DIFFERENT_SRIDS = 3033;
    exports2.ER_GIS_UNSUPPORTED_ARGUMENT = 3034;
    exports2.ER_GIS_UNKNOWN_ERROR = 3035;
    exports2.ER_GIS_UNKNOWN_EXCEPTION = 3036;
    exports2.ER_GIS_INVALID_DATA = 3037;
    exports2.ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION = 3038;
    exports2.ER_BOOST_GEOMETRY_CENTROID_EXCEPTION = 3039;
    exports2.ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION = 3040;
    exports2.ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION = 3041;
    exports2.ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION = 3042;
    exports2.ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION = 3043;
    exports2.ER_STD_BAD_ALLOC_ERROR = 3044;
    exports2.ER_STD_DOMAIN_ERROR = 3045;
    exports2.ER_STD_LENGTH_ERROR = 3046;
    exports2.ER_STD_INVALID_ARGUMENT = 3047;
    exports2.ER_STD_OUT_OF_RANGE_ERROR = 3048;
    exports2.ER_STD_OVERFLOW_ERROR = 3049;
    exports2.ER_STD_RANGE_ERROR = 3050;
    exports2.ER_STD_UNDERFLOW_ERROR = 3051;
    exports2.ER_STD_LOGIC_ERROR = 3052;
    exports2.ER_STD_RUNTIME_ERROR = 3053;
    exports2.ER_STD_UNKNOWN_EXCEPTION = 3054;
    exports2.ER_GIS_DATA_WRONG_ENDIANESS = 3055;
    exports2.ER_CHANGE_SOURCE_PASSWORD_LENGTH = 3056;
    exports2.ER_USER_LOCK_WRONG_NAME = 3057;
    exports2.ER_USER_LOCK_DEADLOCK = 3058;
    exports2.ER_REPLACE_INACCESSIBLE_ROWS = 3059;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS = 3060;
    exports2.ER_ILLEGAL_USER_VAR = 3061;
    exports2.ER_GTID_MODE_OFF = 3062;
    exports2.ER_UNSUPPORTED_BY_REPLICATION_THREAD = 3063;
    exports2.ER_INCORRECT_TYPE = 3064;
    exports2.ER_FIELD_IN_ORDER_NOT_SELECT = 3065;
    exports2.ER_AGGREGATE_IN_ORDER_NOT_SELECT = 3066;
    exports2.ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN = 3067;
    exports2.ER_NET_OK_PACKET_TOO_LARGE = 3068;
    exports2.ER_INVALID_JSON_DATA = 3069;
    exports2.ER_INVALID_GEOJSON_MISSING_MEMBER = 3070;
    exports2.ER_INVALID_GEOJSON_WRONG_TYPE = 3071;
    exports2.ER_INVALID_GEOJSON_UNSPECIFIED = 3072;
    exports2.ER_DIMENSION_UNSUPPORTED = 3073;
    exports2.ER_REPLICA_CHANNEL_DOES_NOT_EXIST = 3074;
    exports2.ER_SLAVE_MULTIPLE_CHANNELS_HOST_PORT = 3075;
    exports2.ER_REPLICA_CHANNEL_NAME_INVALID_OR_TOO_LONG = 3076;
    exports2.ER_REPLICA_NEW_CHANNEL_WRONG_REPOSITORY = 3077;
    exports2.ER_SLAVE_CHANNEL_DELETE = 3078;
    exports2.ER_REPLICA_MULTIPLE_CHANNELS_CMD = 3079;
    exports2.ER_REPLICA_MAX_CHANNELS_EXCEEDED = 3080;
    exports2.ER_REPLICA_CHANNEL_MUST_STOP = 3081;
    exports2.ER_REPLICA_CHANNEL_NOT_RUNNING = 3082;
    exports2.ER_REPLICA_CHANNEL_WAS_RUNNING = 3083;
    exports2.ER_REPLICA_CHANNEL_WAS_NOT_RUNNING = 3084;
    exports2.ER_REPLICA_CHANNEL_SQL_THREAD_MUST_STOP = 3085;
    exports2.ER_REPLICA_CHANNEL_SQL_SKIP_COUNTER = 3086;
    exports2.ER_WRONG_FIELD_WITH_GROUP_V2 = 3087;
    exports2.ER_MIX_OF_GROUP_FUNC_AND_FIELDS_V2 = 3088;
    exports2.ER_WARN_DEPRECATED_SYSVAR_UPDATE = 3089;
    exports2.ER_WARN_DEPRECATED_SQLMODE = 3090;
    exports2.ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID = 3091;
    exports2.ER_GROUP_REPLICATION_CONFIGURATION = 3092;
    exports2.ER_GROUP_REPLICATION_RUNNING = 3093;
    exports2.ER_GROUP_REPLICATION_APPLIER_INIT_ERROR = 3094;
    exports2.ER_GROUP_REPLICATION_STOP_APPLIER_THREAD_TIMEOUT = 3095;
    exports2.ER_GROUP_REPLICATION_COMMUNICATION_LAYER_SESSION_ERROR = 3096;
    exports2.ER_GROUP_REPLICATION_COMMUNICATION_LAYER_JOIN_ERROR = 3097;
    exports2.ER_BEFORE_DML_VALIDATION_ERROR = 3098;
    exports2.ER_PREVENTS_VARIABLE_WITHOUT_RBR = 3099;
    exports2.ER_RUN_HOOK_ERROR = 3100;
    exports2.ER_TRANSACTION_ROLLBACK_DURING_COMMIT = 3101;
    exports2.ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED = 3102;
    exports2.ER_UNSUPPORTED_ALTER_INPLACE_ON_VIRTUAL_COLUMN = 3103;
    exports2.ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN = 3104;
    exports2.ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN = 3105;
    exports2.ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN = 3106;
    exports2.ER_GENERATED_COLUMN_NON_PRIOR = 3107;
    exports2.ER_DEPENDENT_BY_GENERATED_COLUMN = 3108;
    exports2.ER_GENERATED_COLUMN_REF_AUTO_INC = 3109;
    exports2.ER_FEATURE_NOT_AVAILABLE = 3110;
    exports2.ER_CANT_SET_GTID_MODE = 3111;
    exports2.ER_CANT_USE_AUTO_POSITION_WITH_GTID_MODE_OFF = 3112;
    exports2.ER_CANT_REPLICATE_ANONYMOUS_WITH_AUTO_POSITION = 3113;
    exports2.ER_CANT_REPLICATE_ANONYMOUS_WITH_GTID_MODE_ON = 3114;
    exports2.ER_CANT_REPLICATE_GTID_WITH_GTID_MODE_OFF = 3115;
    exports2.ER_CANT_ENFORCE_GTID_CONSISTENCY_WITH_ONGOING_GTID_VIOLATING_TX = 3116;
    exports2.ER_ENFORCE_GTID_CONSISTENCY_WARN_WITH_ONGOING_GTID_VIOLATING_TX = 3117;
    exports2.ER_ACCOUNT_HAS_BEEN_LOCKED = 3118;
    exports2.ER_WRONG_TABLESPACE_NAME = 3119;
    exports2.ER_TABLESPACE_IS_NOT_EMPTY = 3120;
    exports2.ER_WRONG_FILE_NAME = 3121;
    exports2.ER_BOOST_GEOMETRY_INCONSISTENT_TURNS_EXCEPTION = 3122;
    exports2.ER_WARN_OPTIMIZER_HINT_SYNTAX_ERROR = 3123;
    exports2.ER_WARN_BAD_MAX_EXECUTION_TIME = 3124;
    exports2.ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME = 3125;
    exports2.ER_WARN_CONFLICTING_HINT = 3126;
    exports2.ER_WARN_UNKNOWN_QB_NAME = 3127;
    exports2.ER_UNRESOLVED_HINT_NAME = 3128;
    exports2.ER_WARN_ON_MODIFYING_GTID_EXECUTED_TABLE = 3129;
    exports2.ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED = 3130;
    exports2.ER_LOCKING_SERVICE_WRONG_NAME = 3131;
    exports2.ER_LOCKING_SERVICE_DEADLOCK = 3132;
    exports2.ER_LOCKING_SERVICE_TIMEOUT = 3133;
    exports2.ER_GIS_MAX_POINTS_IN_GEOMETRY_OVERFLOWED = 3134;
    exports2.ER_SQL_MODE_MERGED = 3135;
    exports2.ER_VTOKEN_PLUGIN_TOKEN_MISMATCH = 3136;
    exports2.ER_VTOKEN_PLUGIN_TOKEN_NOT_FOUND = 3137;
    exports2.ER_CANT_SET_VARIABLE_WHEN_OWNING_GTID = 3138;
    exports2.ER_REPLICA_CHANNEL_OPERATION_NOT_ALLOWED = 3139;
    exports2.ER_INVALID_JSON_TEXT = 3140;
    exports2.ER_INVALID_JSON_TEXT_IN_PARAM = 3141;
    exports2.ER_INVALID_JSON_BINARY_DATA = 3142;
    exports2.ER_INVALID_JSON_PATH = 3143;
    exports2.ER_INVALID_JSON_CHARSET = 3144;
    exports2.ER_INVALID_JSON_CHARSET_IN_FUNCTION = 3145;
    exports2.ER_INVALID_TYPE_FOR_JSON = 3146;
    exports2.ER_INVALID_CAST_TO_JSON = 3147;
    exports2.ER_INVALID_JSON_PATH_CHARSET = 3148;
    exports2.ER_INVALID_JSON_PATH_WILDCARD = 3149;
    exports2.ER_JSON_VALUE_TOO_BIG = 3150;
    exports2.ER_JSON_KEY_TOO_BIG = 3151;
    exports2.ER_JSON_USED_AS_KEY = 3152;
    exports2.ER_JSON_VACUOUS_PATH = 3153;
    exports2.ER_JSON_BAD_ONE_OR_ALL_ARG = 3154;
    exports2.ER_NUMERIC_JSON_VALUE_OUT_OF_RANGE = 3155;
    exports2.ER_INVALID_JSON_VALUE_FOR_CAST = 3156;
    exports2.ER_JSON_DOCUMENT_TOO_DEEP = 3157;
    exports2.ER_JSON_DOCUMENT_NULL_KEY = 3158;
    exports2.ER_SECURE_TRANSPORT_REQUIRED = 3159;
    exports2.ER_NO_SECURE_TRANSPORTS_CONFIGURED = 3160;
    exports2.ER_DISABLED_STORAGE_ENGINE = 3161;
    exports2.ER_USER_DOES_NOT_EXIST = 3162;
    exports2.ER_USER_ALREADY_EXISTS = 3163;
    exports2.ER_AUDIT_API_ABORT = 3164;
    exports2.ER_INVALID_JSON_PATH_ARRAY_CELL = 3165;
    exports2.ER_BUFPOOL_RESIZE_INPROGRESS = 3166;
    exports2.ER_FEATURE_DISABLED_SEE_DOC = 3167;
    exports2.ER_SERVER_ISNT_AVAILABLE = 3168;
    exports2.ER_SESSION_WAS_KILLED = 3169;
    exports2.ER_CAPACITY_EXCEEDED = 3170;
    exports2.ER_CAPACITY_EXCEEDED_IN_RANGE_OPTIMIZER = 3171;
    exports2.ER_TABLE_NEEDS_UPG_PART = 3172;
    exports2.ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID = 3173;
    exports2.ER_CANNOT_ADD_FOREIGN_BASE_COL_VIRTUAL = 3174;
    exports2.ER_CANNOT_CREATE_VIRTUAL_INDEX_CONSTRAINT = 3175;
    exports2.ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE = 3176;
    exports2.ER_LOCK_REFUSED_BY_ENGINE = 3177;
    exports2.ER_UNSUPPORTED_ALTER_ONLINE_ON_VIRTUAL_COLUMN = 3178;
    exports2.ER_MASTER_KEY_ROTATION_NOT_SUPPORTED_BY_SE = 3179;
    exports2.ER_MASTER_KEY_ROTATION_ERROR_BY_SE = 3180;
    exports2.ER_MASTER_KEY_ROTATION_BINLOG_FAILED = 3181;
    exports2.ER_MASTER_KEY_ROTATION_SE_UNAVAILABLE = 3182;
    exports2.ER_TABLESPACE_CANNOT_ENCRYPT = 3183;
    exports2.ER_INVALID_ENCRYPTION_OPTION = 3184;
    exports2.ER_CANNOT_FIND_KEY_IN_KEYRING = 3185;
    exports2.ER_CAPACITY_EXCEEDED_IN_PARSER = 3186;
    exports2.ER_UNSUPPORTED_ALTER_ENCRYPTION_INPLACE = 3187;
    exports2.ER_KEYRING_UDF_KEYRING_SERVICE_ERROR = 3188;
    exports2.ER_USER_COLUMN_OLD_LENGTH = 3189;
    exports2.ER_CANT_RESET_SOURCE = 3190;
    exports2.ER_GROUP_REPLICATION_MAX_GROUP_SIZE = 3191;
    exports2.ER_CANNOT_ADD_FOREIGN_BASE_COL_STORED = 3192;
    exports2.ER_TABLE_REFERENCED = 3193;
    exports2.ER_PARTITION_ENGINE_DEPRECATED_FOR_TABLE = 3194;
    exports2.ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID_ZERO = 3195;
    exports2.ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID = 3196;
    exports2.ER_XA_RETRY = 3197;
    exports2.ER_KEYRING_AWS_UDF_AWS_KMS_ERROR = 3198;
    exports2.ER_BINLOG_UNSAFE_XA = 3199;
    exports2.ER_UDF_ERROR = 3200;
    exports2.ER_KEYRING_MIGRATION_FAILURE = 3201;
    exports2.ER_KEYRING_ACCESS_DENIED_ERROR = 3202;
    exports2.ER_KEYRING_MIGRATION_STATUS = 3203;
    exports2.ER_PLUGIN_FAILED_TO_OPEN_TABLES = 3204;
    exports2.ER_PLUGIN_FAILED_TO_OPEN_TABLE = 3205;
    exports2.ER_AUDIT_LOG_NO_KEYRING_PLUGIN_INSTALLED = 3206;
    exports2.ER_AUDIT_LOG_ENCRYPTION_PASSWORD_HAS_NOT_BEEN_SET = 3207;
    exports2.ER_AUDIT_LOG_COULD_NOT_CREATE_AES_KEY = 3208;
    exports2.ER_AUDIT_LOG_ENCRYPTION_PASSWORD_CANNOT_BE_FETCHED = 3209;
    exports2.ER_AUDIT_LOG_JSON_FILTERING_NOT_ENABLED = 3210;
    exports2.ER_AUDIT_LOG_UDF_INSUFFICIENT_PRIVILEGE = 3211;
    exports2.ER_AUDIT_LOG_SUPER_PRIVILEGE_REQUIRED = 3212;
    exports2.ER_COULD_NOT_REINITIALIZE_AUDIT_LOG_FILTERS = 3213;
    exports2.ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_TYPE = 3214;
    exports2.ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_COUNT = 3215;
    exports2.ER_AUDIT_LOG_HAS_NOT_BEEN_INSTALLED = 3216;
    exports2.ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_TYPE = 3217;
    exports2.ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_VALUE = 3218;
    exports2.ER_AUDIT_LOG_JSON_FILTER_PARSING_ERROR = 3219;
    exports2.ER_AUDIT_LOG_JSON_FILTER_NAME_CANNOT_BE_EMPTY = 3220;
    exports2.ER_AUDIT_LOG_JSON_USER_NAME_CANNOT_BE_EMPTY = 3221;
    exports2.ER_AUDIT_LOG_JSON_FILTER_DOES_NOT_EXISTS = 3222;
    exports2.ER_AUDIT_LOG_USER_FIRST_CHARACTER_MUST_BE_ALPHANUMERIC = 3223;
    exports2.ER_AUDIT_LOG_USER_NAME_INVALID_CHARACTER = 3224;
    exports2.ER_AUDIT_LOG_HOST_NAME_INVALID_CHARACTER = 3225;
    exports2.WARN_DEPRECATED_MAXDB_SQL_MODE_FOR_TIMESTAMP = 3226;
    exports2.ER_XA_REPLICATION_FILTERS = 3227;
    exports2.ER_CANT_OPEN_ERROR_LOG = 3228;
    exports2.ER_GROUPING_ON_TIMESTAMP_IN_DST = 3229;
    exports2.ER_CANT_START_SERVER_NAMED_PIPE = 3230;
    exports2.ER_WRITE_SET_EXCEEDS_LIMIT = 3231;
    exports2.ER_DEPRECATED_TLS_VERSION_SESSION_57 = 3232;
    exports2.ER_WARN_DEPRECATED_TLS_VERSION_57 = 3233;
    exports2.ER_WARN_WRONG_NATIVE_TABLE_STRUCTURE = 3234;
    exports2.ER_AES_INVALID_KDF_NAME = 3235;
    exports2.ER_AES_INVALID_KDF_ITERATIONS = 3236;
    exports2.WARN_AES_KEY_SIZE = 3237;
    exports2.ER_AES_INVALID_KDF_OPTION_SIZE = 3238;
    exports2.ER_UNSUPPORT_COMPRESSED_TEMPORARY_TABLE = 3500;
    exports2.ER_ACL_OPERATION_FAILED = 3501;
    exports2.ER_UNSUPPORTED_INDEX_ALGORITHM = 3502;
    exports2.ER_NO_SUCH_DB = 3503;
    exports2.ER_TOO_BIG_ENUM = 3504;
    exports2.ER_TOO_LONG_SET_ENUM_VALUE = 3505;
    exports2.ER_INVALID_DD_OBJECT = 3506;
    exports2.ER_UPDATING_DD_TABLE = 3507;
    exports2.ER_INVALID_DD_OBJECT_ID = 3508;
    exports2.ER_INVALID_DD_OBJECT_NAME = 3509;
    exports2.ER_TABLESPACE_MISSING_WITH_NAME = 3510;
    exports2.ER_TOO_LONG_ROUTINE_COMMENT = 3511;
    exports2.ER_SP_LOAD_FAILED = 3512;
    exports2.ER_INVALID_BITWISE_OPERANDS_SIZE = 3513;
    exports2.ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE = 3514;
    exports2.ER_WARN_UNSUPPORTED_HINT = 3515;
    exports2.ER_UNEXPECTED_GEOMETRY_TYPE = 3516;
    exports2.ER_SRS_PARSE_ERROR = 3517;
    exports2.ER_SRS_PROJ_PARAMETER_MISSING = 3518;
    exports2.ER_WARN_SRS_NOT_FOUND = 3519;
    exports2.ER_SRS_NOT_CARTESIAN = 3520;
    exports2.ER_SRS_NOT_CARTESIAN_UNDEFINED = 3521;
    exports2.ER_PK_INDEX_CANT_BE_INVISIBLE = 3522;
    exports2.ER_UNKNOWN_AUTHID = 3523;
    exports2.ER_FAILED_ROLE_GRANT = 3524;
    exports2.ER_OPEN_ROLE_TABLES = 3525;
    exports2.ER_FAILED_DEFAULT_ROLES = 3526;
    exports2.ER_COMPONENTS_NO_SCHEME = 3527;
    exports2.ER_COMPONENTS_NO_SCHEME_SERVICE = 3528;
    exports2.ER_COMPONENTS_CANT_LOAD = 3529;
    exports2.ER_ROLE_NOT_GRANTED = 3530;
    exports2.ER_FAILED_REVOKE_ROLE = 3531;
    exports2.ER_RENAME_ROLE = 3532;
    exports2.ER_COMPONENTS_CANT_ACQUIRE_SERVICE_IMPLEMENTATION = 3533;
    exports2.ER_COMPONENTS_CANT_SATISFY_DEPENDENCY = 3534;
    exports2.ER_COMPONENTS_LOAD_CANT_REGISTER_SERVICE_IMPLEMENTATION = 3535;
    exports2.ER_COMPONENTS_LOAD_CANT_INITIALIZE = 3536;
    exports2.ER_COMPONENTS_UNLOAD_NOT_LOADED = 3537;
    exports2.ER_COMPONENTS_UNLOAD_CANT_DEINITIALIZE = 3538;
    exports2.ER_COMPONENTS_CANT_RELEASE_SERVICE = 3539;
    exports2.ER_COMPONENTS_UNLOAD_CANT_UNREGISTER_SERVICE = 3540;
    exports2.ER_COMPONENTS_CANT_UNLOAD = 3541;
    exports2.ER_WARN_UNLOAD_THE_NOT_PERSISTED = 3542;
    exports2.ER_COMPONENT_TABLE_INCORRECT = 3543;
    exports2.ER_COMPONENT_MANIPULATE_ROW_FAILED = 3544;
    exports2.ER_COMPONENTS_UNLOAD_DUPLICATE_IN_GROUP = 3545;
    exports2.ER_CANT_SET_GTID_PURGED_DUE_SETS_CONSTRAINTS = 3546;
    exports2.ER_CANNOT_LOCK_USER_MANAGEMENT_CACHES = 3547;
    exports2.ER_SRS_NOT_FOUND = 3548;
    exports2.ER_VARIABLE_NOT_PERSISTED = 3549;
    exports2.ER_IS_QUERY_INVALID_CLAUSE = 3550;
    exports2.ER_UNABLE_TO_STORE_STATISTICS = 3551;
    exports2.ER_NO_SYSTEM_SCHEMA_ACCESS = 3552;
    exports2.ER_NO_SYSTEM_TABLESPACE_ACCESS = 3553;
    exports2.ER_NO_SYSTEM_TABLE_ACCESS = 3554;
    exports2.ER_NO_SYSTEM_TABLE_ACCESS_FOR_DICTIONARY_TABLE = 3555;
    exports2.ER_NO_SYSTEM_TABLE_ACCESS_FOR_SYSTEM_TABLE = 3556;
    exports2.ER_NO_SYSTEM_TABLE_ACCESS_FOR_TABLE = 3557;
    exports2.ER_INVALID_OPTION_KEY = 3558;
    exports2.ER_INVALID_OPTION_VALUE = 3559;
    exports2.ER_INVALID_OPTION_KEY_VALUE_PAIR = 3560;
    exports2.ER_INVALID_OPTION_START_CHARACTER = 3561;
    exports2.ER_INVALID_OPTION_END_CHARACTER = 3562;
    exports2.ER_INVALID_OPTION_CHARACTERS = 3563;
    exports2.ER_DUPLICATE_OPTION_KEY = 3564;
    exports2.ER_WARN_SRS_NOT_FOUND_AXIS_ORDER = 3565;
    exports2.ER_NO_ACCESS_TO_NATIVE_FCT = 3566;
    exports2.ER_RESET_SOURCE_TO_VALUE_OUT_OF_RANGE = 3567;
    exports2.ER_UNRESOLVED_TABLE_LOCK = 3568;
    exports2.ER_DUPLICATE_TABLE_LOCK = 3569;
    exports2.ER_BINLOG_UNSAFE_SKIP_LOCKED = 3570;
    exports2.ER_BINLOG_UNSAFE_NOWAIT = 3571;
    exports2.ER_LOCK_NOWAIT = 3572;
    exports2.ER_CTE_RECURSIVE_REQUIRES_UNION = 3573;
    exports2.ER_CTE_RECURSIVE_REQUIRES_NONRECURSIVE_FIRST = 3574;
    exports2.ER_CTE_RECURSIVE_FORBIDS_AGGREGATION = 3575;
    exports2.ER_CTE_RECURSIVE_FORBIDDEN_JOIN_ORDER = 3576;
    exports2.ER_CTE_RECURSIVE_REQUIRES_SINGLE_REFERENCE = 3577;
    exports2.ER_SWITCH_TMP_ENGINE = 3578;
    exports2.ER_WINDOW_NO_SUCH_WINDOW = 3579;
    exports2.ER_WINDOW_CIRCULARITY_IN_WINDOW_GRAPH = 3580;
    exports2.ER_WINDOW_NO_CHILD_PARTITIONING = 3581;
    exports2.ER_WINDOW_NO_INHERIT_FRAME = 3582;
    exports2.ER_WINDOW_NO_REDEFINE_ORDER_BY = 3583;
    exports2.ER_WINDOW_FRAME_START_ILLEGAL = 3584;
    exports2.ER_WINDOW_FRAME_END_ILLEGAL = 3585;
    exports2.ER_WINDOW_FRAME_ILLEGAL = 3586;
    exports2.ER_WINDOW_RANGE_FRAME_ORDER_TYPE = 3587;
    exports2.ER_WINDOW_RANGE_FRAME_TEMPORAL_TYPE = 3588;
    exports2.ER_WINDOW_RANGE_FRAME_NUMERIC_TYPE = 3589;
    exports2.ER_WINDOW_RANGE_BOUND_NOT_CONSTANT = 3590;
    exports2.ER_WINDOW_DUPLICATE_NAME = 3591;
    exports2.ER_WINDOW_ILLEGAL_ORDER_BY = 3592;
    exports2.ER_WINDOW_INVALID_WINDOW_FUNC_USE = 3593;
    exports2.ER_WINDOW_INVALID_WINDOW_FUNC_ALIAS_USE = 3594;
    exports2.ER_WINDOW_NESTED_WINDOW_FUNC_USE_IN_WINDOW_SPEC = 3595;
    exports2.ER_WINDOW_ROWS_INTERVAL_USE = 3596;
    exports2.ER_WINDOW_NO_GROUP_ORDER = 3597;
    exports2.ER_WINDOW_EXPLAIN_JSON = 3598;
    exports2.ER_WINDOW_FUNCTION_IGNORES_FRAME = 3599;
    exports2.ER_WL9236_NOW = 3600;
    exports2.ER_INVALID_NO_OF_ARGS = 3601;
    exports2.ER_FIELD_IN_GROUPING_NOT_GROUP_BY = 3602;
    exports2.ER_TOO_LONG_TABLESPACE_COMMENT = 3603;
    exports2.ER_ENGINE_CANT_DROP_TABLE = 3604;
    exports2.ER_ENGINE_CANT_DROP_MISSING_TABLE = 3605;
    exports2.ER_TABLESPACE_DUP_FILENAME = 3606;
    exports2.ER_DB_DROP_RMDIR2 = 3607;
    exports2.ER_IMP_NO_FILES_MATCHED = 3608;
    exports2.ER_IMP_SCHEMA_DOES_NOT_EXIST = 3609;
    exports2.ER_IMP_TABLE_ALREADY_EXISTS = 3610;
    exports2.ER_IMP_INCOMPATIBLE_MYSQLD_VERSION = 3611;
    exports2.ER_IMP_INCOMPATIBLE_DD_VERSION = 3612;
    exports2.ER_IMP_INCOMPATIBLE_SDI_VERSION = 3613;
    exports2.ER_WARN_INVALID_HINT = 3614;
    exports2.ER_VAR_DOES_NOT_EXIST = 3615;
    exports2.ER_LONGITUDE_OUT_OF_RANGE = 3616;
    exports2.ER_LATITUDE_OUT_OF_RANGE = 3617;
    exports2.ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS = 3618;
    exports2.ER_ILLEGAL_PRIVILEGE_LEVEL = 3619;
    exports2.ER_NO_SYSTEM_VIEW_ACCESS = 3620;
    exports2.ER_COMPONENT_FILTER_FLABBERGASTED = 3621;
    exports2.ER_PART_EXPR_TOO_LONG = 3622;
    exports2.ER_UDF_DROP_DYNAMICALLY_REGISTERED = 3623;
    exports2.ER_UNABLE_TO_STORE_COLUMN_STATISTICS = 3624;
    exports2.ER_UNABLE_TO_UPDATE_COLUMN_STATISTICS = 3625;
    exports2.ER_UNABLE_TO_DROP_COLUMN_STATISTICS = 3626;
    exports2.ER_UNABLE_TO_BUILD_HISTOGRAM = 3627;
    exports2.ER_MANDATORY_ROLE = 3628;
    exports2.ER_MISSING_TABLESPACE_FILE = 3629;
    exports2.ER_PERSIST_ONLY_ACCESS_DENIED_ERROR = 3630;
    exports2.ER_CMD_NEED_SUPER = 3631;
    exports2.ER_PATH_IN_DATADIR = 3632;
    exports2.ER_CLONE_DDL_IN_PROGRESS = 3633;
    exports2.ER_CLONE_TOO_MANY_CONCURRENT_CLONES = 3634;
    exports2.ER_APPLIER_LOG_EVENT_VALIDATION_ERROR = 3635;
    exports2.ER_CTE_MAX_RECURSION_DEPTH = 3636;
    exports2.ER_NOT_HINT_UPDATABLE_VARIABLE = 3637;
    exports2.ER_CREDENTIALS_CONTRADICT_TO_HISTORY = 3638;
    exports2.ER_WARNING_PASSWORD_HISTORY_CLAUSES_VOID = 3639;
    exports2.ER_CLIENT_DOES_NOT_SUPPORT = 3640;
    exports2.ER_I_S_SKIPPED_TABLESPACE = 3641;
    exports2.ER_TABLESPACE_ENGINE_MISMATCH = 3642;
    exports2.ER_WRONG_SRID_FOR_COLUMN = 3643;
    exports2.ER_CANNOT_ALTER_SRID_DUE_TO_INDEX = 3644;
    exports2.ER_WARN_BINLOG_PARTIAL_UPDATES_DISABLED = 3645;
    exports2.ER_WARN_BINLOG_V1_ROW_EVENTS_DISABLED = 3646;
    exports2.ER_WARN_BINLOG_PARTIAL_UPDATES_SUGGESTS_PARTIAL_IMAGES = 3647;
    exports2.ER_COULD_NOT_APPLY_JSON_DIFF = 3648;
    exports2.ER_CORRUPTED_JSON_DIFF = 3649;
    exports2.ER_RESOURCE_GROUP_EXISTS = 3650;
    exports2.ER_RESOURCE_GROUP_NOT_EXISTS = 3651;
    exports2.ER_INVALID_VCPU_ID = 3652;
    exports2.ER_INVALID_VCPU_RANGE = 3653;
    exports2.ER_INVALID_THREAD_PRIORITY = 3654;
    exports2.ER_DISALLOWED_OPERATION = 3655;
    exports2.ER_RESOURCE_GROUP_BUSY = 3656;
    exports2.ER_RESOURCE_GROUP_DISABLED = 3657;
    exports2.ER_FEATURE_UNSUPPORTED = 3658;
    exports2.ER_ATTRIBUTE_IGNORED = 3659;
    exports2.ER_INVALID_THREAD_ID = 3660;
    exports2.ER_RESOURCE_GROUP_BIND_FAILED = 3661;
    exports2.ER_INVALID_USE_OF_FORCE_OPTION = 3662;
    exports2.ER_GROUP_REPLICATION_COMMAND_FAILURE = 3663;
    exports2.ER_SDI_OPERATION_FAILED = 3664;
    exports2.ER_MISSING_JSON_TABLE_VALUE = 3665;
    exports2.ER_WRONG_JSON_TABLE_VALUE = 3666;
    exports2.ER_TF_MUST_HAVE_ALIAS = 3667;
    exports2.ER_TF_FORBIDDEN_JOIN_TYPE = 3668;
    exports2.ER_JT_VALUE_OUT_OF_RANGE = 3669;
    exports2.ER_JT_MAX_NESTED_PATH = 3670;
    exports2.ER_PASSWORD_EXPIRATION_NOT_SUPPORTED_BY_AUTH_METHOD = 3671;
    exports2.ER_INVALID_GEOJSON_CRS_NOT_TOP_LEVEL = 3672;
    exports2.ER_BAD_NULL_ERROR_NOT_IGNORED = 3673;
    exports2.WARN_USELESS_SPATIAL_INDEX = 3674;
    exports2.ER_DISK_FULL_NOWAIT = 3675;
    exports2.ER_PARSE_ERROR_IN_DIGEST_FN = 3676;
    exports2.ER_UNDISCLOSED_PARSE_ERROR_IN_DIGEST_FN = 3677;
    exports2.ER_SCHEMA_DIR_EXISTS = 3678;
    exports2.ER_SCHEMA_DIR_MISSING = 3679;
    exports2.ER_SCHEMA_DIR_CREATE_FAILED = 3680;
    exports2.ER_SCHEMA_DIR_UNKNOWN = 3681;
    exports2.ER_ONLY_IMPLEMENTED_FOR_SRID_0_AND_4326 = 3682;
    exports2.ER_BINLOG_EXPIRE_LOG_DAYS_AND_SECS_USED_TOGETHER = 3683;
    exports2.ER_REGEXP_BUFFER_OVERFLOW = 3684;
    exports2.ER_REGEXP_ILLEGAL_ARGUMENT = 3685;
    exports2.ER_REGEXP_INDEX_OUTOFBOUNDS_ERROR = 3686;
    exports2.ER_REGEXP_INTERNAL_ERROR = 3687;
    exports2.ER_REGEXP_RULE_SYNTAX = 3688;
    exports2.ER_REGEXP_BAD_ESCAPE_SEQUENCE = 3689;
    exports2.ER_REGEXP_UNIMPLEMENTED = 3690;
    exports2.ER_REGEXP_MISMATCHED_PAREN = 3691;
    exports2.ER_REGEXP_BAD_INTERVAL = 3692;
    exports2.ER_REGEXP_MAX_LT_MIN = 3693;
    exports2.ER_REGEXP_INVALID_BACK_REF = 3694;
    exports2.ER_REGEXP_LOOK_BEHIND_LIMIT = 3695;
    exports2.ER_REGEXP_MISSING_CLOSE_BRACKET = 3696;
    exports2.ER_REGEXP_INVALID_RANGE = 3697;
    exports2.ER_REGEXP_STACK_OVERFLOW = 3698;
    exports2.ER_REGEXP_TIME_OUT = 3699;
    exports2.ER_REGEXP_PATTERN_TOO_BIG = 3700;
    exports2.ER_CANT_SET_ERROR_LOG_SERVICE = 3701;
    exports2.ER_EMPTY_PIPELINE_FOR_ERROR_LOG_SERVICE = 3702;
    exports2.ER_COMPONENT_FILTER_DIAGNOSTICS = 3703;
    exports2.ER_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS = 3704;
    exports2.ER_NOT_IMPLEMENTED_FOR_PROJECTED_SRS = 3705;
    exports2.ER_NONPOSITIVE_RADIUS = 3706;
    exports2.ER_RESTART_SERVER_FAILED = 3707;
    exports2.ER_SRS_MISSING_MANDATORY_ATTRIBUTE = 3708;
    exports2.ER_SRS_MULTIPLE_ATTRIBUTE_DEFINITIONS = 3709;
    exports2.ER_SRS_NAME_CANT_BE_EMPTY_OR_WHITESPACE = 3710;
    exports2.ER_SRS_ORGANIZATION_CANT_BE_EMPTY_OR_WHITESPACE = 3711;
    exports2.ER_SRS_ID_ALREADY_EXISTS = 3712;
    exports2.ER_WARN_SRS_ID_ALREADY_EXISTS = 3713;
    exports2.ER_CANT_MODIFY_SRID_0 = 3714;
    exports2.ER_WARN_RESERVED_SRID_RANGE = 3715;
    exports2.ER_CANT_MODIFY_SRS_USED_BY_COLUMN = 3716;
    exports2.ER_SRS_INVALID_CHARACTER_IN_ATTRIBUTE = 3717;
    exports2.ER_SRS_ATTRIBUTE_STRING_TOO_LONG = 3718;
    exports2.ER_DEPRECATED_UTF8_ALIAS = 3719;
    exports2.ER_DEPRECATED_NATIONAL = 3720;
    exports2.ER_INVALID_DEFAULT_UTF8MB4_COLLATION = 3721;
    exports2.ER_UNABLE_TO_COLLECT_LOG_STATUS = 3722;
    exports2.ER_RESERVED_TABLESPACE_NAME = 3723;
    exports2.ER_UNABLE_TO_SET_OPTION = 3724;
    exports2.ER_REPLICA_POSSIBLY_DIVERGED_AFTER_DDL = 3725;
    exports2.ER_SRS_NOT_GEOGRAPHIC = 3726;
    exports2.ER_POLYGON_TOO_LARGE = 3727;
    exports2.ER_SPATIAL_UNIQUE_INDEX = 3728;
    exports2.ER_INDEX_TYPE_NOT_SUPPORTED_FOR_SPATIAL_INDEX = 3729;
    exports2.ER_FK_CANNOT_DROP_PARENT = 3730;
    exports2.ER_GEOMETRY_PARAM_LONGITUDE_OUT_OF_RANGE = 3731;
    exports2.ER_GEOMETRY_PARAM_LATITUDE_OUT_OF_RANGE = 3732;
    exports2.ER_FK_CANNOT_USE_VIRTUAL_COLUMN = 3733;
    exports2.ER_FK_NO_COLUMN_PARENT = 3734;
    exports2.ER_CANT_SET_ERROR_SUPPRESSION_LIST = 3735;
    exports2.ER_SRS_GEOGCS_INVALID_AXES = 3736;
    exports2.ER_SRS_INVALID_SEMI_MAJOR_AXIS = 3737;
    exports2.ER_SRS_INVALID_INVERSE_FLATTENING = 3738;
    exports2.ER_SRS_INVALID_ANGULAR_UNIT = 3739;
    exports2.ER_SRS_INVALID_PRIME_MERIDIAN = 3740;
    exports2.ER_TRANSFORM_SOURCE_SRS_NOT_SUPPORTED = 3741;
    exports2.ER_TRANSFORM_TARGET_SRS_NOT_SUPPORTED = 3742;
    exports2.ER_TRANSFORM_SOURCE_SRS_MISSING_TOWGS84 = 3743;
    exports2.ER_TRANSFORM_TARGET_SRS_MISSING_TOWGS84 = 3744;
    exports2.ER_TEMP_TABLE_PREVENTS_SWITCH_SESSION_BINLOG_FORMAT = 3745;
    exports2.ER_TEMP_TABLE_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT = 3746;
    exports2.ER_RUNNING_APPLIER_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT = 3747;
    exports2.ER_CLIENT_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR = 3748;
    exports2.ER_XA_CANT_CREATE_MDL_BACKUP = 3749;
    exports2.ER_TABLE_WITHOUT_PK = 3750;
    exports2.ER_WARN_DATA_TRUNCATED_FUNCTIONAL_INDEX = 3751;
    exports2.ER_WARN_DATA_OUT_OF_RANGE_FUNCTIONAL_INDEX = 3752;
    exports2.ER_FUNCTIONAL_INDEX_ON_JSON_OR_GEOMETRY_FUNCTION = 3753;
    exports2.ER_FUNCTIONAL_INDEX_REF_AUTO_INCREMENT = 3754;
    exports2.ER_CANNOT_DROP_COLUMN_FUNCTIONAL_INDEX = 3755;
    exports2.ER_FUNCTIONAL_INDEX_PRIMARY_KEY = 3756;
    exports2.ER_FUNCTIONAL_INDEX_ON_LOB = 3757;
    exports2.ER_FUNCTIONAL_INDEX_FUNCTION_IS_NOT_ALLOWED = 3758;
    exports2.ER_FULLTEXT_FUNCTIONAL_INDEX = 3759;
    exports2.ER_SPATIAL_FUNCTIONAL_INDEX = 3760;
    exports2.ER_WRONG_KEY_COLUMN_FUNCTIONAL_INDEX = 3761;
    exports2.ER_FUNCTIONAL_INDEX_ON_FIELD = 3762;
    exports2.ER_GENERATED_COLUMN_NAMED_FUNCTION_IS_NOT_ALLOWED = 3763;
    exports2.ER_GENERATED_COLUMN_ROW_VALUE = 3764;
    exports2.ER_GENERATED_COLUMN_VARIABLES = 3765;
    exports2.ER_DEPENDENT_BY_DEFAULT_GENERATED_VALUE = 3766;
    exports2.ER_DEFAULT_VAL_GENERATED_NON_PRIOR = 3767;
    exports2.ER_DEFAULT_VAL_GENERATED_REF_AUTO_INC = 3768;
    exports2.ER_DEFAULT_VAL_GENERATED_FUNCTION_IS_NOT_ALLOWED = 3769;
    exports2.ER_DEFAULT_VAL_GENERATED_NAMED_FUNCTION_IS_NOT_ALLOWED = 3770;
    exports2.ER_DEFAULT_VAL_GENERATED_ROW_VALUE = 3771;
    exports2.ER_DEFAULT_VAL_GENERATED_VARIABLES = 3772;
    exports2.ER_DEFAULT_AS_VAL_GENERATED = 3773;
    exports2.ER_UNSUPPORTED_ACTION_ON_DEFAULT_VAL_GENERATED = 3774;
    exports2.ER_GTID_UNSAFE_ALTER_ADD_COL_WITH_DEFAULT_EXPRESSION = 3775;
    exports2.ER_FK_CANNOT_CHANGE_ENGINE = 3776;
    exports2.ER_WARN_DEPRECATED_USER_SET_EXPR = 3777;
    exports2.ER_WARN_DEPRECATED_UTF8MB3_COLLATION = 3778;
    exports2.ER_WARN_DEPRECATED_NESTED_COMMENT_SYNTAX = 3779;
    exports2.ER_FK_INCOMPATIBLE_COLUMNS = 3780;
    exports2.ER_GR_HOLD_WAIT_TIMEOUT = 3781;
    exports2.ER_GR_HOLD_KILLED = 3782;
    exports2.ER_GR_HOLD_MEMBER_STATUS_ERROR = 3783;
    exports2.ER_RPL_ENCRYPTION_FAILED_TO_FETCH_KEY = 3784;
    exports2.ER_RPL_ENCRYPTION_KEY_NOT_FOUND = 3785;
    exports2.ER_RPL_ENCRYPTION_KEYRING_INVALID_KEY = 3786;
    exports2.ER_RPL_ENCRYPTION_HEADER_ERROR = 3787;
    exports2.ER_RPL_ENCRYPTION_FAILED_TO_ROTATE_LOGS = 3788;
    exports2.ER_RPL_ENCRYPTION_KEY_EXISTS_UNEXPECTED = 3789;
    exports2.ER_RPL_ENCRYPTION_FAILED_TO_GENERATE_KEY = 3790;
    exports2.ER_RPL_ENCRYPTION_FAILED_TO_STORE_KEY = 3791;
    exports2.ER_RPL_ENCRYPTION_FAILED_TO_REMOVE_KEY = 3792;
    exports2.ER_RPL_ENCRYPTION_UNABLE_TO_CHANGE_OPTION = 3793;
    exports2.ER_RPL_ENCRYPTION_MASTER_KEY_RECOVERY_FAILED = 3794;
    exports2.ER_SLOW_LOG_MODE_IGNORED_WHEN_NOT_LOGGING_TO_FILE = 3795;
    exports2.ER_GRP_TRX_CONSISTENCY_NOT_ALLOWED = 3796;
    exports2.ER_GRP_TRX_CONSISTENCY_BEFORE = 3797;
    exports2.ER_GRP_TRX_CONSISTENCY_AFTER_ON_TRX_BEGIN = 3798;
    exports2.ER_GRP_TRX_CONSISTENCY_BEGIN_NOT_ALLOWED = 3799;
    exports2.ER_FUNCTIONAL_INDEX_ROW_VALUE_IS_NOT_ALLOWED = 3800;
    exports2.ER_RPL_ENCRYPTION_FAILED_TO_ENCRYPT = 3801;
    exports2.ER_PAGE_TRACKING_NOT_STARTED = 3802;
    exports2.ER_PAGE_TRACKING_RANGE_NOT_TRACKED = 3803;
    exports2.ER_PAGE_TRACKING_CANNOT_PURGE = 3804;
    exports2.ER_RPL_ENCRYPTION_CANNOT_ROTATE_BINLOG_MASTER_KEY = 3805;
    exports2.ER_BINLOG_MASTER_KEY_RECOVERY_OUT_OF_COMBINATION = 3806;
    exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_OPERATE_KEY = 3807;
    exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_ROTATE_LOGS = 3808;
    exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_REENCRYPT_LOG = 3809;
    exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_UNUSED_KEYS = 3810;
    exports2.ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_AUX_KEY = 3811;
    exports2.ER_NON_BOOLEAN_EXPR_FOR_CHECK_CONSTRAINT = 3812;
    exports2.ER_COLUMN_CHECK_CONSTRAINT_REFERENCES_OTHER_COLUMN = 3813;
    exports2.ER_CHECK_CONSTRAINT_NAMED_FUNCTION_IS_NOT_ALLOWED = 3814;
    exports2.ER_CHECK_CONSTRAINT_FUNCTION_IS_NOT_ALLOWED = 3815;
    exports2.ER_CHECK_CONSTRAINT_VARIABLES = 3816;
    exports2.ER_CHECK_CONSTRAINT_ROW_VALUE = 3817;
    exports2.ER_CHECK_CONSTRAINT_REFERS_AUTO_INCREMENT_COLUMN = 3818;
    exports2.ER_CHECK_CONSTRAINT_VIOLATED = 3819;
    exports2.ER_CHECK_CONSTRAINT_REFERS_UNKNOWN_COLUMN = 3820;
    exports2.ER_CHECK_CONSTRAINT_NOT_FOUND = 3821;
    exports2.ER_CHECK_CONSTRAINT_DUP_NAME = 3822;
    exports2.ER_CHECK_CONSTRAINT_CLAUSE_USING_FK_REFER_ACTION_COLUMN = 3823;
    exports2.WARN_UNENCRYPTED_TABLE_IN_ENCRYPTED_DB = 3824;
    exports2.ER_INVALID_ENCRYPTION_REQUEST = 3825;
    exports2.ER_CANNOT_SET_TABLE_ENCRYPTION = 3826;
    exports2.ER_CANNOT_SET_DATABASE_ENCRYPTION = 3827;
    exports2.ER_CANNOT_SET_TABLESPACE_ENCRYPTION = 3828;
    exports2.ER_TABLESPACE_CANNOT_BE_ENCRYPTED = 3829;
    exports2.ER_TABLESPACE_CANNOT_BE_DECRYPTED = 3830;
    exports2.ER_TABLESPACE_TYPE_UNKNOWN = 3831;
    exports2.ER_TARGET_TABLESPACE_UNENCRYPTED = 3832;
    exports2.ER_CANNOT_USE_ENCRYPTION_CLAUSE = 3833;
    exports2.ER_INVALID_MULTIPLE_CLAUSES = 3834;
    exports2.ER_UNSUPPORTED_USE_OF_GRANT_AS = 3835;
    exports2.ER_UKNOWN_AUTH_ID_OR_ACCESS_DENIED_FOR_GRANT_AS = 3836;
    exports2.ER_DEPENDENT_BY_FUNCTIONAL_INDEX = 3837;
    exports2.ER_PLUGIN_NOT_EARLY = 3838;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_START_SUBDIR_PATH = 3839;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_START_TIMEOUT = 3840;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIRS_INVALID = 3841;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_LABEL_NOT_FOUND = 3842;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIR_EMPTY = 3843;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_NO_SUCH_DIR = 3844;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIR_CLASH = 3845;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_DIR_PERMISSIONS = 3846;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_FILE_CREATE = 3847;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_ACTIVE = 3848;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_INACTIVE = 3849;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_FAILED = 3850;
    exports2.ER_INNODB_REDO_LOG_ARCHIVE_SESSION = 3851;
    exports2.ER_STD_REGEX_ERROR = 3852;
    exports2.ER_INVALID_JSON_TYPE = 3853;
    exports2.ER_CANNOT_CONVERT_STRING = 3854;
    exports2.ER_DEPENDENT_BY_PARTITION_FUNC = 3855;
    exports2.ER_WARN_DEPRECATED_FLOAT_AUTO_INCREMENT = 3856;
    exports2.ER_RPL_CANT_STOP_REPLICA_WHILE_LOCKED_BACKUP = 3857;
    exports2.ER_WARN_DEPRECATED_FLOAT_DIGITS = 3858;
    exports2.ER_WARN_DEPRECATED_FLOAT_UNSIGNED = 3859;
    exports2.ER_WARN_DEPRECATED_INTEGER_DISPLAY_WIDTH = 3860;
    exports2.ER_WARN_DEPRECATED_ZEROFILL = 3861;
    exports2.ER_CLONE_DONOR = 3862;
    exports2.ER_CLONE_PROTOCOL = 3863;
    exports2.ER_CLONE_DONOR_VERSION = 3864;
    exports2.ER_CLONE_OS = 3865;
    exports2.ER_CLONE_PLATFORM = 3866;
    exports2.ER_CLONE_CHARSET = 3867;
    exports2.ER_CLONE_CONFIG = 3868;
    exports2.ER_CLONE_SYS_CONFIG = 3869;
    exports2.ER_CLONE_PLUGIN_MATCH = 3870;
    exports2.ER_CLONE_LOOPBACK = 3871;
    exports2.ER_CLONE_ENCRYPTION = 3872;
    exports2.ER_CLONE_DISK_SPACE = 3873;
    exports2.ER_CLONE_IN_PROGRESS = 3874;
    exports2.ER_CLONE_DISALLOWED = 3875;
    exports2.ER_CANNOT_GRANT_ROLES_TO_ANONYMOUS_USER = 3876;
    exports2.ER_SECONDARY_ENGINE_PLUGIN = 3877;
    exports2.ER_SECOND_PASSWORD_CANNOT_BE_EMPTY = 3878;
    exports2.ER_DB_ACCESS_DENIED = 3879;
    exports2.ER_DA_AUTH_ID_WITH_SYSTEM_USER_PRIV_IN_MANDATORY_ROLES = 3880;
    exports2.ER_DA_RPL_GTID_TABLE_CANNOT_OPEN = 3881;
    exports2.ER_GEOMETRY_IN_UNKNOWN_LENGTH_UNIT = 3882;
    exports2.ER_DA_PLUGIN_INSTALL_ERROR = 3883;
    exports2.ER_NO_SESSION_TEMP = 3884;
    exports2.ER_DA_UNKNOWN_ERROR_NUMBER = 3885;
    exports2.ER_COLUMN_CHANGE_SIZE = 3886;
    exports2.ER_REGEXP_INVALID_CAPTURE_GROUP_NAME = 3887;
    exports2.ER_DA_SSL_LIBRARY_ERROR = 3888;
    exports2.ER_SECONDARY_ENGINE = 3889;
    exports2.ER_SECONDARY_ENGINE_DDL = 3890;
    exports2.ER_INCORRECT_CURRENT_PASSWORD = 3891;
    exports2.ER_MISSING_CURRENT_PASSWORD = 3892;
    exports2.ER_CURRENT_PASSWORD_NOT_REQUIRED = 3893;
    exports2.ER_PASSWORD_CANNOT_BE_RETAINED_ON_PLUGIN_CHANGE = 3894;
    exports2.ER_CURRENT_PASSWORD_CANNOT_BE_RETAINED = 3895;
    exports2.ER_PARTIAL_REVOKES_EXIST = 3896;
    exports2.ER_CANNOT_GRANT_SYSTEM_PRIV_TO_MANDATORY_ROLE = 3897;
    exports2.ER_XA_REPLICATION_FILTERS = 3898;
    exports2.ER_UNSUPPORTED_SQL_MODE = 3899;
    exports2.ER_REGEXP_INVALID_FLAG = 3900;
    exports2.ER_PARTIAL_REVOKE_AND_DB_GRANT_BOTH_EXISTS = 3901;
    exports2.ER_UNIT_NOT_FOUND = 3902;
    exports2.ER_INVALID_JSON_VALUE_FOR_FUNC_INDEX = 3903;
    exports2.ER_JSON_VALUE_OUT_OF_RANGE_FOR_FUNC_INDEX = 3904;
    exports2.ER_EXCEEDED_MV_KEYS_NUM = 3905;
    exports2.ER_EXCEEDED_MV_KEYS_SPACE = 3906;
    exports2.ER_FUNCTIONAL_INDEX_DATA_IS_TOO_LONG = 3907;
    exports2.ER_WRONG_MVI_VALUE = 3908;
    exports2.ER_WARN_FUNC_INDEX_NOT_APPLICABLE = 3909;
    exports2.ER_GRP_RPL_UDF_ERROR = 3910;
    exports2.ER_UPDATE_GTID_PURGED_WITH_GR = 3911;
    exports2.ER_GROUPING_ON_TIMESTAMP_IN_DST = 3912;
    exports2.ER_TABLE_NAME_CAUSES_TOO_LONG_PATH = 3913;
    exports2.ER_AUDIT_LOG_INSUFFICIENT_PRIVILEGE = 3914;
    exports2.ER_AUDIT_LOG_PASSWORD_HAS_BEEN_COPIED = 3915;
    exports2.ER_DA_GRP_RPL_STARTED_AUTO_REJOIN = 3916;
    exports2.ER_SYSVAR_CHANGE_DURING_QUERY = 3917;
    exports2.ER_GLOBSTAT_CHANGE_DURING_QUERY = 3918;
    exports2.ER_GRP_RPL_MESSAGE_SERVICE_INIT_FAILURE = 3919;
    exports2.ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_CLIENT = 3920;
    exports2.ER_CHANGE_SOURCE_WRONG_COMPRESSION_LEVEL_CLIENT = 3921;
    exports2.ER_WRONG_COMPRESSION_ALGORITHM_CLIENT = 3922;
    exports2.ER_WRONG_COMPRESSION_LEVEL_CLIENT = 3923;
    exports2.ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_LIST_CLIENT = 3924;
    exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_CANNOT_BE_ANONYMOUS = 3925;
    exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_DOES_NOT_EXIST = 3926;
    exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_CORRUPT = 3927;
    exports2.ER_CLIENT_PRIVILEGE_CHECKS_USER_NEEDS_RPL_APPLIER_PRIV = 3928;
    exports2.ER_WARN_DA_PRIVILEGE_NOT_REGISTERED = 3929;
    exports2.ER_CLIENT_KEYRING_UDF_KEY_INVALID = 3930;
    exports2.ER_CLIENT_KEYRING_UDF_KEY_TYPE_INVALID = 3931;
    exports2.ER_CLIENT_KEYRING_UDF_KEY_TOO_LONG = 3932;
    exports2.ER_CLIENT_KEYRING_UDF_KEY_TYPE_TOO_LONG = 3933;
    exports2.ER_JSON_SCHEMA_VALIDATION_ERROR_WITH_DETAILED_REPORT = 3934;
    exports2.ER_DA_UDF_INVALID_CHARSET_SPECIFIED = 3935;
    exports2.ER_DA_UDF_INVALID_CHARSET = 3936;
    exports2.ER_DA_UDF_INVALID_COLLATION = 3937;
    exports2.ER_DA_UDF_INVALID_EXTENSION_ARGUMENT_TYPE = 3938;
    exports2.ER_MULTIPLE_CONSTRAINTS_WITH_SAME_NAME = 3939;
    exports2.ER_CONSTRAINT_NOT_FOUND = 3940;
    exports2.ER_ALTER_CONSTRAINT_ENFORCEMENT_NOT_SUPPORTED = 3941;
    exports2.ER_TABLE_VALUE_CONSTRUCTOR_MUST_HAVE_COLUMNS = 3942;
    exports2.ER_TABLE_VALUE_CONSTRUCTOR_CANNOT_HAVE_DEFAULT = 3943;
    exports2.ER_CLIENT_QUERY_FAILURE_INVALID_NON_ROW_FORMAT = 3944;
    exports2.ER_REQUIRE_ROW_FORMAT_INVALID_VALUE = 3945;
    exports2.ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY = 3946;
    exports2.ER_FAILED_TO_FETCH_MANDATORY_ROLE_LIST = 3947;
    exports2.ER_CLIENT_LOCAL_FILES_DISABLED = 3948;
    exports2.ER_IMP_INCOMPATIBLE_CFG_VERSION = 3949;
    exports2.ER_DA_OOM = 3950;
    exports2.ER_DA_UDF_INVALID_ARGUMENT_TO_SET_CHARSET = 3951;
    exports2.ER_DA_UDF_INVALID_RETURN_TYPE_TO_SET_CHARSET = 3952;
    exports2.ER_MULTIPLE_INTO_CLAUSES = 3953;
    exports2.ER_MISPLACED_INTO = 3954;
    exports2.ER_USER_ACCESS_DENIED_FOR_USER_ACCOUNT_BLOCKED_BY_PASSWORD_LOCK = 3955;
    exports2.ER_WARN_DEPRECATED_YEAR_UNSIGNED = 3956;
    exports2.ER_CLONE_NETWORK_PACKET = 3957;
    exports2.ER_SDI_OPERATION_FAILED_MISSING_RECORD = 3958;
    exports2.ER_DEPENDENT_BY_CHECK_CONSTRAINT = 3959;
    exports2.ER_GRP_OPERATION_NOT_ALLOWED_GR_MUST_STOP = 3960;
    exports2.ER_WARN_DEPRECATED_JSON_TABLE_ON_ERROR_ON_EMPTY = 3961;
    exports2.ER_WARN_DEPRECATED_INNER_INTO = 3962;
    exports2.ER_WARN_DEPRECATED_VALUES_FUNCTION_ALWAYS_NULL = 3963;
    exports2.ER_WARN_DEPRECATED_SQL_CALC_FOUND_ROWS = 3964;
    exports2.ER_WARN_DEPRECATED_FOUND_ROWS = 3965;
    exports2.ER_MISSING_JSON_VALUE = 3966;
    exports2.ER_MULTIPLE_JSON_VALUES = 3967;
    exports2.ER_HOSTNAME_TOO_LONG = 3968;
    exports2.ER_WARN_CLIENT_DEPRECATED_PARTITION_PREFIX_KEY = 3969;
    exports2.ER_GROUP_REPLICATION_USER_EMPTY_MSG = 3970;
    exports2.ER_GROUP_REPLICATION_USER_MANDATORY_MSG = 3971;
    exports2.ER_GROUP_REPLICATION_PASSWORD_LENGTH = 3972;
    exports2.ER_SUBQUERY_TRANSFORM_REJECTED = 3973;
    exports2.ER_DA_GRP_RPL_RECOVERY_ENDPOINT_FORMAT = 3974;
    exports2.ER_DA_GRP_RPL_RECOVERY_ENDPOINT_INVALID = 3975;
    exports2.ER_WRONG_VALUE_FOR_VAR_PLUS_ACTIONABLE_PART = 3976;
    exports2.ER_STATEMENT_NOT_ALLOWED_AFTER_START_TRANSACTION = 3977;
    exports2.ER_FOREIGN_KEY_WITH_ATOMIC_CREATE_SELECT = 3978;
    exports2.ER_NOT_ALLOWED_WITH_START_TRANSACTION = 3979;
    exports2.ER_INVALID_JSON_ATTRIBUTE = 3980;
    exports2.ER_ENGINE_ATTRIBUTE_NOT_SUPPORTED = 3981;
    exports2.ER_INVALID_USER_ATTRIBUTE_JSON = 3982;
    exports2.ER_INNODB_REDO_DISABLED = 3983;
    exports2.ER_INNODB_REDO_ARCHIVING_ENABLED = 3984;
    exports2.ER_MDL_OUT_OF_RESOURCES = 3985;
    exports2.ER_IMPLICIT_COMPARISON_FOR_JSON = 3986;
    exports2.ER_FUNCTION_DOES_NOT_SUPPORT_CHARACTER_SET = 3987;
    exports2.ER_IMPOSSIBLE_STRING_CONVERSION = 3988;
    exports2.ER_SCHEMA_READ_ONLY = 3989;
    exports2.ER_RPL_ASYNC_RECONNECT_GTID_MODE_OFF = 3990;
    exports2.ER_RPL_ASYNC_RECONNECT_AUTO_POSITION_OFF = 3991;
    exports2.ER_DISABLE_GTID_MODE_REQUIRES_ASYNC_RECONNECT_OFF = 3992;
    exports2.ER_DISABLE_AUTO_POSITION_REQUIRES_ASYNC_RECONNECT_OFF = 3993;
    exports2.ER_INVALID_PARAMETER_USE = 3994;
    exports2.ER_CHARACTER_SET_MISMATCH = 3995;
    exports2.ER_WARN_VAR_VALUE_CHANGE_NOT_SUPPORTED = 3996;
    exports2.ER_INVALID_TIME_ZONE_INTERVAL = 3997;
    exports2.ER_INVALID_CAST = 3998;
    exports2.ER_HYPERGRAPH_NOT_SUPPORTED_YET = 3999;
    exports2.ER_WARN_HYPERGRAPH_EXPERIMENTAL = 4e3;
    exports2.ER_DA_NO_ERROR_LOG_PARSER_CONFIGURED = 4001;
    exports2.ER_DA_ERROR_LOG_TABLE_DISABLED = 4002;
    exports2.ER_DA_ERROR_LOG_MULTIPLE_FILTERS = 4003;
    exports2.ER_DA_CANT_OPEN_ERROR_LOG = 4004;
    exports2.ER_USER_REFERENCED_AS_DEFINER = 4005;
    exports2.ER_CANNOT_USER_REFERENCED_AS_DEFINER = 4006;
    exports2.ER_REGEX_NUMBER_TOO_BIG = 4007;
    exports2.ER_SPVAR_NONINTEGER_TYPE = 4008;
    exports2.WARN_UNSUPPORTED_ACL_TABLES_READ = 4009;
    exports2.ER_BINLOG_UNSAFE_ACL_TABLE_READ_IN_DML_DDL = 4010;
    exports2.ER_STOP_REPLICA_MONITOR_IO_THREAD_TIMEOUT = 4011;
    exports2.ER_STARTING_REPLICA_MONITOR_IO_THREAD = 4012;
    exports2.ER_CANT_USE_ANONYMOUS_TO_GTID_WITH_GTID_MODE_NOT_ON = 4013;
    exports2.ER_CANT_COMBINE_ANONYMOUS_TO_GTID_AND_AUTOPOSITION = 4014;
    exports2.ER_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_REQUIRES_GTID_MODE_ON = 4015;
    exports2.ER_SQL_REPLICA_SKIP_COUNTER_USED_WITH_GTID_MODE_ON = 4016;
    exports2.ER_USING_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_AS_LOCAL_OR_UUID = 4017;
    exports2.ER_CANT_SET_ANONYMOUS_TO_GTID_AND_WAIT_UNTIL_SQL_THD_AFTER_GTIDS = 4018;
    exports2.ER_CANT_SET_SQL_AFTER_OR_BEFORE_GTIDS_WITH_ANONYMOUS_TO_GTID = 4019;
    exports2.ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_GROUP_NAME = 4020;
    exports2.ER_CANT_USE_SAME_UUID_AS_GROUP_NAME = 4021;
    exports2.ER_GRP_RPL_RECOVERY_CHANNEL_STILL_RUNNING = 4022;
    exports2.ER_INNODB_INVALID_AUTOEXTEND_SIZE_VALUE = 4023;
    exports2.ER_INNODB_INCOMPATIBLE_WITH_TABLESPACE = 4024;
    exports2.ER_INNODB_AUTOEXTEND_SIZE_OUT_OF_RANGE = 4025;
    exports2.ER_CANNOT_USE_AUTOEXTEND_SIZE_CLAUSE = 4026;
    exports2.ER_ROLE_GRANTED_TO_ITSELF = 4027;
    exports2.ER_TABLE_MUST_HAVE_A_VISIBLE_COLUMN = 4028;
    exports2.ER_INNODB_COMPRESSION_FAILURE = 4029;
    exports2.ER_WARN_ASYNC_CONN_FAILOVER_NETWORK_NAMESPACE = 4030;
    exports2.ER_CLIENT_INTERACTION_TIMEOUT = 4031;
    exports2.ER_INVALID_CAST_TO_GEOMETRY = 4032;
    exports2.ER_INVALID_CAST_POLYGON_RING_DIRECTION = 4033;
    exports2.ER_GIS_DIFFERENT_SRIDS_AGGREGATION = 4034;
    exports2.ER_RELOAD_KEYRING_FAILURE = 4035;
    exports2.ER_SDI_GET_KEYS_INVALID_TABLESPACE = 4036;
    exports2.ER_CHANGE_RPL_SRC_WRONG_COMPRESSION_ALGORITHM_SIZE = 4037;
    exports2.ER_WARN_DEPRECATED_TLS_VERSION_FOR_CHANNEL_CLI = 4038;
    exports2.ER_CANT_USE_SAME_UUID_AS_VIEW_CHANGE_UUID = 4039;
    exports2.ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_VIEW_CHANGE_UUID = 4040;
    exports2.ER_GRP_RPL_VIEW_CHANGE_UUID_FAIL_GET_VARIABLE = 4041;
    exports2.ER_WARN_ADUIT_LOG_MAX_SIZE_AND_PRUNE_SECONDS = 4042;
    exports2.ER_WARN_ADUIT_LOG_MAX_SIZE_CLOSE_TO_ROTATE_ON_SIZE = 4043;
    exports2.ER_KERBEROS_CREATE_USER = 4044;
    exports2.ER_INSTALL_PLUGIN_CONFLICT_CLIENT = 4045;
    exports2.ER_DA_ERROR_LOG_COMPONENT_FLUSH_FAILED = 4046;
    exports2.ER_WARN_SQL_AFTER_MTS_GAPS_GAP_NOT_CALCULATED = 4047;
    exports2.ER_INVALID_ASSIGNMENT_TARGET = 4048;
    exports2.ER_OPERATION_NOT_ALLOWED_ON_GR_SECONDARY = 4049;
    exports2.ER_GRP_RPL_FAILOVER_CHANNEL_STATUS_PROPAGATION = 4050;
    exports2.ER_WARN_AUDIT_LOG_FORMAT_UNIX_TIMESTAMP_ONLY_WHEN_JSON = 4051;
    exports2.ER_INVALID_MFA_PLUGIN_SPECIFIED = 4052;
    exports2.ER_IDENTIFIED_BY_UNSUPPORTED = 4053;
    exports2.ER_INVALID_PLUGIN_FOR_REGISTRATION = 4054;
    exports2.ER_PLUGIN_REQUIRES_REGISTRATION = 4055;
    exports2.ER_MFA_METHOD_EXISTS = 4056;
    exports2.ER_MFA_METHOD_NOT_EXISTS = 4057;
    exports2.ER_AUTHENTICATION_POLICY_MISMATCH = 4058;
    exports2.ER_PLUGIN_REGISTRATION_DONE = 4059;
    exports2.ER_INVALID_USER_FOR_REGISTRATION = 4060;
    exports2.ER_USER_REGISTRATION_FAILED = 4061;
    exports2.ER_MFA_METHODS_INVALID_ORDER = 4062;
    exports2.ER_MFA_METHODS_IDENTICAL = 4063;
    exports2.ER_INVALID_MFA_OPERATIONS_FOR_PASSWORDLESS_USER = 4064;
    exports2.ER_CHANGE_REPLICATION_SOURCE_NO_OPTIONS_FOR_GTID_ONLY = 4065;
    exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_REQ_ROW_FORMAT_WITH_GTID_ONLY = 4066;
    exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POSITION_WITH_GTID_ONLY = 4067;
    exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_GTID_ONLY_WITHOUT_POSITIONS = 4068;
    exports2.ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POS_WITHOUT_POSITIONS = 4069;
    exports2.ER_CHANGE_REP_SOURCE_GR_CHANNEL_WITH_GTID_MODE_NOT_ON = 4070;
    exports2.ER_CANT_USE_GTID_ONLY_WITH_GTID_MODE_NOT_ON = 4071;
    exports2.ER_WARN_C_DISABLE_GTID_ONLY_WITH_SOURCE_AUTO_POS_INVALID_POS = 4072;
    exports2.ER_DA_SSL_FIPS_MODE_ERROR = 4073;
    exports2.ER_VALUE_OUT_OF_RANGE = 4074;
    exports2.ER_FULLTEXT_WITH_ROLLUP = 4075;
    exports2.ER_REGEXP_MISSING_RESOURCE = 4076;
    exports2.ER_WARN_REGEXP_USING_DEFAULT = 4077;
    exports2.ER_REGEXP_MISSING_FILE = 4078;
    exports2.ER_WARN_DEPRECATED_COLLATION = 4079;
    exports2.ER_CONCURRENT_PROCEDURE_USAGE = 4080;
    exports2.ER_DA_GLOBAL_CONN_LIMIT = 4081;
    exports2.ER_DA_CONN_LIMIT = 4082;
    exports2.ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE_INSTANT = 4083;
    exports2.ER_WARN_SF_UDF_NAME_COLLISION = 4084;
    exports2.ER_CANNOT_PURGE_BINLOG_WITH_BACKUP_LOCK = 4085;
    exports2.ER_TOO_MANY_WINDOWS = 4086;
    exports2.ER_MYSQLBACKUP_CLIENT_MSG = 4087;
    exports2.ER_COMMENT_CONTAINS_INVALID_STRING = 4088;
    exports2.ER_DEFINITION_CONTAINS_INVALID_STRING = 4089;
    exports2.ER_CANT_EXECUTE_COMMAND_WITH_ASSIGNED_GTID_NEXT = 4090;
    exports2.ER_XA_TEMP_TABLE = 4091;
    exports2.ER_INNODB_MAX_ROW_VERSION = 4092;
    exports2.ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_SIZE = 4093;
    exports2.ER_OPERATION_NOT_ALLOWED_WHILE_PRIMARY_CHANGE_IS_RUNNING = 4094;
    exports2.ER_WARN_DEPRECATED_DATETIME_DELIMITER = 4095;
    exports2.ER_WARN_DEPRECATED_SUPERFLUOUS_DELIMITER = 4096;
    exports2.ER_CANNOT_PERSIST_SENSITIVE_VARIABLES = 4097;
    exports2.ER_WARN_CANNOT_SECURELY_PERSIST_SENSITIVE_VARIABLES = 4098;
    exports2.ER_WARN_TRG_ALREADY_EXISTS = 4099;
    exports2.ER_IF_NOT_EXISTS_UNSUPPORTED_TRG_EXISTS_ON_DIFFERENT_TABLE = 4100;
    exports2.ER_IF_NOT_EXISTS_UNSUPPORTED_UDF_NATIVE_FCT_NAME_COLLISION = 4101;
    exports2.ER_SET_PASSWORD_AUTH_PLUGIN_ERROR = 4102;
    exports2.ER_REDUCED_DBLWR_FILE_CORRUPTED = 4103;
    exports2.ER_REDUCED_DBLWR_PAGE_FOUND = 4104;
    exports2.ER_SRS_INVALID_LATITUDE_OF_ORIGIN = 4105;
    exports2.ER_SRS_INVALID_LONGITUDE_OF_ORIGIN = 4106;
    exports2.ER_SRS_UNUSED_PROJ_PARAMETER_PRESENT = 4107;
    exports2.ER_GIPK_COLUMN_EXISTS = 4108;
    exports2.ER_GIPK_FAILED_AUTOINC_COLUMN_EXISTS = 4109;
    exports2.ER_GIPK_COLUMN_ALTER_NOT_ALLOWED = 4110;
    exports2.ER_DROP_PK_COLUMN_TO_DROP_GIPK = 4111;
    exports2.ER_CREATE_SELECT_WITH_GIPK_DISALLOWED_IN_SBR = 4112;
    exports2.ER_DA_EXPIRE_LOGS_DAYS_IGNORED = 4113;
    exports2.ER_CTE_RECURSIVE_NOT_UNION = 4114;
    exports2.ER_COMMAND_BACKEND_FAILED_TO_FETCH_SECURITY_CTX = 4115;
    exports2.ER_COMMAND_SERVICE_BACKEND_FAILED = 4116;
    exports2.ER_CLIENT_FILE_PRIVILEGE_FOR_REPLICATION_CHECKS = 4117;
    exports2.ER_GROUP_REPLICATION_FORCE_MEMBERS_COMMAND_FAILURE = 4118;
    exports2.ER_WARN_DEPRECATED_IDENT = 4119;
    exports2.ER_INTERSECT_ALL_MAX_DUPLICATES_EXCEEDED = 4120;
    exports2.ER_TP_QUERY_THRS_PER_GRP_EXCEEDS_TXN_THR_LIMIT = 4121;
    exports2.ER_BAD_TIMESTAMP_FORMAT = 4122;
    exports2.ER_SHAPE_PRIDICTION_UDF = 4123;
    exports2.ER_SRS_INVALID_HEIGHT = 4124;
    exports2.ER_SRS_INVALID_SCALING = 4125;
    exports2.ER_SRS_INVALID_ZONE_WIDTH = 4126;
    exports2.ER_SRS_INVALID_LATITUDE_POLAR_STERE_VAR_A = 4127;
    exports2.ER_WARN_DEPRECATED_CLIENT_NO_SCHEMA_OPTION = 4128;
    exports2.ER_TABLE_NOT_EMPTY = 4129;
    exports2.ER_TABLE_NO_PRIMARY_KEY = 4130;
    exports2.ER_TABLE_IN_SHARED_TABLESPACE = 4131;
    exports2.ER_INDEX_OTHER_THAN_PK = 4132;
    exports2.ER_LOAD_BULK_DATA_UNSORTED = 4133;
    exports2.ER_BULK_EXECUTOR_ERROR = 4134;
    exports2.ER_BULK_READER_LIBCURL_INIT_FAILED = 4135;
    exports2.ER_BULK_READER_LIBCURL_ERROR = 4136;
    exports2.ER_BULK_READER_SERVER_ERROR = 4137;
    exports2.ER_BULK_READER_COMMUNICATION_ERROR = 4138;
    exports2.ER_BULK_LOAD_DATA_FAILED = 4139;
    exports2.ER_BULK_LOADER_COLUMN_TOO_BIG_FOR_LEFTOVER_BUFFER = 4140;
    exports2.ER_BULK_LOADER_COMPONENT_ERROR = 4141;
    exports2.ER_BULK_LOADER_FILE_CONTAINS_LESS_LINES_THAN_IGNORE_CLAUSE = 4142;
    exports2.ER_BULK_PARSER_MISSING_ENCLOSED_BY = 4143;
    exports2.ER_BULK_PARSER_ROW_BUFFER_MAX_TOTAL_COLS_EXCEEDED = 4144;
    exports2.ER_BULK_PARSER_COPY_BUFFER_SIZE_EXCEEDED = 4145;
    exports2.ER_BULK_PARSER_UNEXPECTED_END_OF_INPUT = 4146;
    exports2.ER_BULK_PARSER_UNEXPECTED_ROW_TERMINATOR = 4147;
    exports2.ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_ENDING_ENCLOSED_BY = 4148;
    exports2.ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_NULL_ESCAPE = 4149;
    exports2.ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_COLUMN_TERMINATOR = 4150;
    exports2.ER_BULK_PARSER_INCOMPLETE_ESCAPE_SEQUENCE = 4151;
    exports2.ER_LOAD_BULK_DATA_FAILED = 4152;
    exports2.ER_LOAD_BULK_DATA_WRONG_VALUE_FOR_FIELD = 4153;
    exports2.ER_LOAD_BULK_DATA_WARN_NULL_TO_NOTNULL = 4154;
    exports2.ER_REQUIRE_TABLE_PRIMARY_KEY_CHECK_GENERATE_WITH_GR = 4155;
    exports2.ER_CANT_CHANGE_SYS_VAR_IN_READ_ONLY_MODE = 4156;
    exports2.ER_INNODB_INSTANT_ADD_DROP_NOT_SUPPORTED_MAX_SIZE = 4157;
    exports2.ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_FIELDS = 4158;
    exports2.ER_CANT_SET_PERSISTED = 4159;
    exports2.ER_INSTALL_COMPONENT_SET_NULL_VALUE = 4160;
    exports2.ER_INSTALL_COMPONENT_SET_UNUSED_VALUE = 4161;
    exports2.ER_WARN_DEPRECATED_USER_DEFINED_COLLATIONS = 4162;
    exports2[1] = "EE_CANTCREATEFILE";
    exports2[2] = "EE_READ";
    exports2[3] = "EE_WRITE";
    exports2[4] = "EE_BADCLOSE";
    exports2[5] = "EE_OUTOFMEMORY";
    exports2[6] = "EE_DELETE";
    exports2[7] = "EE_LINK";
    exports2[9] = "EE_EOFERR";
    exports2[10] = "EE_CANTLOCK";
    exports2[11] = "EE_CANTUNLOCK";
    exports2[12] = "EE_DIR";
    exports2[13] = "EE_STAT";
    exports2[14] = "EE_CANT_CHSIZE";
    exports2[15] = "EE_CANT_OPEN_STREAM";
    exports2[16] = "EE_GETWD";
    exports2[17] = "EE_SETWD";
    exports2[18] = "EE_LINK_WARNING";
    exports2[19] = "EE_OPEN_WARNING";
    exports2[20] = "EE_DISK_FULL";
    exports2[21] = "EE_CANT_MKDIR";
    exports2[22] = "EE_UNKNOWN_CHARSET";
    exports2[23] = "EE_OUT_OF_FILERESOURCES";
    exports2[24] = "EE_CANT_READLINK";
    exports2[25] = "EE_CANT_SYMLINK";
    exports2[26] = "EE_REALPATH";
    exports2[27] = "EE_SYNC";
    exports2[28] = "EE_UNKNOWN_COLLATION";
    exports2[29] = "EE_FILENOTFOUND";
    exports2[30] = "EE_FILE_NOT_CLOSED";
    exports2[31] = "EE_CHANGE_OWNERSHIP";
    exports2[32] = "EE_CHANGE_PERMISSIONS";
    exports2[33] = "EE_CANT_SEEK";
    exports2[34] = "EE_CAPACITY_EXCEEDED";
    exports2[35] = "EE_DISK_FULL_WITH_RETRY_MSG";
    exports2[36] = "EE_FAILED_TO_CREATE_TIMER";
    exports2[37] = "EE_FAILED_TO_DELETE_TIMER";
    exports2[38] = "EE_FAILED_TO_CREATE_TIMER_QUEUE";
    exports2[39] = "EE_FAILED_TO_START_TIMER_NOTIFY_THREAD";
    exports2[40] = "EE_FAILED_TO_CREATE_TIMER_NOTIFY_THREAD_INTERRUPT_EVENT";
    exports2[41] = "EE_EXITING_TIMER_NOTIFY_THREAD";
    exports2[42] = "EE_WIN_LIBRARY_LOAD_FAILED";
    exports2[43] = "EE_WIN_RUN_TIME_ERROR_CHECK";
    exports2[44] = "EE_FAILED_TO_DETERMINE_LARGE_PAGE_SIZE";
    exports2[45] = "EE_FAILED_TO_KILL_ALL_THREADS";
    exports2[46] = "EE_FAILED_TO_CREATE_IO_COMPLETION_PORT";
    exports2[47] = "EE_FAILED_TO_OPEN_DEFAULTS_FILE";
    exports2[48] = "EE_FAILED_TO_HANDLE_DEFAULTS_FILE";
    exports2[49] = "EE_WRONG_DIRECTIVE_IN_CONFIG_FILE";
    exports2[50] = "EE_SKIPPING_DIRECTIVE_DUE_TO_MAX_INCLUDE_RECURSION";
    exports2[51] = "EE_INCORRECT_GRP_DEFINITION_IN_CONFIG_FILE";
    exports2[52] = "EE_OPTION_WITHOUT_GRP_IN_CONFIG_FILE";
    exports2[53] = "EE_CONFIG_FILE_PERMISSION_ERROR";
    exports2[54] = "EE_IGNORE_WORLD_WRITABLE_CONFIG_FILE";
    exports2[55] = "EE_USING_DISABLED_OPTION";
    exports2[56] = "EE_USING_DISABLED_SHORT_OPTION";
    exports2[57] = "EE_USING_PASSWORD_ON_CLI_IS_INSECURE";
    exports2[58] = "EE_UNKNOWN_SUFFIX_FOR_VARIABLE";
    exports2[59] = "EE_SSL_ERROR_FROM_FILE";
    exports2[60] = "EE_SSL_ERROR";
    exports2[61] = "EE_NET_SEND_ERROR_IN_BOOTSTRAP";
    exports2[62] = "EE_PACKETS_OUT_OF_ORDER";
    exports2[63] = "EE_UNKNOWN_PROTOCOL_OPTION";
    exports2[64] = "EE_FAILED_TO_LOCATE_SERVER_PUBLIC_KEY";
    exports2[65] = "EE_PUBLIC_KEY_NOT_IN_PEM_FORMAT";
    exports2[66] = "EE_DEBUG_INFO";
    exports2[67] = "EE_UNKNOWN_VARIABLE";
    exports2[68] = "EE_UNKNOWN_OPTION";
    exports2[69] = "EE_UNKNOWN_SHORT_OPTION";
    exports2[70] = "EE_OPTION_WITHOUT_ARGUMENT";
    exports2[71] = "EE_OPTION_REQUIRES_ARGUMENT";
    exports2[72] = "EE_SHORT_OPTION_REQUIRES_ARGUMENT";
    exports2[73] = "EE_OPTION_IGNORED_DUE_TO_INVALID_VALUE";
    exports2[74] = "EE_OPTION_WITH_EMPTY_VALUE";
    exports2[75] = "EE_FAILED_TO_ASSIGN_MAX_VALUE_TO_OPTION";
    exports2[76] = "EE_INCORRECT_BOOLEAN_VALUE_FOR_OPTION";
    exports2[77] = "EE_FAILED_TO_SET_OPTION_VALUE";
    exports2[78] = "EE_INCORRECT_INT_VALUE_FOR_OPTION";
    exports2[79] = "EE_INCORRECT_UINT_VALUE_FOR_OPTION";
    exports2[80] = "EE_ADJUSTED_SIGNED_VALUE_FOR_OPTION";
    exports2[81] = "EE_ADJUSTED_UNSIGNED_VALUE_FOR_OPTION";
    exports2[82] = "EE_ADJUSTED_ULONGLONG_VALUE_FOR_OPTION";
    exports2[83] = "EE_ADJUSTED_DOUBLE_VALUE_FOR_OPTION";
    exports2[84] = "EE_INVALID_DECIMAL_VALUE_FOR_OPTION";
    exports2[85] = "EE_COLLATION_PARSER_ERROR";
    exports2[86] = "EE_FAILED_TO_RESET_BEFORE_PRIMARY_IGNORABLE_CHAR";
    exports2[87] = "EE_FAILED_TO_RESET_BEFORE_TERTIARY_IGNORABLE_CHAR";
    exports2[88] = "EE_SHIFT_CHAR_OUT_OF_RANGE";
    exports2[89] = "EE_RESET_CHAR_OUT_OF_RANGE";
    exports2[90] = "EE_UNKNOWN_LDML_TAG";
    exports2[91] = "EE_FAILED_TO_RESET_BEFORE_SECONDARY_IGNORABLE_CHAR";
    exports2[92] = "EE_FAILED_PROCESSING_DIRECTIVE";
    exports2[93] = "EE_PTHREAD_KILL_FAILED";
    exports2[120] = "HA_ERR_KEY_NOT_FOUND";
    exports2[121] = "HA_ERR_FOUND_DUPP_KEY";
    exports2[122] = "HA_ERR_INTERNAL_ERROR";
    exports2[123] = "HA_ERR_RECORD_CHANGED";
    exports2[124] = "HA_ERR_WRONG_INDEX";
    exports2[125] = "HA_ERR_ROLLED_BACK";
    exports2[126] = "HA_ERR_CRASHED";
    exports2[127] = "HA_ERR_WRONG_IN_RECORD";
    exports2[128] = "HA_ERR_OUT_OF_MEM";
    exports2[130] = "HA_ERR_NOT_A_TABLE";
    exports2[131] = "HA_ERR_WRONG_COMMAND";
    exports2[132] = "HA_ERR_OLD_FILE";
    exports2[133] = "HA_ERR_NO_ACTIVE_RECORD";
    exports2[134] = "HA_ERR_RECORD_DELETED";
    exports2[135] = "HA_ERR_RECORD_FILE_FULL";
    exports2[136] = "HA_ERR_INDEX_FILE_FULL";
    exports2[137] = "HA_ERR_END_OF_FILE";
    exports2[138] = "HA_ERR_UNSUPPORTED";
    exports2[139] = "HA_ERR_TOO_BIG_ROW";
    exports2[140] = "HA_WRONG_CREATE_OPTION";
    exports2[141] = "HA_ERR_FOUND_DUPP_UNIQUE";
    exports2[142] = "HA_ERR_UNKNOWN_CHARSET";
    exports2[143] = "HA_ERR_WRONG_MRG_TABLE_DEF";
    exports2[144] = "HA_ERR_CRASHED_ON_REPAIR";
    exports2[145] = "HA_ERR_CRASHED_ON_USAGE";
    exports2[146] = "HA_ERR_LOCK_WAIT_TIMEOUT";
    exports2[147] = "HA_ERR_LOCK_TABLE_FULL";
    exports2[148] = "HA_ERR_READ_ONLY_TRANSACTION";
    exports2[149] = "HA_ERR_LOCK_DEADLOCK";
    exports2[150] = "HA_ERR_CANNOT_ADD_FOREIGN";
    exports2[151] = "HA_ERR_NO_REFERENCED_ROW";
    exports2[152] = "HA_ERR_ROW_IS_REFERENCED";
    exports2[153] = "HA_ERR_NO_SAVEPOINT";
    exports2[154] = "HA_ERR_NON_UNIQUE_BLOCK_SIZE";
    exports2[155] = "HA_ERR_NO_SUCH_TABLE";
    exports2[156] = "HA_ERR_TABLE_EXIST";
    exports2[157] = "HA_ERR_NO_CONNECTION";
    exports2[158] = "HA_ERR_NULL_IN_SPATIAL";
    exports2[159] = "HA_ERR_TABLE_DEF_CHANGED";
    exports2[160] = "HA_ERR_NO_PARTITION_FOUND";
    exports2[161] = "HA_ERR_RBR_LOGGING_FAILED";
    exports2[162] = "HA_ERR_DROP_INDEX_FK";
    exports2[163] = "HA_ERR_FOREIGN_DUPLICATE_KEY";
    exports2[164] = "HA_ERR_TABLE_NEEDS_UPGRADE";
    exports2[165] = "HA_ERR_TABLE_READONLY";
    exports2[166] = "HA_ERR_AUTOINC_READ_FAILED";
    exports2[167] = "HA_ERR_AUTOINC_ERANGE";
    exports2[168] = "HA_ERR_GENERIC";
    exports2[169] = "HA_ERR_RECORD_IS_THE_SAME";
    exports2[170] = "HA_ERR_LOGGING_IMPOSSIBLE";
    exports2[171] = "HA_ERR_CORRUPT_EVENT";
    exports2[172] = "HA_ERR_NEW_FILE";
    exports2[173] = "HA_ERR_ROWS_EVENT_APPLY";
    exports2[174] = "HA_ERR_INITIALIZATION";
    exports2[175] = "HA_ERR_FILE_TOO_SHORT";
    exports2[176] = "HA_ERR_WRONG_CRC";
    exports2[177] = "HA_ERR_TOO_MANY_CONCURRENT_TRXS";
    exports2[178] = "HA_ERR_NOT_IN_LOCK_PARTITIONS";
    exports2[179] = "HA_ERR_INDEX_COL_TOO_LONG";
    exports2[180] = "HA_ERR_INDEX_CORRUPT";
    exports2[181] = "HA_ERR_UNDO_REC_TOO_BIG";
    exports2[182] = "HA_FTS_INVALID_DOCID";
    exports2[183] = "HA_ERR_TABLE_IN_FK_CHECK";
    exports2[184] = "HA_ERR_TABLESPACE_EXISTS";
    exports2[185] = "HA_ERR_TOO_MANY_FIELDS";
    exports2[186] = "HA_ERR_ROW_IN_WRONG_PARTITION";
    exports2[187] = "HA_ERR_INNODB_READ_ONLY";
    exports2[188] = "HA_ERR_FTS_EXCEED_RESULT_CACHE_LIMIT";
    exports2[189] = "HA_ERR_TEMP_FILE_WRITE_FAILURE";
    exports2[190] = "HA_ERR_INNODB_FORCED_RECOVERY";
    exports2[191] = "HA_ERR_FTS_TOO_MANY_WORDS_IN_PHRASE";
    exports2[192] = "HA_ERR_FK_DEPTH_EXCEEDED";
    exports2[193] = "HA_MISSING_CREATE_OPTION";
    exports2[194] = "HA_ERR_SE_OUT_OF_MEMORY";
    exports2[195] = "HA_ERR_TABLE_CORRUPT";
    exports2[196] = "HA_ERR_QUERY_INTERRUPTED";
    exports2[197] = "HA_ERR_TABLESPACE_MISSING";
    exports2[198] = "HA_ERR_TABLESPACE_IS_NOT_EMPTY";
    exports2[199] = "HA_ERR_WRONG_FILE_NAME";
    exports2[200] = "HA_ERR_NOT_ALLOWED_COMMAND";
    exports2[201] = "HA_ERR_COMPUTE_FAILED";
    exports2[202] = "HA_ERR_ROW_FORMAT_CHANGED";
    exports2[203] = "HA_ERR_NO_WAIT_LOCK";
    exports2[204] = "HA_ERR_DISK_FULL_NOWAIT";
    exports2[205] = "HA_ERR_NO_SESSION_TEMP";
    exports2[206] = "HA_ERR_WRONG_TABLE_NAME";
    exports2[207] = "HA_ERR_TOO_LONG_PATH";
    exports2[208] = "HA_ERR_SAMPLING_INIT_FAILED";
    exports2[209] = "HA_ERR_FTS_TOO_MANY_NESTED_EXP";
    exports2[1e3] = "ER_HASHCHK";
    exports2[1001] = "ER_NISAMCHK";
    exports2[1002] = "ER_NO";
    exports2[1003] = "ER_YES";
    exports2[1004] = "ER_CANT_CREATE_FILE";
    exports2[1005] = "ER_CANT_CREATE_TABLE";
    exports2[1006] = "ER_CANT_CREATE_DB";
    exports2[1007] = "ER_DB_CREATE_EXISTS";
    exports2[1008] = "ER_DB_DROP_EXISTS";
    exports2[1009] = "ER_DB_DROP_DELETE";
    exports2[1010] = "ER_DB_DROP_RMDIR";
    exports2[1011] = "ER_CANT_DELETE_FILE";
    exports2[1012] = "ER_CANT_FIND_SYSTEM_REC";
    exports2[1013] = "ER_CANT_GET_STAT";
    exports2[1014] = "ER_CANT_GET_WD";
    exports2[1015] = "ER_CANT_LOCK";
    exports2[1016] = "ER_CANT_OPEN_FILE";
    exports2[1017] = "ER_FILE_NOT_FOUND";
    exports2[1018] = "ER_CANT_READ_DIR";
    exports2[1019] = "ER_CANT_SET_WD";
    exports2[1020] = "ER_CHECKREAD";
    exports2[1021] = "ER_DISK_FULL";
    exports2[1022] = "ER_DUP_KEY";
    exports2[1023] = "ER_ERROR_ON_CLOSE";
    exports2[1024] = "ER_ERROR_ON_READ";
    exports2[1025] = "ER_ERROR_ON_RENAME";
    exports2[1026] = "ER_ERROR_ON_WRITE";
    exports2[1027] = "ER_FILE_USED";
    exports2[1028] = "ER_FILSORT_ABORT";
    exports2[1029] = "ER_FORM_NOT_FOUND";
    exports2[1030] = "ER_GET_ERRNO";
    exports2[1031] = "ER_ILLEGAL_HA";
    exports2[1032] = "ER_KEY_NOT_FOUND";
    exports2[1033] = "ER_NOT_FORM_FILE";
    exports2[1034] = "ER_NOT_KEYFILE";
    exports2[1035] = "ER_OLD_KEYFILE";
    exports2[1036] = "ER_OPEN_AS_READONLY";
    exports2[1037] = "ER_OUTOFMEMORY";
    exports2[1038] = "ER_OUT_OF_SORTMEMORY";
    exports2[1039] = "ER_UNEXPECTED_EOF";
    exports2[1040] = "ER_CON_COUNT_ERROR";
    exports2[1041] = "ER_OUT_OF_RESOURCES";
    exports2[1042] = "ER_BAD_HOST_ERROR";
    exports2[1043] = "ER_HANDSHAKE_ERROR";
    exports2[1044] = "ER_DBACCESS_DENIED_ERROR";
    exports2[1045] = "ER_ACCESS_DENIED_ERROR";
    exports2[1046] = "ER_NO_DB_ERROR";
    exports2[1047] = "ER_UNKNOWN_COM_ERROR";
    exports2[1048] = "ER_BAD_NULL_ERROR";
    exports2[1049] = "ER_BAD_DB_ERROR";
    exports2[1050] = "ER_TABLE_EXISTS_ERROR";
    exports2[1051] = "ER_BAD_TABLE_ERROR";
    exports2[1052] = "ER_NON_UNIQ_ERROR";
    exports2[1053] = "ER_SERVER_SHUTDOWN";
    exports2[1054] = "ER_BAD_FIELD_ERROR";
    exports2[1055] = "ER_WRONG_FIELD_WITH_GROUP";
    exports2[1056] = "ER_WRONG_GROUP_FIELD";
    exports2[1057] = "ER_WRONG_SUM_SELECT";
    exports2[1058] = "ER_WRONG_VALUE_COUNT";
    exports2[1059] = "ER_TOO_LONG_IDENT";
    exports2[1060] = "ER_DUP_FIELDNAME";
    exports2[1061] = "ER_DUP_KEYNAME";
    exports2[1062] = "ER_DUP_ENTRY";
    exports2[1063] = "ER_WRONG_FIELD_SPEC";
    exports2[1064] = "ER_PARSE_ERROR";
    exports2[1065] = "ER_EMPTY_QUERY";
    exports2[1066] = "ER_NONUNIQ_TABLE";
    exports2[1067] = "ER_INVALID_DEFAULT";
    exports2[1068] = "ER_MULTIPLE_PRI_KEY";
    exports2[1069] = "ER_TOO_MANY_KEYS";
    exports2[1070] = "ER_TOO_MANY_KEY_PARTS";
    exports2[1071] = "ER_TOO_LONG_KEY";
    exports2[1072] = "ER_KEY_COLUMN_DOES_NOT_EXITS";
    exports2[1073] = "ER_BLOB_USED_AS_KEY";
    exports2[1074] = "ER_TOO_BIG_FIELDLENGTH";
    exports2[1075] = "ER_WRONG_AUTO_KEY";
    exports2[1076] = "ER_READY";
    exports2[1077] = "ER_NORMAL_SHUTDOWN";
    exports2[1078] = "ER_GOT_SIGNAL";
    exports2[1079] = "ER_SHUTDOWN_COMPLETE";
    exports2[1080] = "ER_FORCING_CLOSE";
    exports2[1081] = "ER_IPSOCK_ERROR";
    exports2[1082] = "ER_NO_SUCH_INDEX";
    exports2[1083] = "ER_WRONG_FIELD_TERMINATORS";
    exports2[1084] = "ER_BLOBS_AND_NO_TERMINATED";
    exports2[1085] = "ER_TEXTFILE_NOT_READABLE";
    exports2[1086] = "ER_FILE_EXISTS_ERROR";
    exports2[1087] = "ER_LOAD_INFO";
    exports2[1088] = "ER_ALTER_INFO";
    exports2[1089] = "ER_WRONG_SUB_KEY";
    exports2[1090] = "ER_CANT_REMOVE_ALL_FIELDS";
    exports2[1091] = "ER_CANT_DROP_FIELD_OR_KEY";
    exports2[1092] = "ER_INSERT_INFO";
    exports2[1093] = "ER_UPDATE_TABLE_USED";
    exports2[1094] = "ER_NO_SUCH_THREAD";
    exports2[1095] = "ER_KILL_DENIED_ERROR";
    exports2[1096] = "ER_NO_TABLES_USED";
    exports2[1097] = "ER_TOO_BIG_SET";
    exports2[1098] = "ER_NO_UNIQUE_LOGFILE";
    exports2[1099] = "ER_TABLE_NOT_LOCKED_FOR_WRITE";
    exports2[1100] = "ER_TABLE_NOT_LOCKED";
    exports2[1101] = "ER_BLOB_CANT_HAVE_DEFAULT";
    exports2[1102] = "ER_WRONG_DB_NAME";
    exports2[1103] = "ER_WRONG_TABLE_NAME";
    exports2[1104] = "ER_TOO_BIG_SELECT";
    exports2[1105] = "ER_UNKNOWN_ERROR";
    exports2[1106] = "ER_UNKNOWN_PROCEDURE";
    exports2[1107] = "ER_WRONG_PARAMCOUNT_TO_PROCEDURE";
    exports2[1108] = "ER_WRONG_PARAMETERS_TO_PROCEDURE";
    exports2[1109] = "ER_UNKNOWN_TABLE";
    exports2[1110] = "ER_FIELD_SPECIFIED_TWICE";
    exports2[1111] = "ER_INVALID_GROUP_FUNC_USE";
    exports2[1112] = "ER_UNSUPPORTED_EXTENSION";
    exports2[1113] = "ER_TABLE_MUST_HAVE_COLUMNS";
    exports2[1114] = "ER_RECORD_FILE_FULL";
    exports2[1115] = "ER_UNKNOWN_CHARACTER_SET";
    exports2[1116] = "ER_TOO_MANY_TABLES";
    exports2[1117] = "ER_TOO_MANY_FIELDS";
    exports2[1118] = "ER_TOO_BIG_ROWSIZE";
    exports2[1119] = "ER_STACK_OVERRUN";
    exports2[1120] = "ER_WRONG_OUTER_JOIN";
    exports2[1121] = "ER_NULL_COLUMN_IN_INDEX";
    exports2[1122] = "ER_CANT_FIND_UDF";
    exports2[1123] = "ER_CANT_INITIALIZE_UDF";
    exports2[1124] = "ER_UDF_NO_PATHS";
    exports2[1125] = "ER_UDF_EXISTS";
    exports2[1126] = "ER_CANT_OPEN_LIBRARY";
    exports2[1127] = "ER_CANT_FIND_DL_ENTRY";
    exports2[1128] = "ER_FUNCTION_NOT_DEFINED";
    exports2[1129] = "ER_HOST_IS_BLOCKED";
    exports2[1130] = "ER_HOST_NOT_PRIVILEGED";
    exports2[1131] = "ER_PASSWORD_ANONYMOUS_USER";
    exports2[1132] = "ER_PASSWORD_NOT_ALLOWED";
    exports2[1133] = "ER_PASSWORD_NO_MATCH";
    exports2[1134] = "ER_UPDATE_INFO";
    exports2[1135] = "ER_CANT_CREATE_THREAD";
    exports2[1136] = "ER_WRONG_VALUE_COUNT_ON_ROW";
    exports2[1137] = "ER_CANT_REOPEN_TABLE";
    exports2[1138] = "ER_INVALID_USE_OF_NULL";
    exports2[1139] = "ER_REGEXP_ERROR";
    exports2[1140] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS";
    exports2[1141] = "ER_NONEXISTING_GRANT";
    exports2[1142] = "ER_TABLEACCESS_DENIED_ERROR";
    exports2[1143] = "ER_COLUMNACCESS_DENIED_ERROR";
    exports2[1144] = "ER_ILLEGAL_GRANT_FOR_TABLE";
    exports2[1145] = "ER_GRANT_WRONG_HOST_OR_USER";
    exports2[1146] = "ER_NO_SUCH_TABLE";
    exports2[1147] = "ER_NONEXISTING_TABLE_GRANT";
    exports2[1148] = "ER_NOT_ALLOWED_COMMAND";
    exports2[1149] = "ER_SYNTAX_ERROR";
    exports2[1150] = "ER_UNUSED1";
    exports2[1151] = "ER_UNUSED2";
    exports2[1152] = "ER_ABORTING_CONNECTION";
    exports2[1153] = "ER_NET_PACKET_TOO_LARGE";
    exports2[1154] = "ER_NET_READ_ERROR_FROM_PIPE";
    exports2[1155] = "ER_NET_FCNTL_ERROR";
    exports2[1156] = "ER_NET_PACKETS_OUT_OF_ORDER";
    exports2[1157] = "ER_NET_UNCOMPRESS_ERROR";
    exports2[1158] = "ER_NET_READ_ERROR";
    exports2[1159] = "ER_NET_READ_INTERRUPTED";
    exports2[1160] = "ER_NET_ERROR_ON_WRITE";
    exports2[1161] = "ER_NET_WRITE_INTERRUPTED";
    exports2[1162] = "ER_TOO_LONG_STRING";
    exports2[1163] = "ER_TABLE_CANT_HANDLE_BLOB";
    exports2[1164] = "ER_TABLE_CANT_HANDLE_AUTO_INCREMENT";
    exports2[1165] = "ER_UNUSED3";
    exports2[1166] = "ER_WRONG_COLUMN_NAME";
    exports2[1167] = "ER_WRONG_KEY_COLUMN";
    exports2[1168] = "ER_WRONG_MRG_TABLE";
    exports2[1169] = "ER_DUP_UNIQUE";
    exports2[1170] = "ER_BLOB_KEY_WITHOUT_LENGTH";
    exports2[1171] = "ER_PRIMARY_CANT_HAVE_NULL";
    exports2[1172] = "ER_TOO_MANY_ROWS";
    exports2[1173] = "ER_REQUIRES_PRIMARY_KEY";
    exports2[1174] = "ER_NO_RAID_COMPILED";
    exports2[1175] = "ER_UPDATE_WITHOUT_KEY_IN_SAFE_MODE";
    exports2[1176] = "ER_KEY_DOES_NOT_EXITS";
    exports2[1177] = "ER_CHECK_NO_SUCH_TABLE";
    exports2[1178] = "ER_CHECK_NOT_IMPLEMENTED";
    exports2[1179] = "ER_CANT_DO_THIS_DURING_AN_TRANSACTION";
    exports2[1180] = "ER_ERROR_DURING_COMMIT";
    exports2[1181] = "ER_ERROR_DURING_ROLLBACK";
    exports2[1182] = "ER_ERROR_DURING_FLUSH_LOGS";
    exports2[1183] = "ER_ERROR_DURING_CHECKPOINT";
    exports2[1184] = "ER_NEW_ABORTING_CONNECTION";
    exports2[1185] = "ER_DUMP_NOT_IMPLEMENTED";
    exports2[1186] = "ER_FLUSH_MASTER_BINLOG_CLOSED";
    exports2[1187] = "ER_INDEX_REBUILD";
    exports2[1188] = "ER_SOURCE";
    exports2[1189] = "ER_SOURCE_NET_READ";
    exports2[1190] = "ER_SOURCE_NET_WRITE";
    exports2[1191] = "ER_FT_MATCHING_KEY_NOT_FOUND";
    exports2[1192] = "ER_LOCK_OR_ACTIVE_TRANSACTION";
    exports2[1193] = "ER_UNKNOWN_SYSTEM_VARIABLE";
    exports2[1194] = "ER_CRASHED_ON_USAGE";
    exports2[1195] = "ER_CRASHED_ON_REPAIR";
    exports2[1196] = "ER_WARNING_NOT_COMPLETE_ROLLBACK";
    exports2[1197] = "ER_TRANS_CACHE_FULL";
    exports2[1198] = "ER_SLAVE_MUST_STOP";
    exports2[1199] = "ER_REPLICA_NOT_RUNNING";
    exports2[1200] = "ER_BAD_REPLICA";
    exports2[1201] = "ER_CONNECTION_METADATA";
    exports2[1202] = "ER_REPLICA_THREAD";
    exports2[1203] = "ER_TOO_MANY_USER_CONNECTIONS";
    exports2[1204] = "ER_SET_CONSTANTS_ONLY";
    exports2[1205] = "ER_LOCK_WAIT_TIMEOUT";
    exports2[1206] = "ER_LOCK_TABLE_FULL";
    exports2[1207] = "ER_READ_ONLY_TRANSACTION";
    exports2[1208] = "ER_DROP_DB_WITH_READ_LOCK";
    exports2[1209] = "ER_CREATE_DB_WITH_READ_LOCK";
    exports2[1210] = "ER_WRONG_ARGUMENTS";
    exports2[1211] = "ER_NO_PERMISSION_TO_CREATE_USER";
    exports2[1212] = "ER_UNION_TABLES_IN_DIFFERENT_DIR";
    exports2[1213] = "ER_LOCK_DEADLOCK";
    exports2[1214] = "ER_TABLE_CANT_HANDLE_FT";
    exports2[1215] = "ER_CANNOT_ADD_FOREIGN";
    exports2[1216] = "ER_NO_REFERENCED_ROW";
    exports2[1217] = "ER_ROW_IS_REFERENCED";
    exports2[1218] = "ER_CONNECT_TO_SOURCE";
    exports2[1219] = "ER_QUERY_ON_MASTER";
    exports2[1220] = "ER_ERROR_WHEN_EXECUTING_COMMAND";
    exports2[1221] = "ER_WRONG_USAGE";
    exports2[1222] = "ER_WRONG_NUMBER_OF_COLUMNS_IN_SELECT";
    exports2[1223] = "ER_CANT_UPDATE_WITH_READLOCK";
    exports2[1224] = "ER_MIXING_NOT_ALLOWED";
    exports2[1225] = "ER_DUP_ARGUMENT";
    exports2[1226] = "ER_USER_LIMIT_REACHED";
    exports2[1227] = "ER_SPECIFIC_ACCESS_DENIED_ERROR";
    exports2[1228] = "ER_LOCAL_VARIABLE";
    exports2[1229] = "ER_GLOBAL_VARIABLE";
    exports2[1230] = "ER_NO_DEFAULT";
    exports2[1231] = "ER_WRONG_VALUE_FOR_VAR";
    exports2[1232] = "ER_WRONG_TYPE_FOR_VAR";
    exports2[1233] = "ER_VAR_CANT_BE_READ";
    exports2[1234] = "ER_CANT_USE_OPTION_HERE";
    exports2[1235] = "ER_NOT_SUPPORTED_YET";
    exports2[1236] = "ER_SOURCE_FATAL_ERROR_READING_BINLOG";
    exports2[1237] = "ER_REPLICA_IGNORED_TABLE";
    exports2[1238] = "ER_INCORRECT_GLOBAL_LOCAL_VAR";
    exports2[1239] = "ER_WRONG_FK_DEF";
    exports2[1240] = "ER_KEY_REF_DO_NOT_MATCH_TABLE_REF";
    exports2[1241] = "ER_OPERAND_COLUMNS";
    exports2[1242] = "ER_SUBQUERY_NO_1_ROW";
    exports2[1243] = "ER_UNKNOWN_STMT_HANDLER";
    exports2[1244] = "ER_CORRUPT_HELP_DB";
    exports2[1245] = "ER_CYCLIC_REFERENCE";
    exports2[1246] = "ER_AUTO_CONVERT";
    exports2[1247] = "ER_ILLEGAL_REFERENCE";
    exports2[1248] = "ER_DERIVED_MUST_HAVE_ALIAS";
    exports2[1249] = "ER_SELECT_REDUCED";
    exports2[1250] = "ER_TABLENAME_NOT_ALLOWED_HERE";
    exports2[1251] = "ER_NOT_SUPPORTED_AUTH_MODE";
    exports2[1252] = "ER_SPATIAL_CANT_HAVE_NULL";
    exports2[1253] = "ER_COLLATION_CHARSET_MISMATCH";
    exports2[1254] = "ER_SLAVE_WAS_RUNNING";
    exports2[1255] = "ER_SLAVE_WAS_NOT_RUNNING";
    exports2[1256] = "ER_TOO_BIG_FOR_UNCOMPRESS";
    exports2[1257] = "ER_ZLIB_Z_MEM_ERROR";
    exports2[1258] = "ER_ZLIB_Z_BUF_ERROR";
    exports2[1259] = "ER_ZLIB_Z_DATA_ERROR";
    exports2[1260] = "ER_CUT_VALUE_GROUP_CONCAT";
    exports2[1261] = "ER_WARN_TOO_FEW_RECORDS";
    exports2[1262] = "ER_WARN_TOO_MANY_RECORDS";
    exports2[1263] = "ER_WARN_NULL_TO_NOTNULL";
    exports2[1264] = "ER_WARN_DATA_OUT_OF_RANGE";
    exports2[1265] = "WARN_DATA_TRUNCATED";
    exports2[1266] = "ER_WARN_USING_OTHER_HANDLER";
    exports2[1267] = "ER_CANT_AGGREGATE_2COLLATIONS";
    exports2[1268] = "ER_DROP_USER";
    exports2[1269] = "ER_REVOKE_GRANTS";
    exports2[1270] = "ER_CANT_AGGREGATE_3COLLATIONS";
    exports2[1271] = "ER_CANT_AGGREGATE_NCOLLATIONS";
    exports2[1272] = "ER_VARIABLE_IS_NOT_STRUCT";
    exports2[1273] = "ER_UNKNOWN_COLLATION";
    exports2[1274] = "ER_REPLICA_IGNORED_SSL_PARAMS";
    exports2[1275] = "ER_SERVER_IS_IN_SECURE_AUTH_MODE";
    exports2[1276] = "ER_WARN_FIELD_RESOLVED";
    exports2[1277] = "ER_BAD_REPLICA_UNTIL_COND";
    exports2[1278] = "ER_MISSING_SKIP_REPLICA";
    exports2[1279] = "ER_UNTIL_COND_IGNORED";
    exports2[1280] = "ER_WRONG_NAME_FOR_INDEX";
    exports2[1281] = "ER_WRONG_NAME_FOR_CATALOG";
    exports2[1282] = "ER_WARN_QC_RESIZE";
    exports2[1283] = "ER_BAD_FT_COLUMN";
    exports2[1284] = "ER_UNKNOWN_KEY_CACHE";
    exports2[1285] = "ER_WARN_HOSTNAME_WONT_WORK";
    exports2[1286] = "ER_UNKNOWN_STORAGE_ENGINE";
    exports2[1287] = "ER_WARN_DEPRECATED_SYNTAX";
    exports2[1288] = "ER_NON_UPDATABLE_TABLE";
    exports2[1289] = "ER_FEATURE_DISABLED";
    exports2[1290] = "ER_OPTION_PREVENTS_STATEMENT";
    exports2[1291] = "ER_DUPLICATED_VALUE_IN_TYPE";
    exports2[1292] = "ER_TRUNCATED_WRONG_VALUE";
    exports2[1293] = "ER_TOO_MUCH_AUTO_TIMESTAMP_COLS";
    exports2[1294] = "ER_INVALID_ON_UPDATE";
    exports2[1295] = "ER_UNSUPPORTED_PS";
    exports2[1296] = "ER_GET_ERRMSG";
    exports2[1297] = "ER_GET_TEMPORARY_ERRMSG";
    exports2[1298] = "ER_UNKNOWN_TIME_ZONE";
    exports2[1299] = "ER_WARN_INVALID_TIMESTAMP";
    exports2[1300] = "ER_INVALID_CHARACTER_STRING";
    exports2[1301] = "ER_WARN_ALLOWED_PACKET_OVERFLOWED";
    exports2[1302] = "ER_CONFLICTING_DECLARATIONS";
    exports2[1303] = "ER_SP_NO_RECURSIVE_CREATE";
    exports2[1304] = "ER_SP_ALREADY_EXISTS";
    exports2[1305] = "ER_SP_DOES_NOT_EXIST";
    exports2[1306] = "ER_SP_DROP_FAILED";
    exports2[1307] = "ER_SP_STORE_FAILED";
    exports2[1308] = "ER_SP_LILABEL_MISMATCH";
    exports2[1309] = "ER_SP_LABEL_REDEFINE";
    exports2[1310] = "ER_SP_LABEL_MISMATCH";
    exports2[1311] = "ER_SP_UNINIT_VAR";
    exports2[1312] = "ER_SP_BADSELECT";
    exports2[1313] = "ER_SP_BADRETURN";
    exports2[1314] = "ER_SP_BADSTATEMENT";
    exports2[1315] = "ER_UPDATE_LOG_DEPRECATED_IGNORED";
    exports2[1316] = "ER_UPDATE_LOG_DEPRECATED_TRANSLATED";
    exports2[1317] = "ER_QUERY_INTERRUPTED";
    exports2[1318] = "ER_SP_WRONG_NO_OF_ARGS";
    exports2[1319] = "ER_SP_COND_MISMATCH";
    exports2[1320] = "ER_SP_NORETURN";
    exports2[1321] = "ER_SP_NORETURNEND";
    exports2[1322] = "ER_SP_BAD_CURSOR_QUERY";
    exports2[1323] = "ER_SP_BAD_CURSOR_SELECT";
    exports2[1324] = "ER_SP_CURSOR_MISMATCH";
    exports2[1325] = "ER_SP_CURSOR_ALREADY_OPEN";
    exports2[1326] = "ER_SP_CURSOR_NOT_OPEN";
    exports2[1327] = "ER_SP_UNDECLARED_VAR";
    exports2[1328] = "ER_SP_WRONG_NO_OF_FETCH_ARGS";
    exports2[1329] = "ER_SP_FETCH_NO_DATA";
    exports2[1330] = "ER_SP_DUP_PARAM";
    exports2[1331] = "ER_SP_DUP_VAR";
    exports2[1332] = "ER_SP_DUP_COND";
    exports2[1333] = "ER_SP_DUP_CURS";
    exports2[1334] = "ER_SP_CANT_ALTER";
    exports2[1335] = "ER_SP_SUBSELECT_NYI";
    exports2[1336] = "ER_STMT_NOT_ALLOWED_IN_SF_OR_TRG";
    exports2[1337] = "ER_SP_VARCOND_AFTER_CURSHNDLR";
    exports2[1338] = "ER_SP_CURSOR_AFTER_HANDLER";
    exports2[1339] = "ER_SP_CASE_NOT_FOUND";
    exports2[1340] = "ER_FPARSER_TOO_BIG_FILE";
    exports2[1341] = "ER_FPARSER_BAD_HEADER";
    exports2[1342] = "ER_FPARSER_EOF_IN_COMMENT";
    exports2[1343] = "ER_FPARSER_ERROR_IN_PARAMETER";
    exports2[1344] = "ER_FPARSER_EOF_IN_UNKNOWN_PARAMETER";
    exports2[1345] = "ER_VIEW_NO_EXPLAIN";
    exports2[1346] = "ER_FRM_UNKNOWN_TYPE";
    exports2[1347] = "ER_WRONG_OBJECT";
    exports2[1348] = "ER_NONUPDATEABLE_COLUMN";
    exports2[1349] = "ER_VIEW_SELECT_DERIVED";
    exports2[1350] = "ER_VIEW_SELECT_CLAUSE";
    exports2[1351] = "ER_VIEW_SELECT_VARIABLE";
    exports2[1352] = "ER_VIEW_SELECT_TMPTABLE";
    exports2[1353] = "ER_VIEW_WRONG_LIST";
    exports2[1354] = "ER_WARN_VIEW_MERGE";
    exports2[1355] = "ER_WARN_VIEW_WITHOUT_KEY";
    exports2[1356] = "ER_VIEW_INVALID";
    exports2[1357] = "ER_SP_NO_DROP_SP";
    exports2[1358] = "ER_SP_GOTO_IN_HNDLR";
    exports2[1359] = "ER_TRG_ALREADY_EXISTS";
    exports2[1360] = "ER_TRG_DOES_NOT_EXIST";
    exports2[1361] = "ER_TRG_ON_VIEW_OR_TEMP_TABLE";
    exports2[1362] = "ER_TRG_CANT_CHANGE_ROW";
    exports2[1363] = "ER_TRG_NO_SUCH_ROW_IN_TRG";
    exports2[1364] = "ER_NO_DEFAULT_FOR_FIELD";
    exports2[1365] = "ER_DIVISION_BY_ZERO";
    exports2[1366] = "ER_TRUNCATED_WRONG_VALUE_FOR_FIELD";
    exports2[1367] = "ER_ILLEGAL_VALUE_FOR_TYPE";
    exports2[1368] = "ER_VIEW_NONUPD_CHECK";
    exports2[1369] = "ER_VIEW_CHECK_FAILED";
    exports2[1370] = "ER_PROCACCESS_DENIED_ERROR";
    exports2[1371] = "ER_RELAY_LOG_FAIL";
    exports2[1372] = "ER_PASSWD_LENGTH";
    exports2[1373] = "ER_UNKNOWN_TARGET_BINLOG";
    exports2[1374] = "ER_IO_ERR_LOG_INDEX_READ";
    exports2[1375] = "ER_BINLOG_PURGE_PROHIBITED";
    exports2[1376] = "ER_FSEEK_FAIL";
    exports2[1377] = "ER_BINLOG_PURGE_FATAL_ERR";
    exports2[1378] = "ER_LOG_IN_USE";
    exports2[1379] = "ER_LOG_PURGE_UNKNOWN_ERR";
    exports2[1380] = "ER_RELAY_LOG_INIT";
    exports2[1381] = "ER_NO_BINARY_LOGGING";
    exports2[1382] = "ER_RESERVED_SYNTAX";
    exports2[1383] = "ER_WSAS_FAILED";
    exports2[1384] = "ER_DIFF_GROUPS_PROC";
    exports2[1385] = "ER_NO_GROUP_FOR_PROC";
    exports2[1386] = "ER_ORDER_WITH_PROC";
    exports2[1387] = "ER_LOGGING_PROHIBIT_CHANGING_OF";
    exports2[1388] = "ER_NO_FILE_MAPPING";
    exports2[1389] = "ER_WRONG_MAGIC";
    exports2[1390] = "ER_PS_MANY_PARAM";
    exports2[1391] = "ER_KEY_PART_0";
    exports2[1392] = "ER_VIEW_CHECKSUM";
    exports2[1393] = "ER_VIEW_MULTIUPDATE";
    exports2[1394] = "ER_VIEW_NO_INSERT_FIELD_LIST";
    exports2[1395] = "ER_VIEW_DELETE_MERGE_VIEW";
    exports2[1396] = "ER_CANNOT_USER";
    exports2[1397] = "ER_XAER_NOTA";
    exports2[1398] = "ER_XAER_INVAL";
    exports2[1399] = "ER_XAER_RMFAIL";
    exports2[1400] = "ER_XAER_OUTSIDE";
    exports2[1401] = "ER_XAER_RMERR";
    exports2[1402] = "ER_XA_RBROLLBACK";
    exports2[1403] = "ER_NONEXISTING_PROC_GRANT";
    exports2[1404] = "ER_PROC_AUTO_GRANT_FAIL";
    exports2[1405] = "ER_PROC_AUTO_REVOKE_FAIL";
    exports2[1406] = "ER_DATA_TOO_LONG";
    exports2[1407] = "ER_SP_BAD_SQLSTATE";
    exports2[1408] = "ER_STARTUP";
    exports2[1409] = "ER_LOAD_FROM_FIXED_SIZE_ROWS_TO_VAR";
    exports2[1410] = "ER_CANT_CREATE_USER_WITH_GRANT";
    exports2[1411] = "ER_WRONG_VALUE_FOR_TYPE";
    exports2[1412] = "ER_TABLE_DEF_CHANGED";
    exports2[1413] = "ER_SP_DUP_HANDLER";
    exports2[1414] = "ER_SP_NOT_VAR_ARG";
    exports2[1415] = "ER_SP_NO_RETSET";
    exports2[1416] = "ER_CANT_CREATE_GEOMETRY_OBJECT";
    exports2[1417] = "ER_FAILED_ROUTINE_BREAK_BINLOG";
    exports2[1418] = "ER_BINLOG_UNSAFE_ROUTINE";
    exports2[1419] = "ER_BINLOG_CREATE_ROUTINE_NEED_SUPER";
    exports2[1420] = "ER_EXEC_STMT_WITH_OPEN_CURSOR";
    exports2[1421] = "ER_STMT_HAS_NO_OPEN_CURSOR";
    exports2[1422] = "ER_COMMIT_NOT_ALLOWED_IN_SF_OR_TRG";
    exports2[1423] = "ER_NO_DEFAULT_FOR_VIEW_FIELD";
    exports2[1424] = "ER_SP_NO_RECURSION";
    exports2[1425] = "ER_TOO_BIG_SCALE";
    exports2[1426] = "ER_TOO_BIG_PRECISION";
    exports2[1427] = "ER_M_BIGGER_THAN_D";
    exports2[1428] = "ER_WRONG_LOCK_OF_SYSTEM_TABLE";
    exports2[1429] = "ER_CONNECT_TO_FOREIGN_DATA_SOURCE";
    exports2[1430] = "ER_QUERY_ON_FOREIGN_DATA_SOURCE";
    exports2[1431] = "ER_FOREIGN_DATA_SOURCE_DOESNT_EXIST";
    exports2[1432] = "ER_FOREIGN_DATA_STRING_INVALID_CANT_CREATE";
    exports2[1433] = "ER_FOREIGN_DATA_STRING_INVALID";
    exports2[1434] = "ER_CANT_CREATE_FEDERATED_TABLE";
    exports2[1435] = "ER_TRG_IN_WRONG_SCHEMA";
    exports2[1436] = "ER_STACK_OVERRUN_NEED_MORE";
    exports2[1437] = "ER_TOO_LONG_BODY";
    exports2[1438] = "ER_WARN_CANT_DROP_DEFAULT_KEYCACHE";
    exports2[1439] = "ER_TOO_BIG_DISPLAYWIDTH";
    exports2[1440] = "ER_XAER_DUPID";
    exports2[1441] = "ER_DATETIME_FUNCTION_OVERFLOW";
    exports2[1442] = "ER_CANT_UPDATE_USED_TABLE_IN_SF_OR_TRG";
    exports2[1443] = "ER_VIEW_PREVENT_UPDATE";
    exports2[1444] = "ER_PS_NO_RECURSION";
    exports2[1445] = "ER_SP_CANT_SET_AUTOCOMMIT";
    exports2[1446] = "ER_MALFORMED_DEFINER";
    exports2[1447] = "ER_VIEW_FRM_NO_USER";
    exports2[1448] = "ER_VIEW_OTHER_USER";
    exports2[1449] = "ER_NO_SUCH_USER";
    exports2[1450] = "ER_FORBID_SCHEMA_CHANGE";
    exports2[1451] = "ER_ROW_IS_REFERENCED_2";
    exports2[1452] = "ER_NO_REFERENCED_ROW_2";
    exports2[1453] = "ER_SP_BAD_VAR_SHADOW";
    exports2[1454] = "ER_TRG_NO_DEFINER";
    exports2[1455] = "ER_OLD_FILE_FORMAT";
    exports2[1456] = "ER_SP_RECURSION_LIMIT";
    exports2[1457] = "ER_SP_PROC_TABLE_CORRUPT";
    exports2[1458] = "ER_SP_WRONG_NAME";
    exports2[1459] = "ER_TABLE_NEEDS_UPGRADE";
    exports2[1460] = "ER_SP_NO_AGGREGATE";
    exports2[1461] = "ER_MAX_PREPARED_STMT_COUNT_REACHED";
    exports2[1462] = "ER_VIEW_RECURSIVE";
    exports2[1463] = "ER_NON_GROUPING_FIELD_USED";
    exports2[1464] = "ER_TABLE_CANT_HANDLE_SPKEYS";
    exports2[1465] = "ER_NO_TRIGGERS_ON_SYSTEM_SCHEMA";
    exports2[1466] = "ER_REMOVED_SPACES";
    exports2[1467] = "ER_AUTOINC_READ_FAILED";
    exports2[1468] = "ER_USERNAME";
    exports2[1469] = "ER_HOSTNAME";
    exports2[1470] = "ER_WRONG_STRING_LENGTH";
    exports2[1471] = "ER_NON_INSERTABLE_TABLE";
    exports2[1472] = "ER_ADMIN_WRONG_MRG_TABLE";
    exports2[1473] = "ER_TOO_HIGH_LEVEL_OF_NESTING_FOR_SELECT";
    exports2[1474] = "ER_NAME_BECOMES_EMPTY";
    exports2[1475] = "ER_AMBIGUOUS_FIELD_TERM";
    exports2[1476] = "ER_FOREIGN_SERVER_EXISTS";
    exports2[1477] = "ER_FOREIGN_SERVER_DOESNT_EXIST";
    exports2[1478] = "ER_ILLEGAL_HA_CREATE_OPTION";
    exports2[1479] = "ER_PARTITION_REQUIRES_VALUES_ERROR";
    exports2[1480] = "ER_PARTITION_WRONG_VALUES_ERROR";
    exports2[1481] = "ER_PARTITION_MAXVALUE_ERROR";
    exports2[1482] = "ER_PARTITION_SUBPARTITION_ERROR";
    exports2[1483] = "ER_PARTITION_SUBPART_MIX_ERROR";
    exports2[1484] = "ER_PARTITION_WRONG_NO_PART_ERROR";
    exports2[1485] = "ER_PARTITION_WRONG_NO_SUBPART_ERROR";
    exports2[1486] = "ER_WRONG_EXPR_IN_PARTITION_FUNC_ERROR";
    exports2[1487] = "ER_NO_CONST_EXPR_IN_RANGE_OR_LIST_ERROR";
    exports2[1488] = "ER_FIELD_NOT_FOUND_PART_ERROR";
    exports2[1489] = "ER_LIST_OF_FIELDS_ONLY_IN_HASH_ERROR";
    exports2[1490] = "ER_INCONSISTENT_PARTITION_INFO_ERROR";
    exports2[1491] = "ER_PARTITION_FUNC_NOT_ALLOWED_ERROR";
    exports2[1492] = "ER_PARTITIONS_MUST_BE_DEFINED_ERROR";
    exports2[1493] = "ER_RANGE_NOT_INCREASING_ERROR";
    exports2[1494] = "ER_INCONSISTENT_TYPE_OF_FUNCTIONS_ERROR";
    exports2[1495] = "ER_MULTIPLE_DEF_CONST_IN_LIST_PART_ERROR";
    exports2[1496] = "ER_PARTITION_ENTRY_ERROR";
    exports2[1497] = "ER_MIX_HANDLER_ERROR";
    exports2[1498] = "ER_PARTITION_NOT_DEFINED_ERROR";
    exports2[1499] = "ER_TOO_MANY_PARTITIONS_ERROR";
    exports2[1500] = "ER_SUBPARTITION_ERROR";
    exports2[1501] = "ER_CANT_CREATE_HANDLER_FILE";
    exports2[1502] = "ER_BLOB_FIELD_IN_PART_FUNC_ERROR";
    exports2[1503] = "ER_UNIQUE_KEY_NEED_ALL_FIELDS_IN_PF";
    exports2[1504] = "ER_NO_PARTS_ERROR";
    exports2[1505] = "ER_PARTITION_MGMT_ON_NONPARTITIONED";
    exports2[1506] = "ER_FOREIGN_KEY_ON_PARTITIONED";
    exports2[1507] = "ER_DROP_PARTITION_NON_EXISTENT";
    exports2[1508] = "ER_DROP_LAST_PARTITION";
    exports2[1509] = "ER_COALESCE_ONLY_ON_HASH_PARTITION";
    exports2[1510] = "ER_REORG_HASH_ONLY_ON_SAME_NO";
    exports2[1511] = "ER_REORG_NO_PARAM_ERROR";
    exports2[1512] = "ER_ONLY_ON_RANGE_LIST_PARTITION";
    exports2[1513] = "ER_ADD_PARTITION_SUBPART_ERROR";
    exports2[1514] = "ER_ADD_PARTITION_NO_NEW_PARTITION";
    exports2[1515] = "ER_COALESCE_PARTITION_NO_PARTITION";
    exports2[1516] = "ER_REORG_PARTITION_NOT_EXIST";
    exports2[1517] = "ER_SAME_NAME_PARTITION";
    exports2[1518] = "ER_NO_BINLOG_ERROR";
    exports2[1519] = "ER_CONSECUTIVE_REORG_PARTITIONS";
    exports2[1520] = "ER_REORG_OUTSIDE_RANGE";
    exports2[1521] = "ER_PARTITION_FUNCTION_FAILURE";
    exports2[1522] = "ER_PART_STATE_ERROR";
    exports2[1523] = "ER_LIMITED_PART_RANGE";
    exports2[1524] = "ER_PLUGIN_IS_NOT_LOADED";
    exports2[1525] = "ER_WRONG_VALUE";
    exports2[1526] = "ER_NO_PARTITION_FOR_GIVEN_VALUE";
    exports2[1527] = "ER_FILEGROUP_OPTION_ONLY_ONCE";
    exports2[1528] = "ER_CREATE_FILEGROUP_FAILED";
    exports2[1529] = "ER_DROP_FILEGROUP_FAILED";
    exports2[1530] = "ER_TABLESPACE_AUTO_EXTEND_ERROR";
    exports2[1531] = "ER_WRONG_SIZE_NUMBER";
    exports2[1532] = "ER_SIZE_OVERFLOW_ERROR";
    exports2[1533] = "ER_ALTER_FILEGROUP_FAILED";
    exports2[1534] = "ER_BINLOG_ROW_LOGGING_FAILED";
    exports2[1535] = "ER_BINLOG_ROW_WRONG_TABLE_DEF";
    exports2[1536] = "ER_BINLOG_ROW_RBR_TO_SBR";
    exports2[1537] = "ER_EVENT_ALREADY_EXISTS";
    exports2[1538] = "ER_EVENT_STORE_FAILED";
    exports2[1539] = "ER_EVENT_DOES_NOT_EXIST";
    exports2[1540] = "ER_EVENT_CANT_ALTER";
    exports2[1541] = "ER_EVENT_DROP_FAILED";
    exports2[1542] = "ER_EVENT_INTERVAL_NOT_POSITIVE_OR_TOO_BIG";
    exports2[1543] = "ER_EVENT_ENDS_BEFORE_STARTS";
    exports2[1544] = "ER_EVENT_EXEC_TIME_IN_THE_PAST";
    exports2[1545] = "ER_EVENT_OPEN_TABLE_FAILED";
    exports2[1546] = "ER_EVENT_NEITHER_M_EXPR_NOR_M_AT";
    exports2[1547] = "ER_COL_COUNT_DOESNT_MATCH_CORRUPTED";
    exports2[1548] = "ER_CANNOT_LOAD_FROM_TABLE";
    exports2[1549] = "ER_EVENT_CANNOT_DELETE";
    exports2[1550] = "ER_EVENT_COMPILE_ERROR";
    exports2[1551] = "ER_EVENT_SAME_NAME";
    exports2[1552] = "ER_EVENT_DATA_TOO_LONG";
    exports2[1553] = "ER_DROP_INDEX_FK";
    exports2[1554] = "ER_WARN_DEPRECATED_SYNTAX_WITH_VER";
    exports2[1555] = "ER_CANT_WRITE_LOCK_LOG_TABLE";
    exports2[1556] = "ER_CANT_LOCK_LOG_TABLE";
    exports2[1557] = "ER_FOREIGN_DUPLICATE_KEY";
    exports2[1558] = "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE";
    exports2[1559] = "ER_TEMP_TABLE_PREVENTS_SWITCH_OUT_OF_RBR";
    exports2[1560] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_FORMAT";
    exports2[1561] = "ER_NDB_CANT_SWITCH_BINLOG_FORMAT";
    exports2[1562] = "ER_PARTITION_NO_TEMPORARY";
    exports2[1563] = "ER_PARTITION_CONST_DOMAIN_ERROR";
    exports2[1564] = "ER_PARTITION_FUNCTION_IS_NOT_ALLOWED";
    exports2[1565] = "ER_DDL_LOG_ERROR";
    exports2[1566] = "ER_NULL_IN_VALUES_LESS_THAN";
    exports2[1567] = "ER_WRONG_PARTITION_NAME";
    exports2[1568] = "ER_CANT_CHANGE_TX_CHARACTERISTICS";
    exports2[1569] = "ER_DUP_ENTRY_AUTOINCREMENT_CASE";
    exports2[1570] = "ER_EVENT_MODIFY_QUEUE_ERROR";
    exports2[1571] = "ER_EVENT_SET_VAR_ERROR";
    exports2[1572] = "ER_PARTITION_MERGE_ERROR";
    exports2[1573] = "ER_CANT_ACTIVATE_LOG";
    exports2[1574] = "ER_RBR_NOT_AVAILABLE";
    exports2[1575] = "ER_BASE64_DECODE_ERROR";
    exports2[1576] = "ER_EVENT_RECURSION_FORBIDDEN";
    exports2[1577] = "ER_EVENTS_DB_ERROR";
    exports2[1578] = "ER_ONLY_INTEGERS_ALLOWED";
    exports2[1579] = "ER_UNSUPORTED_LOG_ENGINE";
    exports2[1580] = "ER_BAD_LOG_STATEMENT";
    exports2[1581] = "ER_CANT_RENAME_LOG_TABLE";
    exports2[1582] = "ER_WRONG_PARAMCOUNT_TO_NATIVE_FCT";
    exports2[1583] = "ER_WRONG_PARAMETERS_TO_NATIVE_FCT";
    exports2[1584] = "ER_WRONG_PARAMETERS_TO_STORED_FCT";
    exports2[1585] = "ER_NATIVE_FCT_NAME_COLLISION";
    exports2[1586] = "ER_DUP_ENTRY_WITH_KEY_NAME";
    exports2[1587] = "ER_BINLOG_PURGE_EMFILE";
    exports2[1588] = "ER_EVENT_CANNOT_CREATE_IN_THE_PAST";
    exports2[1589] = "ER_EVENT_CANNOT_ALTER_IN_THE_PAST";
    exports2[1590] = "ER_SLAVE_INCIDENT";
    exports2[1591] = "ER_NO_PARTITION_FOR_GIVEN_VALUE_SILENT";
    exports2[1592] = "ER_BINLOG_UNSAFE_STATEMENT";
    exports2[1593] = "ER_BINLOG_FATAL_ERROR";
    exports2[1594] = "ER_SLAVE_RELAY_LOG_READ_FAILURE";
    exports2[1595] = "ER_SLAVE_RELAY_LOG_WRITE_FAILURE";
    exports2[1596] = "ER_SLAVE_CREATE_EVENT_FAILURE";
    exports2[1597] = "ER_SLAVE_MASTER_COM_FAILURE";
    exports2[1598] = "ER_BINLOG_LOGGING_IMPOSSIBLE";
    exports2[1599] = "ER_VIEW_NO_CREATION_CTX";
    exports2[1600] = "ER_VIEW_INVALID_CREATION_CTX";
    exports2[1601] = "ER_SR_INVALID_CREATION_CTX";
    exports2[1602] = "ER_TRG_CORRUPTED_FILE";
    exports2[1603] = "ER_TRG_NO_CREATION_CTX";
    exports2[1604] = "ER_TRG_INVALID_CREATION_CTX";
    exports2[1605] = "ER_EVENT_INVALID_CREATION_CTX";
    exports2[1606] = "ER_TRG_CANT_OPEN_TABLE";
    exports2[1607] = "ER_CANT_CREATE_SROUTINE";
    exports2[1608] = "ER_NEVER_USED";
    exports2[1609] = "ER_NO_FORMAT_DESCRIPTION_EVENT_BEFORE_BINLOG_STATEMENT";
    exports2[1610] = "ER_REPLICA_CORRUPT_EVENT";
    exports2[1611] = "ER_LOAD_DATA_INVALID_COLUMN";
    exports2[1612] = "ER_LOG_PURGE_NO_FILE";
    exports2[1613] = "ER_XA_RBTIMEOUT";
    exports2[1614] = "ER_XA_RBDEADLOCK";
    exports2[1615] = "ER_NEED_REPREPARE";
    exports2[1616] = "ER_DELAYED_NOT_SUPPORTED";
    exports2[1617] = "WARN_NO_CONNECTION_METADATA";
    exports2[1618] = "WARN_OPTION_IGNORED";
    exports2[1619] = "ER_PLUGIN_DELETE_BUILTIN";
    exports2[1620] = "WARN_PLUGIN_BUSY";
    exports2[1621] = "ER_VARIABLE_IS_READONLY";
    exports2[1622] = "ER_WARN_ENGINE_TRANSACTION_ROLLBACK";
    exports2[1623] = "ER_SLAVE_HEARTBEAT_FAILURE";
    exports2[1624] = "ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE";
    exports2[1625] = "ER_NDB_REPLICATION_SCHEMA_ERROR";
    exports2[1626] = "ER_CONFLICT_FN_PARSE_ERROR";
    exports2[1627] = "ER_EXCEPTIONS_WRITE_ERROR";
    exports2[1628] = "ER_TOO_LONG_TABLE_COMMENT";
    exports2[1629] = "ER_TOO_LONG_FIELD_COMMENT";
    exports2[1630] = "ER_FUNC_INEXISTENT_NAME_COLLISION";
    exports2[1631] = "ER_DATABASE_NAME";
    exports2[1632] = "ER_TABLE_NAME";
    exports2[1633] = "ER_PARTITION_NAME";
    exports2[1634] = "ER_SUBPARTITION_NAME";
    exports2[1635] = "ER_TEMPORARY_NAME";
    exports2[1636] = "ER_RENAMED_NAME";
    exports2[1637] = "ER_TOO_MANY_CONCURRENT_TRXS";
    exports2[1638] = "WARN_NON_ASCII_SEPARATOR_NOT_IMPLEMENTED";
    exports2[1639] = "ER_DEBUG_SYNC_TIMEOUT";
    exports2[1640] = "ER_DEBUG_SYNC_HIT_LIMIT";
    exports2[1641] = "ER_DUP_SIGNAL_SET";
    exports2[1642] = "ER_SIGNAL_WARN";
    exports2[1643] = "ER_SIGNAL_NOT_FOUND";
    exports2[1644] = "ER_SIGNAL_EXCEPTION";
    exports2[1645] = "ER_RESIGNAL_WITHOUT_ACTIVE_HANDLER";
    exports2[1646] = "ER_SIGNAL_BAD_CONDITION_TYPE";
    exports2[1647] = "WARN_COND_ITEM_TRUNCATED";
    exports2[1648] = "ER_COND_ITEM_TOO_LONG";
    exports2[1649] = "ER_UNKNOWN_LOCALE";
    exports2[1650] = "ER_REPLICA_IGNORE_SERVER_IDS";
    exports2[1651] = "ER_QUERY_CACHE_DISABLED";
    exports2[1652] = "ER_SAME_NAME_PARTITION_FIELD";
    exports2[1653] = "ER_PARTITION_COLUMN_LIST_ERROR";
    exports2[1654] = "ER_WRONG_TYPE_COLUMN_VALUE_ERROR";
    exports2[1655] = "ER_TOO_MANY_PARTITION_FUNC_FIELDS_ERROR";
    exports2[1656] = "ER_MAXVALUE_IN_VALUES_IN";
    exports2[1657] = "ER_TOO_MANY_VALUES_ERROR";
    exports2[1658] = "ER_ROW_SINGLE_PARTITION_FIELD_ERROR";
    exports2[1659] = "ER_FIELD_TYPE_NOT_ALLOWED_AS_PARTITION_FIELD";
    exports2[1660] = "ER_PARTITION_FIELDS_TOO_LONG";
    exports2[1661] = "ER_BINLOG_ROW_ENGINE_AND_STMT_ENGINE";
    exports2[1662] = "ER_BINLOG_ROW_MODE_AND_STMT_ENGINE";
    exports2[1663] = "ER_BINLOG_UNSAFE_AND_STMT_ENGINE";
    exports2[1664] = "ER_BINLOG_ROW_INJECTION_AND_STMT_ENGINE";
    exports2[1665] = "ER_BINLOG_STMT_MODE_AND_ROW_ENGINE";
    exports2[1666] = "ER_BINLOG_ROW_INJECTION_AND_STMT_MODE";
    exports2[1667] = "ER_BINLOG_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE";
    exports2[1668] = "ER_BINLOG_UNSAFE_LIMIT";
    exports2[1669] = "ER_UNUSED4";
    exports2[1670] = "ER_BINLOG_UNSAFE_SYSTEM_TABLE";
    exports2[1671] = "ER_BINLOG_UNSAFE_AUTOINC_COLUMNS";
    exports2[1672] = "ER_BINLOG_UNSAFE_UDF";
    exports2[1673] = "ER_BINLOG_UNSAFE_SYSTEM_VARIABLE";
    exports2[1674] = "ER_BINLOG_UNSAFE_SYSTEM_FUNCTION";
    exports2[1675] = "ER_BINLOG_UNSAFE_NONTRANS_AFTER_TRANS";
    exports2[1676] = "ER_MESSAGE_AND_STATEMENT";
    exports2[1677] = "ER_SLAVE_CONVERSION_FAILED";
    exports2[1678] = "ER_REPLICA_CANT_CREATE_CONVERSION";
    exports2[1679] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_FORMAT";
    exports2[1680] = "ER_PATH_LENGTH";
    exports2[1681] = "ER_WARN_DEPRECATED_SYNTAX_NO_REPLACEMENT";
    exports2[1682] = "ER_WRONG_NATIVE_TABLE_STRUCTURE";
    exports2[1683] = "ER_WRONG_PERFSCHEMA_USAGE";
    exports2[1684] = "ER_WARN_I_S_SKIPPED_TABLE";
    exports2[1685] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_BINLOG_DIRECT";
    exports2[1686] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_BINLOG_DIRECT";
    exports2[1687] = "ER_SPATIAL_MUST_HAVE_GEOM_COL";
    exports2[1688] = "ER_TOO_LONG_INDEX_COMMENT";
    exports2[1689] = "ER_LOCK_ABORTED";
    exports2[1690] = "ER_DATA_OUT_OF_RANGE";
    exports2[1691] = "ER_WRONG_SPVAR_TYPE_IN_LIMIT";
    exports2[1692] = "ER_BINLOG_UNSAFE_MULTIPLE_ENGINES_AND_SELF_LOGGING_ENGINE";
    exports2[1693] = "ER_BINLOG_UNSAFE_MIXED_STATEMENT";
    exports2[1694] = "ER_INSIDE_TRANSACTION_PREVENTS_SWITCH_SQL_LOG_BIN";
    exports2[1695] = "ER_STORED_FUNCTION_PREVENTS_SWITCH_SQL_LOG_BIN";
    exports2[1696] = "ER_FAILED_READ_FROM_PAR_FILE";
    exports2[1697] = "ER_VALUES_IS_NOT_INT_TYPE_ERROR";
    exports2[1698] = "ER_ACCESS_DENIED_NO_PASSWORD_ERROR";
    exports2[1699] = "ER_SET_PASSWORD_AUTH_PLUGIN";
    exports2[1700] = "ER_GRANT_PLUGIN_USER_EXISTS";
    exports2[1701] = "ER_TRUNCATE_ILLEGAL_FK";
    exports2[1702] = "ER_PLUGIN_IS_PERMANENT";
    exports2[1703] = "ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MIN";
    exports2[1704] = "ER_REPLICA_HEARTBEAT_VALUE_OUT_OF_RANGE_MAX";
    exports2[1705] = "ER_STMT_CACHE_FULL";
    exports2[1706] = "ER_MULTI_UPDATE_KEY_CONFLICT";
    exports2[1707] = "ER_TABLE_NEEDS_REBUILD";
    exports2[1708] = "WARN_OPTION_BELOW_LIMIT";
    exports2[1709] = "ER_INDEX_COLUMN_TOO_LONG";
    exports2[1710] = "ER_ERROR_IN_TRIGGER_BODY";
    exports2[1711] = "ER_ERROR_IN_UNKNOWN_TRIGGER_BODY";
    exports2[1712] = "ER_INDEX_CORRUPT";
    exports2[1713] = "ER_UNDO_RECORD_TOO_BIG";
    exports2[1714] = "ER_BINLOG_UNSAFE_INSERT_IGNORE_SELECT";
    exports2[1715] = "ER_BINLOG_UNSAFE_INSERT_SELECT_UPDATE";
    exports2[1716] = "ER_BINLOG_UNSAFE_REPLACE_SELECT";
    exports2[1717] = "ER_BINLOG_UNSAFE_CREATE_IGNORE_SELECT";
    exports2[1718] = "ER_BINLOG_UNSAFE_CREATE_REPLACE_SELECT";
    exports2[1719] = "ER_BINLOG_UNSAFE_UPDATE_IGNORE";
    exports2[1720] = "ER_PLUGIN_NO_UNINSTALL";
    exports2[1721] = "ER_PLUGIN_NO_INSTALL";
    exports2[1722] = "ER_BINLOG_UNSAFE_WRITE_AUTOINC_SELECT";
    exports2[1723] = "ER_BINLOG_UNSAFE_CREATE_SELECT_AUTOINC";
    exports2[1724] = "ER_BINLOG_UNSAFE_INSERT_TWO_KEYS";
    exports2[1725] = "ER_TABLE_IN_FK_CHECK";
    exports2[1726] = "ER_UNSUPPORTED_ENGINE";
    exports2[1727] = "ER_BINLOG_UNSAFE_AUTOINC_NOT_FIRST";
    exports2[1728] = "ER_CANNOT_LOAD_FROM_TABLE_V2";
    exports2[1729] = "ER_SOURCE_DELAY_VALUE_OUT_OF_RANGE";
    exports2[1730] = "ER_ONLY_FD_AND_RBR_EVENTS_ALLOWED_IN_BINLOG_STATEMENT";
    exports2[1731] = "ER_PARTITION_EXCHANGE_DIFFERENT_OPTION";
    exports2[1732] = "ER_PARTITION_EXCHANGE_PART_TABLE";
    exports2[1733] = "ER_PARTITION_EXCHANGE_TEMP_TABLE";
    exports2[1734] = "ER_PARTITION_INSTEAD_OF_SUBPARTITION";
    exports2[1735] = "ER_UNKNOWN_PARTITION";
    exports2[1736] = "ER_TABLES_DIFFERENT_METADATA";
    exports2[1737] = "ER_ROW_DOES_NOT_MATCH_PARTITION";
    exports2[1738] = "ER_BINLOG_CACHE_SIZE_GREATER_THAN_MAX";
    exports2[1739] = "ER_WARN_INDEX_NOT_APPLICABLE";
    exports2[1740] = "ER_PARTITION_EXCHANGE_FOREIGN_KEY";
    exports2[1741] = "ER_NO_SUCH_KEY_VALUE";
    exports2[1742] = "ER_RPL_INFO_DATA_TOO_LONG";
    exports2[1743] = "ER_NETWORK_READ_EVENT_CHECKSUM_FAILURE";
    exports2[1744] = "ER_BINLOG_READ_EVENT_CHECKSUM_FAILURE";
    exports2[1745] = "ER_BINLOG_STMT_CACHE_SIZE_GREATER_THAN_MAX";
    exports2[1746] = "ER_CANT_UPDATE_TABLE_IN_CREATE_TABLE_SELECT";
    exports2[1747] = "ER_PARTITION_CLAUSE_ON_NONPARTITIONED";
    exports2[1748] = "ER_ROW_DOES_NOT_MATCH_GIVEN_PARTITION_SET";
    exports2[1749] = "ER_NO_SUCH_PARTITION";
    exports2[1750] = "ER_CHANGE_RPL_INFO_REPOSITORY_FAILURE";
    exports2[1751] = "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_CREATED_TEMP_TABLE";
    exports2[1752] = "ER_WARNING_NOT_COMPLETE_ROLLBACK_WITH_DROPPED_TEMP_TABLE";
    exports2[1753] = "ER_MTA_FEATURE_IS_NOT_SUPPORTED";
    exports2[1754] = "ER_MTA_UPDATED_DBS_GREATER_MAX";
    exports2[1755] = "ER_MTA_CANT_PARALLEL";
    exports2[1756] = "ER_MTA_INCONSISTENT_DATA";
    exports2[1757] = "ER_FULLTEXT_NOT_SUPPORTED_WITH_PARTITIONING";
    exports2[1758] = "ER_DA_INVALID_CONDITION_NUMBER";
    exports2[1759] = "ER_INSECURE_PLAIN_TEXT";
    exports2[1760] = "ER_INSECURE_CHANGE_SOURCE";
    exports2[1761] = "ER_FOREIGN_DUPLICATE_KEY_WITH_CHILD_INFO";
    exports2[1762] = "ER_FOREIGN_DUPLICATE_KEY_WITHOUT_CHILD_INFO";
    exports2[1763] = "ER_SQLTHREAD_WITH_SECURE_REPLICA";
    exports2[1764] = "ER_TABLE_HAS_NO_FT";
    exports2[1765] = "ER_VARIABLE_NOT_SETTABLE_IN_SF_OR_TRIGGER";
    exports2[1766] = "ER_VARIABLE_NOT_SETTABLE_IN_TRANSACTION";
    exports2[1767] = "ER_GTID_NEXT_IS_NOT_IN_GTID_NEXT_LIST";
    exports2[1768] = "ER_CANT_CHANGE_GTID_NEXT_IN_TRANSACTION";
    exports2[1769] = "ER_SET_STATEMENT_CANNOT_INVOKE_FUNCTION";
    exports2[1770] = "ER_GTID_NEXT_CANT_BE_AUTOMATIC_IF_GTID_NEXT_LIST_IS_NON_NULL";
    exports2[1771] = "ER_SKIPPING_LOGGED_TRANSACTION";
    exports2[1772] = "ER_MALFORMED_GTID_SET_SPECIFICATION";
    exports2[1773] = "ER_MALFORMED_GTID_SET_ENCODING";
    exports2[1774] = "ER_MALFORMED_GTID_SPECIFICATION";
    exports2[1775] = "ER_GNO_EXHAUSTED";
    exports2[1776] = "ER_BAD_REPLICA_AUTO_POSITION";
    exports2[1777] = "ER_AUTO_POSITION_REQUIRES_GTID_MODE_NOT_OFF";
    exports2[1778] = "ER_CANT_DO_IMPLICIT_COMMIT_IN_TRX_WHEN_GTID_NEXT_IS_SET";
    exports2[1779] = "ER_GTID_MODE_ON_REQUIRES_ENFORCE_GTID_CONSISTENCY_ON";
    exports2[1780] = "ER_GTID_MODE_REQUIRES_BINLOG";
    exports2[1781] = "ER_CANT_SET_GTID_NEXT_TO_GTID_WHEN_GTID_MODE_IS_OFF";
    exports2[1782] = "ER_CANT_SET_GTID_NEXT_TO_ANONYMOUS_WHEN_GTID_MODE_IS_ON";
    exports2[1783] = "ER_CANT_SET_GTID_NEXT_LIST_TO_NON_NULL_WHEN_GTID_MODE_IS_OFF";
    exports2[1784] = "ER_FOUND_GTID_EVENT_WHEN_GTID_MODE_IS_OFF";
    exports2[1785] = "ER_GTID_UNSAFE_NON_TRANSACTIONAL_TABLE";
    exports2[1786] = "ER_GTID_UNSAFE_CREATE_SELECT";
    exports2[1787] = "ER_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRANSACTION";
    exports2[1788] = "ER_GTID_MODE_CAN_ONLY_CHANGE_ONE_STEP_AT_A_TIME";
    exports2[1789] = "ER_SOURCE_HAS_PURGED_REQUIRED_GTIDS";
    exports2[1790] = "ER_CANT_SET_GTID_NEXT_WHEN_OWNING_GTID";
    exports2[1791] = "ER_UNKNOWN_EXPLAIN_FORMAT";
    exports2[1792] = "ER_CANT_EXECUTE_IN_READ_ONLY_TRANSACTION";
    exports2[1793] = "ER_TOO_LONG_TABLE_PARTITION_COMMENT";
    exports2[1794] = "ER_REPLICA_CONFIGURATION";
    exports2[1795] = "ER_INNODB_FT_LIMIT";
    exports2[1796] = "ER_INNODB_NO_FT_TEMP_TABLE";
    exports2[1797] = "ER_INNODB_FT_WRONG_DOCID_COLUMN";
    exports2[1798] = "ER_INNODB_FT_WRONG_DOCID_INDEX";
    exports2[1799] = "ER_INNODB_ONLINE_LOG_TOO_BIG";
    exports2[1800] = "ER_UNKNOWN_ALTER_ALGORITHM";
    exports2[1801] = "ER_UNKNOWN_ALTER_LOCK";
    exports2[1802] = "ER_MTA_CHANGE_SOURCE_CANT_RUN_WITH_GAPS";
    exports2[1803] = "ER_MTA_RECOVERY_FAILURE";
    exports2[1804] = "ER_MTA_RESET_WORKERS";
    exports2[1805] = "ER_COL_COUNT_DOESNT_MATCH_CORRUPTED_V2";
    exports2[1806] = "ER_REPLICA_SILENT_RETRY_TRANSACTION";
    exports2[1807] = "ER_DISCARD_FK_CHECKS_RUNNING";
    exports2[1808] = "ER_TABLE_SCHEMA_MISMATCH";
    exports2[1809] = "ER_TABLE_IN_SYSTEM_TABLESPACE";
    exports2[1810] = "ER_IO_READ_ERROR";
    exports2[1811] = "ER_IO_WRITE_ERROR";
    exports2[1812] = "ER_TABLESPACE_MISSING";
    exports2[1813] = "ER_TABLESPACE_EXISTS";
    exports2[1814] = "ER_TABLESPACE_DISCARDED";
    exports2[1815] = "ER_INTERNAL_ERROR";
    exports2[1816] = "ER_INNODB_IMPORT_ERROR";
    exports2[1817] = "ER_INNODB_INDEX_CORRUPT";
    exports2[1818] = "ER_INVALID_YEAR_COLUMN_LENGTH";
    exports2[1819] = "ER_NOT_VALID_PASSWORD";
    exports2[1820] = "ER_MUST_CHANGE_PASSWORD";
    exports2[1821] = "ER_FK_NO_INDEX_CHILD";
    exports2[1822] = "ER_FK_NO_INDEX_PARENT";
    exports2[1823] = "ER_FK_FAIL_ADD_SYSTEM";
    exports2[1824] = "ER_FK_CANNOT_OPEN_PARENT";
    exports2[1825] = "ER_FK_INCORRECT_OPTION";
    exports2[1826] = "ER_FK_DUP_NAME";
    exports2[1827] = "ER_PASSWORD_FORMAT";
    exports2[1828] = "ER_FK_COLUMN_CANNOT_DROP";
    exports2[1829] = "ER_FK_COLUMN_CANNOT_DROP_CHILD";
    exports2[1830] = "ER_FK_COLUMN_NOT_NULL";
    exports2[1831] = "ER_DUP_INDEX";
    exports2[1832] = "ER_FK_COLUMN_CANNOT_CHANGE";
    exports2[1833] = "ER_FK_COLUMN_CANNOT_CHANGE_CHILD";
    exports2[1834] = "ER_UNUSED5";
    exports2[1835] = "ER_MALFORMED_PACKET";
    exports2[1836] = "ER_READ_ONLY_MODE";
    exports2[1837] = "ER_GTID_NEXT_TYPE_UNDEFINED_GTID";
    exports2[1838] = "ER_VARIABLE_NOT_SETTABLE_IN_SP";
    exports2[1839] = "ER_CANT_SET_GTID_PURGED_WHEN_GTID_MODE_IS_OFF";
    exports2[1840] = "ER_CANT_SET_GTID_PURGED_WHEN_GTID_EXECUTED_IS_NOT_EMPTY";
    exports2[1841] = "ER_CANT_SET_GTID_PURGED_WHEN_OWNED_GTIDS_IS_NOT_EMPTY";
    exports2[1842] = "ER_GTID_PURGED_WAS_CHANGED";
    exports2[1843] = "ER_GTID_EXECUTED_WAS_CHANGED";
    exports2[1844] = "ER_BINLOG_STMT_MODE_AND_NO_REPL_TABLES";
    exports2[1845] = "ER_ALTER_OPERATION_NOT_SUPPORTED";
    exports2[1846] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON";
    exports2[1847] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COPY";
    exports2[1848] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_PARTITION";
    exports2[1849] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_RENAME";
    exports2[1850] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE";
    exports2[1851] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FK_CHECK";
    exports2[1852] = "ER_UNUSED6";
    exports2[1853] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOPK";
    exports2[1854] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_AUTOINC";
    exports2[1855] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_HIDDEN_FTS";
    exports2[1856] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_CHANGE_FTS";
    exports2[1857] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_FTS";
    exports2[1858] = "ER_SQL_REPLICA_SKIP_COUNTER_NOT_SETTABLE_IN_GTID_MODE";
    exports2[1859] = "ER_DUP_UNKNOWN_IN_INDEX";
    exports2[1860] = "ER_IDENT_CAUSES_TOO_LONG_PATH";
    exports2[1861] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_NOT_NULL";
    exports2[1862] = "ER_MUST_CHANGE_PASSWORD_LOGIN";
    exports2[1863] = "ER_ROW_IN_WRONG_PARTITION";
    exports2[1864] = "ER_MTA_EVENT_BIGGER_PENDING_JOBS_SIZE_MAX";
    exports2[1865] = "ER_INNODB_NO_FT_USES_PARSER";
    exports2[1866] = "ER_BINLOG_LOGICAL_CORRUPTION";
    exports2[1867] = "ER_WARN_PURGE_LOG_IN_USE";
    exports2[1868] = "ER_WARN_PURGE_LOG_IS_ACTIVE";
    exports2[1869] = "ER_AUTO_INCREMENT_CONFLICT";
    exports2[1870] = "WARN_ON_BLOCKHOLE_IN_RBR";
    exports2[1871] = "ER_REPLICA_CM_INIT_REPOSITORY";
    exports2[1872] = "ER_REPLICA_AM_INIT_REPOSITORY";
    exports2[1873] = "ER_ACCESS_DENIED_CHANGE_USER_ERROR";
    exports2[1874] = "ER_INNODB_READ_ONLY";
    exports2[1875] = "ER_STOP_REPLICA_SQL_THREAD_TIMEOUT";
    exports2[1876] = "ER_STOP_REPLICA_IO_THREAD_TIMEOUT";
    exports2[1877] = "ER_TABLE_CORRUPT";
    exports2[1878] = "ER_TEMP_FILE_WRITE_FAILURE";
    exports2[1879] = "ER_INNODB_FT_AUX_NOT_HEX_ID";
    exports2[1880] = "ER_OLD_TEMPORALS_UPGRADED";
    exports2[1881] = "ER_INNODB_FORCED_RECOVERY";
    exports2[1882] = "ER_AES_INVALID_IV";
    exports2[1883] = "ER_PLUGIN_CANNOT_BE_UNINSTALLED";
    exports2[1884] = "ER_GTID_UNSAFE_BINLOG_SPLITTABLE_STATEMENT_AND_ASSIGNED_GTID";
    exports2[1885] = "ER_REPLICA_HAS_MORE_GTIDS_THAN_SOURCE";
    exports2[1886] = "ER_MISSING_KEY";
    exports2[1887] = "WARN_NAMED_PIPE_ACCESS_EVERYONE";
    exports2[3e3] = "ER_FILE_CORRUPT";
    exports2[3001] = "ER_ERROR_ON_SOURCE";
    exports2[3002] = "ER_INCONSISTENT_ERROR";
    exports2[3003] = "ER_STORAGE_ENGINE_NOT_LOADED";
    exports2[3004] = "ER_GET_STACKED_DA_WITHOUT_ACTIVE_HANDLER";
    exports2[3005] = "ER_WARN_LEGACY_SYNTAX_CONVERTED";
    exports2[3006] = "ER_BINLOG_UNSAFE_FULLTEXT_PLUGIN";
    exports2[3007] = "ER_CANNOT_DISCARD_TEMPORARY_TABLE";
    exports2[3008] = "ER_FK_DEPTH_EXCEEDED";
    exports2[3009] = "ER_COL_COUNT_DOESNT_MATCH_PLEASE_UPDATE_V2";
    exports2[3010] = "ER_WARN_TRIGGER_DOESNT_HAVE_CREATED";
    exports2[3011] = "ER_REFERENCED_TRG_DOES_NOT_EXIST";
    exports2[3012] = "ER_EXPLAIN_NOT_SUPPORTED";
    exports2[3013] = "ER_INVALID_FIELD_SIZE";
    exports2[3014] = "ER_MISSING_HA_CREATE_OPTION";
    exports2[3015] = "ER_ENGINE_OUT_OF_MEMORY";
    exports2[3016] = "ER_PASSWORD_EXPIRE_ANONYMOUS_USER";
    exports2[3017] = "ER_REPLICA_SQL_THREAD_MUST_STOP";
    exports2[3018] = "ER_NO_FT_MATERIALIZED_SUBQUERY";
    exports2[3019] = "ER_INNODB_UNDO_LOG_FULL";
    exports2[3020] = "ER_INVALID_ARGUMENT_FOR_LOGARITHM";
    exports2[3021] = "ER_REPLICA_CHANNEL_IO_THREAD_MUST_STOP";
    exports2[3022] = "ER_WARN_OPEN_TEMP_TABLES_MUST_BE_ZERO";
    exports2[3023] = "ER_WARN_ONLY_SOURCE_LOG_FILE_NO_POS";
    exports2[3024] = "ER_QUERY_TIMEOUT";
    exports2[3025] = "ER_NON_RO_SELECT_DISABLE_TIMER";
    exports2[3026] = "ER_DUP_LIST_ENTRY";
    exports2[3027] = "ER_SQL_MODE_NO_EFFECT";
    exports2[3028] = "ER_AGGREGATE_ORDER_FOR_UNION";
    exports2[3029] = "ER_AGGREGATE_ORDER_NON_AGG_QUERY";
    exports2[3030] = "ER_REPLICA_WORKER_STOPPED_PREVIOUS_THD_ERROR";
    exports2[3031] = "ER_DONT_SUPPORT_REPLICA_PRESERVE_COMMIT_ORDER";
    exports2[3032] = "ER_SERVER_OFFLINE_MODE";
    exports2[3033] = "ER_GIS_DIFFERENT_SRIDS";
    exports2[3034] = "ER_GIS_UNSUPPORTED_ARGUMENT";
    exports2[3035] = "ER_GIS_UNKNOWN_ERROR";
    exports2[3036] = "ER_GIS_UNKNOWN_EXCEPTION";
    exports2[3037] = "ER_GIS_INVALID_DATA";
    exports2[3038] = "ER_BOOST_GEOMETRY_EMPTY_INPUT_EXCEPTION";
    exports2[3039] = "ER_BOOST_GEOMETRY_CENTROID_EXCEPTION";
    exports2[3040] = "ER_BOOST_GEOMETRY_OVERLAY_INVALID_INPUT_EXCEPTION";
    exports2[3041] = "ER_BOOST_GEOMETRY_TURN_INFO_EXCEPTION";
    exports2[3042] = "ER_BOOST_GEOMETRY_SELF_INTERSECTION_POINT_EXCEPTION";
    exports2[3043] = "ER_BOOST_GEOMETRY_UNKNOWN_EXCEPTION";
    exports2[3044] = "ER_STD_BAD_ALLOC_ERROR";
    exports2[3045] = "ER_STD_DOMAIN_ERROR";
    exports2[3046] = "ER_STD_LENGTH_ERROR";
    exports2[3047] = "ER_STD_INVALID_ARGUMENT";
    exports2[3048] = "ER_STD_OUT_OF_RANGE_ERROR";
    exports2[3049] = "ER_STD_OVERFLOW_ERROR";
    exports2[3050] = "ER_STD_RANGE_ERROR";
    exports2[3051] = "ER_STD_UNDERFLOW_ERROR";
    exports2[3052] = "ER_STD_LOGIC_ERROR";
    exports2[3053] = "ER_STD_RUNTIME_ERROR";
    exports2[3054] = "ER_STD_UNKNOWN_EXCEPTION";
    exports2[3055] = "ER_GIS_DATA_WRONG_ENDIANESS";
    exports2[3056] = "ER_CHANGE_SOURCE_PASSWORD_LENGTH";
    exports2[3057] = "ER_USER_LOCK_WRONG_NAME";
    exports2[3058] = "ER_USER_LOCK_DEADLOCK";
    exports2[3059] = "ER_REPLACE_INACCESSIBLE_ROWS";
    exports2[3060] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_GIS";
    exports2[3061] = "ER_ILLEGAL_USER_VAR";
    exports2[3062] = "ER_GTID_MODE_OFF";
    exports2[3063] = "ER_UNSUPPORTED_BY_REPLICATION_THREAD";
    exports2[3064] = "ER_INCORRECT_TYPE";
    exports2[3065] = "ER_FIELD_IN_ORDER_NOT_SELECT";
    exports2[3066] = "ER_AGGREGATE_IN_ORDER_NOT_SELECT";
    exports2[3067] = "ER_INVALID_RPL_WILD_TABLE_FILTER_PATTERN";
    exports2[3068] = "ER_NET_OK_PACKET_TOO_LARGE";
    exports2[3069] = "ER_INVALID_JSON_DATA";
    exports2[3070] = "ER_INVALID_GEOJSON_MISSING_MEMBER";
    exports2[3071] = "ER_INVALID_GEOJSON_WRONG_TYPE";
    exports2[3072] = "ER_INVALID_GEOJSON_UNSPECIFIED";
    exports2[3073] = "ER_DIMENSION_UNSUPPORTED";
    exports2[3074] = "ER_REPLICA_CHANNEL_DOES_NOT_EXIST";
    exports2[3075] = "ER_SLAVE_MULTIPLE_CHANNELS_HOST_PORT";
    exports2[3076] = "ER_REPLICA_CHANNEL_NAME_INVALID_OR_TOO_LONG";
    exports2[3077] = "ER_REPLICA_NEW_CHANNEL_WRONG_REPOSITORY";
    exports2[3078] = "ER_SLAVE_CHANNEL_DELETE";
    exports2[3079] = "ER_REPLICA_MULTIPLE_CHANNELS_CMD";
    exports2[3080] = "ER_REPLICA_MAX_CHANNELS_EXCEEDED";
    exports2[3081] = "ER_REPLICA_CHANNEL_MUST_STOP";
    exports2[3082] = "ER_REPLICA_CHANNEL_NOT_RUNNING";
    exports2[3083] = "ER_REPLICA_CHANNEL_WAS_RUNNING";
    exports2[3084] = "ER_REPLICA_CHANNEL_WAS_NOT_RUNNING";
    exports2[3085] = "ER_REPLICA_CHANNEL_SQL_THREAD_MUST_STOP";
    exports2[3086] = "ER_REPLICA_CHANNEL_SQL_SKIP_COUNTER";
    exports2[3087] = "ER_WRONG_FIELD_WITH_GROUP_V2";
    exports2[3088] = "ER_MIX_OF_GROUP_FUNC_AND_FIELDS_V2";
    exports2[3089] = "ER_WARN_DEPRECATED_SYSVAR_UPDATE";
    exports2[3090] = "ER_WARN_DEPRECATED_SQLMODE";
    exports2[3091] = "ER_CANNOT_LOG_PARTIAL_DROP_DATABASE_WITH_GTID";
    exports2[3092] = "ER_GROUP_REPLICATION_CONFIGURATION";
    exports2[3093] = "ER_GROUP_REPLICATION_RUNNING";
    exports2[3094] = "ER_GROUP_REPLICATION_APPLIER_INIT_ERROR";
    exports2[3095] = "ER_GROUP_REPLICATION_STOP_APPLIER_THREAD_TIMEOUT";
    exports2[3096] = "ER_GROUP_REPLICATION_COMMUNICATION_LAYER_SESSION_ERROR";
    exports2[3097] = "ER_GROUP_REPLICATION_COMMUNICATION_LAYER_JOIN_ERROR";
    exports2[3098] = "ER_BEFORE_DML_VALIDATION_ERROR";
    exports2[3099] = "ER_PREVENTS_VARIABLE_WITHOUT_RBR";
    exports2[3100] = "ER_RUN_HOOK_ERROR";
    exports2[3101] = "ER_TRANSACTION_ROLLBACK_DURING_COMMIT";
    exports2[3102] = "ER_GENERATED_COLUMN_FUNCTION_IS_NOT_ALLOWED";
    exports2[3103] = "ER_UNSUPPORTED_ALTER_INPLACE_ON_VIRTUAL_COLUMN";
    exports2[3104] = "ER_WRONG_FK_OPTION_FOR_GENERATED_COLUMN";
    exports2[3105] = "ER_NON_DEFAULT_VALUE_FOR_GENERATED_COLUMN";
    exports2[3106] = "ER_UNSUPPORTED_ACTION_ON_GENERATED_COLUMN";
    exports2[3107] = "ER_GENERATED_COLUMN_NON_PRIOR";
    exports2[3108] = "ER_DEPENDENT_BY_GENERATED_COLUMN";
    exports2[3109] = "ER_GENERATED_COLUMN_REF_AUTO_INC";
    exports2[3110] = "ER_FEATURE_NOT_AVAILABLE";
    exports2[3111] = "ER_CANT_SET_GTID_MODE";
    exports2[3112] = "ER_CANT_USE_AUTO_POSITION_WITH_GTID_MODE_OFF";
    exports2[3113] = "ER_CANT_REPLICATE_ANONYMOUS_WITH_AUTO_POSITION";
    exports2[3114] = "ER_CANT_REPLICATE_ANONYMOUS_WITH_GTID_MODE_ON";
    exports2[3115] = "ER_CANT_REPLICATE_GTID_WITH_GTID_MODE_OFF";
    exports2[3116] = "ER_CANT_ENFORCE_GTID_CONSISTENCY_WITH_ONGOING_GTID_VIOLATING_TX";
    exports2[3117] = "ER_ENFORCE_GTID_CONSISTENCY_WARN_WITH_ONGOING_GTID_VIOLATING_TX";
    exports2[3118] = "ER_ACCOUNT_HAS_BEEN_LOCKED";
    exports2[3119] = "ER_WRONG_TABLESPACE_NAME";
    exports2[3120] = "ER_TABLESPACE_IS_NOT_EMPTY";
    exports2[3121] = "ER_WRONG_FILE_NAME";
    exports2[3122] = "ER_BOOST_GEOMETRY_INCONSISTENT_TURNS_EXCEPTION";
    exports2[3123] = "ER_WARN_OPTIMIZER_HINT_SYNTAX_ERROR";
    exports2[3124] = "ER_WARN_BAD_MAX_EXECUTION_TIME";
    exports2[3125] = "ER_WARN_UNSUPPORTED_MAX_EXECUTION_TIME";
    exports2[3126] = "ER_WARN_CONFLICTING_HINT";
    exports2[3127] = "ER_WARN_UNKNOWN_QB_NAME";
    exports2[3128] = "ER_UNRESOLVED_HINT_NAME";
    exports2[3129] = "ER_WARN_ON_MODIFYING_GTID_EXECUTED_TABLE";
    exports2[3130] = "ER_PLUGGABLE_PROTOCOL_COMMAND_NOT_SUPPORTED";
    exports2[3131] = "ER_LOCKING_SERVICE_WRONG_NAME";
    exports2[3132] = "ER_LOCKING_SERVICE_DEADLOCK";
    exports2[3133] = "ER_LOCKING_SERVICE_TIMEOUT";
    exports2[3134] = "ER_GIS_MAX_POINTS_IN_GEOMETRY_OVERFLOWED";
    exports2[3135] = "ER_SQL_MODE_MERGED";
    exports2[3136] = "ER_VTOKEN_PLUGIN_TOKEN_MISMATCH";
    exports2[3137] = "ER_VTOKEN_PLUGIN_TOKEN_NOT_FOUND";
    exports2[3138] = "ER_CANT_SET_VARIABLE_WHEN_OWNING_GTID";
    exports2[3139] = "ER_REPLICA_CHANNEL_OPERATION_NOT_ALLOWED";
    exports2[3140] = "ER_INVALID_JSON_TEXT";
    exports2[3141] = "ER_INVALID_JSON_TEXT_IN_PARAM";
    exports2[3142] = "ER_INVALID_JSON_BINARY_DATA";
    exports2[3143] = "ER_INVALID_JSON_PATH";
    exports2[3144] = "ER_INVALID_JSON_CHARSET";
    exports2[3145] = "ER_INVALID_JSON_CHARSET_IN_FUNCTION";
    exports2[3146] = "ER_INVALID_TYPE_FOR_JSON";
    exports2[3147] = "ER_INVALID_CAST_TO_JSON";
    exports2[3148] = "ER_INVALID_JSON_PATH_CHARSET";
    exports2[3149] = "ER_INVALID_JSON_PATH_WILDCARD";
    exports2[3150] = "ER_JSON_VALUE_TOO_BIG";
    exports2[3151] = "ER_JSON_KEY_TOO_BIG";
    exports2[3152] = "ER_JSON_USED_AS_KEY";
    exports2[3153] = "ER_JSON_VACUOUS_PATH";
    exports2[3154] = "ER_JSON_BAD_ONE_OR_ALL_ARG";
    exports2[3155] = "ER_NUMERIC_JSON_VALUE_OUT_OF_RANGE";
    exports2[3156] = "ER_INVALID_JSON_VALUE_FOR_CAST";
    exports2[3157] = "ER_JSON_DOCUMENT_TOO_DEEP";
    exports2[3158] = "ER_JSON_DOCUMENT_NULL_KEY";
    exports2[3159] = "ER_SECURE_TRANSPORT_REQUIRED";
    exports2[3160] = "ER_NO_SECURE_TRANSPORTS_CONFIGURED";
    exports2[3161] = "ER_DISABLED_STORAGE_ENGINE";
    exports2[3162] = "ER_USER_DOES_NOT_EXIST";
    exports2[3163] = "ER_USER_ALREADY_EXISTS";
    exports2[3164] = "ER_AUDIT_API_ABORT";
    exports2[3165] = "ER_INVALID_JSON_PATH_ARRAY_CELL";
    exports2[3166] = "ER_BUFPOOL_RESIZE_INPROGRESS";
    exports2[3167] = "ER_FEATURE_DISABLED_SEE_DOC";
    exports2[3168] = "ER_SERVER_ISNT_AVAILABLE";
    exports2[3169] = "ER_SESSION_WAS_KILLED";
    exports2[3170] = "ER_CAPACITY_EXCEEDED";
    exports2[3171] = "ER_CAPACITY_EXCEEDED_IN_RANGE_OPTIMIZER";
    exports2[3172] = "ER_TABLE_NEEDS_UPG_PART";
    exports2[3173] = "ER_CANT_WAIT_FOR_EXECUTED_GTID_SET_WHILE_OWNING_A_GTID";
    exports2[3174] = "ER_CANNOT_ADD_FOREIGN_BASE_COL_VIRTUAL";
    exports2[3175] = "ER_CANNOT_CREATE_VIRTUAL_INDEX_CONSTRAINT";
    exports2[3176] = "ER_ERROR_ON_MODIFYING_GTID_EXECUTED_TABLE";
    exports2[3177] = "ER_LOCK_REFUSED_BY_ENGINE";
    exports2[3178] = "ER_UNSUPPORTED_ALTER_ONLINE_ON_VIRTUAL_COLUMN";
    exports2[3179] = "ER_MASTER_KEY_ROTATION_NOT_SUPPORTED_BY_SE";
    exports2[3180] = "ER_MASTER_KEY_ROTATION_ERROR_BY_SE";
    exports2[3181] = "ER_MASTER_KEY_ROTATION_BINLOG_FAILED";
    exports2[3182] = "ER_MASTER_KEY_ROTATION_SE_UNAVAILABLE";
    exports2[3183] = "ER_TABLESPACE_CANNOT_ENCRYPT";
    exports2[3184] = "ER_INVALID_ENCRYPTION_OPTION";
    exports2[3185] = "ER_CANNOT_FIND_KEY_IN_KEYRING";
    exports2[3186] = "ER_CAPACITY_EXCEEDED_IN_PARSER";
    exports2[3187] = "ER_UNSUPPORTED_ALTER_ENCRYPTION_INPLACE";
    exports2[3188] = "ER_KEYRING_UDF_KEYRING_SERVICE_ERROR";
    exports2[3189] = "ER_USER_COLUMN_OLD_LENGTH";
    exports2[3190] = "ER_CANT_RESET_SOURCE";
    exports2[3191] = "ER_GROUP_REPLICATION_MAX_GROUP_SIZE";
    exports2[3192] = "ER_CANNOT_ADD_FOREIGN_BASE_COL_STORED";
    exports2[3193] = "ER_TABLE_REFERENCED";
    exports2[3194] = "ER_PARTITION_ENGINE_DEPRECATED_FOR_TABLE";
    exports2[3195] = "ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID_ZERO";
    exports2[3196] = "ER_WARN_USING_GEOMFROMWKB_TO_SET_SRID";
    exports2[3197] = "ER_XA_RETRY";
    exports2[3198] = "ER_KEYRING_AWS_UDF_AWS_KMS_ERROR";
    exports2[3199] = "ER_BINLOG_UNSAFE_XA";
    exports2[3200] = "ER_UDF_ERROR";
    exports2[3201] = "ER_KEYRING_MIGRATION_FAILURE";
    exports2[3202] = "ER_KEYRING_ACCESS_DENIED_ERROR";
    exports2[3203] = "ER_KEYRING_MIGRATION_STATUS";
    exports2[3204] = "ER_PLUGIN_FAILED_TO_OPEN_TABLES";
    exports2[3205] = "ER_PLUGIN_FAILED_TO_OPEN_TABLE";
    exports2[3206] = "ER_AUDIT_LOG_NO_KEYRING_PLUGIN_INSTALLED";
    exports2[3207] = "ER_AUDIT_LOG_ENCRYPTION_PASSWORD_HAS_NOT_BEEN_SET";
    exports2[3208] = "ER_AUDIT_LOG_COULD_NOT_CREATE_AES_KEY";
    exports2[3209] = "ER_AUDIT_LOG_ENCRYPTION_PASSWORD_CANNOT_BE_FETCHED";
    exports2[3210] = "ER_AUDIT_LOG_JSON_FILTERING_NOT_ENABLED";
    exports2[3211] = "ER_AUDIT_LOG_UDF_INSUFFICIENT_PRIVILEGE";
    exports2[3212] = "ER_AUDIT_LOG_SUPER_PRIVILEGE_REQUIRED";
    exports2[3213] = "ER_COULD_NOT_REINITIALIZE_AUDIT_LOG_FILTERS";
    exports2[3214] = "ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_TYPE";
    exports2[3215] = "ER_AUDIT_LOG_UDF_INVALID_ARGUMENT_COUNT";
    exports2[3216] = "ER_AUDIT_LOG_HAS_NOT_BEEN_INSTALLED";
    exports2[3217] = "ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_TYPE";
    exports2[3218] = "ER_AUDIT_LOG_UDF_READ_INVALID_MAX_ARRAY_LENGTH_ARG_VALUE";
    exports2[3219] = "ER_AUDIT_LOG_JSON_FILTER_PARSING_ERROR";
    exports2[3220] = "ER_AUDIT_LOG_JSON_FILTER_NAME_CANNOT_BE_EMPTY";
    exports2[3221] = "ER_AUDIT_LOG_JSON_USER_NAME_CANNOT_BE_EMPTY";
    exports2[3222] = "ER_AUDIT_LOG_JSON_FILTER_DOES_NOT_EXISTS";
    exports2[3223] = "ER_AUDIT_LOG_USER_FIRST_CHARACTER_MUST_BE_ALPHANUMERIC";
    exports2[3224] = "ER_AUDIT_LOG_USER_NAME_INVALID_CHARACTER";
    exports2[3225] = "ER_AUDIT_LOG_HOST_NAME_INVALID_CHARACTER";
    exports2[3226] = "WARN_DEPRECATED_MAXDB_SQL_MODE_FOR_TIMESTAMP";
    exports2[3227] = "ER_XA_REPLICATION_FILTERS";
    exports2[3228] = "ER_CANT_OPEN_ERROR_LOG";
    exports2[3229] = "ER_GROUPING_ON_TIMESTAMP_IN_DST";
    exports2[3230] = "ER_CANT_START_SERVER_NAMED_PIPE";
    exports2[3231] = "ER_WRITE_SET_EXCEEDS_LIMIT";
    exports2[3232] = "ER_DEPRECATED_TLS_VERSION_SESSION_57";
    exports2[3233] = "ER_WARN_DEPRECATED_TLS_VERSION_57";
    exports2[3234] = "ER_WARN_WRONG_NATIVE_TABLE_STRUCTURE";
    exports2[3235] = "ER_AES_INVALID_KDF_NAME";
    exports2[3236] = "ER_AES_INVALID_KDF_ITERATIONS";
    exports2[3237] = "WARN_AES_KEY_SIZE";
    exports2[3238] = "ER_AES_INVALID_KDF_OPTION_SIZE";
    exports2[3500] = "ER_UNSUPPORT_COMPRESSED_TEMPORARY_TABLE";
    exports2[3501] = "ER_ACL_OPERATION_FAILED";
    exports2[3502] = "ER_UNSUPPORTED_INDEX_ALGORITHM";
    exports2[3503] = "ER_NO_SUCH_DB";
    exports2[3504] = "ER_TOO_BIG_ENUM";
    exports2[3505] = "ER_TOO_LONG_SET_ENUM_VALUE";
    exports2[3506] = "ER_INVALID_DD_OBJECT";
    exports2[3507] = "ER_UPDATING_DD_TABLE";
    exports2[3508] = "ER_INVALID_DD_OBJECT_ID";
    exports2[3509] = "ER_INVALID_DD_OBJECT_NAME";
    exports2[3510] = "ER_TABLESPACE_MISSING_WITH_NAME";
    exports2[3511] = "ER_TOO_LONG_ROUTINE_COMMENT";
    exports2[3512] = "ER_SP_LOAD_FAILED";
    exports2[3513] = "ER_INVALID_BITWISE_OPERANDS_SIZE";
    exports2[3514] = "ER_INVALID_BITWISE_AGGREGATE_OPERANDS_SIZE";
    exports2[3515] = "ER_WARN_UNSUPPORTED_HINT";
    exports2[3516] = "ER_UNEXPECTED_GEOMETRY_TYPE";
    exports2[3517] = "ER_SRS_PARSE_ERROR";
    exports2[3518] = "ER_SRS_PROJ_PARAMETER_MISSING";
    exports2[3519] = "ER_WARN_SRS_NOT_FOUND";
    exports2[3520] = "ER_SRS_NOT_CARTESIAN";
    exports2[3521] = "ER_SRS_NOT_CARTESIAN_UNDEFINED";
    exports2[3522] = "ER_PK_INDEX_CANT_BE_INVISIBLE";
    exports2[3523] = "ER_UNKNOWN_AUTHID";
    exports2[3524] = "ER_FAILED_ROLE_GRANT";
    exports2[3525] = "ER_OPEN_ROLE_TABLES";
    exports2[3526] = "ER_FAILED_DEFAULT_ROLES";
    exports2[3527] = "ER_COMPONENTS_NO_SCHEME";
    exports2[3528] = "ER_COMPONENTS_NO_SCHEME_SERVICE";
    exports2[3529] = "ER_COMPONENTS_CANT_LOAD";
    exports2[3530] = "ER_ROLE_NOT_GRANTED";
    exports2[3531] = "ER_FAILED_REVOKE_ROLE";
    exports2[3532] = "ER_RENAME_ROLE";
    exports2[3533] = "ER_COMPONENTS_CANT_ACQUIRE_SERVICE_IMPLEMENTATION";
    exports2[3534] = "ER_COMPONENTS_CANT_SATISFY_DEPENDENCY";
    exports2[3535] = "ER_COMPONENTS_LOAD_CANT_REGISTER_SERVICE_IMPLEMENTATION";
    exports2[3536] = "ER_COMPONENTS_LOAD_CANT_INITIALIZE";
    exports2[3537] = "ER_COMPONENTS_UNLOAD_NOT_LOADED";
    exports2[3538] = "ER_COMPONENTS_UNLOAD_CANT_DEINITIALIZE";
    exports2[3539] = "ER_COMPONENTS_CANT_RELEASE_SERVICE";
    exports2[3540] = "ER_COMPONENTS_UNLOAD_CANT_UNREGISTER_SERVICE";
    exports2[3541] = "ER_COMPONENTS_CANT_UNLOAD";
    exports2[3542] = "ER_WARN_UNLOAD_THE_NOT_PERSISTED";
    exports2[3543] = "ER_COMPONENT_TABLE_INCORRECT";
    exports2[3544] = "ER_COMPONENT_MANIPULATE_ROW_FAILED";
    exports2[3545] = "ER_COMPONENTS_UNLOAD_DUPLICATE_IN_GROUP";
    exports2[3546] = "ER_CANT_SET_GTID_PURGED_DUE_SETS_CONSTRAINTS";
    exports2[3547] = "ER_CANNOT_LOCK_USER_MANAGEMENT_CACHES";
    exports2[3548] = "ER_SRS_NOT_FOUND";
    exports2[3549] = "ER_VARIABLE_NOT_PERSISTED";
    exports2[3550] = "ER_IS_QUERY_INVALID_CLAUSE";
    exports2[3551] = "ER_UNABLE_TO_STORE_STATISTICS";
    exports2[3552] = "ER_NO_SYSTEM_SCHEMA_ACCESS";
    exports2[3553] = "ER_NO_SYSTEM_TABLESPACE_ACCESS";
    exports2[3554] = "ER_NO_SYSTEM_TABLE_ACCESS";
    exports2[3555] = "ER_NO_SYSTEM_TABLE_ACCESS_FOR_DICTIONARY_TABLE";
    exports2[3556] = "ER_NO_SYSTEM_TABLE_ACCESS_FOR_SYSTEM_TABLE";
    exports2[3557] = "ER_NO_SYSTEM_TABLE_ACCESS_FOR_TABLE";
    exports2[3558] = "ER_INVALID_OPTION_KEY";
    exports2[3559] = "ER_INVALID_OPTION_VALUE";
    exports2[3560] = "ER_INVALID_OPTION_KEY_VALUE_PAIR";
    exports2[3561] = "ER_INVALID_OPTION_START_CHARACTER";
    exports2[3562] = "ER_INVALID_OPTION_END_CHARACTER";
    exports2[3563] = "ER_INVALID_OPTION_CHARACTERS";
    exports2[3564] = "ER_DUPLICATE_OPTION_KEY";
    exports2[3565] = "ER_WARN_SRS_NOT_FOUND_AXIS_ORDER";
    exports2[3566] = "ER_NO_ACCESS_TO_NATIVE_FCT";
    exports2[3567] = "ER_RESET_SOURCE_TO_VALUE_OUT_OF_RANGE";
    exports2[3568] = "ER_UNRESOLVED_TABLE_LOCK";
    exports2[3569] = "ER_DUPLICATE_TABLE_LOCK";
    exports2[3570] = "ER_BINLOG_UNSAFE_SKIP_LOCKED";
    exports2[3571] = "ER_BINLOG_UNSAFE_NOWAIT";
    exports2[3572] = "ER_LOCK_NOWAIT";
    exports2[3573] = "ER_CTE_RECURSIVE_REQUIRES_UNION";
    exports2[3574] = "ER_CTE_RECURSIVE_REQUIRES_NONRECURSIVE_FIRST";
    exports2[3575] = "ER_CTE_RECURSIVE_FORBIDS_AGGREGATION";
    exports2[3576] = "ER_CTE_RECURSIVE_FORBIDDEN_JOIN_ORDER";
    exports2[3577] = "ER_CTE_RECURSIVE_REQUIRES_SINGLE_REFERENCE";
    exports2[3578] = "ER_SWITCH_TMP_ENGINE";
    exports2[3579] = "ER_WINDOW_NO_SUCH_WINDOW";
    exports2[3580] = "ER_WINDOW_CIRCULARITY_IN_WINDOW_GRAPH";
    exports2[3581] = "ER_WINDOW_NO_CHILD_PARTITIONING";
    exports2[3582] = "ER_WINDOW_NO_INHERIT_FRAME";
    exports2[3583] = "ER_WINDOW_NO_REDEFINE_ORDER_BY";
    exports2[3584] = "ER_WINDOW_FRAME_START_ILLEGAL";
    exports2[3585] = "ER_WINDOW_FRAME_END_ILLEGAL";
    exports2[3586] = "ER_WINDOW_FRAME_ILLEGAL";
    exports2[3587] = "ER_WINDOW_RANGE_FRAME_ORDER_TYPE";
    exports2[3588] = "ER_WINDOW_RANGE_FRAME_TEMPORAL_TYPE";
    exports2[3589] = "ER_WINDOW_RANGE_FRAME_NUMERIC_TYPE";
    exports2[3590] = "ER_WINDOW_RANGE_BOUND_NOT_CONSTANT";
    exports2[3591] = "ER_WINDOW_DUPLICATE_NAME";
    exports2[3592] = "ER_WINDOW_ILLEGAL_ORDER_BY";
    exports2[3593] = "ER_WINDOW_INVALID_WINDOW_FUNC_USE";
    exports2[3594] = "ER_WINDOW_INVALID_WINDOW_FUNC_ALIAS_USE";
    exports2[3595] = "ER_WINDOW_NESTED_WINDOW_FUNC_USE_IN_WINDOW_SPEC";
    exports2[3596] = "ER_WINDOW_ROWS_INTERVAL_USE";
    exports2[3597] = "ER_WINDOW_NO_GROUP_ORDER";
    exports2[3598] = "ER_WINDOW_EXPLAIN_JSON";
    exports2[3599] = "ER_WINDOW_FUNCTION_IGNORES_FRAME";
    exports2[3600] = "ER_WL9236_NOW";
    exports2[3601] = "ER_INVALID_NO_OF_ARGS";
    exports2[3602] = "ER_FIELD_IN_GROUPING_NOT_GROUP_BY";
    exports2[3603] = "ER_TOO_LONG_TABLESPACE_COMMENT";
    exports2[3604] = "ER_ENGINE_CANT_DROP_TABLE";
    exports2[3605] = "ER_ENGINE_CANT_DROP_MISSING_TABLE";
    exports2[3606] = "ER_TABLESPACE_DUP_FILENAME";
    exports2[3607] = "ER_DB_DROP_RMDIR2";
    exports2[3608] = "ER_IMP_NO_FILES_MATCHED";
    exports2[3609] = "ER_IMP_SCHEMA_DOES_NOT_EXIST";
    exports2[3610] = "ER_IMP_TABLE_ALREADY_EXISTS";
    exports2[3611] = "ER_IMP_INCOMPATIBLE_MYSQLD_VERSION";
    exports2[3612] = "ER_IMP_INCOMPATIBLE_DD_VERSION";
    exports2[3613] = "ER_IMP_INCOMPATIBLE_SDI_VERSION";
    exports2[3614] = "ER_WARN_INVALID_HINT";
    exports2[3615] = "ER_VAR_DOES_NOT_EXIST";
    exports2[3616] = "ER_LONGITUDE_OUT_OF_RANGE";
    exports2[3617] = "ER_LATITUDE_OUT_OF_RANGE";
    exports2[3618] = "ER_NOT_IMPLEMENTED_FOR_GEOGRAPHIC_SRS";
    exports2[3619] = "ER_ILLEGAL_PRIVILEGE_LEVEL";
    exports2[3620] = "ER_NO_SYSTEM_VIEW_ACCESS";
    exports2[3621] = "ER_COMPONENT_FILTER_FLABBERGASTED";
    exports2[3622] = "ER_PART_EXPR_TOO_LONG";
    exports2[3623] = "ER_UDF_DROP_DYNAMICALLY_REGISTERED";
    exports2[3624] = "ER_UNABLE_TO_STORE_COLUMN_STATISTICS";
    exports2[3625] = "ER_UNABLE_TO_UPDATE_COLUMN_STATISTICS";
    exports2[3626] = "ER_UNABLE_TO_DROP_COLUMN_STATISTICS";
    exports2[3627] = "ER_UNABLE_TO_BUILD_HISTOGRAM";
    exports2[3628] = "ER_MANDATORY_ROLE";
    exports2[3629] = "ER_MISSING_TABLESPACE_FILE";
    exports2[3630] = "ER_PERSIST_ONLY_ACCESS_DENIED_ERROR";
    exports2[3631] = "ER_CMD_NEED_SUPER";
    exports2[3632] = "ER_PATH_IN_DATADIR";
    exports2[3633] = "ER_CLONE_DDL_IN_PROGRESS";
    exports2[3634] = "ER_CLONE_TOO_MANY_CONCURRENT_CLONES";
    exports2[3635] = "ER_APPLIER_LOG_EVENT_VALIDATION_ERROR";
    exports2[3636] = "ER_CTE_MAX_RECURSION_DEPTH";
    exports2[3637] = "ER_NOT_HINT_UPDATABLE_VARIABLE";
    exports2[3638] = "ER_CREDENTIALS_CONTRADICT_TO_HISTORY";
    exports2[3639] = "ER_WARNING_PASSWORD_HISTORY_CLAUSES_VOID";
    exports2[3640] = "ER_CLIENT_DOES_NOT_SUPPORT";
    exports2[3641] = "ER_I_S_SKIPPED_TABLESPACE";
    exports2[3642] = "ER_TABLESPACE_ENGINE_MISMATCH";
    exports2[3643] = "ER_WRONG_SRID_FOR_COLUMN";
    exports2[3644] = "ER_CANNOT_ALTER_SRID_DUE_TO_INDEX";
    exports2[3645] = "ER_WARN_BINLOG_PARTIAL_UPDATES_DISABLED";
    exports2[3646] = "ER_WARN_BINLOG_V1_ROW_EVENTS_DISABLED";
    exports2[3647] = "ER_WARN_BINLOG_PARTIAL_UPDATES_SUGGESTS_PARTIAL_IMAGES";
    exports2[3648] = "ER_COULD_NOT_APPLY_JSON_DIFF";
    exports2[3649] = "ER_CORRUPTED_JSON_DIFF";
    exports2[3650] = "ER_RESOURCE_GROUP_EXISTS";
    exports2[3651] = "ER_RESOURCE_GROUP_NOT_EXISTS";
    exports2[3652] = "ER_INVALID_VCPU_ID";
    exports2[3653] = "ER_INVALID_VCPU_RANGE";
    exports2[3654] = "ER_INVALID_THREAD_PRIORITY";
    exports2[3655] = "ER_DISALLOWED_OPERATION";
    exports2[3656] = "ER_RESOURCE_GROUP_BUSY";
    exports2[3657] = "ER_RESOURCE_GROUP_DISABLED";
    exports2[3658] = "ER_FEATURE_UNSUPPORTED";
    exports2[3659] = "ER_ATTRIBUTE_IGNORED";
    exports2[3660] = "ER_INVALID_THREAD_ID";
    exports2[3661] = "ER_RESOURCE_GROUP_BIND_FAILED";
    exports2[3662] = "ER_INVALID_USE_OF_FORCE_OPTION";
    exports2[3663] = "ER_GROUP_REPLICATION_COMMAND_FAILURE";
    exports2[3664] = "ER_SDI_OPERATION_FAILED";
    exports2[3665] = "ER_MISSING_JSON_TABLE_VALUE";
    exports2[3666] = "ER_WRONG_JSON_TABLE_VALUE";
    exports2[3667] = "ER_TF_MUST_HAVE_ALIAS";
    exports2[3668] = "ER_TF_FORBIDDEN_JOIN_TYPE";
    exports2[3669] = "ER_JT_VALUE_OUT_OF_RANGE";
    exports2[3670] = "ER_JT_MAX_NESTED_PATH";
    exports2[3671] = "ER_PASSWORD_EXPIRATION_NOT_SUPPORTED_BY_AUTH_METHOD";
    exports2[3672] = "ER_INVALID_GEOJSON_CRS_NOT_TOP_LEVEL";
    exports2[3673] = "ER_BAD_NULL_ERROR_NOT_IGNORED";
    exports2[3674] = "WARN_USELESS_SPATIAL_INDEX";
    exports2[3675] = "ER_DISK_FULL_NOWAIT";
    exports2[3676] = "ER_PARSE_ERROR_IN_DIGEST_FN";
    exports2[3677] = "ER_UNDISCLOSED_PARSE_ERROR_IN_DIGEST_FN";
    exports2[3678] = "ER_SCHEMA_DIR_EXISTS";
    exports2[3679] = "ER_SCHEMA_DIR_MISSING";
    exports2[3680] = "ER_SCHEMA_DIR_CREATE_FAILED";
    exports2[3681] = "ER_SCHEMA_DIR_UNKNOWN";
    exports2[3682] = "ER_ONLY_IMPLEMENTED_FOR_SRID_0_AND_4326";
    exports2[3683] = "ER_BINLOG_EXPIRE_LOG_DAYS_AND_SECS_USED_TOGETHER";
    exports2[3684] = "ER_REGEXP_BUFFER_OVERFLOW";
    exports2[3685] = "ER_REGEXP_ILLEGAL_ARGUMENT";
    exports2[3686] = "ER_REGEXP_INDEX_OUTOFBOUNDS_ERROR";
    exports2[3687] = "ER_REGEXP_INTERNAL_ERROR";
    exports2[3688] = "ER_REGEXP_RULE_SYNTAX";
    exports2[3689] = "ER_REGEXP_BAD_ESCAPE_SEQUENCE";
    exports2[3690] = "ER_REGEXP_UNIMPLEMENTED";
    exports2[3691] = "ER_REGEXP_MISMATCHED_PAREN";
    exports2[3692] = "ER_REGEXP_BAD_INTERVAL";
    exports2[3693] = "ER_REGEXP_MAX_LT_MIN";
    exports2[3694] = "ER_REGEXP_INVALID_BACK_REF";
    exports2[3695] = "ER_REGEXP_LOOK_BEHIND_LIMIT";
    exports2[3696] = "ER_REGEXP_MISSING_CLOSE_BRACKET";
    exports2[3697] = "ER_REGEXP_INVALID_RANGE";
    exports2[3698] = "ER_REGEXP_STACK_OVERFLOW";
    exports2[3699] = "ER_REGEXP_TIME_OUT";
    exports2[3700] = "ER_REGEXP_PATTERN_TOO_BIG";
    exports2[3701] = "ER_CANT_SET_ERROR_LOG_SERVICE";
    exports2[3702] = "ER_EMPTY_PIPELINE_FOR_ERROR_LOG_SERVICE";
    exports2[3703] = "ER_COMPONENT_FILTER_DIAGNOSTICS";
    exports2[3704] = "ER_NOT_IMPLEMENTED_FOR_CARTESIAN_SRS";
    exports2[3705] = "ER_NOT_IMPLEMENTED_FOR_PROJECTED_SRS";
    exports2[3706] = "ER_NONPOSITIVE_RADIUS";
    exports2[3707] = "ER_RESTART_SERVER_FAILED";
    exports2[3708] = "ER_SRS_MISSING_MANDATORY_ATTRIBUTE";
    exports2[3709] = "ER_SRS_MULTIPLE_ATTRIBUTE_DEFINITIONS";
    exports2[3710] = "ER_SRS_NAME_CANT_BE_EMPTY_OR_WHITESPACE";
    exports2[3711] = "ER_SRS_ORGANIZATION_CANT_BE_EMPTY_OR_WHITESPACE";
    exports2[3712] = "ER_SRS_ID_ALREADY_EXISTS";
    exports2[3713] = "ER_WARN_SRS_ID_ALREADY_EXISTS";
    exports2[3714] = "ER_CANT_MODIFY_SRID_0";
    exports2[3715] = "ER_WARN_RESERVED_SRID_RANGE";
    exports2[3716] = "ER_CANT_MODIFY_SRS_USED_BY_COLUMN";
    exports2[3717] = "ER_SRS_INVALID_CHARACTER_IN_ATTRIBUTE";
    exports2[3718] = "ER_SRS_ATTRIBUTE_STRING_TOO_LONG";
    exports2[3719] = "ER_DEPRECATED_UTF8_ALIAS";
    exports2[3720] = "ER_DEPRECATED_NATIONAL";
    exports2[3721] = "ER_INVALID_DEFAULT_UTF8MB4_COLLATION";
    exports2[3722] = "ER_UNABLE_TO_COLLECT_LOG_STATUS";
    exports2[3723] = "ER_RESERVED_TABLESPACE_NAME";
    exports2[3724] = "ER_UNABLE_TO_SET_OPTION";
    exports2[3725] = "ER_REPLICA_POSSIBLY_DIVERGED_AFTER_DDL";
    exports2[3726] = "ER_SRS_NOT_GEOGRAPHIC";
    exports2[3727] = "ER_POLYGON_TOO_LARGE";
    exports2[3728] = "ER_SPATIAL_UNIQUE_INDEX";
    exports2[3729] = "ER_INDEX_TYPE_NOT_SUPPORTED_FOR_SPATIAL_INDEX";
    exports2[3730] = "ER_FK_CANNOT_DROP_PARENT";
    exports2[3731] = "ER_GEOMETRY_PARAM_LONGITUDE_OUT_OF_RANGE";
    exports2[3732] = "ER_GEOMETRY_PARAM_LATITUDE_OUT_OF_RANGE";
    exports2[3733] = "ER_FK_CANNOT_USE_VIRTUAL_COLUMN";
    exports2[3734] = "ER_FK_NO_COLUMN_PARENT";
    exports2[3735] = "ER_CANT_SET_ERROR_SUPPRESSION_LIST";
    exports2[3736] = "ER_SRS_GEOGCS_INVALID_AXES";
    exports2[3737] = "ER_SRS_INVALID_SEMI_MAJOR_AXIS";
    exports2[3738] = "ER_SRS_INVALID_INVERSE_FLATTENING";
    exports2[3739] = "ER_SRS_INVALID_ANGULAR_UNIT";
    exports2[3740] = "ER_SRS_INVALID_PRIME_MERIDIAN";
    exports2[3741] = "ER_TRANSFORM_SOURCE_SRS_NOT_SUPPORTED";
    exports2[3742] = "ER_TRANSFORM_TARGET_SRS_NOT_SUPPORTED";
    exports2[3743] = "ER_TRANSFORM_SOURCE_SRS_MISSING_TOWGS84";
    exports2[3744] = "ER_TRANSFORM_TARGET_SRS_MISSING_TOWGS84";
    exports2[3745] = "ER_TEMP_TABLE_PREVENTS_SWITCH_SESSION_BINLOG_FORMAT";
    exports2[3746] = "ER_TEMP_TABLE_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT";
    exports2[3747] = "ER_RUNNING_APPLIER_PREVENTS_SWITCH_GLOBAL_BINLOG_FORMAT";
    exports2[3748] = "ER_CLIENT_GTID_UNSAFE_CREATE_DROP_TEMP_TABLE_IN_TRX_IN_SBR";
    exports2[3749] = "ER_XA_CANT_CREATE_MDL_BACKUP";
    exports2[3750] = "ER_TABLE_WITHOUT_PK";
    exports2[3751] = "ER_WARN_DATA_TRUNCATED_FUNCTIONAL_INDEX";
    exports2[3752] = "ER_WARN_DATA_OUT_OF_RANGE_FUNCTIONAL_INDEX";
    exports2[3753] = "ER_FUNCTIONAL_INDEX_ON_JSON_OR_GEOMETRY_FUNCTION";
    exports2[3754] = "ER_FUNCTIONAL_INDEX_REF_AUTO_INCREMENT";
    exports2[3755] = "ER_CANNOT_DROP_COLUMN_FUNCTIONAL_INDEX";
    exports2[3756] = "ER_FUNCTIONAL_INDEX_PRIMARY_KEY";
    exports2[3757] = "ER_FUNCTIONAL_INDEX_ON_LOB";
    exports2[3758] = "ER_FUNCTIONAL_INDEX_FUNCTION_IS_NOT_ALLOWED";
    exports2[3759] = "ER_FULLTEXT_FUNCTIONAL_INDEX";
    exports2[3760] = "ER_SPATIAL_FUNCTIONAL_INDEX";
    exports2[3761] = "ER_WRONG_KEY_COLUMN_FUNCTIONAL_INDEX";
    exports2[3762] = "ER_FUNCTIONAL_INDEX_ON_FIELD";
    exports2[3763] = "ER_GENERATED_COLUMN_NAMED_FUNCTION_IS_NOT_ALLOWED";
    exports2[3764] = "ER_GENERATED_COLUMN_ROW_VALUE";
    exports2[3765] = "ER_GENERATED_COLUMN_VARIABLES";
    exports2[3766] = "ER_DEPENDENT_BY_DEFAULT_GENERATED_VALUE";
    exports2[3767] = "ER_DEFAULT_VAL_GENERATED_NON_PRIOR";
    exports2[3768] = "ER_DEFAULT_VAL_GENERATED_REF_AUTO_INC";
    exports2[3769] = "ER_DEFAULT_VAL_GENERATED_FUNCTION_IS_NOT_ALLOWED";
    exports2[3770] = "ER_DEFAULT_VAL_GENERATED_NAMED_FUNCTION_IS_NOT_ALLOWED";
    exports2[3771] = "ER_DEFAULT_VAL_GENERATED_ROW_VALUE";
    exports2[3772] = "ER_DEFAULT_VAL_GENERATED_VARIABLES";
    exports2[3773] = "ER_DEFAULT_AS_VAL_GENERATED";
    exports2[3774] = "ER_UNSUPPORTED_ACTION_ON_DEFAULT_VAL_GENERATED";
    exports2[3775] = "ER_GTID_UNSAFE_ALTER_ADD_COL_WITH_DEFAULT_EXPRESSION";
    exports2[3776] = "ER_FK_CANNOT_CHANGE_ENGINE";
    exports2[3777] = "ER_WARN_DEPRECATED_USER_SET_EXPR";
    exports2[3778] = "ER_WARN_DEPRECATED_UTF8MB3_COLLATION";
    exports2[3779] = "ER_WARN_DEPRECATED_NESTED_COMMENT_SYNTAX";
    exports2[3780] = "ER_FK_INCOMPATIBLE_COLUMNS";
    exports2[3781] = "ER_GR_HOLD_WAIT_TIMEOUT";
    exports2[3782] = "ER_GR_HOLD_KILLED";
    exports2[3783] = "ER_GR_HOLD_MEMBER_STATUS_ERROR";
    exports2[3784] = "ER_RPL_ENCRYPTION_FAILED_TO_FETCH_KEY";
    exports2[3785] = "ER_RPL_ENCRYPTION_KEY_NOT_FOUND";
    exports2[3786] = "ER_RPL_ENCRYPTION_KEYRING_INVALID_KEY";
    exports2[3787] = "ER_RPL_ENCRYPTION_HEADER_ERROR";
    exports2[3788] = "ER_RPL_ENCRYPTION_FAILED_TO_ROTATE_LOGS";
    exports2[3789] = "ER_RPL_ENCRYPTION_KEY_EXISTS_UNEXPECTED";
    exports2[3790] = "ER_RPL_ENCRYPTION_FAILED_TO_GENERATE_KEY";
    exports2[3791] = "ER_RPL_ENCRYPTION_FAILED_TO_STORE_KEY";
    exports2[3792] = "ER_RPL_ENCRYPTION_FAILED_TO_REMOVE_KEY";
    exports2[3793] = "ER_RPL_ENCRYPTION_UNABLE_TO_CHANGE_OPTION";
    exports2[3794] = "ER_RPL_ENCRYPTION_MASTER_KEY_RECOVERY_FAILED";
    exports2[3795] = "ER_SLOW_LOG_MODE_IGNORED_WHEN_NOT_LOGGING_TO_FILE";
    exports2[3796] = "ER_GRP_TRX_CONSISTENCY_NOT_ALLOWED";
    exports2[3797] = "ER_GRP_TRX_CONSISTENCY_BEFORE";
    exports2[3798] = "ER_GRP_TRX_CONSISTENCY_AFTER_ON_TRX_BEGIN";
    exports2[3799] = "ER_GRP_TRX_CONSISTENCY_BEGIN_NOT_ALLOWED";
    exports2[3800] = "ER_FUNCTIONAL_INDEX_ROW_VALUE_IS_NOT_ALLOWED";
    exports2[3801] = "ER_RPL_ENCRYPTION_FAILED_TO_ENCRYPT";
    exports2[3802] = "ER_PAGE_TRACKING_NOT_STARTED";
    exports2[3803] = "ER_PAGE_TRACKING_RANGE_NOT_TRACKED";
    exports2[3804] = "ER_PAGE_TRACKING_CANNOT_PURGE";
    exports2[3805] = "ER_RPL_ENCRYPTION_CANNOT_ROTATE_BINLOG_MASTER_KEY";
    exports2[3806] = "ER_BINLOG_MASTER_KEY_RECOVERY_OUT_OF_COMBINATION";
    exports2[3807] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_OPERATE_KEY";
    exports2[3808] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_ROTATE_LOGS";
    exports2[3809] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_REENCRYPT_LOG";
    exports2[3810] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_UNUSED_KEYS";
    exports2[3811] = "ER_BINLOG_MASTER_KEY_ROTATION_FAIL_TO_CLEANUP_AUX_KEY";
    exports2[3812] = "ER_NON_BOOLEAN_EXPR_FOR_CHECK_CONSTRAINT";
    exports2[3813] = "ER_COLUMN_CHECK_CONSTRAINT_REFERENCES_OTHER_COLUMN";
    exports2[3814] = "ER_CHECK_CONSTRAINT_NAMED_FUNCTION_IS_NOT_ALLOWED";
    exports2[3815] = "ER_CHECK_CONSTRAINT_FUNCTION_IS_NOT_ALLOWED";
    exports2[3816] = "ER_CHECK_CONSTRAINT_VARIABLES";
    exports2[3817] = "ER_CHECK_CONSTRAINT_ROW_VALUE";
    exports2[3818] = "ER_CHECK_CONSTRAINT_REFERS_AUTO_INCREMENT_COLUMN";
    exports2[3819] = "ER_CHECK_CONSTRAINT_VIOLATED";
    exports2[3820] = "ER_CHECK_CONSTRAINT_REFERS_UNKNOWN_COLUMN";
    exports2[3821] = "ER_CHECK_CONSTRAINT_NOT_FOUND";
    exports2[3822] = "ER_CHECK_CONSTRAINT_DUP_NAME";
    exports2[3823] = "ER_CHECK_CONSTRAINT_CLAUSE_USING_FK_REFER_ACTION_COLUMN";
    exports2[3824] = "WARN_UNENCRYPTED_TABLE_IN_ENCRYPTED_DB";
    exports2[3825] = "ER_INVALID_ENCRYPTION_REQUEST";
    exports2[3826] = "ER_CANNOT_SET_TABLE_ENCRYPTION";
    exports2[3827] = "ER_CANNOT_SET_DATABASE_ENCRYPTION";
    exports2[3828] = "ER_CANNOT_SET_TABLESPACE_ENCRYPTION";
    exports2[3829] = "ER_TABLESPACE_CANNOT_BE_ENCRYPTED";
    exports2[3830] = "ER_TABLESPACE_CANNOT_BE_DECRYPTED";
    exports2[3831] = "ER_TABLESPACE_TYPE_UNKNOWN";
    exports2[3832] = "ER_TARGET_TABLESPACE_UNENCRYPTED";
    exports2[3833] = "ER_CANNOT_USE_ENCRYPTION_CLAUSE";
    exports2[3834] = "ER_INVALID_MULTIPLE_CLAUSES";
    exports2[3835] = "ER_UNSUPPORTED_USE_OF_GRANT_AS";
    exports2[3836] = "ER_UKNOWN_AUTH_ID_OR_ACCESS_DENIED_FOR_GRANT_AS";
    exports2[3837] = "ER_DEPENDENT_BY_FUNCTIONAL_INDEX";
    exports2[3838] = "ER_PLUGIN_NOT_EARLY";
    exports2[3839] = "ER_INNODB_REDO_LOG_ARCHIVE_START_SUBDIR_PATH";
    exports2[3840] = "ER_INNODB_REDO_LOG_ARCHIVE_START_TIMEOUT";
    exports2[3841] = "ER_INNODB_REDO_LOG_ARCHIVE_DIRS_INVALID";
    exports2[3842] = "ER_INNODB_REDO_LOG_ARCHIVE_LABEL_NOT_FOUND";
    exports2[3843] = "ER_INNODB_REDO_LOG_ARCHIVE_DIR_EMPTY";
    exports2[3844] = "ER_INNODB_REDO_LOG_ARCHIVE_NO_SUCH_DIR";
    exports2[3845] = "ER_INNODB_REDO_LOG_ARCHIVE_DIR_CLASH";
    exports2[3846] = "ER_INNODB_REDO_LOG_ARCHIVE_DIR_PERMISSIONS";
    exports2[3847] = "ER_INNODB_REDO_LOG_ARCHIVE_FILE_CREATE";
    exports2[3848] = "ER_INNODB_REDO_LOG_ARCHIVE_ACTIVE";
    exports2[3849] = "ER_INNODB_REDO_LOG_ARCHIVE_INACTIVE";
    exports2[3850] = "ER_INNODB_REDO_LOG_ARCHIVE_FAILED";
    exports2[3851] = "ER_INNODB_REDO_LOG_ARCHIVE_SESSION";
    exports2[3852] = "ER_STD_REGEX_ERROR";
    exports2[3853] = "ER_INVALID_JSON_TYPE";
    exports2[3854] = "ER_CANNOT_CONVERT_STRING";
    exports2[3855] = "ER_DEPENDENT_BY_PARTITION_FUNC";
    exports2[3856] = "ER_WARN_DEPRECATED_FLOAT_AUTO_INCREMENT";
    exports2[3857] = "ER_RPL_CANT_STOP_REPLICA_WHILE_LOCKED_BACKUP";
    exports2[3858] = "ER_WARN_DEPRECATED_FLOAT_DIGITS";
    exports2[3859] = "ER_WARN_DEPRECATED_FLOAT_UNSIGNED";
    exports2[3860] = "ER_WARN_DEPRECATED_INTEGER_DISPLAY_WIDTH";
    exports2[3861] = "ER_WARN_DEPRECATED_ZEROFILL";
    exports2[3862] = "ER_CLONE_DONOR";
    exports2[3863] = "ER_CLONE_PROTOCOL";
    exports2[3864] = "ER_CLONE_DONOR_VERSION";
    exports2[3865] = "ER_CLONE_OS";
    exports2[3866] = "ER_CLONE_PLATFORM";
    exports2[3867] = "ER_CLONE_CHARSET";
    exports2[3868] = "ER_CLONE_CONFIG";
    exports2[3869] = "ER_CLONE_SYS_CONFIG";
    exports2[3870] = "ER_CLONE_PLUGIN_MATCH";
    exports2[3871] = "ER_CLONE_LOOPBACK";
    exports2[3872] = "ER_CLONE_ENCRYPTION";
    exports2[3873] = "ER_CLONE_DISK_SPACE";
    exports2[3874] = "ER_CLONE_IN_PROGRESS";
    exports2[3875] = "ER_CLONE_DISALLOWED";
    exports2[3876] = "ER_CANNOT_GRANT_ROLES_TO_ANONYMOUS_USER";
    exports2[3877] = "ER_SECONDARY_ENGINE_PLUGIN";
    exports2[3878] = "ER_SECOND_PASSWORD_CANNOT_BE_EMPTY";
    exports2[3879] = "ER_DB_ACCESS_DENIED";
    exports2[3880] = "ER_DA_AUTH_ID_WITH_SYSTEM_USER_PRIV_IN_MANDATORY_ROLES";
    exports2[3881] = "ER_DA_RPL_GTID_TABLE_CANNOT_OPEN";
    exports2[3882] = "ER_GEOMETRY_IN_UNKNOWN_LENGTH_UNIT";
    exports2[3883] = "ER_DA_PLUGIN_INSTALL_ERROR";
    exports2[3884] = "ER_NO_SESSION_TEMP";
    exports2[3885] = "ER_DA_UNKNOWN_ERROR_NUMBER";
    exports2[3886] = "ER_COLUMN_CHANGE_SIZE";
    exports2[3887] = "ER_REGEXP_INVALID_CAPTURE_GROUP_NAME";
    exports2[3888] = "ER_DA_SSL_LIBRARY_ERROR";
    exports2[3889] = "ER_SECONDARY_ENGINE";
    exports2[3890] = "ER_SECONDARY_ENGINE_DDL";
    exports2[3891] = "ER_INCORRECT_CURRENT_PASSWORD";
    exports2[3892] = "ER_MISSING_CURRENT_PASSWORD";
    exports2[3893] = "ER_CURRENT_PASSWORD_NOT_REQUIRED";
    exports2[3894] = "ER_PASSWORD_CANNOT_BE_RETAINED_ON_PLUGIN_CHANGE";
    exports2[3895] = "ER_CURRENT_PASSWORD_CANNOT_BE_RETAINED";
    exports2[3896] = "ER_PARTIAL_REVOKES_EXIST";
    exports2[3897] = "ER_CANNOT_GRANT_SYSTEM_PRIV_TO_MANDATORY_ROLE";
    exports2[3898] = "ER_XA_REPLICATION_FILTERS";
    exports2[3899] = "ER_UNSUPPORTED_SQL_MODE";
    exports2[3900] = "ER_REGEXP_INVALID_FLAG";
    exports2[3901] = "ER_PARTIAL_REVOKE_AND_DB_GRANT_BOTH_EXISTS";
    exports2[3902] = "ER_UNIT_NOT_FOUND";
    exports2[3903] = "ER_INVALID_JSON_VALUE_FOR_FUNC_INDEX";
    exports2[3904] = "ER_JSON_VALUE_OUT_OF_RANGE_FOR_FUNC_INDEX";
    exports2[3905] = "ER_EXCEEDED_MV_KEYS_NUM";
    exports2[3906] = "ER_EXCEEDED_MV_KEYS_SPACE";
    exports2[3907] = "ER_FUNCTIONAL_INDEX_DATA_IS_TOO_LONG";
    exports2[3908] = "ER_WRONG_MVI_VALUE";
    exports2[3909] = "ER_WARN_FUNC_INDEX_NOT_APPLICABLE";
    exports2[3910] = "ER_GRP_RPL_UDF_ERROR";
    exports2[3911] = "ER_UPDATE_GTID_PURGED_WITH_GR";
    exports2[3912] = "ER_GROUPING_ON_TIMESTAMP_IN_DST";
    exports2[3913] = "ER_TABLE_NAME_CAUSES_TOO_LONG_PATH";
    exports2[3914] = "ER_AUDIT_LOG_INSUFFICIENT_PRIVILEGE";
    exports2[3915] = "ER_AUDIT_LOG_PASSWORD_HAS_BEEN_COPIED";
    exports2[3916] = "ER_DA_GRP_RPL_STARTED_AUTO_REJOIN";
    exports2[3917] = "ER_SYSVAR_CHANGE_DURING_QUERY";
    exports2[3918] = "ER_GLOBSTAT_CHANGE_DURING_QUERY";
    exports2[3919] = "ER_GRP_RPL_MESSAGE_SERVICE_INIT_FAILURE";
    exports2[3920] = "ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_CLIENT";
    exports2[3921] = "ER_CHANGE_SOURCE_WRONG_COMPRESSION_LEVEL_CLIENT";
    exports2[3922] = "ER_WRONG_COMPRESSION_ALGORITHM_CLIENT";
    exports2[3923] = "ER_WRONG_COMPRESSION_LEVEL_CLIENT";
    exports2[3924] = "ER_CHANGE_SOURCE_WRONG_COMPRESSION_ALGORITHM_LIST_CLIENT";
    exports2[3925] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_CANNOT_BE_ANONYMOUS";
    exports2[3926] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_DOES_NOT_EXIST";
    exports2[3927] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_CORRUPT";
    exports2[3928] = "ER_CLIENT_PRIVILEGE_CHECKS_USER_NEEDS_RPL_APPLIER_PRIV";
    exports2[3929] = "ER_WARN_DA_PRIVILEGE_NOT_REGISTERED";
    exports2[3930] = "ER_CLIENT_KEYRING_UDF_KEY_INVALID";
    exports2[3931] = "ER_CLIENT_KEYRING_UDF_KEY_TYPE_INVALID";
    exports2[3932] = "ER_CLIENT_KEYRING_UDF_KEY_TOO_LONG";
    exports2[3933] = "ER_CLIENT_KEYRING_UDF_KEY_TYPE_TOO_LONG";
    exports2[3934] = "ER_JSON_SCHEMA_VALIDATION_ERROR_WITH_DETAILED_REPORT";
    exports2[3935] = "ER_DA_UDF_INVALID_CHARSET_SPECIFIED";
    exports2[3936] = "ER_DA_UDF_INVALID_CHARSET";
    exports2[3937] = "ER_DA_UDF_INVALID_COLLATION";
    exports2[3938] = "ER_DA_UDF_INVALID_EXTENSION_ARGUMENT_TYPE";
    exports2[3939] = "ER_MULTIPLE_CONSTRAINTS_WITH_SAME_NAME";
    exports2[3940] = "ER_CONSTRAINT_NOT_FOUND";
    exports2[3941] = "ER_ALTER_CONSTRAINT_ENFORCEMENT_NOT_SUPPORTED";
    exports2[3942] = "ER_TABLE_VALUE_CONSTRUCTOR_MUST_HAVE_COLUMNS";
    exports2[3943] = "ER_TABLE_VALUE_CONSTRUCTOR_CANNOT_HAVE_DEFAULT";
    exports2[3944] = "ER_CLIENT_QUERY_FAILURE_INVALID_NON_ROW_FORMAT";
    exports2[3945] = "ER_REQUIRE_ROW_FORMAT_INVALID_VALUE";
    exports2[3946] = "ER_FAILED_TO_DETERMINE_IF_ROLE_IS_MANDATORY";
    exports2[3947] = "ER_FAILED_TO_FETCH_MANDATORY_ROLE_LIST";
    exports2[3948] = "ER_CLIENT_LOCAL_FILES_DISABLED";
    exports2[3949] = "ER_IMP_INCOMPATIBLE_CFG_VERSION";
    exports2[3950] = "ER_DA_OOM";
    exports2[3951] = "ER_DA_UDF_INVALID_ARGUMENT_TO_SET_CHARSET";
    exports2[3952] = "ER_DA_UDF_INVALID_RETURN_TYPE_TO_SET_CHARSET";
    exports2[3953] = "ER_MULTIPLE_INTO_CLAUSES";
    exports2[3954] = "ER_MISPLACED_INTO";
    exports2[3955] = "ER_USER_ACCESS_DENIED_FOR_USER_ACCOUNT_BLOCKED_BY_PASSWORD_LOCK";
    exports2[3956] = "ER_WARN_DEPRECATED_YEAR_UNSIGNED";
    exports2[3957] = "ER_CLONE_NETWORK_PACKET";
    exports2[3958] = "ER_SDI_OPERATION_FAILED_MISSING_RECORD";
    exports2[3959] = "ER_DEPENDENT_BY_CHECK_CONSTRAINT";
    exports2[3960] = "ER_GRP_OPERATION_NOT_ALLOWED_GR_MUST_STOP";
    exports2[3961] = "ER_WARN_DEPRECATED_JSON_TABLE_ON_ERROR_ON_EMPTY";
    exports2[3962] = "ER_WARN_DEPRECATED_INNER_INTO";
    exports2[3963] = "ER_WARN_DEPRECATED_VALUES_FUNCTION_ALWAYS_NULL";
    exports2[3964] = "ER_WARN_DEPRECATED_SQL_CALC_FOUND_ROWS";
    exports2[3965] = "ER_WARN_DEPRECATED_FOUND_ROWS";
    exports2[3966] = "ER_MISSING_JSON_VALUE";
    exports2[3967] = "ER_MULTIPLE_JSON_VALUES";
    exports2[3968] = "ER_HOSTNAME_TOO_LONG";
    exports2[3969] = "ER_WARN_CLIENT_DEPRECATED_PARTITION_PREFIX_KEY";
    exports2[3970] = "ER_GROUP_REPLICATION_USER_EMPTY_MSG";
    exports2[3971] = "ER_GROUP_REPLICATION_USER_MANDATORY_MSG";
    exports2[3972] = "ER_GROUP_REPLICATION_PASSWORD_LENGTH";
    exports2[3973] = "ER_SUBQUERY_TRANSFORM_REJECTED";
    exports2[3974] = "ER_DA_GRP_RPL_RECOVERY_ENDPOINT_FORMAT";
    exports2[3975] = "ER_DA_GRP_RPL_RECOVERY_ENDPOINT_INVALID";
    exports2[3976] = "ER_WRONG_VALUE_FOR_VAR_PLUS_ACTIONABLE_PART";
    exports2[3977] = "ER_STATEMENT_NOT_ALLOWED_AFTER_START_TRANSACTION";
    exports2[3978] = "ER_FOREIGN_KEY_WITH_ATOMIC_CREATE_SELECT";
    exports2[3979] = "ER_NOT_ALLOWED_WITH_START_TRANSACTION";
    exports2[3980] = "ER_INVALID_JSON_ATTRIBUTE";
    exports2[3981] = "ER_ENGINE_ATTRIBUTE_NOT_SUPPORTED";
    exports2[3982] = "ER_INVALID_USER_ATTRIBUTE_JSON";
    exports2[3983] = "ER_INNODB_REDO_DISABLED";
    exports2[3984] = "ER_INNODB_REDO_ARCHIVING_ENABLED";
    exports2[3985] = "ER_MDL_OUT_OF_RESOURCES";
    exports2[3986] = "ER_IMPLICIT_COMPARISON_FOR_JSON";
    exports2[3987] = "ER_FUNCTION_DOES_NOT_SUPPORT_CHARACTER_SET";
    exports2[3988] = "ER_IMPOSSIBLE_STRING_CONVERSION";
    exports2[3989] = "ER_SCHEMA_READ_ONLY";
    exports2[3990] = "ER_RPL_ASYNC_RECONNECT_GTID_MODE_OFF";
    exports2[3991] = "ER_RPL_ASYNC_RECONNECT_AUTO_POSITION_OFF";
    exports2[3992] = "ER_DISABLE_GTID_MODE_REQUIRES_ASYNC_RECONNECT_OFF";
    exports2[3993] = "ER_DISABLE_AUTO_POSITION_REQUIRES_ASYNC_RECONNECT_OFF";
    exports2[3994] = "ER_INVALID_PARAMETER_USE";
    exports2[3995] = "ER_CHARACTER_SET_MISMATCH";
    exports2[3996] = "ER_WARN_VAR_VALUE_CHANGE_NOT_SUPPORTED";
    exports2[3997] = "ER_INVALID_TIME_ZONE_INTERVAL";
    exports2[3998] = "ER_INVALID_CAST";
    exports2[3999] = "ER_HYPERGRAPH_NOT_SUPPORTED_YET";
    exports2[4e3] = "ER_WARN_HYPERGRAPH_EXPERIMENTAL";
    exports2[4001] = "ER_DA_NO_ERROR_LOG_PARSER_CONFIGURED";
    exports2[4002] = "ER_DA_ERROR_LOG_TABLE_DISABLED";
    exports2[4003] = "ER_DA_ERROR_LOG_MULTIPLE_FILTERS";
    exports2[4004] = "ER_DA_CANT_OPEN_ERROR_LOG";
    exports2[4005] = "ER_USER_REFERENCED_AS_DEFINER";
    exports2[4006] = "ER_CANNOT_USER_REFERENCED_AS_DEFINER";
    exports2[4007] = "ER_REGEX_NUMBER_TOO_BIG";
    exports2[4008] = "ER_SPVAR_NONINTEGER_TYPE";
    exports2[4009] = "WARN_UNSUPPORTED_ACL_TABLES_READ";
    exports2[4010] = "ER_BINLOG_UNSAFE_ACL_TABLE_READ_IN_DML_DDL";
    exports2[4011] = "ER_STOP_REPLICA_MONITOR_IO_THREAD_TIMEOUT";
    exports2[4012] = "ER_STARTING_REPLICA_MONITOR_IO_THREAD";
    exports2[4013] = "ER_CANT_USE_ANONYMOUS_TO_GTID_WITH_GTID_MODE_NOT_ON";
    exports2[4014] = "ER_CANT_COMBINE_ANONYMOUS_TO_GTID_AND_AUTOPOSITION";
    exports2[4015] = "ER_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_REQUIRES_GTID_MODE_ON";
    exports2[4016] = "ER_SQL_REPLICA_SKIP_COUNTER_USED_WITH_GTID_MODE_ON";
    exports2[4017] = "ER_USING_ASSIGN_GTIDS_TO_ANONYMOUS_TRANSACTIONS_AS_LOCAL_OR_UUID";
    exports2[4018] = "ER_CANT_SET_ANONYMOUS_TO_GTID_AND_WAIT_UNTIL_SQL_THD_AFTER_GTIDS";
    exports2[4019] = "ER_CANT_SET_SQL_AFTER_OR_BEFORE_GTIDS_WITH_ANONYMOUS_TO_GTID";
    exports2[4020] = "ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_GROUP_NAME";
    exports2[4021] = "ER_CANT_USE_SAME_UUID_AS_GROUP_NAME";
    exports2[4022] = "ER_GRP_RPL_RECOVERY_CHANNEL_STILL_RUNNING";
    exports2[4023] = "ER_INNODB_INVALID_AUTOEXTEND_SIZE_VALUE";
    exports2[4024] = "ER_INNODB_INCOMPATIBLE_WITH_TABLESPACE";
    exports2[4025] = "ER_INNODB_AUTOEXTEND_SIZE_OUT_OF_RANGE";
    exports2[4026] = "ER_CANNOT_USE_AUTOEXTEND_SIZE_CLAUSE";
    exports2[4027] = "ER_ROLE_GRANTED_TO_ITSELF";
    exports2[4028] = "ER_TABLE_MUST_HAVE_A_VISIBLE_COLUMN";
    exports2[4029] = "ER_INNODB_COMPRESSION_FAILURE";
    exports2[4030] = "ER_WARN_ASYNC_CONN_FAILOVER_NETWORK_NAMESPACE";
    exports2[4031] = "ER_CLIENT_INTERACTION_TIMEOUT";
    exports2[4032] = "ER_INVALID_CAST_TO_GEOMETRY";
    exports2[4033] = "ER_INVALID_CAST_POLYGON_RING_DIRECTION";
    exports2[4034] = "ER_GIS_DIFFERENT_SRIDS_AGGREGATION";
    exports2[4035] = "ER_RELOAD_KEYRING_FAILURE";
    exports2[4036] = "ER_SDI_GET_KEYS_INVALID_TABLESPACE";
    exports2[4037] = "ER_CHANGE_RPL_SRC_WRONG_COMPRESSION_ALGORITHM_SIZE";
    exports2[4038] = "ER_WARN_DEPRECATED_TLS_VERSION_FOR_CHANNEL_CLI";
    exports2[4039] = "ER_CANT_USE_SAME_UUID_AS_VIEW_CHANGE_UUID";
    exports2[4040] = "ER_ANONYMOUS_TO_GTID_UUID_SAME_AS_VIEW_CHANGE_UUID";
    exports2[4041] = "ER_GRP_RPL_VIEW_CHANGE_UUID_FAIL_GET_VARIABLE";
    exports2[4042] = "ER_WARN_ADUIT_LOG_MAX_SIZE_AND_PRUNE_SECONDS";
    exports2[4043] = "ER_WARN_ADUIT_LOG_MAX_SIZE_CLOSE_TO_ROTATE_ON_SIZE";
    exports2[4044] = "ER_KERBEROS_CREATE_USER";
    exports2[4045] = "ER_INSTALL_PLUGIN_CONFLICT_CLIENT";
    exports2[4046] = "ER_DA_ERROR_LOG_COMPONENT_FLUSH_FAILED";
    exports2[4047] = "ER_WARN_SQL_AFTER_MTS_GAPS_GAP_NOT_CALCULATED";
    exports2[4048] = "ER_INVALID_ASSIGNMENT_TARGET";
    exports2[4049] = "ER_OPERATION_NOT_ALLOWED_ON_GR_SECONDARY";
    exports2[4050] = "ER_GRP_RPL_FAILOVER_CHANNEL_STATUS_PROPAGATION";
    exports2[4051] = "ER_WARN_AUDIT_LOG_FORMAT_UNIX_TIMESTAMP_ONLY_WHEN_JSON";
    exports2[4052] = "ER_INVALID_MFA_PLUGIN_SPECIFIED";
    exports2[4053] = "ER_IDENTIFIED_BY_UNSUPPORTED";
    exports2[4054] = "ER_INVALID_PLUGIN_FOR_REGISTRATION";
    exports2[4055] = "ER_PLUGIN_REQUIRES_REGISTRATION";
    exports2[4056] = "ER_MFA_METHOD_EXISTS";
    exports2[4057] = "ER_MFA_METHOD_NOT_EXISTS";
    exports2[4058] = "ER_AUTHENTICATION_POLICY_MISMATCH";
    exports2[4059] = "ER_PLUGIN_REGISTRATION_DONE";
    exports2[4060] = "ER_INVALID_USER_FOR_REGISTRATION";
    exports2[4061] = "ER_USER_REGISTRATION_FAILED";
    exports2[4062] = "ER_MFA_METHODS_INVALID_ORDER";
    exports2[4063] = "ER_MFA_METHODS_IDENTICAL";
    exports2[4064] = "ER_INVALID_MFA_OPERATIONS_FOR_PASSWORDLESS_USER";
    exports2[4065] = "ER_CHANGE_REPLICATION_SOURCE_NO_OPTIONS_FOR_GTID_ONLY";
    exports2[4066] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_REQ_ROW_FORMAT_WITH_GTID_ONLY";
    exports2[4067] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POSITION_WITH_GTID_ONLY";
    exports2[4068] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_GTID_ONLY_WITHOUT_POSITIONS";
    exports2[4069] = "ER_CHANGE_REP_SOURCE_CANT_DISABLE_AUTO_POS_WITHOUT_POSITIONS";
    exports2[4070] = "ER_CHANGE_REP_SOURCE_GR_CHANNEL_WITH_GTID_MODE_NOT_ON";
    exports2[4071] = "ER_CANT_USE_GTID_ONLY_WITH_GTID_MODE_NOT_ON";
    exports2[4072] = "ER_WARN_C_DISABLE_GTID_ONLY_WITH_SOURCE_AUTO_POS_INVALID_POS";
    exports2[4073] = "ER_DA_SSL_FIPS_MODE_ERROR";
    exports2[4074] = "ER_VALUE_OUT_OF_RANGE";
    exports2[4075] = "ER_FULLTEXT_WITH_ROLLUP";
    exports2[4076] = "ER_REGEXP_MISSING_RESOURCE";
    exports2[4077] = "ER_WARN_REGEXP_USING_DEFAULT";
    exports2[4078] = "ER_REGEXP_MISSING_FILE";
    exports2[4079] = "ER_WARN_DEPRECATED_COLLATION";
    exports2[4080] = "ER_CONCURRENT_PROCEDURE_USAGE";
    exports2[4081] = "ER_DA_GLOBAL_CONN_LIMIT";
    exports2[4082] = "ER_DA_CONN_LIMIT";
    exports2[4083] = "ER_ALTER_OPERATION_NOT_SUPPORTED_REASON_COLUMN_TYPE_INSTANT";
    exports2[4084] = "ER_WARN_SF_UDF_NAME_COLLISION";
    exports2[4085] = "ER_CANNOT_PURGE_BINLOG_WITH_BACKUP_LOCK";
    exports2[4086] = "ER_TOO_MANY_WINDOWS";
    exports2[4087] = "ER_MYSQLBACKUP_CLIENT_MSG";
    exports2[4088] = "ER_COMMENT_CONTAINS_INVALID_STRING";
    exports2[4089] = "ER_DEFINITION_CONTAINS_INVALID_STRING";
    exports2[4090] = "ER_CANT_EXECUTE_COMMAND_WITH_ASSIGNED_GTID_NEXT";
    exports2[4091] = "ER_XA_TEMP_TABLE";
    exports2[4092] = "ER_INNODB_MAX_ROW_VERSION";
    exports2[4093] = "ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_SIZE";
    exports2[4094] = "ER_OPERATION_NOT_ALLOWED_WHILE_PRIMARY_CHANGE_IS_RUNNING";
    exports2[4095] = "ER_WARN_DEPRECATED_DATETIME_DELIMITER";
    exports2[4096] = "ER_WARN_DEPRECATED_SUPERFLUOUS_DELIMITER";
    exports2[4097] = "ER_CANNOT_PERSIST_SENSITIVE_VARIABLES";
    exports2[4098] = "ER_WARN_CANNOT_SECURELY_PERSIST_SENSITIVE_VARIABLES";
    exports2[4099] = "ER_WARN_TRG_ALREADY_EXISTS";
    exports2[4100] = "ER_IF_NOT_EXISTS_UNSUPPORTED_TRG_EXISTS_ON_DIFFERENT_TABLE";
    exports2[4101] = "ER_IF_NOT_EXISTS_UNSUPPORTED_UDF_NATIVE_FCT_NAME_COLLISION";
    exports2[4102] = "ER_SET_PASSWORD_AUTH_PLUGIN_ERROR";
    exports2[4103] = "ER_REDUCED_DBLWR_FILE_CORRUPTED";
    exports2[4104] = "ER_REDUCED_DBLWR_PAGE_FOUND";
    exports2[4105] = "ER_SRS_INVALID_LATITUDE_OF_ORIGIN";
    exports2[4106] = "ER_SRS_INVALID_LONGITUDE_OF_ORIGIN";
    exports2[4107] = "ER_SRS_UNUSED_PROJ_PARAMETER_PRESENT";
    exports2[4108] = "ER_GIPK_COLUMN_EXISTS";
    exports2[4109] = "ER_GIPK_FAILED_AUTOINC_COLUMN_EXISTS";
    exports2[4110] = "ER_GIPK_COLUMN_ALTER_NOT_ALLOWED";
    exports2[4111] = "ER_DROP_PK_COLUMN_TO_DROP_GIPK";
    exports2[4112] = "ER_CREATE_SELECT_WITH_GIPK_DISALLOWED_IN_SBR";
    exports2[4113] = "ER_DA_EXPIRE_LOGS_DAYS_IGNORED";
    exports2[4114] = "ER_CTE_RECURSIVE_NOT_UNION";
    exports2[4115] = "ER_COMMAND_BACKEND_FAILED_TO_FETCH_SECURITY_CTX";
    exports2[4116] = "ER_COMMAND_SERVICE_BACKEND_FAILED";
    exports2[4117] = "ER_CLIENT_FILE_PRIVILEGE_FOR_REPLICATION_CHECKS";
    exports2[4118] = "ER_GROUP_REPLICATION_FORCE_MEMBERS_COMMAND_FAILURE";
    exports2[4119] = "ER_WARN_DEPRECATED_IDENT";
    exports2[4120] = "ER_INTERSECT_ALL_MAX_DUPLICATES_EXCEEDED";
    exports2[4121] = "ER_TP_QUERY_THRS_PER_GRP_EXCEEDS_TXN_THR_LIMIT";
    exports2[4122] = "ER_BAD_TIMESTAMP_FORMAT";
    exports2[4123] = "ER_SHAPE_PRIDICTION_UDF";
    exports2[4124] = "ER_SRS_INVALID_HEIGHT";
    exports2[4125] = "ER_SRS_INVALID_SCALING";
    exports2[4126] = "ER_SRS_INVALID_ZONE_WIDTH";
    exports2[4127] = "ER_SRS_INVALID_LATITUDE_POLAR_STERE_VAR_A";
    exports2[4128] = "ER_WARN_DEPRECATED_CLIENT_NO_SCHEMA_OPTION";
    exports2[4129] = "ER_TABLE_NOT_EMPTY";
    exports2[4130] = "ER_TABLE_NO_PRIMARY_KEY";
    exports2[4131] = "ER_TABLE_IN_SHARED_TABLESPACE";
    exports2[4132] = "ER_INDEX_OTHER_THAN_PK";
    exports2[4133] = "ER_LOAD_BULK_DATA_UNSORTED";
    exports2[4134] = "ER_BULK_EXECUTOR_ERROR";
    exports2[4135] = "ER_BULK_READER_LIBCURL_INIT_FAILED";
    exports2[4136] = "ER_BULK_READER_LIBCURL_ERROR";
    exports2[4137] = "ER_BULK_READER_SERVER_ERROR";
    exports2[4138] = "ER_BULK_READER_COMMUNICATION_ERROR";
    exports2[4139] = "ER_BULK_LOAD_DATA_FAILED";
    exports2[4140] = "ER_BULK_LOADER_COLUMN_TOO_BIG_FOR_LEFTOVER_BUFFER";
    exports2[4141] = "ER_BULK_LOADER_COMPONENT_ERROR";
    exports2[4142] = "ER_BULK_LOADER_FILE_CONTAINS_LESS_LINES_THAN_IGNORE_CLAUSE";
    exports2[4143] = "ER_BULK_PARSER_MISSING_ENCLOSED_BY";
    exports2[4144] = "ER_BULK_PARSER_ROW_BUFFER_MAX_TOTAL_COLS_EXCEEDED";
    exports2[4145] = "ER_BULK_PARSER_COPY_BUFFER_SIZE_EXCEEDED";
    exports2[4146] = "ER_BULK_PARSER_UNEXPECTED_END_OF_INPUT";
    exports2[4147] = "ER_BULK_PARSER_UNEXPECTED_ROW_TERMINATOR";
    exports2[4148] = "ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_ENDING_ENCLOSED_BY";
    exports2[4149] = "ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_NULL_ESCAPE";
    exports2[4150] = "ER_BULK_PARSER_UNEXPECTED_CHAR_AFTER_COLUMN_TERMINATOR";
    exports2[4151] = "ER_BULK_PARSER_INCOMPLETE_ESCAPE_SEQUENCE";
    exports2[4152] = "ER_LOAD_BULK_DATA_FAILED";
    exports2[4153] = "ER_LOAD_BULK_DATA_WRONG_VALUE_FOR_FIELD";
    exports2[4154] = "ER_LOAD_BULK_DATA_WARN_NULL_TO_NOTNULL";
    exports2[4155] = "ER_REQUIRE_TABLE_PRIMARY_KEY_CHECK_GENERATE_WITH_GR";
    exports2[4156] = "ER_CANT_CHANGE_SYS_VAR_IN_READ_ONLY_MODE";
    exports2[4157] = "ER_INNODB_INSTANT_ADD_DROP_NOT_SUPPORTED_MAX_SIZE";
    exports2[4158] = "ER_INNODB_INSTANT_ADD_NOT_SUPPORTED_MAX_FIELDS";
    exports2[4159] = "ER_CANT_SET_PERSISTED";
    exports2[4160] = "ER_INSTALL_COMPONENT_SET_NULL_VALUE";
    exports2[4161] = "ER_INSTALL_COMPONENT_SET_UNUSED_VALUE";
    exports2[4162] = "ER_WARN_DEPRECATED_USER_DEFINED_COLLATIONS";
  }
});

// ../node_modules/.pnpm/long@5.3.2/node_modules/long/umd/index.js
var require_umd = __commonJS({
  "../node_modules/.pnpm/long@5.3.2/node_modules/long/umd/index.js"(exports2, module2) {
    "use strict";
    (function(global2, factory) {
      function preferDefault(exports3) {
        return exports3.default || exports3;
      }
      if (typeof define === "function" && define.amd) {
        define([], function() {
          var exports3 = {};
          factory(exports3);
          return preferDefault(exports3);
        });
      } else if (typeof exports2 === "object") {
        factory(exports2);
        if (typeof module2 === "object") module2.exports = preferDefault(exports2);
      } else {
        (function() {
          var exports3 = {};
          factory(exports3);
          global2.Long = preferDefault(exports3);
        })();
      }
    })(
      typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : exports2,
      function(_exports) {
        "use strict";
        Object.defineProperty(_exports, "__esModule", {
          value: true
        });
        _exports.default = void 0;
        var wasm = null;
        try {
          wasm = new WebAssembly.Instance(
            new WebAssembly.Module(
              new Uint8Array([
                // \0asm
                0,
                97,
                115,
                109,
                // version 1
                1,
                0,
                0,
                0,
                // section "type"
                1,
                13,
                2,
                // 0, () => i32
                96,
                0,
                1,
                127,
                // 1, (i32, i32, i32, i32) => i32
                96,
                4,
                127,
                127,
                127,
                127,
                1,
                127,
                // section "function"
                3,
                7,
                6,
                // 0, type 0
                0,
                // 1, type 1
                1,
                // 2, type 1
                1,
                // 3, type 1
                1,
                // 4, type 1
                1,
                // 5, type 1
                1,
                // section "global"
                6,
                6,
                1,
                // 0, "high", mutable i32
                127,
                1,
                65,
                0,
                11,
                // section "export"
                7,
                50,
                6,
                // 0, "mul"
                3,
                109,
                117,
                108,
                0,
                1,
                // 1, "div_s"
                5,
                100,
                105,
                118,
                95,
                115,
                0,
                2,
                // 2, "div_u"
                5,
                100,
                105,
                118,
                95,
                117,
                0,
                3,
                // 3, "rem_s"
                5,
                114,
                101,
                109,
                95,
                115,
                0,
                4,
                // 4, "rem_u"
                5,
                114,
                101,
                109,
                95,
                117,
                0,
                5,
                // 5, "get_high"
                8,
                103,
                101,
                116,
                95,
                104,
                105,
                103,
                104,
                0,
                0,
                // section "code"
                10,
                191,
                1,
                6,
                // 0, "get_high"
                4,
                0,
                35,
                0,
                11,
                // 1, "mul"
                36,
                1,
                1,
                126,
                32,
                0,
                173,
                32,
                1,
                173,
                66,
                32,
                134,
                132,
                32,
                2,
                173,
                32,
                3,
                173,
                66,
                32,
                134,
                132,
                126,
                34,
                4,
                66,
                32,
                135,
                167,
                36,
                0,
                32,
                4,
                167,
                11,
                // 2, "div_s"
                36,
                1,
                1,
                126,
                32,
                0,
                173,
                32,
                1,
                173,
                66,
                32,
                134,
                132,
                32,
                2,
                173,
                32,
                3,
                173,
                66,
                32,
                134,
                132,
                127,
                34,
                4,
                66,
                32,
                135,
                167,
                36,
                0,
                32,
                4,
                167,
                11,
                // 3, "div_u"
                36,
                1,
                1,
                126,
                32,
                0,
                173,
                32,
                1,
                173,
                66,
                32,
                134,
                132,
                32,
                2,
                173,
                32,
                3,
                173,
                66,
                32,
                134,
                132,
                128,
                34,
                4,
                66,
                32,
                135,
                167,
                36,
                0,
                32,
                4,
                167,
                11,
                // 4, "rem_s"
                36,
                1,
                1,
                126,
                32,
                0,
                173,
                32,
                1,
                173,
                66,
                32,
                134,
                132,
                32,
                2,
                173,
                32,
                3,
                173,
                66,
                32,
                134,
                132,
                129,
                34,
                4,
                66,
                32,
                135,
                167,
                36,
                0,
                32,
                4,
                167,
                11,
                // 5, "rem_u"
                36,
                1,
                1,
                126,
                32,
                0,
                173,
                32,
                1,
                173,
                66,
                32,
                134,
                132,
                32,
                2,
                173,
                32,
                3,
                173,
                66,
                32,
                134,
                132,
                130,
                34,
                4,
                66,
                32,
                135,
                167,
                36,
                0,
                32,
                4,
                167,
                11
              ])
            ),
            {}
          ).exports;
        } catch {
        }
        function Long(low, high, unsigned) {
          this.low = low | 0;
          this.high = high | 0;
          this.unsigned = !!unsigned;
        }
        Long.prototype.__isLong__;
        Object.defineProperty(Long.prototype, "__isLong__", {
          value: true
        });
        function isLong(obj) {
          return (obj && obj["__isLong__"]) === true;
        }
        function ctz32(value) {
          var c6 = Math.clz32(value & -value);
          return value ? 31 - c6 : c6;
        }
        Long.isLong = isLong;
        var INT_CACHE = {};
        var UINT_CACHE = {};
        function fromInt(value, unsigned) {
          var obj, cachedObj, cache5;
          if (unsigned) {
            value >>>= 0;
            if (cache5 = 0 <= value && value < 256) {
              cachedObj = UINT_CACHE[value];
              if (cachedObj) return cachedObj;
            }
            obj = fromBits(value, 0, true);
            if (cache5) UINT_CACHE[value] = obj;
            return obj;
          } else {
            value |= 0;
            if (cache5 = -128 <= value && value < 128) {
              cachedObj = INT_CACHE[value];
              if (cachedObj) return cachedObj;
            }
            obj = fromBits(value, value < 0 ? -1 : 0, false);
            if (cache5) INT_CACHE[value] = obj;
            return obj;
          }
        }
        Long.fromInt = fromInt;
        function fromNumber(value, unsigned) {
          if (isNaN(value)) return unsigned ? UZERO : ZERO;
          if (unsigned) {
            if (value < 0) return UZERO;
            if (value >= TWO_PWR_64_DBL) return MAX_UNSIGNED_VALUE;
          } else {
            if (value <= -TWO_PWR_63_DBL) return MIN_VALUE;
            if (value + 1 >= TWO_PWR_63_DBL) return MAX_VALUE;
          }
          if (value < 0) return fromNumber(-value, unsigned).neg();
          return fromBits(
            value % TWO_PWR_32_DBL | 0,
            value / TWO_PWR_32_DBL | 0,
            unsigned
          );
        }
        Long.fromNumber = fromNumber;
        function fromBits(lowBits, highBits, unsigned) {
          return new Long(lowBits, highBits, unsigned);
        }
        Long.fromBits = fromBits;
        var pow_dbl = Math.pow;
        function fromString2(str, unsigned, radix) {
          if (str.length === 0) throw Error("empty string");
          if (typeof unsigned === "number") {
            radix = unsigned;
            unsigned = false;
          } else {
            unsigned = !!unsigned;
          }
          if (str === "NaN" || str === "Infinity" || str === "+Infinity" || str === "-Infinity")
            return unsigned ? UZERO : ZERO;
          radix = radix || 10;
          if (radix < 2 || 36 < radix) throw RangeError("radix");
          var p11;
          if ((p11 = str.indexOf("-")) > 0) throw Error("interior hyphen");
          else if (p11 === 0) {
            return fromString2(str.substring(1), unsigned, radix).neg();
          }
          var radixToPower = fromNumber(pow_dbl(radix, 8));
          var result = ZERO;
          for (var i8 = 0; i8 < str.length; i8 += 8) {
            var size2 = Math.min(8, str.length - i8), value = parseInt(str.substring(i8, i8 + size2), radix);
            if (size2 < 8) {
              var power = fromNumber(pow_dbl(radix, size2));
              result = result.mul(power).add(fromNumber(value));
            } else {
              result = result.mul(radixToPower);
              result = result.add(fromNumber(value));
            }
          }
          result.unsigned = unsigned;
          return result;
        }
        Long.fromString = fromString2;
        function fromValue(val2, unsigned) {
          if (typeof val2 === "number") return fromNumber(val2, unsigned);
          if (typeof val2 === "string") return fromString2(val2, unsigned);
          return fromBits(
            val2.low,
            val2.high,
            typeof unsigned === "boolean" ? unsigned : val2.unsigned
          );
        }
        Long.fromValue = fromValue;
        var TWO_PWR_16_DBL = 1 << 16;
        var TWO_PWR_24_DBL = 1 << 24;
        var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;
        var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;
        var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;
        var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);
        var ZERO = fromInt(0);
        Long.ZERO = ZERO;
        var UZERO = fromInt(0, true);
        Long.UZERO = UZERO;
        var ONE = fromInt(1);
        Long.ONE = ONE;
        var UONE = fromInt(1, true);
        Long.UONE = UONE;
        var NEG_ONE = fromInt(-1);
        Long.NEG_ONE = NEG_ONE;
        var MAX_VALUE = fromBits(4294967295 | 0, 2147483647 | 0, false);
        Long.MAX_VALUE = MAX_VALUE;
        var MAX_UNSIGNED_VALUE = fromBits(4294967295 | 0, 4294967295 | 0, true);
        Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;
        var MIN_VALUE = fromBits(0, 2147483648 | 0, false);
        Long.MIN_VALUE = MIN_VALUE;
        var LongPrototype = Long.prototype;
        LongPrototype.toInt = function toInt() {
          return this.unsigned ? this.low >>> 0 : this.low;
        };
        LongPrototype.toNumber = function toNumber() {
          if (this.unsigned)
            return (this.high >>> 0) * TWO_PWR_32_DBL + (this.low >>> 0);
          return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
        };
        LongPrototype.toString = function toString(radix) {
          radix = radix || 10;
          if (radix < 2 || 36 < radix) throw RangeError("radix");
          if (this.isZero()) return "0";
          if (this.isNegative()) {
            if (this.eq(MIN_VALUE)) {
              var radixLong = fromNumber(radix), div = this.div(radixLong), rem1 = div.mul(radixLong).sub(this);
              return div.toString(radix) + rem1.toInt().toString(radix);
            } else return "-" + this.neg().toString(radix);
          }
          var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned), rem = this;
          var result = "";
          while (true) {
            var remDiv = rem.div(radixToPower), intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0, digits = intval.toString(radix);
            rem = remDiv;
            if (rem.isZero()) return digits + result;
            else {
              while (digits.length < 6) digits = "0" + digits;
              result = "" + digits + result;
            }
          }
        };
        LongPrototype.getHighBits = function getHighBits() {
          return this.high;
        };
        LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
          return this.high >>> 0;
        };
        LongPrototype.getLowBits = function getLowBits() {
          return this.low;
        };
        LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
          return this.low >>> 0;
        };
        LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
          if (this.isNegative())
            return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
          var val2 = this.high != 0 ? this.high : this.low;
          for (var bit2 = 31; bit2 > 0; bit2--) if ((val2 & 1 << bit2) != 0) break;
          return this.high != 0 ? bit2 + 33 : bit2 + 1;
        };
        LongPrototype.isSafeInteger = function isSafeInteger() {
          var top11Bits = this.high >> 21;
          if (!top11Bits) return true;
          if (this.unsigned) return false;
          return top11Bits === -1 && !(this.low === 0 && this.high === -2097152);
        };
        LongPrototype.isZero = function isZero() {
          return this.high === 0 && this.low === 0;
        };
        LongPrototype.eqz = LongPrototype.isZero;
        LongPrototype.isNegative = function isNegative() {
          return !this.unsigned && this.high < 0;
        };
        LongPrototype.isPositive = function isPositive() {
          return this.unsigned || this.high >= 0;
        };
        LongPrototype.isOdd = function isOdd() {
          return (this.low & 1) === 1;
        };
        LongPrototype.isEven = function isEven() {
          return (this.low & 1) === 0;
        };
        LongPrototype.equals = function equals(other) {
          if (!isLong(other)) other = fromValue(other);
          if (this.unsigned !== other.unsigned && this.high >>> 31 === 1 && other.high >>> 31 === 1)
            return false;
          return this.high === other.high && this.low === other.low;
        };
        LongPrototype.eq = LongPrototype.equals;
        LongPrototype.notEquals = function notEquals(other) {
          return !this.eq(
            /* validates */
            other
          );
        };
        LongPrototype.neq = LongPrototype.notEquals;
        LongPrototype.ne = LongPrototype.notEquals;
        LongPrototype.lessThan = function lessThan(other) {
          return this.comp(
            /* validates */
            other
          ) < 0;
        };
        LongPrototype.lt = LongPrototype.lessThan;
        LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
          return this.comp(
            /* validates */
            other
          ) <= 0;
        };
        LongPrototype.lte = LongPrototype.lessThanOrEqual;
        LongPrototype.le = LongPrototype.lessThanOrEqual;
        LongPrototype.greaterThan = function greaterThan(other) {
          return this.comp(
            /* validates */
            other
          ) > 0;
        };
        LongPrototype.gt = LongPrototype.greaterThan;
        LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
          return this.comp(
            /* validates */
            other
          ) >= 0;
        };
        LongPrototype.gte = LongPrototype.greaterThanOrEqual;
        LongPrototype.ge = LongPrototype.greaterThanOrEqual;
        LongPrototype.compare = function compare(other) {
          if (!isLong(other)) other = fromValue(other);
          if (this.eq(other)) return 0;
          var thisNeg = this.isNegative(), otherNeg = other.isNegative();
          if (thisNeg && !otherNeg) return -1;
          if (!thisNeg && otherNeg) return 1;
          if (!this.unsigned) return this.sub(other).isNegative() ? -1 : 1;
          return other.high >>> 0 > this.high >>> 0 || other.high === this.high && other.low >>> 0 > this.low >>> 0 ? -1 : 1;
        };
        LongPrototype.comp = LongPrototype.compare;
        LongPrototype.negate = function negate2() {
          if (!this.unsigned && this.eq(MIN_VALUE)) return MIN_VALUE;
          return this.not().add(ONE);
        };
        LongPrototype.neg = LongPrototype.negate;
        LongPrototype.add = function add(addend) {
          if (!isLong(addend)) addend = fromValue(addend);
          var a48 = this.high >>> 16;
          var a32 = this.high & 65535;
          var a16 = this.low >>> 16;
          var a00 = this.low & 65535;
          var b48 = addend.high >>> 16;
          var b32 = addend.high & 65535;
          var b16 = addend.low >>> 16;
          var b00 = addend.low & 65535;
          var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
          c00 += a00 + b00;
          c16 += c00 >>> 16;
          c00 &= 65535;
          c16 += a16 + b16;
          c32 += c16 >>> 16;
          c16 &= 65535;
          c32 += a32 + b32;
          c48 += c32 >>> 16;
          c32 &= 65535;
          c48 += a48 + b48;
          c48 &= 65535;
          return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
        };
        LongPrototype.subtract = function subtract(subtrahend) {
          if (!isLong(subtrahend)) subtrahend = fromValue(subtrahend);
          return this.add(subtrahend.neg());
        };
        LongPrototype.sub = LongPrototype.subtract;
        LongPrototype.multiply = function multiply(multiplier) {
          if (this.isZero()) return this;
          if (!isLong(multiplier)) multiplier = fromValue(multiplier);
          if (wasm) {
            var low = wasm["mul"](
              this.low,
              this.high,
              multiplier.low,
              multiplier.high
            );
            return fromBits(low, wasm["get_high"](), this.unsigned);
          }
          if (multiplier.isZero()) return this.unsigned ? UZERO : ZERO;
          if (this.eq(MIN_VALUE)) return multiplier.isOdd() ? MIN_VALUE : ZERO;
          if (multiplier.eq(MIN_VALUE)) return this.isOdd() ? MIN_VALUE : ZERO;
          if (this.isNegative()) {
            if (multiplier.isNegative()) return this.neg().mul(multiplier.neg());
            else return this.neg().mul(multiplier).neg();
          } else if (multiplier.isNegative())
            return this.mul(multiplier.neg()).neg();
          if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
            return fromNumber(
              this.toNumber() * multiplier.toNumber(),
              this.unsigned
            );
          var a48 = this.high >>> 16;
          var a32 = this.high & 65535;
          var a16 = this.low >>> 16;
          var a00 = this.low & 65535;
          var b48 = multiplier.high >>> 16;
          var b32 = multiplier.high & 65535;
          var b16 = multiplier.low >>> 16;
          var b00 = multiplier.low & 65535;
          var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
          c00 += a00 * b00;
          c16 += c00 >>> 16;
          c00 &= 65535;
          c16 += a16 * b00;
          c32 += c16 >>> 16;
          c16 &= 65535;
          c16 += a00 * b16;
          c32 += c16 >>> 16;
          c16 &= 65535;
          c32 += a32 * b00;
          c48 += c32 >>> 16;
          c32 &= 65535;
          c32 += a16 * b16;
          c48 += c32 >>> 16;
          c32 &= 65535;
          c32 += a00 * b32;
          c48 += c32 >>> 16;
          c32 &= 65535;
          c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
          c48 &= 65535;
          return fromBits(c16 << 16 | c00, c48 << 16 | c32, this.unsigned);
        };
        LongPrototype.mul = LongPrototype.multiply;
        LongPrototype.divide = function divide(divisor) {
          if (!isLong(divisor)) divisor = fromValue(divisor);
          if (divisor.isZero()) throw Error("division by zero");
          if (wasm) {
            if (!this.unsigned && this.high === -2147483648 && divisor.low === -1 && divisor.high === -1) {
              return this;
            }
            var low = (this.unsigned ? wasm["div_u"] : wasm["div_s"])(
              this.low,
              this.high,
              divisor.low,
              divisor.high
            );
            return fromBits(low, wasm["get_high"](), this.unsigned);
          }
          if (this.isZero()) return this.unsigned ? UZERO : ZERO;
          var approx, rem, res;
          if (!this.unsigned) {
            if (this.eq(MIN_VALUE)) {
              if (divisor.eq(ONE) || divisor.eq(NEG_ONE))
                return MIN_VALUE;
              else if (divisor.eq(MIN_VALUE)) return ONE;
              else {
                var halfThis = this.shr(1);
                approx = halfThis.div(divisor).shl(1);
                if (approx.eq(ZERO)) {
                  return divisor.isNegative() ? ONE : NEG_ONE;
                } else {
                  rem = this.sub(divisor.mul(approx));
                  res = approx.add(rem.div(divisor));
                  return res;
                }
              }
            } else if (divisor.eq(MIN_VALUE)) return this.unsigned ? UZERO : ZERO;
            if (this.isNegative()) {
              if (divisor.isNegative()) return this.neg().div(divisor.neg());
              return this.neg().div(divisor).neg();
            } else if (divisor.isNegative()) return this.div(divisor.neg()).neg();
            res = ZERO;
          } else {
            if (!divisor.unsigned) divisor = divisor.toUnsigned();
            if (divisor.gt(this)) return UZERO;
            if (divisor.gt(this.shru(1)))
              return UONE;
            res = UZERO;
          }
          rem = this;
          while (rem.gte(divisor)) {
            approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));
            var log2 = Math.ceil(Math.log(approx) / Math.LN2), delta = log2 <= 48 ? 1 : pow_dbl(2, log2 - 48), approxRes = fromNumber(approx), approxRem = approxRes.mul(divisor);
            while (approxRem.isNegative() || approxRem.gt(rem)) {
              approx -= delta;
              approxRes = fromNumber(approx, this.unsigned);
              approxRem = approxRes.mul(divisor);
            }
            if (approxRes.isZero()) approxRes = ONE;
            res = res.add(approxRes);
            rem = rem.sub(approxRem);
          }
          return res;
        };
        LongPrototype.div = LongPrototype.divide;
        LongPrototype.modulo = function modulo(divisor) {
          if (!isLong(divisor)) divisor = fromValue(divisor);
          if (wasm) {
            var low = (this.unsigned ? wasm["rem_u"] : wasm["rem_s"])(
              this.low,
              this.high,
              divisor.low,
              divisor.high
            );
            return fromBits(low, wasm["get_high"](), this.unsigned);
          }
          return this.sub(this.div(divisor).mul(divisor));
        };
        LongPrototype.mod = LongPrototype.modulo;
        LongPrototype.rem = LongPrototype.modulo;
        LongPrototype.not = function not3() {
          return fromBits(~this.low, ~this.high, this.unsigned);
        };
        LongPrototype.countLeadingZeros = function countLeadingZeros() {
          return this.high ? Math.clz32(this.high) : Math.clz32(this.low) + 32;
        };
        LongPrototype.clz = LongPrototype.countLeadingZeros;
        LongPrototype.countTrailingZeros = function countTrailingZeros() {
          return this.low ? ctz32(this.low) : ctz32(this.high) + 32;
        };
        LongPrototype.ctz = LongPrototype.countTrailingZeros;
        LongPrototype.and = function and2(other) {
          if (!isLong(other)) other = fromValue(other);
          return fromBits(
            this.low & other.low,
            this.high & other.high,
            this.unsigned
          );
        };
        LongPrototype.or = function or6(other) {
          if (!isLong(other)) other = fromValue(other);
          return fromBits(
            this.low | other.low,
            this.high | other.high,
            this.unsigned
          );
        };
        LongPrototype.xor = function xor2(other) {
          if (!isLong(other)) other = fromValue(other);
          return fromBits(
            this.low ^ other.low,
            this.high ^ other.high,
            this.unsigned
          );
        };
        LongPrototype.shiftLeft = function shiftLeft(numBits) {
          if (isLong(numBits)) numBits = numBits.toInt();
          if ((numBits &= 63) === 0) return this;
          else if (numBits < 32)
            return fromBits(
              this.low << numBits,
              this.high << numBits | this.low >>> 32 - numBits,
              this.unsigned
            );
          else return fromBits(0, this.low << numBits - 32, this.unsigned);
        };
        LongPrototype.shl = LongPrototype.shiftLeft;
        LongPrototype.shiftRight = function shiftRight(numBits) {
          if (isLong(numBits)) numBits = numBits.toInt();
          if ((numBits &= 63) === 0) return this;
          else if (numBits < 32)
            return fromBits(
              this.low >>> numBits | this.high << 32 - numBits,
              this.high >> numBits,
              this.unsigned
            );
          else
            return fromBits(
              this.high >> numBits - 32,
              this.high >= 0 ? 0 : -1,
              this.unsigned
            );
        };
        LongPrototype.shr = LongPrototype.shiftRight;
        LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
          if (isLong(numBits)) numBits = numBits.toInt();
          if ((numBits &= 63) === 0) return this;
          if (numBits < 32)
            return fromBits(
              this.low >>> numBits | this.high << 32 - numBits,
              this.high >>> numBits,
              this.unsigned
            );
          if (numBits === 32) return fromBits(this.high, 0, this.unsigned);
          return fromBits(this.high >>> numBits - 32, 0, this.unsigned);
        };
        LongPrototype.shru = LongPrototype.shiftRightUnsigned;
        LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;
        LongPrototype.rotateLeft = function rotateLeft(numBits) {
          var b9;
          if (isLong(numBits)) numBits = numBits.toInt();
          if ((numBits &= 63) === 0) return this;
          if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);
          if (numBits < 32) {
            b9 = 32 - numBits;
            return fromBits(
              this.low << numBits | this.high >>> b9,
              this.high << numBits | this.low >>> b9,
              this.unsigned
            );
          }
          numBits -= 32;
          b9 = 32 - numBits;
          return fromBits(
            this.high << numBits | this.low >>> b9,
            this.low << numBits | this.high >>> b9,
            this.unsigned
          );
        };
        LongPrototype.rotl = LongPrototype.rotateLeft;
        LongPrototype.rotateRight = function rotateRight(numBits) {
          var b9;
          if (isLong(numBits)) numBits = numBits.toInt();
          if ((numBits &= 63) === 0) return this;
          if (numBits === 32) return fromBits(this.high, this.low, this.unsigned);
          if (numBits < 32) {
            b9 = 32 - numBits;
            return fromBits(
              this.high << b9 | this.low >>> numBits,
              this.low << b9 | this.high >>> numBits,
              this.unsigned
            );
          }
          numBits -= 32;
          b9 = 32 - numBits;
          return fromBits(
            this.low << b9 | this.high >>> numBits,
            this.high << b9 | this.low >>> numBits,
            this.unsigned
          );
        };
        LongPrototype.rotr = LongPrototype.rotateRight;
        LongPrototype.toSigned = function toSigned() {
          if (!this.unsigned) return this;
          return fromBits(this.low, this.high, false);
        };
        LongPrototype.toUnsigned = function toUnsigned() {
          if (this.unsigned) return this;
          return fromBits(this.low, this.high, true);
        };
        LongPrototype.toBytes = function toBytes(le2) {
          return le2 ? this.toBytesLE() : this.toBytesBE();
        };
        LongPrototype.toBytesLE = function toBytesLE() {
          var hi3 = this.high, lo = this.low;
          return [
            lo & 255,
            lo >>> 8 & 255,
            lo >>> 16 & 255,
            lo >>> 24,
            hi3 & 255,
            hi3 >>> 8 & 255,
            hi3 >>> 16 & 255,
            hi3 >>> 24
          ];
        };
        LongPrototype.toBytesBE = function toBytesBE() {
          var hi3 = this.high, lo = this.low;
          return [
            hi3 >>> 24,
            hi3 >>> 16 & 255,
            hi3 >>> 8 & 255,
            hi3 & 255,
            lo >>> 24,
            lo >>> 16 & 255,
            lo >>> 8 & 255,
            lo & 255
          ];
        };
        Long.fromBytes = function fromBytes(bytes2, unsigned, le2) {
          return le2 ? Long.fromBytesLE(bytes2, unsigned) : Long.fromBytesBE(bytes2, unsigned);
        };
        Long.fromBytesLE = function fromBytesLE(bytes2, unsigned) {
          return new Long(
            bytes2[0] | bytes2[1] << 8 | bytes2[2] << 16 | bytes2[3] << 24,
            bytes2[4] | bytes2[5] << 8 | bytes2[6] << 16 | bytes2[7] << 24,
            unsigned
          );
        };
        Long.fromBytesBE = function fromBytesBE(bytes2, unsigned) {
          return new Long(
            bytes2[4] << 24 | bytes2[5] << 16 | bytes2[6] << 8 | bytes2[7],
            bytes2[0] << 24 | bytes2[1] << 16 | bytes2[2] << 8 | bytes2[3],
            unsigned
          );
        };
        if (typeof BigInt === "function") {
          Long.fromBigInt = function fromBigInt(value, unsigned) {
            var lowBits = Number(BigInt.asIntN(32, value));
            var highBits = Number(BigInt.asIntN(32, value >> BigInt(32)));
            return fromBits(lowBits, highBits, unsigned);
          };
          Long.fromValue = function fromValueWithBigInt(value, unsigned) {
            if (typeof value === "bigint") return Long.fromBigInt(value, unsigned);
            return fromValue(value, unsigned);
          };
          LongPrototype.toBigInt = function toBigInt() {
            var lowBigInt = BigInt(this.low >>> 0);
            var highBigInt = BigInt(this.unsigned ? this.high >>> 0 : this.high);
            return highBigInt << BigInt(32) | lowBigInt;
          };
        }
        var _default = _exports.default = Long;
      }
    );
  }
});

// ../node_modules/.pnpm/safer-buffer@2.1.2/node_modules/safer-buffer/safer.js
var require_safer = __commonJS({
  "../node_modules/.pnpm/safer-buffer@2.1.2/node_modules/safer-buffer/safer.js"(exports2, module2) {
    "use strict";
    var buffer2 = require("buffer");
    var Buffer8 = buffer2.Buffer;
    var safer = {};
    var key;
    for (key in buffer2) {
      if (!buffer2.hasOwnProperty(key)) continue;
      if (key === "SlowBuffer" || key === "Buffer") continue;
      safer[key] = buffer2[key];
    }
    var Safer = safer.Buffer = {};
    for (key in Buffer8) {
      if (!Buffer8.hasOwnProperty(key)) continue;
      if (key === "allocUnsafe" || key === "allocUnsafeSlow") continue;
      Safer[key] = Buffer8[key];
    }
    safer.Buffer.prototype = Buffer8.prototype;
    if (!Safer.from || Safer.from === Uint8Array.from) {
      Safer.from = function(value, encodingOrOffset, length) {
        if (typeof value === "number") {
          throw new TypeError('The "value" argument must not be of type number. Received type ' + typeof value);
        }
        if (value && typeof value.length === "undefined") {
          throw new TypeError("The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value);
        }
        return Buffer8(value, encodingOrOffset, length);
      };
    }
    if (!Safer.alloc) {
      Safer.alloc = function(size2, fill, encoding) {
        if (typeof size2 !== "number") {
          throw new TypeError('The "size" argument must be of type number. Received type ' + typeof size2);
        }
        if (size2 < 0 || size2 >= 2 * (1 << 30)) {
          throw new RangeError('The value "' + size2 + '" is invalid for option "size"');
        }
        var buf = Buffer8(size2);
        if (!fill || fill.length === 0) {
          buf.fill(0);
        } else if (typeof encoding === "string") {
          buf.fill(fill, encoding);
        } else {
          buf.fill(fill);
        }
        return buf;
      };
    }
    if (!safer.kStringMaxLength) {
      try {
        safer.kStringMaxLength = process.binding("buffer").kStringMaxLength;
      } catch (e6) {
      }
    }
    if (!safer.constants) {
      safer.constants = {
        MAX_LENGTH: safer.kMaxLength
      };
      if (safer.kStringMaxLength) {
        safer.constants.MAX_STRING_LENGTH = safer.kStringMaxLength;
      }
    }
    module2.exports = safer;
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/bom-handling.js
var require_bom_handling = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/bom-handling.js"(exports2) {
    "use strict";
    var BOMChar = "\uFEFF";
    exports2.PrependBOM = PrependBOMWrapper;
    function PrependBOMWrapper(encoder, options) {
      this.encoder = encoder;
      this.addBOM = true;
    }
    PrependBOMWrapper.prototype.write = function(str) {
      if (this.addBOM) {
        str = BOMChar + str;
        this.addBOM = false;
      }
      return this.encoder.write(str);
    };
    PrependBOMWrapper.prototype.end = function() {
      return this.encoder.end();
    };
    exports2.StripBOM = StripBOMWrapper;
    function StripBOMWrapper(decoder2, options) {
      this.decoder = decoder2;
      this.pass = false;
      this.options = options || {};
    }
    StripBOMWrapper.prototype.write = function(buf) {
      var res = this.decoder.write(buf);
      if (this.pass || !res)
        return res;
      if (res[0] === BOMChar) {
        res = res.slice(1);
        if (typeof this.options.stripBOM === "function")
          this.options.stripBOM();
      }
      this.pass = true;
      return res;
    };
    StripBOMWrapper.prototype.end = function() {
      return this.decoder.end();
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/internal.js
var require_internal = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/internal.js"(exports2, module2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    module2.exports = {
      // Encodings
      utf8: { type: "_internal", bomAware: true },
      cesu8: { type: "_internal", bomAware: true },
      unicode11utf8: "utf8",
      ucs2: { type: "_internal", bomAware: true },
      utf16le: "ucs2",
      binary: { type: "_internal" },
      base64: { type: "_internal" },
      hex: { type: "_internal" },
      // Codec.
      _internal: InternalCodec
    };
    function InternalCodec(codecOptions, iconv) {
      this.enc = codecOptions.encodingName;
      this.bomAware = codecOptions.bomAware;
      if (this.enc === "base64")
        this.encoder = InternalEncoderBase64;
      else if (this.enc === "cesu8") {
        this.enc = "utf8";
        this.encoder = InternalEncoderCesu8;
        if (Buffer8.from("eda0bdedb2a9", "hex").toString() !== "\u{1F4A9}") {
          this.decoder = InternalDecoderCesu8;
          this.defaultCharUnicode = iconv.defaultCharUnicode;
        }
      }
    }
    InternalCodec.prototype.encoder = InternalEncoder;
    InternalCodec.prototype.decoder = InternalDecoder;
    var StringDecoder = require("string_decoder").StringDecoder;
    if (!StringDecoder.prototype.end)
      StringDecoder.prototype.end = function() {
      };
    function InternalDecoder(options, codec) {
      this.decoder = new StringDecoder(codec.enc);
    }
    InternalDecoder.prototype.write = function(buf) {
      if (!Buffer8.isBuffer(buf)) {
        buf = Buffer8.from(buf);
      }
      return this.decoder.write(buf);
    };
    InternalDecoder.prototype.end = function() {
      return this.decoder.end();
    };
    function InternalEncoder(options, codec) {
      this.enc = codec.enc;
    }
    InternalEncoder.prototype.write = function(str) {
      return Buffer8.from(str, this.enc);
    };
    InternalEncoder.prototype.end = function() {
    };
    function InternalEncoderBase64(options, codec) {
      this.prevStr = "";
    }
    InternalEncoderBase64.prototype.write = function(str) {
      str = this.prevStr + str;
      var completeQuads = str.length - str.length % 4;
      this.prevStr = str.slice(completeQuads);
      str = str.slice(0, completeQuads);
      return Buffer8.from(str, "base64");
    };
    InternalEncoderBase64.prototype.end = function() {
      return Buffer8.from(this.prevStr, "base64");
    };
    function InternalEncoderCesu8(options, codec) {
    }
    InternalEncoderCesu8.prototype.write = function(str) {
      var buf = Buffer8.alloc(str.length * 3), bufIdx = 0;
      for (var i8 = 0; i8 < str.length; i8++) {
        var charCode = str.charCodeAt(i8);
        if (charCode < 128)
          buf[bufIdx++] = charCode;
        else if (charCode < 2048) {
          buf[bufIdx++] = 192 + (charCode >>> 6);
          buf[bufIdx++] = 128 + (charCode & 63);
        } else {
          buf[bufIdx++] = 224 + (charCode >>> 12);
          buf[bufIdx++] = 128 + (charCode >>> 6 & 63);
          buf[bufIdx++] = 128 + (charCode & 63);
        }
      }
      return buf.slice(0, bufIdx);
    };
    InternalEncoderCesu8.prototype.end = function() {
    };
    function InternalDecoderCesu8(options, codec) {
      this.acc = 0;
      this.contBytes = 0;
      this.accBytes = 0;
      this.defaultCharUnicode = codec.defaultCharUnicode;
    }
    InternalDecoderCesu8.prototype.write = function(buf) {
      var acc = this.acc, contBytes = this.contBytes, accBytes = this.accBytes, res = "";
      for (var i8 = 0; i8 < buf.length; i8++) {
        var curByte = buf[i8];
        if ((curByte & 192) !== 128) {
          if (contBytes > 0) {
            res += this.defaultCharUnicode;
            contBytes = 0;
          }
          if (curByte < 128) {
            res += String.fromCharCode(curByte);
          } else if (curByte < 224) {
            acc = curByte & 31;
            contBytes = 1;
            accBytes = 1;
          } else if (curByte < 240) {
            acc = curByte & 15;
            contBytes = 2;
            accBytes = 1;
          } else {
            res += this.defaultCharUnicode;
          }
        } else {
          if (contBytes > 0) {
            acc = acc << 6 | curByte & 63;
            contBytes--;
            accBytes++;
            if (contBytes === 0) {
              if (accBytes === 2 && acc < 128 && acc > 0)
                res += this.defaultCharUnicode;
              else if (accBytes === 3 && acc < 2048)
                res += this.defaultCharUnicode;
              else
                res += String.fromCharCode(acc);
            }
          } else {
            res += this.defaultCharUnicode;
          }
        }
      }
      this.acc = acc;
      this.contBytes = contBytes;
      this.accBytes = accBytes;
      return res;
    };
    InternalDecoderCesu8.prototype.end = function() {
      var res = 0;
      if (this.contBytes > 0)
        res += this.defaultCharUnicode;
      return res;
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf32.js
var require_utf32 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf32.js"(exports2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    exports2._utf32 = Utf32Codec;
    function Utf32Codec(codecOptions, iconv) {
      this.iconv = iconv;
      this.bomAware = true;
      this.isLE = codecOptions.isLE;
    }
    exports2.utf32le = { type: "_utf32", isLE: true };
    exports2.utf32be = { type: "_utf32", isLE: false };
    exports2.ucs4le = "utf32le";
    exports2.ucs4be = "utf32be";
    Utf32Codec.prototype.encoder = Utf32Encoder;
    Utf32Codec.prototype.decoder = Utf32Decoder;
    function Utf32Encoder(options, codec) {
      this.isLE = codec.isLE;
      this.highSurrogate = 0;
    }
    Utf32Encoder.prototype.write = function(str) {
      var src = Buffer8.from(str, "ucs2");
      var dst = Buffer8.alloc(src.length * 2);
      var write32 = this.isLE ? dst.writeUInt32LE : dst.writeUInt32BE;
      var offset = 0;
      for (var i8 = 0; i8 < src.length; i8 += 2) {
        var code = src.readUInt16LE(i8);
        var isHighSurrogate = 55296 <= code && code < 56320;
        var isLowSurrogate = 56320 <= code && code < 57344;
        if (this.highSurrogate) {
          if (isHighSurrogate || !isLowSurrogate) {
            write32.call(dst, this.highSurrogate, offset);
            offset += 4;
          } else {
            var codepoint = (this.highSurrogate - 55296 << 10 | code - 56320) + 65536;
            write32.call(dst, codepoint, offset);
            offset += 4;
            this.highSurrogate = 0;
            continue;
          }
        }
        if (isHighSurrogate)
          this.highSurrogate = code;
        else {
          write32.call(dst, code, offset);
          offset += 4;
          this.highSurrogate = 0;
        }
      }
      if (offset < dst.length)
        dst = dst.slice(0, offset);
      return dst;
    };
    Utf32Encoder.prototype.end = function() {
      if (!this.highSurrogate)
        return;
      var buf = Buffer8.alloc(4);
      if (this.isLE)
        buf.writeUInt32LE(this.highSurrogate, 0);
      else
        buf.writeUInt32BE(this.highSurrogate, 0);
      this.highSurrogate = 0;
      return buf;
    };
    function Utf32Decoder(options, codec) {
      this.isLE = codec.isLE;
      this.badChar = codec.iconv.defaultCharUnicode.charCodeAt(0);
      this.overflow = [];
    }
    Utf32Decoder.prototype.write = function(src) {
      if (src.length === 0)
        return "";
      var i8 = 0;
      var codepoint = 0;
      var dst = Buffer8.alloc(src.length + 4);
      var offset = 0;
      var isLE = this.isLE;
      var overflow = this.overflow;
      var badChar = this.badChar;
      if (overflow.length > 0) {
        for (; i8 < src.length && overflow.length < 4; i8++)
          overflow.push(src[i8]);
        if (overflow.length === 4) {
          if (isLE) {
            codepoint = overflow[i8] | overflow[i8 + 1] << 8 | overflow[i8 + 2] << 16 | overflow[i8 + 3] << 24;
          } else {
            codepoint = overflow[i8 + 3] | overflow[i8 + 2] << 8 | overflow[i8 + 1] << 16 | overflow[i8] << 24;
          }
          overflow.length = 0;
          offset = _writeCodepoint(dst, offset, codepoint, badChar);
        }
      }
      for (; i8 < src.length - 3; i8 += 4) {
        if (isLE) {
          codepoint = src[i8] | src[i8 + 1] << 8 | src[i8 + 2] << 16 | src[i8 + 3] << 24;
        } else {
          codepoint = src[i8 + 3] | src[i8 + 2] << 8 | src[i8 + 1] << 16 | src[i8] << 24;
        }
        offset = _writeCodepoint(dst, offset, codepoint, badChar);
      }
      for (; i8 < src.length; i8++) {
        overflow.push(src[i8]);
      }
      return dst.slice(0, offset).toString("ucs2");
    };
    function _writeCodepoint(dst, offset, codepoint, badChar) {
      if (codepoint < 0 || codepoint > 1114111) {
        codepoint = badChar;
      }
      if (codepoint >= 65536) {
        codepoint -= 65536;
        var high = 55296 | codepoint >> 10;
        dst[offset++] = high & 255;
        dst[offset++] = high >> 8;
        var codepoint = 56320 | codepoint & 1023;
      }
      dst[offset++] = codepoint & 255;
      dst[offset++] = codepoint >> 8;
      return offset;
    }
    Utf32Decoder.prototype.end = function() {
      this.overflow.length = 0;
    };
    exports2.utf32 = Utf32AutoCodec;
    exports2.ucs4 = "utf32";
    function Utf32AutoCodec(options, iconv) {
      this.iconv = iconv;
    }
    Utf32AutoCodec.prototype.encoder = Utf32AutoEncoder;
    Utf32AutoCodec.prototype.decoder = Utf32AutoDecoder;
    function Utf32AutoEncoder(options, codec) {
      options = options || {};
      if (options.addBOM === void 0)
        options.addBOM = true;
      this.encoder = codec.iconv.getEncoder(options.defaultEncoding || "utf-32le", options);
    }
    Utf32AutoEncoder.prototype.write = function(str) {
      return this.encoder.write(str);
    };
    Utf32AutoEncoder.prototype.end = function() {
      return this.encoder.end();
    };
    function Utf32AutoDecoder(options, codec) {
      this.decoder = null;
      this.initialBufs = [];
      this.initialBufsLen = 0;
      this.options = options || {};
      this.iconv = codec.iconv;
    }
    Utf32AutoDecoder.prototype.write = function(buf) {
      if (!this.decoder) {
        this.initialBufs.push(buf);
        this.initialBufsLen += buf.length;
        if (this.initialBufsLen < 32)
          return "";
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i8 = 0; i8 < this.initialBufs.length; i8++)
          resStr += this.decoder.write(this.initialBufs[i8]);
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.write(buf);
    };
    Utf32AutoDecoder.prototype.end = function() {
      if (!this.decoder) {
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i8 = 0; i8 < this.initialBufs.length; i8++)
          resStr += this.decoder.write(this.initialBufs[i8]);
        var trail = this.decoder.end();
        if (trail)
          resStr += trail;
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.end();
    };
    function detectEncoding(bufs, defaultEncoding) {
      var b9 = [];
      var charsProcessed = 0;
      var invalidLE = 0, invalidBE = 0;
      var bmpCharsLE = 0, bmpCharsBE = 0;
      outer_loop:
        for (var i8 = 0; i8 < bufs.length; i8++) {
          var buf = bufs[i8];
          for (var j7 = 0; j7 < buf.length; j7++) {
            b9.push(buf[j7]);
            if (b9.length === 4) {
              if (charsProcessed === 0) {
                if (b9[0] === 255 && b9[1] === 254 && b9[2] === 0 && b9[3] === 0) {
                  return "utf-32le";
                }
                if (b9[0] === 0 && b9[1] === 0 && b9[2] === 254 && b9[3] === 255) {
                  return "utf-32be";
                }
              }
              if (b9[0] !== 0 || b9[1] > 16) invalidBE++;
              if (b9[3] !== 0 || b9[2] > 16) invalidLE++;
              if (b9[0] === 0 && b9[1] === 0 && (b9[2] !== 0 || b9[3] !== 0)) bmpCharsBE++;
              if ((b9[0] !== 0 || b9[1] !== 0) && b9[2] === 0 && b9[3] === 0) bmpCharsLE++;
              b9.length = 0;
              charsProcessed++;
              if (charsProcessed >= 100) {
                break outer_loop;
              }
            }
          }
        }
      if (bmpCharsBE - invalidBE > bmpCharsLE - invalidLE) return "utf-32be";
      if (bmpCharsBE - invalidBE < bmpCharsLE - invalidLE) return "utf-32le";
      return defaultEncoding || "utf-32le";
    }
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf16.js
var require_utf16 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf16.js"(exports2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    exports2.utf16be = Utf16BECodec;
    function Utf16BECodec() {
    }
    Utf16BECodec.prototype.encoder = Utf16BEEncoder;
    Utf16BECodec.prototype.decoder = Utf16BEDecoder;
    Utf16BECodec.prototype.bomAware = true;
    function Utf16BEEncoder() {
    }
    Utf16BEEncoder.prototype.write = function(str) {
      var buf = Buffer8.from(str, "ucs2");
      for (var i8 = 0; i8 < buf.length; i8 += 2) {
        var tmp = buf[i8];
        buf[i8] = buf[i8 + 1];
        buf[i8 + 1] = tmp;
      }
      return buf;
    };
    Utf16BEEncoder.prototype.end = function() {
    };
    function Utf16BEDecoder() {
      this.overflowByte = -1;
    }
    Utf16BEDecoder.prototype.write = function(buf) {
      if (buf.length == 0)
        return "";
      var buf2 = Buffer8.alloc(buf.length + 1), i8 = 0, j7 = 0;
      if (this.overflowByte !== -1) {
        buf2[0] = buf[0];
        buf2[1] = this.overflowByte;
        i8 = 1;
        j7 = 2;
      }
      for (; i8 < buf.length - 1; i8 += 2, j7 += 2) {
        buf2[j7] = buf[i8 + 1];
        buf2[j7 + 1] = buf[i8];
      }
      this.overflowByte = i8 == buf.length - 1 ? buf[buf.length - 1] : -1;
      return buf2.slice(0, j7).toString("ucs2");
    };
    Utf16BEDecoder.prototype.end = function() {
      this.overflowByte = -1;
    };
    exports2.utf16 = Utf16Codec;
    function Utf16Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf16Codec.prototype.encoder = Utf16Encoder;
    Utf16Codec.prototype.decoder = Utf16Decoder;
    function Utf16Encoder(options, codec) {
      options = options || {};
      if (options.addBOM === void 0)
        options.addBOM = true;
      this.encoder = codec.iconv.getEncoder("utf-16le", options);
    }
    Utf16Encoder.prototype.write = function(str) {
      return this.encoder.write(str);
    };
    Utf16Encoder.prototype.end = function() {
      return this.encoder.end();
    };
    function Utf16Decoder(options, codec) {
      this.decoder = null;
      this.initialBufs = [];
      this.initialBufsLen = 0;
      this.options = options || {};
      this.iconv = codec.iconv;
    }
    Utf16Decoder.prototype.write = function(buf) {
      if (!this.decoder) {
        this.initialBufs.push(buf);
        this.initialBufsLen += buf.length;
        if (this.initialBufsLen < 16)
          return "";
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i8 = 0; i8 < this.initialBufs.length; i8++)
          resStr += this.decoder.write(this.initialBufs[i8]);
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.write(buf);
    };
    Utf16Decoder.prototype.end = function() {
      if (!this.decoder) {
        var encoding = detectEncoding(this.initialBufs, this.options.defaultEncoding);
        this.decoder = this.iconv.getDecoder(encoding, this.options);
        var resStr = "";
        for (var i8 = 0; i8 < this.initialBufs.length; i8++)
          resStr += this.decoder.write(this.initialBufs[i8]);
        var trail = this.decoder.end();
        if (trail)
          resStr += trail;
        this.initialBufs.length = this.initialBufsLen = 0;
        return resStr;
      }
      return this.decoder.end();
    };
    function detectEncoding(bufs, defaultEncoding) {
      var b9 = [];
      var charsProcessed = 0;
      var asciiCharsLE = 0, asciiCharsBE = 0;
      outer_loop:
        for (var i8 = 0; i8 < bufs.length; i8++) {
          var buf = bufs[i8];
          for (var j7 = 0; j7 < buf.length; j7++) {
            b9.push(buf[j7]);
            if (b9.length === 2) {
              if (charsProcessed === 0) {
                if (b9[0] === 255 && b9[1] === 254) return "utf-16le";
                if (b9[0] === 254 && b9[1] === 255) return "utf-16be";
              }
              if (b9[0] === 0 && b9[1] !== 0) asciiCharsBE++;
              if (b9[0] !== 0 && b9[1] === 0) asciiCharsLE++;
              b9.length = 0;
              charsProcessed++;
              if (charsProcessed >= 100) {
                break outer_loop;
              }
            }
          }
        }
      if (asciiCharsBE > asciiCharsLE) return "utf-16be";
      if (asciiCharsBE < asciiCharsLE) return "utf-16le";
      return defaultEncoding || "utf-16le";
    }
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf7.js
var require_utf7 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/utf7.js"(exports2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    exports2.utf7 = Utf7Codec;
    exports2.unicode11utf7 = "utf7";
    function Utf7Codec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf7Codec.prototype.encoder = Utf7Encoder;
    Utf7Codec.prototype.decoder = Utf7Decoder;
    Utf7Codec.prototype.bomAware = true;
    var nonDirectChars = /[^A-Za-z0-9'\(\),-\.\/:\? \n\r\t]+/g;
    function Utf7Encoder(options, codec) {
      this.iconv = codec.iconv;
    }
    Utf7Encoder.prototype.write = function(str) {
      return Buffer8.from(str.replace(nonDirectChars, function(chunk) {
        return "+" + (chunk === "+" ? "" : this.iconv.encode(chunk, "utf16-be").toString("base64").replace(/=+$/, "")) + "-";
      }.bind(this)));
    };
    Utf7Encoder.prototype.end = function() {
    };
    function Utf7Decoder(options, codec) {
      this.iconv = codec.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    var base64Regex2 = /[A-Za-z0-9\/+]/;
    var base64Chars = [];
    for (i8 = 0; i8 < 256; i8++)
      base64Chars[i8] = base64Regex2.test(String.fromCharCode(i8));
    var i8;
    var plusChar = "+".charCodeAt(0);
    var minusChar = "-".charCodeAt(0);
    var andChar = "&".charCodeAt(0);
    Utf7Decoder.prototype.write = function(buf) {
      var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
      for (var i9 = 0; i9 < buf.length; i9++) {
        if (!inBase64) {
          if (buf[i9] == plusChar) {
            res += this.iconv.decode(buf.slice(lastI, i9), "ascii");
            lastI = i9 + 1;
            inBase64 = true;
          }
        } else {
          if (!base64Chars[buf[i9]]) {
            if (i9 == lastI && buf[i9] == minusChar) {
              res += "+";
            } else {
              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i9), "ascii");
              res += this.iconv.decode(Buffer8.from(b64str, "base64"), "utf16-be");
            }
            if (buf[i9] != minusChar)
              i9--;
            lastI = i9 + 1;
            inBase64 = false;
            base64Accum = "";
          }
        }
      }
      if (!inBase64) {
        res += this.iconv.decode(buf.slice(lastI), "ascii");
      } else {
        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii");
        var canBeDecoded = b64str.length - b64str.length % 8;
        base64Accum = b64str.slice(canBeDecoded);
        b64str = b64str.slice(0, canBeDecoded);
        res += this.iconv.decode(Buffer8.from(b64str, "base64"), "utf16-be");
      }
      this.inBase64 = inBase64;
      this.base64Accum = base64Accum;
      return res;
    };
    Utf7Decoder.prototype.end = function() {
      var res = "";
      if (this.inBase64 && this.base64Accum.length > 0)
        res = this.iconv.decode(Buffer8.from(this.base64Accum, "base64"), "utf16-be");
      this.inBase64 = false;
      this.base64Accum = "";
      return res;
    };
    exports2.utf7imap = Utf7IMAPCodec;
    function Utf7IMAPCodec(codecOptions, iconv) {
      this.iconv = iconv;
    }
    Utf7IMAPCodec.prototype.encoder = Utf7IMAPEncoder;
    Utf7IMAPCodec.prototype.decoder = Utf7IMAPDecoder;
    Utf7IMAPCodec.prototype.bomAware = true;
    function Utf7IMAPEncoder(options, codec) {
      this.iconv = codec.iconv;
      this.inBase64 = false;
      this.base64Accum = Buffer8.alloc(6);
      this.base64AccumIdx = 0;
    }
    Utf7IMAPEncoder.prototype.write = function(str) {
      var inBase64 = this.inBase64, base64Accum = this.base64Accum, base64AccumIdx = this.base64AccumIdx, buf = Buffer8.alloc(str.length * 5 + 10), bufIdx = 0;
      for (var i9 = 0; i9 < str.length; i9++) {
        var uChar = str.charCodeAt(i9);
        if (32 <= uChar && uChar <= 126) {
          if (inBase64) {
            if (base64AccumIdx > 0) {
              bufIdx += buf.write(base64Accum.slice(0, base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
              base64AccumIdx = 0;
            }
            buf[bufIdx++] = minusChar;
            inBase64 = false;
          }
          if (!inBase64) {
            buf[bufIdx++] = uChar;
            if (uChar === andChar)
              buf[bufIdx++] = minusChar;
          }
        } else {
          if (!inBase64) {
            buf[bufIdx++] = andChar;
            inBase64 = true;
          }
          if (inBase64) {
            base64Accum[base64AccumIdx++] = uChar >> 8;
            base64Accum[base64AccumIdx++] = uChar & 255;
            if (base64AccumIdx == base64Accum.length) {
              bufIdx += buf.write(base64Accum.toString("base64").replace(/\//g, ","), bufIdx);
              base64AccumIdx = 0;
            }
          }
        }
      }
      this.inBase64 = inBase64;
      this.base64AccumIdx = base64AccumIdx;
      return buf.slice(0, bufIdx);
    };
    Utf7IMAPEncoder.prototype.end = function() {
      var buf = Buffer8.alloc(10), bufIdx = 0;
      if (this.inBase64) {
        if (this.base64AccumIdx > 0) {
          bufIdx += buf.write(this.base64Accum.slice(0, this.base64AccumIdx).toString("base64").replace(/\//g, ",").replace(/=+$/, ""), bufIdx);
          this.base64AccumIdx = 0;
        }
        buf[bufIdx++] = minusChar;
        this.inBase64 = false;
      }
      return buf.slice(0, bufIdx);
    };
    function Utf7IMAPDecoder(options, codec) {
      this.iconv = codec.iconv;
      this.inBase64 = false;
      this.base64Accum = "";
    }
    var base64IMAPChars = base64Chars.slice();
    base64IMAPChars[",".charCodeAt(0)] = true;
    Utf7IMAPDecoder.prototype.write = function(buf) {
      var res = "", lastI = 0, inBase64 = this.inBase64, base64Accum = this.base64Accum;
      for (var i9 = 0; i9 < buf.length; i9++) {
        if (!inBase64) {
          if (buf[i9] == andChar) {
            res += this.iconv.decode(buf.slice(lastI, i9), "ascii");
            lastI = i9 + 1;
            inBase64 = true;
          }
        } else {
          if (!base64IMAPChars[buf[i9]]) {
            if (i9 == lastI && buf[i9] == minusChar) {
              res += "&";
            } else {
              var b64str = base64Accum + this.iconv.decode(buf.slice(lastI, i9), "ascii").replace(/,/g, "/");
              res += this.iconv.decode(Buffer8.from(b64str, "base64"), "utf16-be");
            }
            if (buf[i9] != minusChar)
              i9--;
            lastI = i9 + 1;
            inBase64 = false;
            base64Accum = "";
          }
        }
      }
      if (!inBase64) {
        res += this.iconv.decode(buf.slice(lastI), "ascii");
      } else {
        var b64str = base64Accum + this.iconv.decode(buf.slice(lastI), "ascii").replace(/,/g, "/");
        var canBeDecoded = b64str.length - b64str.length % 8;
        base64Accum = b64str.slice(canBeDecoded);
        b64str = b64str.slice(0, canBeDecoded);
        res += this.iconv.decode(Buffer8.from(b64str, "base64"), "utf16-be");
      }
      this.inBase64 = inBase64;
      this.base64Accum = base64Accum;
      return res;
    };
    Utf7IMAPDecoder.prototype.end = function() {
      var res = "";
      if (this.inBase64 && this.base64Accum.length > 0)
        res = this.iconv.decode(Buffer8.from(this.base64Accum, "base64"), "utf16-be");
      this.inBase64 = false;
      this.base64Accum = "";
      return res;
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/sbcs-codec.js
var require_sbcs_codec = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/sbcs-codec.js"(exports2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    exports2._sbcs = SBCSCodec;
    function SBCSCodec(codecOptions, iconv) {
      if (!codecOptions)
        throw new Error("SBCS codec is called without the data.");
      if (!codecOptions.chars || codecOptions.chars.length !== 128 && codecOptions.chars.length !== 256)
        throw new Error("Encoding '" + codecOptions.type + "' has incorrect 'chars' (must be of len 128 or 256)");
      if (codecOptions.chars.length === 128) {
        var asciiString = "";
        for (var i8 = 0; i8 < 128; i8++)
          asciiString += String.fromCharCode(i8);
        codecOptions.chars = asciiString + codecOptions.chars;
      }
      this.decodeBuf = Buffer8.from(codecOptions.chars, "ucs2");
      var encodeBuf = Buffer8.alloc(65536, iconv.defaultCharSingleByte.charCodeAt(0));
      for (var i8 = 0; i8 < codecOptions.chars.length; i8++)
        encodeBuf[codecOptions.chars.charCodeAt(i8)] = i8;
      this.encodeBuf = encodeBuf;
    }
    SBCSCodec.prototype.encoder = SBCSEncoder;
    SBCSCodec.prototype.decoder = SBCSDecoder;
    function SBCSEncoder(options, codec) {
      this.encodeBuf = codec.encodeBuf;
    }
    SBCSEncoder.prototype.write = function(str) {
      var buf = Buffer8.alloc(str.length);
      for (var i8 = 0; i8 < str.length; i8++)
        buf[i8] = this.encodeBuf[str.charCodeAt(i8)];
      return buf;
    };
    SBCSEncoder.prototype.end = function() {
    };
    function SBCSDecoder(options, codec) {
      this.decodeBuf = codec.decodeBuf;
    }
    SBCSDecoder.prototype.write = function(buf) {
      var decodeBuf = this.decodeBuf;
      var newBuf = Buffer8.alloc(buf.length * 2);
      var idx1 = 0, idx2 = 0;
      for (var i8 = 0; i8 < buf.length; i8++) {
        idx1 = buf[i8] * 2;
        idx2 = i8 * 2;
        newBuf[idx2] = decodeBuf[idx1];
        newBuf[idx2 + 1] = decodeBuf[idx1 + 1];
      }
      return newBuf.toString("ucs2");
    };
    SBCSDecoder.prototype.end = function() {
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/sbcs-data.js
var require_sbcs_data = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/sbcs-data.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      // Not supported by iconv, not sure why.
      "10029": "maccenteuro",
      "maccenteuro": {
        "type": "_sbcs",
        "chars": "\xC4\u0100\u0101\xC9\u0104\xD6\xDC\xE1\u0105\u010C\xE4\u010D\u0106\u0107\xE9\u0179\u017A\u010E\xED\u010F\u0112\u0113\u0116\xF3\u0117\xF4\xF6\xF5\xFA\u011A\u011B\xFC\u2020\xB0\u0118\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\u0119\xA8\u2260\u0123\u012E\u012F\u012A\u2264\u2265\u012B\u0136\u2202\u2211\u0142\u013B\u013C\u013D\u013E\u0139\u013A\u0145\u0146\u0143\xAC\u221A\u0144\u0147\u2206\xAB\xBB\u2026\xA0\u0148\u0150\xD5\u0151\u014C\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\u014D\u0154\u0155\u0158\u2039\u203A\u0159\u0156\u0157\u0160\u201A\u201E\u0161\u015A\u015B\xC1\u0164\u0165\xCD\u017D\u017E\u016A\xD3\xD4\u016B\u016E\xDA\u016F\u0170\u0171\u0172\u0173\xDD\xFD\u0137\u017B\u0141\u017C\u0122\u02C7"
      },
      "808": "cp808",
      "ibm808": "cp808",
      "cp808": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\u20AC\u25A0\xA0"
      },
      "mik": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2514\u2534\u252C\u251C\u2500\u253C\u2563\u2551\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2510\u2591\u2592\u2593\u2502\u2524\u2116\xA7\u2557\u255D\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "cp720": {
        "type": "_sbcs",
        "chars": "\x80\x81\xE9\xE2\x84\xE0\x86\xE7\xEA\xEB\xE8\xEF\xEE\x8D\x8E\x8F\x90\u0651\u0652\xF4\xA4\u0640\xFB\xF9\u0621\u0622\u0623\u0624\xA3\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0636\u0637\u0638\u0639\u063A\u0641\xB5\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u2261\u064B\u064C\u064D\u064E\u064F\u0650\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      // Aliases of generated encodings.
      "ascii8bit": "ascii",
      "usascii": "ascii",
      "ansix34": "ascii",
      "ansix341968": "ascii",
      "ansix341986": "ascii",
      "csascii": "ascii",
      "cp367": "ascii",
      "ibm367": "ascii",
      "isoir6": "ascii",
      "iso646us": "ascii",
      "iso646irv": "ascii",
      "us": "ascii",
      "latin1": "iso88591",
      "latin2": "iso88592",
      "latin3": "iso88593",
      "latin4": "iso88594",
      "latin5": "iso88599",
      "latin6": "iso885910",
      "latin7": "iso885913",
      "latin8": "iso885914",
      "latin9": "iso885915",
      "latin10": "iso885916",
      "csisolatin1": "iso88591",
      "csisolatin2": "iso88592",
      "csisolatin3": "iso88593",
      "csisolatin4": "iso88594",
      "csisolatincyrillic": "iso88595",
      "csisolatinarabic": "iso88596",
      "csisolatingreek": "iso88597",
      "csisolatinhebrew": "iso88598",
      "csisolatin5": "iso88599",
      "csisolatin6": "iso885910",
      "l1": "iso88591",
      "l2": "iso88592",
      "l3": "iso88593",
      "l4": "iso88594",
      "l5": "iso88599",
      "l6": "iso885910",
      "l7": "iso885913",
      "l8": "iso885914",
      "l9": "iso885915",
      "l10": "iso885916",
      "isoir14": "iso646jp",
      "isoir57": "iso646cn",
      "isoir100": "iso88591",
      "isoir101": "iso88592",
      "isoir109": "iso88593",
      "isoir110": "iso88594",
      "isoir144": "iso88595",
      "isoir127": "iso88596",
      "isoir126": "iso88597",
      "isoir138": "iso88598",
      "isoir148": "iso88599",
      "isoir157": "iso885910",
      "isoir166": "tis620",
      "isoir179": "iso885913",
      "isoir199": "iso885914",
      "isoir203": "iso885915",
      "isoir226": "iso885916",
      "cp819": "iso88591",
      "ibm819": "iso88591",
      "cyrillic": "iso88595",
      "arabic": "iso88596",
      "arabic8": "iso88596",
      "ecma114": "iso88596",
      "asmo708": "iso88596",
      "greek": "iso88597",
      "greek8": "iso88597",
      "ecma118": "iso88597",
      "elot928": "iso88597",
      "hebrew": "iso88598",
      "hebrew8": "iso88598",
      "turkish": "iso88599",
      "turkish8": "iso88599",
      "thai": "iso885911",
      "thai8": "iso885911",
      "celtic": "iso885914",
      "celtic8": "iso885914",
      "isoceltic": "iso885914",
      "tis6200": "tis620",
      "tis62025291": "tis620",
      "tis62025330": "tis620",
      "10000": "macroman",
      "10006": "macgreek",
      "10007": "maccyrillic",
      "10079": "maciceland",
      "10081": "macturkish",
      "cspc8codepage437": "cp437",
      "cspc775baltic": "cp775",
      "cspc850multilingual": "cp850",
      "cspcp852": "cp852",
      "cspc862latinhebrew": "cp862",
      "cpgr": "cp869",
      "msee": "cp1250",
      "mscyrl": "cp1251",
      "msansi": "cp1252",
      "msgreek": "cp1253",
      "msturk": "cp1254",
      "mshebr": "cp1255",
      "msarab": "cp1256",
      "winbaltrim": "cp1257",
      "cp20866": "koi8r",
      "20866": "koi8r",
      "ibm878": "koi8r",
      "cskoi8r": "koi8r",
      "cp21866": "koi8u",
      "21866": "koi8u",
      "ibm1168": "koi8u",
      "strk10482002": "rk1048",
      "tcvn5712": "tcvn",
      "tcvn57121": "tcvn",
      "gb198880": "iso646cn",
      "cn": "iso646cn",
      "csiso14jisc6220ro": "iso646jp",
      "jisc62201969ro": "iso646jp",
      "jp": "iso646jp",
      "cshproman8": "hproman8",
      "r8": "hproman8",
      "roman8": "hproman8",
      "xroman8": "hproman8",
      "ibm1051": "hproman8",
      "mac": "macintosh",
      "csmacintosh": "macintosh"
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/sbcs-data-generated.js
var require_sbcs_data_generated = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/sbcs-data-generated.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      "437": "cp437",
      "737": "cp737",
      "775": "cp775",
      "850": "cp850",
      "852": "cp852",
      "855": "cp855",
      "856": "cp856",
      "857": "cp857",
      "858": "cp858",
      "860": "cp860",
      "861": "cp861",
      "862": "cp862",
      "863": "cp863",
      "864": "cp864",
      "865": "cp865",
      "866": "cp866",
      "869": "cp869",
      "874": "windows874",
      "922": "cp922",
      "1046": "cp1046",
      "1124": "cp1124",
      "1125": "cp1125",
      "1129": "cp1129",
      "1133": "cp1133",
      "1161": "cp1161",
      "1162": "cp1162",
      "1163": "cp1163",
      "1250": "windows1250",
      "1251": "windows1251",
      "1252": "windows1252",
      "1253": "windows1253",
      "1254": "windows1254",
      "1255": "windows1255",
      "1256": "windows1256",
      "1257": "windows1257",
      "1258": "windows1258",
      "28591": "iso88591",
      "28592": "iso88592",
      "28593": "iso88593",
      "28594": "iso88594",
      "28595": "iso88595",
      "28596": "iso88596",
      "28597": "iso88597",
      "28598": "iso88598",
      "28599": "iso88599",
      "28600": "iso885910",
      "28601": "iso885911",
      "28603": "iso885913",
      "28604": "iso885914",
      "28605": "iso885915",
      "28606": "iso885916",
      "windows874": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\uFFFD\uFFFD\uFFFD\u2026\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "win874": "windows874",
      "cp874": "windows874",
      "windows1250": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\u0160\u2039\u015A\u0164\u017D\u0179\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0161\u203A\u015B\u0165\u017E\u017A\xA0\u02C7\u02D8\u0141\xA4\u0104\xA6\xA7\xA8\xA9\u015E\xAB\xAC\xAD\xAE\u017B\xB0\xB1\u02DB\u0142\xB4\xB5\xB6\xB7\xB8\u0105\u015F\xBB\u013D\u02DD\u013E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
      },
      "win1250": "windows1250",
      "cp1250": "windows1250",
      "windows1251": {
        "type": "_sbcs",
        "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u040C\u040B\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u045C\u045B\u045F\xA0\u040E\u045E\u0408\xA4\u0490\xA6\xA7\u0401\xA9\u0404\xAB\xAC\xAD\xAE\u0407\xB0\xB1\u0406\u0456\u0491\xB5\xB6\xB7\u0451\u2116\u0454\xBB\u0458\u0405\u0455\u0457\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "win1251": "windows1251",
      "cp1251": "windows1251",
      "windows1252": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\u017D\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\u017E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "win1252": "windows1252",
      "cp1252": "windows1252",
      "windows1253": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\u0385\u0386\xA3\xA4\xA5\xA6\xA7\xA8\xA9\uFFFD\xAB\xAC\xAD\xAE\u2015\xB0\xB1\xB2\xB3\u0384\xB5\xB6\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
      },
      "win1253": "windows1253",
      "cp1253": "windows1253",
      "windows1254": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
      },
      "win1254": "windows1254",
      "cp1254": "windows1254",
      "windows1255": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\xA0\xA1\xA2\xA3\u20AA\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\xBF\u05B0\u05B1\u05B2\u05B3\u05B4\u05B5\u05B6\u05B7\u05B8\u05B9\u05BA\u05BB\u05BC\u05BD\u05BE\u05BF\u05C0\u05C1\u05C2\u05C3\u05F0\u05F1\u05F2\u05F3\u05F4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
      },
      "win1255": "windows1255",
      "cp1255": "windows1255",
      "windows1256": {
        "type": "_sbcs",
        "chars": "\u20AC\u067E\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0679\u2039\u0152\u0686\u0698\u0688\u06AF\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u06A9\u2122\u0691\u203A\u0153\u200C\u200D\u06BA\xA0\u060C\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\u06BE\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\u061B\xBB\xBC\xBD\xBE\u061F\u06C1\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\xD7\u0637\u0638\u0639\u063A\u0640\u0641\u0642\u0643\xE0\u0644\xE2\u0645\u0646\u0647\u0648\xE7\xE8\xE9\xEA\xEB\u0649\u064A\xEE\xEF\u064B\u064C\u064D\u064E\xF4\u064F\u0650\xF7\u0651\xF9\u0652\xFB\xFC\u200E\u200F\u06D2"
      },
      "win1256": "windows1256",
      "cp1256": "windows1256",
      "windows1257": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\uFFFD\u201E\u2026\u2020\u2021\uFFFD\u2030\uFFFD\u2039\uFFFD\xA8\u02C7\xB8\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\xAF\u02DB\uFFFD\xA0\uFFFD\xA2\xA3\xA4\uFFFD\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u02D9"
      },
      "win1257": "windows1257",
      "cp1257": "windows1257",
      "windows1258": {
        "type": "_sbcs",
        "chars": "\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\uFFFD\u2039\u0152\uFFFD\uFFFD\uFFFD\uFFFD\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\uFFFD\u203A\u0153\uFFFD\uFFFD\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "win1258": "windows1258",
      "cp1258": "windows1258",
      "iso88591": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "cp28591": "iso88591",
      "iso88592": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u02D8\u0141\xA4\u013D\u015A\xA7\xA8\u0160\u015E\u0164\u0179\xAD\u017D\u017B\xB0\u0105\u02DB\u0142\xB4\u013E\u015B\u02C7\xB8\u0161\u015F\u0165\u017A\u02DD\u017E\u017C\u0154\xC1\xC2\u0102\xC4\u0139\u0106\xC7\u010C\xC9\u0118\xCB\u011A\xCD\xCE\u010E\u0110\u0143\u0147\xD3\xD4\u0150\xD6\xD7\u0158\u016E\xDA\u0170\xDC\xDD\u0162\xDF\u0155\xE1\xE2\u0103\xE4\u013A\u0107\xE7\u010D\xE9\u0119\xEB\u011B\xED\xEE\u010F\u0111\u0144\u0148\xF3\xF4\u0151\xF6\xF7\u0159\u016F\xFA\u0171\xFC\xFD\u0163\u02D9"
      },
      "cp28592": "iso88592",
      "iso88593": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0126\u02D8\xA3\xA4\uFFFD\u0124\xA7\xA8\u0130\u015E\u011E\u0134\xAD\uFFFD\u017B\xB0\u0127\xB2\xB3\xB4\xB5\u0125\xB7\xB8\u0131\u015F\u011F\u0135\xBD\uFFFD\u017C\xC0\xC1\xC2\uFFFD\xC4\u010A\u0108\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\uFFFD\xD1\xD2\xD3\xD4\u0120\xD6\xD7\u011C\xD9\xDA\xDB\xDC\u016C\u015C\xDF\xE0\xE1\xE2\uFFFD\xE4\u010B\u0109\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\uFFFD\xF1\xF2\xF3\xF4\u0121\xF6\xF7\u011D\xF9\xFA\xFB\xFC\u016D\u015D\u02D9"
      },
      "cp28593": "iso88593",
      "iso88594": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0138\u0156\xA4\u0128\u013B\xA7\xA8\u0160\u0112\u0122\u0166\xAD\u017D\xAF\xB0\u0105\u02DB\u0157\xB4\u0129\u013C\u02C7\xB8\u0161\u0113\u0123\u0167\u014A\u017E\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\u012A\u0110\u0145\u014C\u0136\xD4\xD5\xD6\xD7\xD8\u0172\xDA\xDB\xDC\u0168\u016A\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\u012B\u0111\u0146\u014D\u0137\xF4\xF5\xF6\xF7\xF8\u0173\xFA\xFB\xFC\u0169\u016B\u02D9"
      },
      "cp28594": "iso88594",
      "iso88595": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0403\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0453\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
      },
      "cp28595": "iso88595",
      "iso88596": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\uFFFD\uFFFD\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u060C\xAD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u061B\uFFFD\uFFFD\uFFFD\u061F\uFFFD\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\u0638\u0639\u063A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "cp28596": "iso88596",
      "iso88597": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u2018\u2019\xA3\u20AC\u20AF\xA6\xA7\xA8\xA9\u037A\xAB\xAC\xAD\uFFFD\u2015\xB0\xB1\xB2\xB3\u0384\u0385\u0386\xB7\u0388\u0389\u038A\xBB\u038C\xBD\u038E\u038F\u0390\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\uFFFD\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03AA\u03AB\u03AC\u03AD\u03AE\u03AF\u03B0\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C2\u03C3\u03C4\u03C5\u03C6\u03C7\u03C8\u03C9\u03CA\u03CB\u03CC\u03CD\u03CE\uFFFD"
      },
      "cp28597": "iso88597",
      "iso88598": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xD7\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xF7\xBB\xBC\xBD\xBE\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2017\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\uFFFD\u200E\u200F\uFFFD"
      },
      "cp28598": "iso88598",
      "iso88599": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u011E\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u0130\u015E\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u011F\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u0131\u015F\xFF"
      },
      "cp28599": "iso88599",
      "iso885910": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0112\u0122\u012A\u0128\u0136\xA7\u013B\u0110\u0160\u0166\u017D\xAD\u016A\u014A\xB0\u0105\u0113\u0123\u012B\u0129\u0137\xB7\u013C\u0111\u0161\u0167\u017E\u2015\u016B\u014B\u0100\xC1\xC2\xC3\xC4\xC5\xC6\u012E\u010C\xC9\u0118\xCB\u0116\xCD\xCE\xCF\xD0\u0145\u014C\xD3\xD4\xD5\xD6\u0168\xD8\u0172\xDA\xDB\xDC\xDD\xDE\xDF\u0101\xE1\xE2\xE3\xE4\xE5\xE6\u012F\u010D\xE9\u0119\xEB\u0117\xED\xEE\xEF\xF0\u0146\u014D\xF3\xF4\xF5\xF6\u0169\xF8\u0173\xFA\xFB\xFC\xFD\xFE\u0138"
      },
      "cp28600": "iso885910",
      "iso885911": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "cp28601": "iso885911",
      "iso885913": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u201D\xA2\xA3\xA4\u201E\xA6\xA7\xD8\xA9\u0156\xAB\xAC\xAD\xAE\xC6\xB0\xB1\xB2\xB3\u201C\xB5\xB6\xB7\xF8\xB9\u0157\xBB\xBC\xBD\xBE\xE6\u0104\u012E\u0100\u0106\xC4\xC5\u0118\u0112\u010C\xC9\u0179\u0116\u0122\u0136\u012A\u013B\u0160\u0143\u0145\xD3\u014C\xD5\xD6\xD7\u0172\u0141\u015A\u016A\xDC\u017B\u017D\xDF\u0105\u012F\u0101\u0107\xE4\xE5\u0119\u0113\u010D\xE9\u017A\u0117\u0123\u0137\u012B\u013C\u0161\u0144\u0146\xF3\u014D\xF5\xF6\xF7\u0173\u0142\u015B\u016B\xFC\u017C\u017E\u2019"
      },
      "cp28603": "iso885913",
      "iso885914": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u1E02\u1E03\xA3\u010A\u010B\u1E0A\xA7\u1E80\xA9\u1E82\u1E0B\u1EF2\xAD\xAE\u0178\u1E1E\u1E1F\u0120\u0121\u1E40\u1E41\xB6\u1E56\u1E81\u1E57\u1E83\u1E60\u1EF3\u1E84\u1E85\u1E61\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0174\xD1\xD2\xD3\xD4\xD5\xD6\u1E6A\xD8\xD9\xDA\xDB\xDC\xDD\u0176\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0175\xF1\xF2\xF3\xF4\xF5\xF6\u1E6B\xF8\xF9\xFA\xFB\xFC\xFD\u0177\xFF"
      },
      "cp28604": "iso885914",
      "iso885915": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\u0160\xA7\u0161\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u017D\xB5\xB6\xB7\u017E\xB9\xBA\xBB\u0152\u0153\u0178\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\xD0\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\xDE\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "cp28605": "iso885915",
      "iso885916": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0104\u0105\u0141\u20AC\u201E\u0160\xA7\u0161\xA9\u0218\xAB\u0179\xAD\u017A\u017B\xB0\xB1\u010C\u0142\u017D\u201D\xB6\xB7\u017E\u010D\u0219\xBB\u0152\u0153\u0178\u017C\xC0\xC1\xC2\u0102\xC4\u0106\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0110\u0143\xD2\xD3\xD4\u0150\xD6\u015A\u0170\xD9\xDA\xDB\xDC\u0118\u021A\xDF\xE0\xE1\xE2\u0103\xE4\u0107\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0111\u0144\xF2\xF3\xF4\u0151\xF6\u015B\u0171\xF9\xFA\xFB\xFC\u0119\u021B\xFF"
      },
      "cp28606": "iso885916",
      "cp437": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm437": "cp437",
      "csibm437": "cp437",
      "cp737": {
        "type": "_sbcs",
        "chars": "\u0391\u0392\u0393\u0394\u0395\u0396\u0397\u0398\u0399\u039A\u039B\u039C\u039D\u039E\u039F\u03A0\u03A1\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u03B4\u03B5\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u03C5\u03C6\u03C7\u03C8\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03C9\u03AC\u03AD\u03AE\u03CA\u03AF\u03CC\u03CD\u03CB\u03CE\u0386\u0388\u0389\u038A\u038C\u038E\u038F\xB1\u2265\u2264\u03AA\u03AB\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm737": "cp737",
      "csibm737": "cp737",
      "cp775": {
        "type": "_sbcs",
        "chars": "\u0106\xFC\xE9\u0101\xE4\u0123\xE5\u0107\u0142\u0113\u0156\u0157\u012B\u0179\xC4\xC5\xC9\xE6\xC6\u014D\xF6\u0122\xA2\u015A\u015B\xD6\xDC\xF8\xA3\xD8\xD7\xA4\u0100\u012A\xF3\u017B\u017C\u017A\u201D\xA6\xA9\xAE\xAC\xBD\xBC\u0141\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0104\u010C\u0118\u0116\u2563\u2551\u2557\u255D\u012E\u0160\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0172\u016A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u017D\u0105\u010D\u0119\u0117\u012F\u0161\u0173\u016B\u017E\u2518\u250C\u2588\u2584\u258C\u2590\u2580\xD3\xDF\u014C\u0143\xF5\xD5\xB5\u0144\u0136\u0137\u013B\u013C\u0146\u0112\u0145\u2019\xAD\xB1\u201C\xBE\xB6\xA7\xF7\u201E\xB0\u2219\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm775": "cp775",
      "csibm775": "cp775",
      "cp850": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u0131\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm850": "cp850",
      "csibm850": "cp850",
      "cp852": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\u016F\u0107\xE7\u0142\xEB\u0150\u0151\xEE\u0179\xC4\u0106\xC9\u0139\u013A\xF4\xF6\u013D\u013E\u015A\u015B\xD6\xDC\u0164\u0165\u0141\xD7\u010D\xE1\xED\xF3\xFA\u0104\u0105\u017D\u017E\u0118\u0119\xAC\u017A\u010C\u015F\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\u011A\u015E\u2563\u2551\u2557\u255D\u017B\u017C\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u0102\u0103\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u0111\u0110\u010E\xCB\u010F\u0147\xCD\xCE\u011B\u2518\u250C\u2588\u2584\u0162\u016E\u2580\xD3\xDF\xD4\u0143\u0144\u0148\u0160\u0161\u0154\xDA\u0155\u0170\xFD\xDD\u0163\xB4\xAD\u02DD\u02DB\u02C7\u02D8\xA7\xF7\xB8\xB0\xA8\u02D9\u0171\u0158\u0159\u25A0\xA0"
      },
      "ibm852": "cp852",
      "csibm852": "cp852",
      "cp855": {
        "type": "_sbcs",
        "chars": "\u0452\u0402\u0453\u0403\u0451\u0401\u0454\u0404\u0455\u0405\u0456\u0406\u0457\u0407\u0458\u0408\u0459\u0409\u045A\u040A\u045B\u040B\u045C\u040C\u045E\u040E\u045F\u040F\u044E\u042E\u044A\u042A\u0430\u0410\u0431\u0411\u0446\u0426\u0434\u0414\u0435\u0415\u0444\u0424\u0433\u0413\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u0445\u0425\u0438\u0418\u2563\u2551\u2557\u255D\u0439\u0419\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u043A\u041A\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\u043B\u041B\u043C\u041C\u043D\u041D\u043E\u041E\u043F\u2518\u250C\u2588\u2584\u041F\u044F\u2580\u042F\u0440\u0420\u0441\u0421\u0442\u0422\u0443\u0423\u0436\u0416\u0432\u0412\u044C\u042C\u2116\xAD\u044B\u042B\u0437\u0417\u0448\u0428\u044D\u042D\u0449\u0429\u0447\u0427\xA7\u25A0\xA0"
      },
      "ibm855": "cp855",
      "csibm855": "cp855",
      "cp856": {
        "type": "_sbcs",
        "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\uFFFD\xA3\uFFFD\xD7\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAE\xAC\xBD\xBC\uFFFD\xAB\xBB\u2591\u2592\u2593\u2502\u2524\uFFFD\uFFFD\uFFFD\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\uFFFD\uFFFD\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u2518\u250C\u2588\u2584\xA6\uFFFD\u2580\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xB5\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm856": "cp856",
      "csibm856": "cp856",
      "cp857": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\u0131\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\u0130\xD6\xDC\xF8\xA3\xD8\u015E\u015F\xE1\xED\xF3\xFA\xF1\xD1\u011E\u011F\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xBA\xAA\xCA\xCB\xC8\uFFFD\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\uFFFD\xD7\xDA\xDB\xD9\xEC\xFF\xAF\xB4\xAD\xB1\uFFFD\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm857": "cp857",
      "csibm857": "cp857",
      "cp858": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\xD7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xAE\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\xC1\xC2\xC0\xA9\u2563\u2551\u2557\u255D\xA2\xA5\u2510\u2514\u2534\u252C\u251C\u2500\u253C\xE3\xC3\u255A\u2554\u2569\u2566\u2560\u2550\u256C\xA4\xF0\xD0\xCA\xCB\xC8\u20AC\xCD\xCE\xCF\u2518\u250C\u2588\u2584\xA6\xCC\u2580\xD3\xDF\xD4\xD2\xF5\xD5\xB5\xFE\xDE\xDA\xDB\xD9\xFD\xDD\xAF\xB4\xAD\xB1\u2017\xBE\xB6\xA7\xF7\xB8\xB0\xA8\xB7\xB9\xB3\xB2\u25A0\xA0"
      },
      "ibm858": "cp858",
      "csibm858": "cp858",
      "cp860": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE3\xE0\xC1\xE7\xEA\xCA\xE8\xCD\xD4\xEC\xC3\xC2\xC9\xC0\xC8\xF4\xF5\xF2\xDA\xF9\xCC\xD5\xDC\xA2\xA3\xD9\u20A7\xD3\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\xD2\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm860": "cp860",
      "csibm860": "cp860",
      "cp861": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xD0\xF0\xDE\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xFE\xFB\xDD\xFD\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xC1\xCD\xD3\xDA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm861": "cp861",
      "csibm861": "cp861",
      "cp862": {
        "type": "_sbcs",
        "chars": "\u05D0\u05D1\u05D2\u05D3\u05D4\u05D5\u05D6\u05D7\u05D8\u05D9\u05DA\u05DB\u05DC\u05DD\u05DE\u05DF\u05E0\u05E1\u05E2\u05E3\u05E4\u05E5\u05E6\u05E7\u05E8\u05E9\u05EA\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm862": "cp862",
      "csibm862": "cp862",
      "cp863": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xC2\xE0\xB6\xE7\xEA\xEB\xE8\xEF\xEE\u2017\xC0\xA7\xC9\xC8\xCA\xF4\xCB\xCF\xFB\xF9\xA4\xD4\xDC\xA2\xA3\xD9\xDB\u0192\xA6\xB4\xF3\xFA\xA8\xB8\xB3\xAF\xCE\u2310\xAC\xBD\xBC\xBE\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm863": "cp863",
      "csibm863": "cp863",
      "cp864": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#$\u066A&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xB0\xB7\u2219\u221A\u2592\u2500\u2502\u253C\u2524\u252C\u251C\u2534\u2510\u250C\u2514\u2518\u03B2\u221E\u03C6\xB1\xBD\xBC\u2248\xAB\xBB\uFEF7\uFEF8\uFFFD\uFFFD\uFEFB\uFEFC\uFFFD\xA0\xAD\uFE82\xA3\xA4\uFE84\uFFFD\uFFFD\uFE8E\uFE8F\uFE95\uFE99\u060C\uFE9D\uFEA1\uFEA5\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFED1\u061B\uFEB1\uFEB5\uFEB9\u061F\xA2\uFE80\uFE81\uFE83\uFE85\uFECA\uFE8B\uFE8D\uFE91\uFE93\uFE97\uFE9B\uFE9F\uFEA3\uFEA7\uFEA9\uFEAB\uFEAD\uFEAF\uFEB3\uFEB7\uFEBB\uFEBF\uFEC1\uFEC5\uFECB\uFECF\xA6\xAC\xF7\xD7\uFEC9\u0640\uFED3\uFED7\uFEDB\uFEDF\uFEE3\uFEE7\uFEEB\uFEED\uFEEF\uFEF3\uFEBD\uFECC\uFECE\uFECD\uFEE1\uFE7D\u0651\uFEE5\uFEE9\uFEEC\uFEF0\uFEF2\uFED0\uFED5\uFEF5\uFEF6\uFEDD\uFED9\uFEF1\u25A0\uFFFD"
      },
      "ibm864": "cp864",
      "csibm864": "cp864",
      "cp865": {
        "type": "_sbcs",
        "chars": "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xF8\xA3\xD8\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xA4\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0"
      },
      "ibm865": "cp865",
      "csibm865": "cp865",
      "cp866": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0404\u0454\u0407\u0457\u040E\u045E\xB0\u2219\xB7\u221A\u2116\xA4\u25A0\xA0"
      },
      "ibm866": "cp866",
      "csibm866": "cp866",
      "cp869": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0386\uFFFD\xB7\xAC\xA6\u2018\u2019\u0388\u2015\u0389\u038A\u03AA\u038C\uFFFD\uFFFD\u038E\u03AB\xA9\u038F\xB2\xB3\u03AC\xA3\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03CD\u0391\u0392\u0393\u0394\u0395\u0396\u0397\xBD\u0398\u0399\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u039A\u039B\u039C\u039D\u2563\u2551\u2557\u255D\u039E\u039F\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u03A0\u03A1\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u03A3\u03A4\u03A5\u03A6\u03A7\u03A8\u03A9\u03B1\u03B2\u03B3\u2518\u250C\u2588\u2584\u03B4\u03B5\u2580\u03B6\u03B7\u03B8\u03B9\u03BA\u03BB\u03BC\u03BD\u03BE\u03BF\u03C0\u03C1\u03C3\u03C2\u03C4\u0384\xAD\xB1\u03C5\u03C6\u03C7\xA7\u03C8\u0385\xB0\xA8\u03C9\u03CB\u03B0\u03CE\u25A0\xA0"
      },
      "ibm869": "cp869",
      "csibm869": "cp869",
      "cp922": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\u203E\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\xC3\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\xCC\xCD\xCE\xCF\u0160\xD1\xD2\xD3\xD4\xD5\xD6\xD7\xD8\xD9\xDA\xDB\xDC\xDD\u017D\xDF\xE0\xE1\xE2\xE3\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\u0161\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\u017E\xFF"
      },
      "ibm922": "cp922",
      "csibm922": "cp922",
      "cp1046": {
        "type": "_sbcs",
        "chars": "\uFE88\xD7\xF7\uF8F6\uF8F5\uF8F4\uF8F7\uFE71\x88\u25A0\u2502\u2500\u2510\u250C\u2514\u2518\uFE79\uFE7B\uFE7D\uFE7F\uFE77\uFE8A\uFEF0\uFEF3\uFEF2\uFECE\uFECF\uFED0\uFEF6\uFEF8\uFEFA\uFEFC\xA0\uF8FA\uF8F9\uF8F8\xA4\uF8FB\uFE8B\uFE91\uFE97\uFE9B\uFE9F\uFEA3\u060C\xAD\uFEA7\uFEB3\u0660\u0661\u0662\u0663\u0664\u0665\u0666\u0667\u0668\u0669\uFEB7\u061B\uFEBB\uFEBF\uFECA\u061F\uFECB\u0621\u0622\u0623\u0624\u0625\u0626\u0627\u0628\u0629\u062A\u062B\u062C\u062D\u062E\u062F\u0630\u0631\u0632\u0633\u0634\u0635\u0636\u0637\uFEC7\u0639\u063A\uFECC\uFE82\uFE84\uFE8E\uFED3\u0640\u0641\u0642\u0643\u0644\u0645\u0646\u0647\u0648\u0649\u064A\u064B\u064C\u064D\u064E\u064F\u0650\u0651\u0652\uFED7\uFEDB\uFEDF\uF8FC\uFEF5\uFEF7\uFEF9\uFEFB\uFEE3\uFEE7\uFEEC\uFEE9\uFFFD"
      },
      "ibm1046": "cp1046",
      "csibm1046": "cp1046",
      "cp1124": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0401\u0402\u0490\u0404\u0405\u0406\u0407\u0408\u0409\u040A\u040B\u040C\xAD\u040E\u040F\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u2116\u0451\u0452\u0491\u0454\u0455\u0456\u0457\u0458\u0459\u045A\u045B\u045C\xA7\u045E\u045F"
      },
      "ibm1124": "cp1124",
      "csibm1124": "cp1124",
      "cp1125": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F\u0401\u0451\u0490\u0491\u0404\u0454\u0406\u0456\u0407\u0457\xB7\u221A\u2116\xA4\u25A0\xA0"
      },
      "ibm1125": "cp1125",
      "csibm1125": "cp1125",
      "cp1129": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "ibm1129": "cp1129",
      "csibm1129": "cp1129",
      "cp1133": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E81\u0E82\u0E84\u0E87\u0E88\u0EAA\u0E8A\u0E8D\u0E94\u0E95\u0E96\u0E97\u0E99\u0E9A\u0E9B\u0E9C\u0E9D\u0E9E\u0E9F\u0EA1\u0EA2\u0EA3\u0EA5\u0EA7\u0EAB\u0EAD\u0EAE\uFFFD\uFFFD\uFFFD\u0EAF\u0EB0\u0EB2\u0EB3\u0EB4\u0EB5\u0EB6\u0EB7\u0EB8\u0EB9\u0EBC\u0EB1\u0EBB\u0EBD\uFFFD\uFFFD\uFFFD\u0EC0\u0EC1\u0EC2\u0EC3\u0EC4\u0EC8\u0EC9\u0ECA\u0ECB\u0ECC\u0ECD\u0EC6\uFFFD\u0EDC\u0EDD\u20AD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0ED0\u0ED1\u0ED2\u0ED3\u0ED4\u0ED5\u0ED6\u0ED7\u0ED8\u0ED9\uFFFD\uFFFD\xA2\xAC\xA6\uFFFD"
      },
      "ibm1133": "cp1133",
      "csibm1133": "cp1133",
      "cp1161": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E48\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\u0E49\u0E4A\u0E4B\u20AC\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\xA2\xAC\xA6\xA0"
      },
      "ibm1161": "cp1161",
      "csibm1161": "cp1161",
      "cp1162": {
        "type": "_sbcs",
        "chars": "\u20AC\x81\x82\x83\x84\u2026\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "ibm1162": "cp1162",
      "csibm1162": "cp1162",
      "cp1163": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xA1\xA2\xA3\u20AC\xA5\xA6\xA7\u0153\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\u0178\xB5\xB6\xB7\u0152\xB9\xBA\xBB\xBC\xBD\xBE\xBF\xC0\xC1\xC2\u0102\xC4\xC5\xC6\xC7\xC8\xC9\xCA\xCB\u0300\xCD\xCE\xCF\u0110\xD1\u0309\xD3\xD4\u01A0\xD6\xD7\xD8\xD9\xDA\xDB\xDC\u01AF\u0303\xDF\xE0\xE1\xE2\u0103\xE4\xE5\xE6\xE7\xE8\xE9\xEA\xEB\u0301\xED\xEE\xEF\u0111\xF1\u0323\xF3\xF4\u01A1\xF6\xF7\xF8\xF9\xFA\xFB\xFC\u01B0\u20AB\xFF"
      },
      "ibm1163": "cp1163",
      "csibm1163": "cp1163",
      "maccroatian": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\u0160\u2122\xB4\xA8\u2260\u017D\xD8\u221E\xB1\u2264\u2265\u2206\xB5\u2202\u2211\u220F\u0161\u222B\xAA\xBA\u2126\u017E\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u0106\xAB\u010C\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u0110\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\uFFFD\xA9\u2044\xA4\u2039\u203A\xC6\xBB\u2013\xB7\u201A\u201E\u2030\xC2\u0107\xC1\u010D\xC8\xCD\xCE\xCF\xCC\xD3\xD4\u0111\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u03C0\xCB\u02DA\xB8\xCA\xE6\u02C7"
      },
      "maccyrillic": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\xA2\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u2202\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
      },
      "macgreek": {
        "type": "_sbcs",
        "chars": "\xC4\xB9\xB2\xC9\xB3\xD6\xDC\u0385\xE0\xE2\xE4\u0384\xA8\xE7\xE9\xE8\xEA\xEB\xA3\u2122\xEE\xEF\u2022\xBD\u2030\xF4\xF6\xA6\xAD\xF9\xFB\xFC\u2020\u0393\u0394\u0398\u039B\u039E\u03A0\xDF\xAE\xA9\u03A3\u03AA\xA7\u2260\xB0\u0387\u0391\xB1\u2264\u2265\xA5\u0392\u0395\u0396\u0397\u0399\u039A\u039C\u03A6\u03AB\u03A8\u03A9\u03AC\u039D\xAC\u039F\u03A1\u2248\u03A4\xAB\xBB\u2026\xA0\u03A5\u03A7\u0386\u0388\u0153\u2013\u2015\u201C\u201D\u2018\u2019\xF7\u0389\u038A\u038C\u038E\u03AD\u03AE\u03AF\u03CC\u038F\u03CD\u03B1\u03B2\u03C8\u03B4\u03B5\u03C6\u03B3\u03B7\u03B9\u03BE\u03BA\u03BB\u03BC\u03BD\u03BF\u03C0\u03CE\u03C1\u03C3\u03C4\u03B8\u03C9\u03C2\u03C7\u03C5\u03B6\u03CA\u03CB\u0390\u03B0\uFFFD"
      },
      "maciceland": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\xDD\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\xD0\xF0\xDE\xFE\xFD\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macroman": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macromania": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\u0102\u015E\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\u0103\u015F\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\u0162\u0163\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macthai": {
        "type": "_sbcs",
        "chars": "\xAB\xBB\u2026\uF88C\uF88F\uF892\uF895\uF898\uF88B\uF88E\uF891\uF894\uF897\u201C\u201D\uF899\uFFFD\u2022\uF884\uF889\uF885\uF886\uF887\uF888\uF88A\uF88D\uF890\uF893\uF896\u2018\u2019\uFFFD\xA0\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFEFF\u200B\u2013\u2014\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u2122\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\xAE\xA9\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "macturkish": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u011E\u011F\u0130\u0131\u015E\u015F\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\uFFFD\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "macukraine": {
        "type": "_sbcs",
        "chars": "\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u2020\xB0\u0490\xA3\xA7\u2022\xB6\u0406\xAE\xA9\u2122\u0402\u0452\u2260\u0403\u0453\u221E\xB1\u2264\u2265\u0456\xB5\u0491\u0408\u0404\u0454\u0407\u0457\u0409\u0459\u040A\u045A\u0458\u0405\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\u040B\u045B\u040C\u045C\u0455\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u201E\u040E\u045E\u040F\u045F\u2116\u0401\u0451\u044F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\xA4"
      },
      "koi8r": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u2553\u2554\u2555\u2556\u2557\u2558\u2559\u255A\u255B\u255C\u255D\u255E\u255F\u2560\u2561\u0401\u2562\u2563\u2564\u2565\u2566\u2567\u2568\u2569\u256A\u256B\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8u": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u255D\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u256C\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8ru": {
        "type": "_sbcs",
        "chars": "\u2500\u2502\u250C\u2510\u2514\u2518\u251C\u2524\u252C\u2534\u253C\u2580\u2584\u2588\u258C\u2590\u2591\u2592\u2593\u2320\u25A0\u2219\u221A\u2248\u2264\u2265\xA0\u2321\xB0\xB2\xB7\xF7\u2550\u2551\u2552\u0451\u0454\u2554\u0456\u0457\u2557\u2558\u2559\u255A\u255B\u0491\u045E\u255E\u255F\u2560\u2561\u0401\u0404\u2563\u0406\u0407\u2566\u2567\u2568\u2569\u256A\u0490\u040E\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "koi8t": {
        "type": "_sbcs",
        "chars": "\u049B\u0493\u201A\u0492\u201E\u2026\u2020\u2021\uFFFD\u2030\u04B3\u2039\u04B2\u04B7\u04B6\uFFFD\u049A\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\uFFFD\u203A\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u04EF\u04EE\u0451\xA4\u04E3\xA6\xA7\uFFFD\uFFFD\uFFFD\xAB\xAC\xAD\xAE\uFFFD\xB0\xB1\xB2\u0401\uFFFD\u04E2\xB6\xB7\uFFFD\u2116\uFFFD\xBB\uFFFD\uFFFD\uFFFD\xA9\u044E\u0430\u0431\u0446\u0434\u0435\u0444\u0433\u0445\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u044F\u0440\u0441\u0442\u0443\u0436\u0432\u044C\u044B\u0437\u0448\u044D\u0449\u0447\u044A\u042E\u0410\u0411\u0426\u0414\u0415\u0424\u0413\u0425\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u042F\u0420\u0421\u0422\u0423\u0416\u0412\u042C\u042B\u0417\u0428\u042D\u0429\u0427\u042A"
      },
      "armscii8": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\uFFFD\u0587\u0589)(\xBB\xAB\u2014.\u055D,-\u058A\u2026\u055C\u055B\u055E\u0531\u0561\u0532\u0562\u0533\u0563\u0534\u0564\u0535\u0565\u0536\u0566\u0537\u0567\u0538\u0568\u0539\u0569\u053A\u056A\u053B\u056B\u053C\u056C\u053D\u056D\u053E\u056E\u053F\u056F\u0540\u0570\u0541\u0571\u0542\u0572\u0543\u0573\u0544\u0574\u0545\u0575\u0546\u0576\u0547\u0577\u0548\u0578\u0549\u0579\u054A\u057A\u054B\u057B\u054C\u057C\u054D\u057D\u054E\u057E\u054F\u057F\u0550\u0580\u0551\u0581\u0552\u0582\u0553\u0583\u0554\u0584\u0555\u0585\u0556\u0586\u055A\uFFFD"
      },
      "rk1048": {
        "type": "_sbcs",
        "chars": "\u0402\u0403\u201A\u0453\u201E\u2026\u2020\u2021\u20AC\u2030\u0409\u2039\u040A\u049A\u04BA\u040F\u0452\u2018\u2019\u201C\u201D\u2022\u2013\u2014\uFFFD\u2122\u0459\u203A\u045A\u049B\u04BB\u045F\xA0\u04B0\u04B1\u04D8\xA4\u04E8\xA6\xA7\u0401\xA9\u0492\xAB\xAC\xAD\xAE\u04AE\xB0\xB1\u0406\u0456\u04E9\xB5\xB6\xB7\u0451\u2116\u0493\xBB\u04D9\u04A2\u04A3\u04AF\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "tcvn": {
        "type": "_sbcs",
        "chars": "\0\xDA\u1EE4\u1EEA\u1EEC\u1EEE\x07\b	\n\v\f\r\u1EE8\u1EF0\u1EF2\u1EF6\u1EF8\xDD\u1EF4\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\xC0\u1EA2\xC3\xC1\u1EA0\u1EB6\u1EAC\xC8\u1EBA\u1EBC\xC9\u1EB8\u1EC6\xCC\u1EC8\u0128\xCD\u1ECA\xD2\u1ECE\xD5\xD3\u1ECC\u1ED8\u1EDC\u1EDE\u1EE0\u1EDA\u1EE2\xD9\u1EE6\u0168\xA0\u0102\xC2\xCA\xD4\u01A0\u01AF\u0110\u0103\xE2\xEA\xF4\u01A1\u01B0\u0111\u1EB0\u0300\u0309\u0303\u0301\u0323\xE0\u1EA3\xE3\xE1\u1EA1\u1EB2\u1EB1\u1EB3\u1EB5\u1EAF\u1EB4\u1EAE\u1EA6\u1EA8\u1EAA\u1EA4\u1EC0\u1EB7\u1EA7\u1EA9\u1EAB\u1EA5\u1EAD\xE8\u1EC2\u1EBB\u1EBD\xE9\u1EB9\u1EC1\u1EC3\u1EC5\u1EBF\u1EC7\xEC\u1EC9\u1EC4\u1EBE\u1ED2\u0129\xED\u1ECB\xF2\u1ED4\u1ECF\xF5\xF3\u1ECD\u1ED3\u1ED5\u1ED7\u1ED1\u1ED9\u1EDD\u1EDF\u1EE1\u1EDB\u1EE3\xF9\u1ED6\u1EE7\u0169\xFA\u1EE5\u1EEB\u1EED\u1EEF\u1EE9\u1EF1\u1EF3\u1EF7\u1EF9\xFD\u1EF5\u1ED0"
      },
      "georgianacademy": {
        "type": "_sbcs",
        "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10EF\u10F0\u10F1\u10F2\u10F3\u10F4\u10F5\u10F6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "georgianps": {
        "type": "_sbcs",
        "chars": "\x80\x81\u201A\u0192\u201E\u2026\u2020\u2021\u02C6\u2030\u0160\u2039\u0152\x8D\x8E\x8F\x90\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u02DC\u2122\u0161\u203A\u0153\x9D\x9E\u0178\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF\u10D0\u10D1\u10D2\u10D3\u10D4\u10D5\u10D6\u10F1\u10D7\u10D8\u10D9\u10DA\u10DB\u10DC\u10F2\u10DD\u10DE\u10DF\u10E0\u10E1\u10E2\u10F3\u10E3\u10E4\u10E5\u10E6\u10E7\u10E8\u10E9\u10EA\u10EB\u10EC\u10ED\u10EE\u10F4\u10EF\u10F0\u10F5\xE6\xE7\xE8\xE9\xEA\xEB\xEC\xED\xEE\xEF\xF0\xF1\xF2\xF3\xF4\xF5\xF6\xF7\xF8\xF9\xFA\xFB\xFC\xFD\xFE\xFF"
      },
      "pt154": {
        "type": "_sbcs",
        "chars": "\u0496\u0492\u04EE\u0493\u201E\u2026\u04B6\u04AE\u04B2\u04AF\u04A0\u04E2\u04A2\u049A\u04BA\u04B8\u0497\u2018\u2019\u201C\u201D\u2022\u2013\u2014\u04B3\u04B7\u04A1\u04E3\u04A3\u049B\u04BB\u04B9\xA0\u040E\u045E\u0408\u04E8\u0498\u04B0\xA7\u0401\xA9\u04D8\xAB\xAC\u04EF\xAE\u049C\xB0\u04B1\u0406\u0456\u0499\u04E9\xB6\xB7\u0451\u2116\u04D9\xBB\u0458\u04AA\u04AB\u049D\u0410\u0411\u0412\u0413\u0414\u0415\u0416\u0417\u0418\u0419\u041A\u041B\u041C\u041D\u041E\u041F\u0420\u0421\u0422\u0423\u0424\u0425\u0426\u0427\u0428\u0429\u042A\u042B\u042C\u042D\u042E\u042F\u0430\u0431\u0432\u0433\u0434\u0435\u0436\u0437\u0438\u0439\u043A\u043B\u043C\u043D\u043E\u043F\u0440\u0441\u0442\u0443\u0444\u0445\u0446\u0447\u0448\u0449\u044A\u044B\u044C\u044D\u044E\u044F"
      },
      "viscii": {
        "type": "_sbcs",
        "chars": "\0
\u1EB2\u1EB4\u1EAA\x07\b	\n\v\f\r\u1EF6\u1EF8\x1B\u1EF4 !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}~\x7F\u1EA0\u1EAE\u1EB0\u1EB6\u1EA4\u1EA6\u1EA8\u1EAC\u1EBC\u1EB8\u1EBE\u1EC0\u1EC2\u1EC4\u1EC6\u1ED0\u1ED2\u1ED4\u1ED6\u1ED8\u1EE2\u1EDA\u1EDC\u1EDE\u1ECA\u1ECE\u1ECC\u1EC8\u1EE6\u0168\u1EE4\u1EF2\xD5\u1EAF\u1EB1\u1EB7\u1EA5\u1EA7\u1EA9\u1EAD\u1EBD\u1EB9\u1EBF\u1EC1\u1EC3\u1EC5\u1EC7\u1ED1\u1ED3\u1ED5\u1ED7\u1EE0\u01A0\u1ED9\u1EDD\u1EDF\u1ECB\u1EF0\u1EE8\u1EEA\u1EEC\u01A1\u1EDB\u01AF\xC0\xC1\xC2\xC3\u1EA2\u0102\u1EB3\u1EB5\xC8\xC9\xCA\u1EBA\xCC\xCD\u0128\u1EF3\u0110\u1EE9\xD2\xD3\xD4\u1EA1\u1EF7\u1EEB\u1EED\xD9\xDA\u1EF9\u1EF5\xDD\u1EE1\u01B0\xE0\xE1\xE2\xE3\u1EA3\u0103\u1EEF\u1EAB\xE8\xE9\xEA\u1EBB\xEC\xED\u0129\u1EC9\u0111\u1EF1\xF2\xF3\xF4\xF5\u1ECF\u1ECD\u1EE5\xF9\xFA\u0169\u1EE7\xFD\u1EE3\u1EEE"
      },
      "iso646cn": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#\xA5%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "iso646jp": {
        "type": "_sbcs",
        "chars": "\0
\x07\b	\n\v\f\r\x1B !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\xA5]^_`abcdefghijklmnopqrstuvwxyz{|}\u203E\x7F\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "hproman8": {
        "type": "_sbcs",
        "chars": "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F\xA0\xC0\xC2\xC8\xCA\xCB\xCE\xCF\xB4\u02CB\u02C6\xA8\u02DC\xD9\xDB\u20A4\xAF\xDD\xFD\xB0\xC7\xE7\xD1\xF1\xA1\xBF\xA4\xA3\xA5\xA7\u0192\xA2\xE2\xEA\xF4\xFB\xE1\xE9\xF3\xFA\xE0\xE8\xF2\xF9\xE4\xEB\xF6\xFC\xC5\xEE\xD8\xC6\xE5\xED\xF8\xE6\xC4\xEC\xD6\xDC\xC9\xEF\xDF\xD4\xC1\xC3\xE3\xD0\xF0\xCD\xCC\xD3\xD2\xD5\xF5\u0160\u0161\xDA\u0178\xFF\xDE\xFE\xB7\xB5\xB6\xBE\u2014\xBC\xBD\xAA\xBA\xAB\u25A0\xBB\xB1\uFFFD"
      },
      "macintosh": {
        "type": "_sbcs",
        "chars": "\xC4\xC5\xC7\xC9\xD1\xD6\xDC\xE1\xE0\xE2\xE4\xE3\xE5\xE7\xE9\xE8\xEA\xEB\xED\xEC\xEE\xEF\xF1\xF3\xF2\xF4\xF6\xF5\xFA\xF9\xFB\xFC\u2020\xB0\xA2\xA3\xA7\u2022\xB6\xDF\xAE\xA9\u2122\xB4\xA8\u2260\xC6\xD8\u221E\xB1\u2264\u2265\xA5\xB5\u2202\u2211\u220F\u03C0\u222B\xAA\xBA\u2126\xE6\xF8\xBF\xA1\xAC\u221A\u0192\u2248\u2206\xAB\xBB\u2026\xA0\xC0\xC3\xD5\u0152\u0153\u2013\u2014\u201C\u201D\u2018\u2019\xF7\u25CA\xFF\u0178\u2044\xA4\u2039\u203A\uFB01\uFB02\u2021\xB7\u201A\u201E\u2030\xC2\xCA\xC1\xCB\xC8\xCD\xCE\xCF\xCC\xD3\xD4\uFFFD\xD2\xDA\xDB\xD9\u0131\u02C6\u02DC\xAF\u02D8\u02D9\u02DA\xB8\u02DD\u02DB\u02C7"
      },
      "ascii": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD"
      },
      "tis620": {
        "type": "_sbcs",
        "chars": "\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\uFFFD\u0E01\u0E02\u0E03\u0E04\u0E05\u0E06\u0E07\u0E08\u0E09\u0E0A\u0E0B\u0E0C\u0E0D\u0E0E\u0E0F\u0E10\u0E11\u0E12\u0E13\u0E14\u0E15\u0E16\u0E17\u0E18\u0E19\u0E1A\u0E1B\u0E1C\u0E1D\u0E1E\u0E1F\u0E20\u0E21\u0E22\u0E23\u0E24\u0E25\u0E26\u0E27\u0E28\u0E29\u0E2A\u0E2B\u0E2C\u0E2D\u0E2E\u0E2F\u0E30\u0E31\u0E32\u0E33\u0E34\u0E35\u0E36\u0E37\u0E38\u0E39\u0E3A\uFFFD\uFFFD\uFFFD\uFFFD\u0E3F\u0E40\u0E41\u0E42\u0E43\u0E44\u0E45\u0E46\u0E47\u0E48\u0E49\u0E4A\u0E4B\u0E4C\u0E4D\u0E4E\u0E4F\u0E50\u0E51\u0E52\u0E53\u0E54\u0E55\u0E56\u0E57\u0E58\u0E59\u0E5A\u0E5B\uFFFD\uFFFD\uFFFD\uFFFD"
      }
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/dbcs-codec.js
var require_dbcs_codec = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/dbcs-codec.js"(exports2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    exports2._dbcs = DBCSCodec;
    var UNASSIGNED = -1;
    var GB18030_CODE = -2;
    var SEQ_START = -10;
    var NODE_START = -1e3;
    var UNASSIGNED_NODE = new Array(256);
    var DEF_CHAR = -1;
    for (i8 = 0; i8 < 256; i8++)
      UNASSIGNED_NODE[i8] = UNASSIGNED;
    var i8;
    function DBCSCodec(codecOptions, iconv) {
      this.encodingName = codecOptions.encodingName;
      if (!codecOptions)
        throw new Error("DBCS codec is called without the data.");
      if (!codecOptions.table)
        throw new Error("Encoding '" + this.encodingName + "' has no data.");
      var mappingTable = codecOptions.table();
      this.decodeTables = [];
      this.decodeTables[0] = UNASSIGNED_NODE.slice(0);
      this.decodeTableSeq = [];
      for (var i9 = 0; i9 < mappingTable.length; i9++)
        this._addDecodeChunk(mappingTable[i9]);
      if (typeof codecOptions.gb18030 === "function") {
        this.gb18030 = codecOptions.gb18030();
        var commonThirdByteNodeIdx = this.decodeTables.length;
        this.decodeTables.push(UNASSIGNED_NODE.slice(0));
        var commonFourthByteNodeIdx = this.decodeTables.length;
        this.decodeTables.push(UNASSIGNED_NODE.slice(0));
        var firstByteNode = this.decodeTables[0];
        for (var i9 = 129; i9 <= 254; i9++) {
          var secondByteNode = this.decodeTables[NODE_START - firstByteNode[i9]];
          for (var j7 = 48; j7 <= 57; j7++) {
            if (secondByteNode[j7] === UNASSIGNED) {
              secondByteNode[j7] = NODE_START - commonThirdByteNodeIdx;
            } else if (secondByteNode[j7] > NODE_START) {
              throw new Error("gb18030 decode tables conflict at byte 2");
            }
            var thirdByteNode = this.decodeTables[NODE_START - secondByteNode[j7]];
            for (var k9 = 129; k9 <= 254; k9++) {
              if (thirdByteNode[k9] === UNASSIGNED) {
                thirdByteNode[k9] = NODE_START - commonFourthByteNodeIdx;
              } else if (thirdByteNode[k9] === NODE_START - commonFourthByteNodeIdx) {
                continue;
              } else if (thirdByteNode[k9] > NODE_START) {
                throw new Error("gb18030 decode tables conflict at byte 3");
              }
              var fourthByteNode = this.decodeTables[NODE_START - thirdByteNode[k9]];
              for (var l7 = 48; l7 <= 57; l7++) {
                if (fourthByteNode[l7] === UNASSIGNED)
                  fourthByteNode[l7] = GB18030_CODE;
              }
            }
          }
        }
      }
      this.defaultCharUnicode = iconv.defaultCharUnicode;
      this.encodeTable = [];
      this.encodeTableSeq = [];
      var skipEncodeChars = {};
      if (codecOptions.encodeSkipVals)
        for (var i9 = 0; i9 < codecOptions.encodeSkipVals.length; i9++) {
          var val2 = codecOptions.encodeSkipVals[i9];
          if (typeof val2 === "number")
            skipEncodeChars[val2] = true;
          else
            for (var j7 = val2.from; j7 <= val2.to; j7++)
              skipEncodeChars[j7] = true;
        }
      this._fillEncodeTable(0, 0, skipEncodeChars);
      if (codecOptions.encodeAdd) {
        for (var uChar in codecOptions.encodeAdd)
          if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar))
            this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);
      }
      this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];
      if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
      if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0);
    }
    DBCSCodec.prototype.encoder = DBCSEncoder;
    DBCSCodec.prototype.decoder = DBCSDecoder;
    DBCSCodec.prototype._getDecodeTrieNode = function(addr2) {
      var bytes2 = [];
      for (; addr2 > 0; addr2 >>>= 8)
        bytes2.push(addr2 & 255);
      if (bytes2.length == 0)
        bytes2.push(0);
      var node = this.decodeTables[0];
      for (var i9 = bytes2.length - 1; i9 > 0; i9--) {
        var val2 = node[bytes2[i9]];
        if (val2 == UNASSIGNED) {
          node[bytes2[i9]] = NODE_START - this.decodeTables.length;
          this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
        } else if (val2 <= NODE_START) {
          node = this.decodeTables[NODE_START - val2];
        } else
          throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr2.toString(16));
      }
      return node;
    };
    DBCSCodec.prototype._addDecodeChunk = function(chunk) {
      var curAddr = parseInt(chunk[0], 16);
      var writeTable = this._getDecodeTrieNode(curAddr);
      curAddr = curAddr & 255;
      for (var k9 = 1; k9 < chunk.length; k9++) {
        var part = chunk[k9];
        if (typeof part === "string") {
          for (var l7 = 0; l7 < part.length; ) {
            var code = part.charCodeAt(l7++);
            if (55296 <= code && code < 56320) {
              var codeTrail = part.charCodeAt(l7++);
              if (56320 <= codeTrail && codeTrail < 57344)
                writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);
              else
                throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]);
            } else if (4080 < code && code <= 4095) {
              var len = 4095 - code + 2;
              var seq = [];
              for (var m12 = 0; m12 < len; m12++)
                seq.push(part.charCodeAt(l7++));
              writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;
              this.decodeTableSeq.push(seq);
            } else
              writeTable[curAddr++] = code;
          }
        } else if (typeof part === "number") {
          var charCode = writeTable[curAddr - 1] + 1;
          for (var l7 = 0; l7 < part; l7++)
            writeTable[curAddr++] = charCode++;
        } else
          throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]);
      }
      if (curAddr > 255)
        throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr);
    };
    DBCSCodec.prototype._getEncodeBucket = function(uCode) {
      var high = uCode >> 8;
      if (this.encodeTable[high] === void 0)
        this.encodeTable[high] = UNASSIGNED_NODE.slice(0);
      return this.encodeTable[high];
    };
    DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {
      var bucket = this._getEncodeBucket(uCode);
      var low = uCode & 255;
      if (bucket[low] <= SEQ_START)
        this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;
      else if (bucket[low] == UNASSIGNED)
        bucket[low] = dbcsCode;
    };
    DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {
      var uCode = seq[0];
      var bucket = this._getEncodeBucket(uCode);
      var low = uCode & 255;
      var node;
      if (bucket[low] <= SEQ_START) {
        node = this.encodeTableSeq[SEQ_START - bucket[low]];
      } else {
        node = {};
        if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low];
        bucket[low] = SEQ_START - this.encodeTableSeq.length;
        this.encodeTableSeq.push(node);
      }
      for (var j7 = 1; j7 < seq.length - 1; j7++) {
        var oldVal = node[uCode];
        if (typeof oldVal === "object")
          node = oldVal;
        else {
          node = node[uCode] = {};
          if (oldVal !== void 0)
            node[DEF_CHAR] = oldVal;
        }
      }
      uCode = seq[seq.length - 1];
      node[uCode] = dbcsCode;
    };
    DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix2, skipEncodeChars) {
      var node = this.decodeTables[nodeIdx];
      var hasValues = false;
      var subNodeEmpty = {};
      for (var i9 = 0; i9 < 256; i9++) {
        var uCode = node[i9];
        var mbCode = prefix2 + i9;
        if (skipEncodeChars[mbCode])
          continue;
        if (uCode >= 0) {
          this._setEncodeChar(uCode, mbCode);
          hasValues = true;
        } else if (uCode <= NODE_START) {
          var subNodeIdx = NODE_START - uCode;
          if (!subNodeEmpty[subNodeIdx]) {
            var newPrefix = mbCode << 8 >>> 0;
            if (this._fillEncodeTable(subNodeIdx, newPrefix, skipEncodeChars))
              hasValues = true;
            else
              subNodeEmpty[subNodeIdx] = true;
          }
        } else if (uCode <= SEQ_START) {
          this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
          hasValues = true;
        }
      }
      return hasValues;
    };
    function DBCSEncoder(options, codec) {
      this.leadSurrogate = -1;
      this.seqObj = void 0;
      this.encodeTable = codec.encodeTable;
      this.encodeTableSeq = codec.encodeTableSeq;
      this.defaultCharSingleByte = codec.defCharSB;
      this.gb18030 = codec.gb18030;
    }
    DBCSEncoder.prototype.write = function(str) {
      var newBuf = Buffer8.alloc(str.length * (this.gb18030 ? 4 : 3)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i9 = 0, j7 = 0;
      while (true) {
        if (nextChar === -1) {
          if (i9 == str.length) break;
          var uCode = str.charCodeAt(i9++);
        } else {
          var uCode = nextChar;
          nextChar = -1;
        }
        if (55296 <= uCode && uCode < 57344) {
          if (uCode < 56320) {
            if (leadSurrogate === -1) {
              leadSurrogate = uCode;
              continue;
            } else {
              leadSurrogate = uCode;
              uCode = UNASSIGNED;
            }
          } else {
            if (leadSurrogate !== -1) {
              uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320);
              leadSurrogate = -1;
            } else {
              uCode = UNASSIGNED;
            }
          }
        } else if (leadSurrogate !== -1) {
          nextChar = uCode;
          uCode = UNASSIGNED;
          leadSurrogate = -1;
        }
        var dbcsCode = UNASSIGNED;
        if (seqObj !== void 0 && uCode != UNASSIGNED) {
          var resCode = seqObj[uCode];
          if (typeof resCode === "object") {
            seqObj = resCode;
            continue;
          } else if (typeof resCode == "number") {
            dbcsCode = resCode;
          } else if (resCode == void 0) {
            resCode = seqObj[DEF_CHAR];
            if (resCode !== void 0) {
              dbcsCode = resCode;
              nextChar = uCode;
            } else {
            }
          }
          seqObj = void 0;
        } else if (uCode >= 0) {
          var subtable = this.encodeTable[uCode >> 8];
          if (subtable !== void 0)
            dbcsCode = subtable[uCode & 255];
          if (dbcsCode <= SEQ_START) {
            seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];
            continue;
          }
          if (dbcsCode == UNASSIGNED && this.gb18030) {
            var idx = findIdx(this.gb18030.uChars, uCode);
            if (idx != -1) {
              var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);
              newBuf[j7++] = 129 + Math.floor(dbcsCode / 12600);
              dbcsCode = dbcsCode % 12600;
              newBuf[j7++] = 48 + Math.floor(dbcsCode / 1260);
              dbcsCode = dbcsCode % 1260;
              newBuf[j7++] = 129 + Math.floor(dbcsCode / 10);
              dbcsCode = dbcsCode % 10;
              newBuf[j7++] = 48 + dbcsCode;
              continue;
            }
          }
        }
        if (dbcsCode === UNASSIGNED)
          dbcsCode = this.defaultCharSingleByte;
        if (dbcsCode < 256) {
          newBuf[j7++] = dbcsCode;
        } else if (dbcsCode < 65536) {
          newBuf[j7++] = dbcsCode >> 8;
          newBuf[j7++] = dbcsCode & 255;
        } else if (dbcsCode < 16777216) {
          newBuf[j7++] = dbcsCode >> 16;
          newBuf[j7++] = dbcsCode >> 8 & 255;
          newBuf[j7++] = dbcsCode & 255;
        } else {
          newBuf[j7++] = dbcsCode >>> 24;
          newBuf[j7++] = dbcsCode >>> 16 & 255;
          newBuf[j7++] = dbcsCode >>> 8 & 255;
          newBuf[j7++] = dbcsCode & 255;
        }
      }
      this.seqObj = seqObj;
      this.leadSurrogate = leadSurrogate;
      return newBuf.slice(0, j7);
    };
    DBCSEncoder.prototype.end = function() {
      if (this.leadSurrogate === -1 && this.seqObj === void 0)
        return;
      var newBuf = Buffer8.alloc(10), j7 = 0;
      if (this.seqObj) {
        var dbcsCode = this.seqObj[DEF_CHAR];
        if (dbcsCode !== void 0) {
          if (dbcsCode < 256) {
            newBuf[j7++] = dbcsCode;
          } else {
            newBuf[j7++] = dbcsCode >> 8;
            newBuf[j7++] = dbcsCode & 255;
          }
        } else {
        }
        this.seqObj = void 0;
      }
      if (this.leadSurrogate !== -1) {
        newBuf[j7++] = this.defaultCharSingleByte;
        this.leadSurrogate = -1;
      }
      return newBuf.slice(0, j7);
    };
    DBCSEncoder.prototype.findIdx = findIdx;
    function DBCSDecoder(options, codec) {
      this.nodeIdx = 0;
      this.prevBytes = [];
      this.decodeTables = codec.decodeTables;
      this.decodeTableSeq = codec.decodeTableSeq;
      this.defaultCharUnicode = codec.defaultCharUnicode;
      this.gb18030 = codec.gb18030;
    }
    DBCSDecoder.prototype.write = function(buf) {
      var newBuf = Buffer8.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBytes = this.prevBytes, prevOffset = this.prevBytes.length, seqStart = -this.prevBytes.length, uCode;
      for (var i9 = 0, j7 = 0; i9 < buf.length; i9++) {
        var curByte = i9 >= 0 ? buf[i9] : prevBytes[i9 + prevOffset];
        var uCode = this.decodeTables[nodeIdx][curByte];
        if (uCode >= 0) {
        } else if (uCode === UNASSIGNED) {
          uCode = this.defaultCharUnicode.charCodeAt(0);
          i9 = seqStart;
        } else if (uCode === GB18030_CODE) {
          if (i9 >= 3) {
            var ptr = (buf[i9 - 3] - 129) * 12600 + (buf[i9 - 2] - 48) * 1260 + (buf[i9 - 1] - 129) * 10 + (curByte - 48);
          } else {
            var ptr = (prevBytes[i9 - 3 + prevOffset] - 129) * 12600 + ((i9 - 2 >= 0 ? buf[i9 - 2] : prevBytes[i9 - 2 + prevOffset]) - 48) * 1260 + ((i9 - 1 >= 0 ? buf[i9 - 1] : prevBytes[i9 - 1 + prevOffset]) - 129) * 10 + (curByte - 48);
          }
          var idx = findIdx(this.gb18030.gbChars, ptr);
          uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx];
        } else if (uCode <= NODE_START) {
          nodeIdx = NODE_START - uCode;
          continue;
        } else if (uCode <= SEQ_START) {
          var seq = this.decodeTableSeq[SEQ_START - uCode];
          for (var k9 = 0; k9 < seq.length - 1; k9++) {
            uCode = seq[k9];
            newBuf[j7++] = uCode & 255;
            newBuf[j7++] = uCode >> 8;
          }
          uCode = seq[seq.length - 1];
        } else
          throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte);
        if (uCode >= 65536) {
          uCode -= 65536;
          var uCodeLead = 55296 | uCode >> 10;
          newBuf[j7++] = uCodeLead & 255;
          newBuf[j7++] = uCodeLead >> 8;
          uCode = 56320 | uCode & 1023;
        }
        newBuf[j7++] = uCode & 255;
        newBuf[j7++] = uCode >> 8;
        nodeIdx = 0;
        seqStart = i9 + 1;
      }
      this.nodeIdx = nodeIdx;
      this.prevBytes = seqStart >= 0 ? Array.prototype.slice.call(buf, seqStart) : prevBytes.slice(seqStart + prevOffset).concat(Array.prototype.slice.call(buf));
      return newBuf.slice(0, j7).toString("ucs2");
    };
    DBCSDecoder.prototype.end = function() {
      var ret = "";
      while (this.prevBytes.length > 0) {
        ret += this.defaultCharUnicode;
        var bytesArr = this.prevBytes.slice(1);
        this.prevBytes = [];
        this.nodeIdx = 0;
        if (bytesArr.length > 0)
          ret += this.write(bytesArr);
      }
      this.prevBytes = [];
      this.nodeIdx = 0;
      return ret;
    };
    function findIdx(table6, val2) {
      if (table6[0] > val2)
        return -1;
      var l7 = 0, r6 = table6.length;
      while (l7 < r6 - 1) {
        var mid = l7 + (r6 - l7 + 1 >> 1);
        if (table6[mid] <= val2)
          l7 = mid;
        else
          r6 = mid;
      }
      return l7;
    }
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/shiftjis.json
var require_shiftjis = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/shiftjis.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 128],
      ["a1", "\uFF61", 62],
      ["8140", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7"],
      ["8180", "\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
      ["81b8", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
      ["81c8", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
      ["81da", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
      ["81f0", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
      ["81fc", "\u25EF"],
      ["824f", "\uFF10", 9],
      ["8260", "\uFF21", 25],
      ["8281", "\uFF41", 25],
      ["829f", "\u3041", 82],
      ["8340", "\u30A1", 62],
      ["8380", "\u30E0", 22],
      ["839f", "\u0391", 16, "\u03A3", 6],
      ["83bf", "\u03B1", 16, "\u03C3", 6],
      ["8440", "\u0410", 5, "\u0401\u0416", 25],
      ["8470", "\u0430", 5, "\u0451\u0436", 7],
      ["8480", "\u043E", 17],
      ["849f", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
      ["8740", "\u2460", 19, "\u2160", 9],
      ["875f", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
      ["877e", "\u337B"],
      ["8780", "\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
      ["889f", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
      ["8940", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186"],
      ["8980", "\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
      ["8a40", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B"],
      ["8a80", "\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
      ["8b40", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551"],
      ["8b80", "\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
      ["8c40", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8"],
      ["8c80", "\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
      ["8d40", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D"],
      ["8d80", "\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
      ["8e40", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62"],
      ["8e80", "\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
      ["8f40", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3"],
      ["8f80", "\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
      ["9040", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8"],
      ["9080", "\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
      ["9140", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB"],
      ["9180", "\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
      ["9240", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4"],
      ["9280", "\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
      ["9340", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC"],
      ["9380", "\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
      ["9440", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885"],
      ["9480", "\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
      ["9540", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577"],
      ["9580", "\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
      ["9640", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6"],
      ["9680", "\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
      ["9740", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32"],
      ["9780", "\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
      ["9840", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
      ["989f", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
      ["9940", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED"],
      ["9980", "\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
      ["9a40", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638"],
      ["9a80", "\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
      ["9b40", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80"],
      ["9b80", "\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
      ["9c40", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060"],
      ["9c80", "\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
      ["9d40", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B"],
      ["9d80", "\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
      ["9e40", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E"],
      ["9e80", "\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
      ["9f40", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF"],
      ["9f80", "\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
      ["e040", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD"],
      ["e080", "\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
      ["e140", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF"],
      ["e180", "\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
      ["e240", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0"],
      ["e280", "\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
      ["e340", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37"],
      ["e380", "\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
      ["e440", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264"],
      ["e480", "\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
      ["e540", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC"],
      ["e580", "\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
      ["e640", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7"],
      ["e680", "\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
      ["e740", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C"],
      ["e780", "\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
      ["e840", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599"],
      ["e880", "\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
      ["e940", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43"],
      ["e980", "\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
      ["ea40", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF"],
      ["ea80", "\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0\u582F\u69C7\u9059\u7464\u51DC\u7199"],
      ["ed40", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F"],
      ["ed80", "\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
      ["ee40", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559"],
      ["ee80", "\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
      ["eeef", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
      ["f040", "\uE000", 62],
      ["f080", "\uE03F", 124],
      ["f140", "\uE0BC", 62],
      ["f180", "\uE0FB", 124],
      ["f240", "\uE178", 62],
      ["f280", "\uE1B7", 124],
      ["f340", "\uE234", 62],
      ["f380", "\uE273", 124],
      ["f440", "\uE2F0", 62],
      ["f480", "\uE32F", 124],
      ["f540", "\uE3AC", 62],
      ["f580", "\uE3EB", 124],
      ["f640", "\uE468", 62],
      ["f680", "\uE4A7", 124],
      ["f740", "\uE524", 62],
      ["f780", "\uE563", 124],
      ["f840", "\uE5E0", 62],
      ["f880", "\uE61F", 124],
      ["f940", "\uE69C"],
      ["fa40", "\u2170", 9, "\u2160", 9, "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u2235\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A"],
      ["fa80", "\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F"],
      ["fb40", "\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19"],
      ["fb80", "\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9"],
      ["fc40", "\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"]
    ];
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/eucjp.json
var require_eucjp = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/eucjp.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["8ea1", "\uFF61", 62],
      ["a1a1", "\u3000\u3001\u3002\uFF0C\uFF0E\u30FB\uFF1A\uFF1B\uFF1F\uFF01\u309B\u309C\xB4\uFF40\xA8\uFF3E\uFFE3\uFF3F\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\u2015\u2010\uFF0F\uFF3C\uFF5E\u2225\uFF5C\u2026\u2025\u2018\u2019\u201C\u201D\uFF08\uFF09\u3014\u3015\uFF3B\uFF3D\uFF5B\uFF5D\u3008", 9, "\uFF0B\uFF0D\xB1\xD7\xF7\uFF1D\u2260\uFF1C\uFF1E\u2266\u2267\u221E\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFFE5\uFF04\uFFE0\uFFE1\uFF05\uFF03\uFF06\uFF0A\uFF20\xA7\u2606\u2605\u25CB\u25CF\u25CE\u25C7"],
      ["a2a1", "\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u203B\u3012\u2192\u2190\u2191\u2193\u3013"],
      ["a2ba", "\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229"],
      ["a2ca", "\u2227\u2228\uFFE2\u21D2\u21D4\u2200\u2203"],
      ["a2dc", "\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C"],
      ["a2f2", "\u212B\u2030\u266F\u266D\u266A\u2020\u2021\xB6"],
      ["a2fe", "\u25EF"],
      ["a3b0", "\uFF10", 9],
      ["a3c1", "\uFF21", 25],
      ["a3e1", "\uFF41", 25],
      ["a4a1", "\u3041", 82],
      ["a5a1", "\u30A1", 85],
      ["a6a1", "\u0391", 16, "\u03A3", 6],
      ["a6c1", "\u03B1", 16, "\u03C3", 6],
      ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
      ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
      ["a8a1", "\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542"],
      ["ada1", "\u2460", 19, "\u2160", 9],
      ["adc0", "\u3349\u3314\u3322\u334D\u3318\u3327\u3303\u3336\u3351\u3357\u330D\u3326\u3323\u332B\u334A\u333B\u339C\u339D\u339E\u338E\u338F\u33C4\u33A1"],
      ["addf", "\u337B\u301D\u301F\u2116\u33CD\u2121\u32A4", 4, "\u3231\u3232\u3239\u337E\u337D\u337C\u2252\u2261\u222B\u222E\u2211\u221A\u22A5\u2220\u221F\u22BF\u2235\u2229\u222A"],
      ["b0a1", "\u4E9C\u5516\u5A03\u963F\u54C0\u611B\u6328\u59F6\u9022\u8475\u831C\u7A50\u60AA\u63E1\u6E25\u65ED\u8466\u82A6\u9BF5\u6893\u5727\u65A1\u6271\u5B9B\u59D0\u867B\u98F4\u7D62\u7DBE\u9B8E\u6216\u7C9F\u88B7\u5B89\u5EB5\u6309\u6697\u6848\u95C7\u978D\u674F\u4EE5\u4F0A\u4F4D\u4F9D\u5049\u56F2\u5937\u59D4\u5A01\u5C09\u60DF\u610F\u6170\u6613\u6905\u70BA\u754F\u7570\u79FB\u7DAD\u7DEF\u80C3\u840E\u8863\u8B02\u9055\u907A\u533B\u4E95\u4EA5\u57DF\u80B2\u90C1\u78EF\u4E00\u58F1\u6EA2\u9038\u7A32\u8328\u828B\u9C2F\u5141\u5370\u54BD\u54E1\u56E0\u59FB\u5F15\u98F2\u6DEB\u80E4\u852D"],
      ["b1a1", "\u9662\u9670\u96A0\u97FB\u540B\u53F3\u5B87\u70CF\u7FBD\u8FC2\u96E8\u536F\u9D5C\u7ABA\u4E11\u7893\u81FC\u6E26\u5618\u5504\u6B1D\u851A\u9C3B\u59E5\u53A9\u6D66\u74DC\u958F\u5642\u4E91\u904B\u96F2\u834F\u990C\u53E1\u55B6\u5B30\u5F71\u6620\u66F3\u6804\u6C38\u6CF3\u6D29\u745B\u76C8\u7A4E\u9834\u82F1\u885B\u8A60\u92ED\u6DB2\u75AB\u76CA\u99C5\u60A6\u8B01\u8D8A\u95B2\u698E\u53AD\u5186\u5712\u5830\u5944\u5BB4\u5EF6\u6028\u63A9\u63F4\u6CBF\u6F14\u708E\u7114\u7159\u71D5\u733F\u7E01\u8276\u82D1\u8597\u9060\u925B\u9D1B\u5869\u65BC\u6C5A\u7525\u51F9\u592E\u5965\u5F80\u5FDC"],
      ["b2a1", "\u62BC\u65FA\u6A2A\u6B27\u6BB4\u738B\u7FC1\u8956\u9D2C\u9D0E\u9EC4\u5CA1\u6C96\u837B\u5104\u5C4B\u61B6\u81C6\u6876\u7261\u4E59\u4FFA\u5378\u6069\u6E29\u7A4F\u97F3\u4E0B\u5316\u4EEE\u4F55\u4F3D\u4FA1\u4F73\u52A0\u53EF\u5609\u590F\u5AC1\u5BB6\u5BE1\u79D1\u6687\u679C\u67B6\u6B4C\u6CB3\u706B\u73C2\u798D\u79BE\u7A3C\u7B87\u82B1\u82DB\u8304\u8377\u83EF\u83D3\u8766\u8AB2\u5629\u8CA8\u8FE6\u904E\u971E\u868A\u4FC4\u5CE8\u6211\u7259\u753B\u81E5\u82BD\u86FE\u8CC0\u96C5\u9913\u99D5\u4ECB\u4F1A\u89E3\u56DE\u584A\u58CA\u5EFB\u5FEB\u602A\u6094\u6062\u61D0\u6212\u62D0\u6539"],
      ["b3a1", "\u9B41\u6666\u68B0\u6D77\u7070\u754C\u7686\u7D75\u82A5\u87F9\u958B\u968E\u8C9D\u51F1\u52BE\u5916\u54B3\u5BB3\u5D16\u6168\u6982\u6DAF\u788D\u84CB\u8857\u8A72\u93A7\u9AB8\u6D6C\u99A8\u86D9\u57A3\u67FF\u86CE\u920E\u5283\u5687\u5404\u5ED3\u62E1\u64B9\u683C\u6838\u6BBB\u7372\u78BA\u7A6B\u899A\u89D2\u8D6B\u8F03\u90ED\u95A3\u9694\u9769\u5B66\u5CB3\u697D\u984D\u984E\u639B\u7B20\u6A2B\u6A7F\u68B6\u9C0D\u6F5F\u5272\u559D\u6070\u62EC\u6D3B\u6E07\u6ED1\u845B\u8910\u8F44\u4E14\u9C39\u53F6\u691B\u6A3A\u9784\u682A\u515C\u7AC3\u84B2\u91DC\u938C\u565B\u9D28\u6822\u8305\u8431"],
      ["b4a1", "\u7CA5\u5208\u82C5\u74E6\u4E7E\u4F83\u51A0\u5BD2\u520A\u52D8\u52E7\u5DFB\u559A\u582A\u59E6\u5B8C\u5B98\u5BDB\u5E72\u5E79\u60A3\u611F\u6163\u61BE\u63DB\u6562\u67D1\u6853\u68FA\u6B3E\u6B53\u6C57\u6F22\u6F97\u6F45\u74B0\u7518\u76E3\u770B\u7AFF\u7BA1\u7C21\u7DE9\u7F36\u7FF0\u809D\u8266\u839E\u89B3\u8ACC\u8CAB\u9084\u9451\u9593\u9591\u95A2\u9665\u97D3\u9928\u8218\u4E38\u542B\u5CB8\u5DCC\u73A9\u764C\u773C\u5CA9\u7FEB\u8D0B\u96C1\u9811\u9854\u9858\u4F01\u4F0E\u5371\u559C\u5668\u57FA\u5947\u5B09\u5BC4\u5C90\u5E0C\u5E7E\u5FCC\u63EE\u673A\u65D7\u65E2\u671F\u68CB\u68C4"],
      ["b5a1", "\u6A5F\u5E30\u6BC5\u6C17\u6C7D\u757F\u7948\u5B63\u7A00\u7D00\u5FBD\u898F\u8A18\u8CB4\u8D77\u8ECC\u8F1D\u98E2\u9A0E\u9B3C\u4E80\u507D\u5100\u5993\u5B9C\u622F\u6280\u64EC\u6B3A\u72A0\u7591\u7947\u7FA9\u87FB\u8ABC\u8B70\u63AC\u83CA\u97A0\u5409\u5403\u55AB\u6854\u6A58\u8A70\u7827\u6775\u9ECD\u5374\u5BA2\u811A\u8650\u9006\u4E18\u4E45\u4EC7\u4F11\u53CA\u5438\u5BAE\u5F13\u6025\u6551\u673D\u6C42\u6C72\u6CE3\u7078\u7403\u7A76\u7AAE\u7B08\u7D1A\u7CFE\u7D66\u65E7\u725B\u53BB\u5C45\u5DE8\u62D2\u62E0\u6319\u6E20\u865A\u8A31\u8DDD\u92F8\u6F01\u79A6\u9B5A\u4EA8\u4EAB\u4EAC"],
      ["b6a1", "\u4F9B\u4FA0\u50D1\u5147\u7AF6\u5171\u51F6\u5354\u5321\u537F\u53EB\u55AC\u5883\u5CE1\u5F37\u5F4A\u602F\u6050\u606D\u631F\u6559\u6A4B\u6CC1\u72C2\u72ED\u77EF\u80F8\u8105\u8208\u854E\u90F7\u93E1\u97FF\u9957\u9A5A\u4EF0\u51DD\u5C2D\u6681\u696D\u5C40\u66F2\u6975\u7389\u6850\u7C81\u50C5\u52E4\u5747\u5DFE\u9326\u65A4\u6B23\u6B3D\u7434\u7981\u79BD\u7B4B\u7DCA\u82B9\u83CC\u887F\u895F\u8B39\u8FD1\u91D1\u541F\u9280\u4E5D\u5036\u53E5\u533A\u72D7\u7396\u77E9\u82E6\u8EAF\u99C6\u99C8\u99D2\u5177\u611A\u865E\u55B0\u7A7A\u5076\u5BD3\u9047\u9685\u4E32\u6ADB\u91E7\u5C51\u5C48"],
      ["b7a1", "\u6398\u7A9F\u6C93\u9774\u8F61\u7AAA\u718A\u9688\u7C82\u6817\u7E70\u6851\u936C\u52F2\u541B\u85AB\u8A13\u7FA4\u8ECD\u90E1\u5366\u8888\u7941\u4FC2\u50BE\u5211\u5144\u5553\u572D\u73EA\u578B\u5951\u5F62\u5F84\u6075\u6176\u6167\u61A9\u63B2\u643A\u656C\u666F\u6842\u6E13\u7566\u7A3D\u7CFB\u7D4C\u7D99\u7E4B\u7F6B\u830E\u834A\u86CD\u8A08\u8A63\u8B66\u8EFD\u981A\u9D8F\u82B8\u8FCE\u9BE8\u5287\u621F\u6483\u6FC0\u9699\u6841\u5091\u6B20\u6C7A\u6F54\u7A74\u7D50\u8840\u8A23\u6708\u4EF6\u5039\u5026\u5065\u517C\u5238\u5263\u55A7\u570F\u5805\u5ACC\u5EFA\u61B2\u61F8\u62F3\u6372"],
      ["b8a1", "\u691C\u6A29\u727D\u72AC\u732E\u7814\u786F\u7D79\u770C\u80A9\u898B\u8B19\u8CE2\u8ED2\u9063\u9375\u967A\u9855\u9A13\u9E78\u5143\u539F\u53B3\u5E7B\u5F26\u6E1B\u6E90\u7384\u73FE\u7D43\u8237\u8A00\u8AFA\u9650\u4E4E\u500B\u53E4\u547C\u56FA\u59D1\u5B64\u5DF1\u5EAB\u5F27\u6238\u6545\u67AF\u6E56\u72D0\u7CCA\u88B4\u80A1\u80E1\u83F0\u864E\u8A87\u8DE8\u9237\u96C7\u9867\u9F13\u4E94\u4E92\u4F0D\u5348\u5449\u543E\u5A2F\u5F8C\u5FA1\u609F\u68A7\u6A8E\u745A\u7881\u8A9E\u8AA4\u8B77\u9190\u4E5E\u9BC9\u4EA4\u4F7C\u4FAF\u5019\u5016\u5149\u516C\u529F\u52B9\u52FE\u539A\u53E3\u5411"],
      ["b9a1", "\u540E\u5589\u5751\u57A2\u597D\u5B54\u5B5D\u5B8F\u5DE5\u5DE7\u5DF7\u5E78\u5E83\u5E9A\u5EB7\u5F18\u6052\u614C\u6297\u62D8\u63A7\u653B\u6602\u6643\u66F4\u676D\u6821\u6897\u69CB\u6C5F\u6D2A\u6D69\u6E2F\u6E9D\u7532\u7687\u786C\u7A3F\u7CE0\u7D05\u7D18\u7D5E\u7DB1\u8015\u8003\u80AF\u80B1\u8154\u818F\u822A\u8352\u884C\u8861\u8B1B\u8CA2\u8CFC\u90CA\u9175\u9271\u783F\u92FC\u95A4\u964D\u9805\u9999\u9AD8\u9D3B\u525B\u52AB\u53F7\u5408\u58D5\u62F7\u6FE0\u8C6A\u8F5F\u9EB9\u514B\u523B\u544A\u56FD\u7A40\u9177\u9D60\u9ED2\u7344\u6F09\u8170\u7511\u5FFD\u60DA\u9AA8\u72DB\u8FBC"],
      ["baa1", "\u6B64\u9803\u4ECA\u56F0\u5764\u58BE\u5A5A\u6068\u61C7\u660F\u6606\u6839\u68B1\u6DF7\u75D5\u7D3A\u826E\u9B42\u4E9B\u4F50\u53C9\u5506\u5D6F\u5DE6\u5DEE\u67FB\u6C99\u7473\u7802\u8A50\u9396\u88DF\u5750\u5EA7\u632B\u50B5\u50AC\u518D\u6700\u54C9\u585E\u59BB\u5BB0\u5F69\u624D\u63A1\u683D\u6B73\u6E08\u707D\u91C7\u7280\u7815\u7826\u796D\u658E\u7D30\u83DC\u88C1\u8F09\u969B\u5264\u5728\u6750\u7F6A\u8CA1\u51B4\u5742\u962A\u583A\u698A\u80B4\u54B2\u5D0E\u57FC\u7895\u9DFA\u4F5C\u524A\u548B\u643E\u6628\u6714\u67F5\u7A84\u7B56\u7D22\u932F\u685C\u9BAD\u7B39\u5319\u518A\u5237"],
      ["bba1", "\u5BDF\u62F6\u64AE\u64E6\u672D\u6BBA\u85A9\u96D1\u7690\u9BD6\u634C\u9306\u9BAB\u76BF\u6652\u4E09\u5098\u53C2\u5C71\u60E8\u6492\u6563\u685F\u71E6\u73CA\u7523\u7B97\u7E82\u8695\u8B83\u8CDB\u9178\u9910\u65AC\u66AB\u6B8B\u4ED5\u4ED4\u4F3A\u4F7F\u523A\u53F8\u53F2\u55E3\u56DB\u58EB\u59CB\u59C9\u59FF\u5B50\u5C4D\u5E02\u5E2B\u5FD7\u601D\u6307\u652F\u5B5C\u65AF\u65BD\u65E8\u679D\u6B62\u6B7B\u6C0F\u7345\u7949\u79C1\u7CF8\u7D19\u7D2B\u80A2\u8102\u81F3\u8996\u8A5E\u8A69\u8A66\u8A8C\u8AEE\u8CC7\u8CDC\u96CC\u98FC\u6B6F\u4E8B\u4F3C\u4F8D\u5150\u5B57\u5BFA\u6148\u6301\u6642"],
      ["bca1", "\u6B21\u6ECB\u6CBB\u723E\u74BD\u75D4\u78C1\u793A\u800C\u8033\u81EA\u8494\u8F9E\u6C50\u9E7F\u5F0F\u8B58\u9D2B\u7AFA\u8EF8\u5B8D\u96EB\u4E03\u53F1\u57F7\u5931\u5AC9\u5BA4\u6089\u6E7F\u6F06\u75BE\u8CEA\u5B9F\u8500\u7BE0\u5072\u67F4\u829D\u5C61\u854A\u7E1E\u820E\u5199\u5C04\u6368\u8D66\u659C\u716E\u793E\u7D17\u8005\u8B1D\u8ECA\u906E\u86C7\u90AA\u501F\u52FA\u5C3A\u6753\u707C\u7235\u914C\u91C8\u932B\u82E5\u5BC2\u5F31\u60F9\u4E3B\u53D6\u5B88\u624B\u6731\u6B8A\u72E9\u73E0\u7A2E\u816B\u8DA3\u9152\u9996\u5112\u53D7\u546A\u5BFF\u6388\u6A39\u7DAC\u9700\u56DA\u53CE\u5468"],
      ["bda1", "\u5B97\u5C31\u5DDE\u4FEE\u6101\u62FE\u6D32\u79C0\u79CB\u7D42\u7E4D\u7FD2\u81ED\u821F\u8490\u8846\u8972\u8B90\u8E74\u8F2F\u9031\u914B\u916C\u96C6\u919C\u4EC0\u4F4F\u5145\u5341\u5F93\u620E\u67D4\u6C41\u6E0B\u7363\u7E26\u91CD\u9283\u53D4\u5919\u5BBF\u6DD1\u795D\u7E2E\u7C9B\u587E\u719F\u51FA\u8853\u8FF0\u4FCA\u5CFB\u6625\u77AC\u7AE3\u821C\u99FF\u51C6\u5FAA\u65EC\u696F\u6B89\u6DF3\u6E96\u6F64\u76FE\u7D14\u5DE1\u9075\u9187\u9806\u51E6\u521D\u6240\u6691\u66D9\u6E1A\u5EB6\u7DD2\u7F72\u66F8\u85AF\u85F7\u8AF8\u52A9\u53D9\u5973\u5E8F\u5F90\u6055\u92E4\u9664\u50B7\u511F"],
      ["bea1", "\u52DD\u5320\u5347\u53EC\u54E8\u5546\u5531\u5617\u5968\u59BE\u5A3C\u5BB5\u5C06\u5C0F\u5C11\u5C1A\u5E84\u5E8A\u5EE0\u5F70\u627F\u6284\u62DB\u638C\u6377\u6607\u660C\u662D\u6676\u677E\u68A2\u6A1F\u6A35\u6CBC\u6D88\u6E09\u6E58\u713C\u7126\u7167\u75C7\u7701\u785D\u7901\u7965\u79F0\u7AE0\u7B11\u7CA7\u7D39\u8096\u83D6\u848B\u8549\u885D\u88F3\u8A1F\u8A3C\u8A54\u8A73\u8C61\u8CDE\u91A4\u9266\u937E\u9418\u969C\u9798\u4E0A\u4E08\u4E1E\u4E57\u5197\u5270\u57CE\u5834\u58CC\u5B22\u5E38\u60C5\u64FE\u6761\u6756\u6D44\u72B6\u7573\u7A63\u84B8\u8B72\u91B8\u9320\u5631\u57F4\u98FE"],
      ["bfa1", "\u62ED\u690D\u6B96\u71ED\u7E54\u8077\u8272\u89E6\u98DF\u8755\u8FB1\u5C3B\u4F38\u4FE1\u4FB5\u5507\u5A20\u5BDD\u5BE9\u5FC3\u614E\u632F\u65B0\u664B\u68EE\u699B\u6D78\u6DF1\u7533\u75B9\u771F\u795E\u79E6\u7D33\u81E3\u82AF\u85AA\u89AA\u8A3A\u8EAB\u8F9B\u9032\u91DD\u9707\u4EBA\u4EC1\u5203\u5875\u58EC\u5C0B\u751A\u5C3D\u814E\u8A0A\u8FC5\u9663\u976D\u7B25\u8ACF\u9808\u9162\u56F3\u53A8\u9017\u5439\u5782\u5E25\u63A8\u6C34\u708A\u7761\u7C8B\u7FE0\u8870\u9042\u9154\u9310\u9318\u968F\u745E\u9AC4\u5D07\u5D69\u6570\u67A2\u8DA8\u96DB\u636E\u6749\u6919\u83C5\u9817\u96C0\u88FE"],
      ["c0a1", "\u6F84\u647A\u5BF8\u4E16\u702C\u755D\u662F\u51C4\u5236\u52E2\u59D3\u5F81\u6027\u6210\u653F\u6574\u661F\u6674\u68F2\u6816\u6B63\u6E05\u7272\u751F\u76DB\u7CBE\u8056\u58F0\u88FD\u897F\u8AA0\u8A93\u8ACB\u901D\u9192\u9752\u9759\u6589\u7A0E\u8106\u96BB\u5E2D\u60DC\u621A\u65A5\u6614\u6790\u77F3\u7A4D\u7C4D\u7E3E\u810A\u8CAC\u8D64\u8DE1\u8E5F\u78A9\u5207\u62D9\u63A5\u6442\u6298\u8A2D\u7A83\u7BC0\u8AAC\u96EA\u7D76\u820C\u8749\u4ED9\u5148\u5343\u5360\u5BA3\u5C02\u5C16\u5DDD\u6226\u6247\u64B0\u6813\u6834\u6CC9\u6D45\u6D17\u67D3\u6F5C\u714E\u717D\u65CB\u7A7F\u7BAD\u7DDA"],
      ["c1a1", "\u7E4A\u7FA8\u817A\u821B\u8239\u85A6\u8A6E\u8CCE\u8DF5\u9078\u9077\u92AD\u9291\u9583\u9BAE\u524D\u5584\u6F38\u7136\u5168\u7985\u7E55\u81B3\u7CCE\u564C\u5851\u5CA8\u63AA\u66FE\u66FD\u695A\u72D9\u758F\u758E\u790E\u7956\u79DF\u7C97\u7D20\u7D44\u8607\u8A34\u963B\u9061\u9F20\u50E7\u5275\u53CC\u53E2\u5009\u55AA\u58EE\u594F\u723D\u5B8B\u5C64\u531D\u60E3\u60F3\u635C\u6383\u633F\u63BB\u64CD\u65E9\u66F9\u5DE3\u69CD\u69FD\u6F15\u71E5\u4E89\u75E9\u76F8\u7A93\u7CDF\u7DCF\u7D9C\u8061\u8349\u8358\u846C\u84BC\u85FB\u88C5\u8D70\u9001\u906D\u9397\u971C\u9A12\u50CF\u5897\u618E"],
      ["c2a1", "\u81D3\u8535\u8D08\u9020\u4FC3\u5074\u5247\u5373\u606F\u6349\u675F\u6E2C\u8DB3\u901F\u4FD7\u5C5E\u8CCA\u65CF\u7D9A\u5352\u8896\u5176\u63C3\u5B58\u5B6B\u5C0A\u640D\u6751\u905C\u4ED6\u591A\u592A\u6C70\u8A51\u553E\u5815\u59A5\u60F0\u6253\u67C1\u8235\u6955\u9640\u99C4\u9A28\u4F53\u5806\u5BFE\u8010\u5CB1\u5E2F\u5F85\u6020\u614B\u6234\u66FF\u6CF0\u6EDE\u80CE\u817F\u82D4\u888B\u8CB8\u9000\u902E\u968A\u9EDB\u9BDB\u4EE3\u53F0\u5927\u7B2C\u918D\u984C\u9DF9\u6EDD\u7027\u5353\u5544\u5B85\u6258\u629E\u62D3\u6CA2\u6FEF\u7422\u8A17\u9438\u6FC1\u8AFE\u8338\u51E7\u86F8\u53EA"],
      ["c3a1", "\u53E9\u4F46\u9054\u8FB0\u596A\u8131\u5DFD\u7AEA\u8FBF\u68DA\u8C37\u72F8\u9C48\u6A3D\u8AB0\u4E39\u5358\u5606\u5766\u62C5\u63A2\u65E6\u6B4E\u6DE1\u6E5B\u70AD\u77ED\u7AEF\u7BAA\u7DBB\u803D\u80C6\u86CB\u8A95\u935B\u56E3\u58C7\u5F3E\u65AD\u6696\u6A80\u6BB5\u7537\u8AC7\u5024\u77E5\u5730\u5F1B\u6065\u667A\u6C60\u75F4\u7A1A\u7F6E\u81F4\u8718\u9045\u99B3\u7BC9\u755C\u7AF9\u7B51\u84C4\u9010\u79E9\u7A92\u8336\u5AE1\u7740\u4E2D\u4EF2\u5B99\u5FE0\u62BD\u663C\u67F1\u6CE8\u866B\u8877\u8A3B\u914E\u92F3\u99D0\u6A17\u7026\u732A\u82E7\u8457\u8CAF\u4E01\u5146\u51CB\u558B\u5BF5"],
      ["c4a1", "\u5E16\u5E33\u5E81\u5F14\u5F35\u5F6B\u5FB4\u61F2\u6311\u66A2\u671D\u6F6E\u7252\u753A\u773A\u8074\u8139\u8178\u8776\u8ABF\u8ADC\u8D85\u8DF3\u929A\u9577\u9802\u9CE5\u52C5\u6357\u76F4\u6715\u6C88\u73CD\u8CC3\u93AE\u9673\u6D25\u589C\u690E\u69CC\u8FFD\u939A\u75DB\u901A\u585A\u6802\u63B4\u69FB\u4F43\u6F2C\u67D8\u8FBB\u8526\u7DB4\u9354\u693F\u6F70\u576A\u58F7\u5B2C\u7D2C\u722A\u540A\u91E3\u9DB4\u4EAD\u4F4E\u505C\u5075\u5243\u8C9E\u5448\u5824\u5B9A\u5E1D\u5E95\u5EAD\u5EF7\u5F1F\u608C\u62B5\u633A\u63D0\u68AF\u6C40\u7887\u798E\u7A0B\u7DE0\u8247\u8A02\u8AE6\u8E44\u9013"],
      ["c5a1", "\u90B8\u912D\u91D8\u9F0E\u6CE5\u6458\u64E2\u6575\u6EF4\u7684\u7B1B\u9069\u93D1\u6EBA\u54F2\u5FB9\u64A4\u8F4D\u8FED\u9244\u5178\u586B\u5929\u5C55\u5E97\u6DFB\u7E8F\u751C\u8CBC\u8EE2\u985B\u70B9\u4F1D\u6BBF\u6FB1\u7530\u96FB\u514E\u5410\u5835\u5857\u59AC\u5C60\u5F92\u6597\u675C\u6E21\u767B\u83DF\u8CED\u9014\u90FD\u934D\u7825\u783A\u52AA\u5EA6\u571F\u5974\u6012\u5012\u515A\u51AC\u51CD\u5200\u5510\u5854\u5858\u5957\u5B95\u5CF6\u5D8B\u60BC\u6295\u642D\u6771\u6843\u68BC\u68DF\u76D7\u6DD8\u6E6F\u6D9B\u706F\u71C8\u5F53\u75D8\u7977\u7B49\u7B54\u7B52\u7CD6\u7D71\u5230"],
      ["c6a1", "\u8463\u8569\u85E4\u8A0E\u8B04\u8C46\u8E0F\u9003\u900F\u9419\u9676\u982D\u9A30\u95D8\u50CD\u52D5\u540C\u5802\u5C0E\u61A7\u649E\u6D1E\u77B3\u7AE5\u80F4\u8404\u9053\u9285\u5CE0\u9D07\u533F\u5F97\u5FB3\u6D9C\u7279\u7763\u79BF\u7BE4\u6BD2\u72EC\u8AAD\u6803\u6A61\u51F8\u7A81\u6934\u5C4A\u9CF6\u82EB\u5BC5\u9149\u701E\u5678\u5C6F\u60C7\u6566\u6C8C\u8C5A\u9041\u9813\u5451\u66C7\u920D\u5948\u90A3\u5185\u4E4D\u51EA\u8599\u8B0E\u7058\u637A\u934B\u6962\u99B4\u7E04\u7577\u5357\u6960\u8EDF\u96E3\u6C5D\u4E8C\u5C3C\u5F10\u8FE9\u5302\u8CD1\u8089\u8679\u5EFF\u65E5\u4E73\u5165"],
      ["c7a1", "\u5982\u5C3F\u97EE\u4EFB\u598A\u5FCD\u8A8D\u6FE1\u79B0\u7962\u5BE7\u8471\u732B\u71B1\u5E74\u5FF5\u637B\u649A\u71C3\u7C98\u4E43\u5EFC\u4E4B\u57DC\u56A2\u60A9\u6FC3\u7D0D\u80FD\u8133\u81BF\u8FB2\u8997\u86A4\u5DF4\u628A\u64AD\u8987\u6777\u6CE2\u6D3E\u7436\u7834\u5A46\u7F75\u82AD\u99AC\u4FF3\u5EC3\u62DD\u6392\u6557\u676F\u76C3\u724C\u80CC\u80BA\u8F29\u914D\u500D\u57F9\u5A92\u6885\u6973\u7164\u72FD\u8CB7\u58F2\u8CE0\u966A\u9019\u877F\u79E4\u77E7\u8429\u4F2F\u5265\u535A\u62CD\u67CF\u6CCA\u767D\u7B94\u7C95\u8236\u8584\u8FEB\u66DD\u6F20\u7206\u7E1B\u83AB\u99C1\u9EA6"],
      ["c8a1", "\u51FD\u7BB1\u7872\u7BB8\u8087\u7B48\u6AE8\u5E61\u808C\u7551\u7560\u516B\u9262\u6E8C\u767A\u9197\u9AEA\u4F10\u7F70\u629C\u7B4F\u95A5\u9CE9\u567A\u5859\u86E4\u96BC\u4F34\u5224\u534A\u53CD\u53DB\u5E06\u642C\u6591\u677F\u6C3E\u6C4E\u7248\u72AF\u73ED\u7554\u7E41\u822C\u85E9\u8CA9\u7BC4\u91C6\u7169\u9812\u98EF\u633D\u6669\u756A\u76E4\u78D0\u8543\u86EE\u532A\u5351\u5426\u5983\u5E87\u5F7C\u60B2\u6249\u6279\u62AB\u6590\u6BD4\u6CCC\u75B2\u76AE\u7891\u79D8\u7DCB\u7F77\u80A5\u88AB\u8AB9\u8CBB\u907F\u975E\u98DB\u6A0B\u7C38\u5099\u5C3E\u5FAE\u6787\u6BD8\u7435\u7709\u7F8E"],
      ["c9a1", "\u9F3B\u67CA\u7A17\u5339\u758B\u9AED\u5F66\u819D\u83F1\u8098\u5F3C\u5FC5\u7562\u7B46\u903C\u6867\u59EB\u5A9B\u7D10\u767E\u8B2C\u4FF5\u5F6A\u6A19\u6C37\u6F02\u74E2\u7968\u8868\u8A55\u8C79\u5EDF\u63CF\u75C5\u79D2\u82D7\u9328\u92F2\u849C\u86ED\u9C2D\u54C1\u5F6C\u658C\u6D5C\u7015\u8CA7\u8CD3\u983B\u654F\u74F6\u4E0D\u4ED8\u57E0\u592B\u5A66\u5BCC\u51A8\u5E03\u5E9C\u6016\u6276\u6577\u65A7\u666E\u6D6E\u7236\u7B26\u8150\u819A\u8299\u8B5C\u8CA0\u8CE6\u8D74\u961C\u9644\u4FAE\u64AB\u6B66\u821E\u8461\u856A\u90E8\u5C01\u6953\u98A8\u847A\u8557\u4F0F\u526F\u5FA9\u5E45\u670D"],
      ["caa1", "\u798F\u8179\u8907\u8986\u6DF5\u5F17\u6255\u6CB8\u4ECF\u7269\u9B92\u5206\u543B\u5674\u58B3\u61A4\u626E\u711A\u596E\u7C89\u7CDE\u7D1B\u96F0\u6587\u805E\u4E19\u4F75\u5175\u5840\u5E63\u5E73\u5F0A\u67C4\u4E26\u853D\u9589\u965B\u7C73\u9801\u50FB\u58C1\u7656\u78A7\u5225\u77A5\u8511\u7B86\u504F\u5909\u7247\u7BC7\u7DE8\u8FBA\u8FD4\u904D\u4FBF\u52C9\u5A29\u5F01\u97AD\u4FDD\u8217\u92EA\u5703\u6355\u6B69\u752B\u88DC\u8F14\u7A42\u52DF\u5893\u6155\u620A\u66AE\u6BCD\u7C3F\u83E9\u5023\u4FF8\u5305\u5446\u5831\u5949\u5B9D\u5CF0\u5CEF\u5D29\u5E96\u62B1\u6367\u653E\u65B9\u670B"],
      ["cba1", "\u6CD5\u6CE1\u70F9\u7832\u7E2B\u80DE\u82B3\u840C\u84EC\u8702\u8912\u8A2A\u8C4A\u90A6\u92D2\u98FD\u9CF3\u9D6C\u4E4F\u4EA1\u508D\u5256\u574A\u59A8\u5E3D\u5FD8\u5FD9\u623F\u66B4\u671B\u67D0\u68D2\u5192\u7D21\u80AA\u81A8\u8B00\u8C8C\u8CBF\u927E\u9632\u5420\u982C\u5317\u50D5\u535C\u58A8\u64B2\u6734\u7267\u7766\u7A46\u91E6\u52C3\u6CA1\u6B86\u5800\u5E4C\u5954\u672C\u7FFB\u51E1\u76C6\u6469\u78E8\u9B54\u9EBB\u57CB\u59B9\u6627\u679A\u6BCE\u54E9\u69D9\u5E55\u819C\u6795\u9BAA\u67FE\u9C52\u685D\u4EA6\u4FE3\u53C8\u62B9\u672B\u6CAB\u8FC4\u4FAD\u7E6D\u9EBF\u4E07\u6162\u6E80"],
      ["cca1", "\u6F2B\u8513\u5473\u672A\u9B45\u5DF3\u7B95\u5CAC\u5BC6\u871C\u6E4A\u84D1\u7A14\u8108\u5999\u7C8D\u6C11\u7720\u52D9\u5922\u7121\u725F\u77DB\u9727\u9D61\u690B\u5A7F\u5A18\u51A5\u540D\u547D\u660E\u76DF\u8FF7\u9298\u9CF4\u59EA\u725D\u6EC5\u514D\u68C9\u7DBF\u7DEC\u9762\u9EBA\u6478\u6A21\u8302\u5984\u5B5F\u6BDB\u731B\u76F2\u7DB2\u8017\u8499\u5132\u6728\u9ED9\u76EE\u6762\u52FF\u9905\u5C24\u623B\u7C7E\u8CB0\u554F\u60B6\u7D0B\u9580\u5301\u4E5F\u51B6\u591C\u723A\u8036\u91CE\u5F25\u77E2\u5384\u5F79\u7D04\u85AC\u8A33\u8E8D\u9756\u67F3\u85AE\u9453\u6109\u6108\u6CB9\u7652"],
      ["cda1", "\u8AED\u8F38\u552F\u4F51\u512A\u52C7\u53CB\u5BA5\u5E7D\u60A0\u6182\u63D6\u6709\u67DA\u6E67\u6D8C\u7336\u7337\u7531\u7950\u88D5\u8A98\u904A\u9091\u90F5\u96C4\u878D\u5915\u4E88\u4F59\u4E0E\u8A89\u8F3F\u9810\u50AD\u5E7C\u5996\u5BB9\u5EB8\u63DA\u63FA\u64C1\u66DC\u694A\u69D8\u6D0B\u6EB6\u7194\u7528\u7AAF\u7F8A\u8000\u8449\u84C9\u8981\u8B21\u8E0A\u9065\u967D\u990A\u617E\u6291\u6B32\u6C83\u6D74\u7FCC\u7FFC\u6DC0\u7F85\u87BA\u88F8\u6765\u83B1\u983C\u96F7\u6D1B\u7D61\u843D\u916A\u4E71\u5375\u5D50\u6B04\u6FEB\u85CD\u862D\u89A7\u5229\u540F\u5C65\u674E\u68A8\u7406\u7483"],
      ["cea1", "\u75E2\u88CF\u88E1\u91CC\u96E2\u9678\u5F8B\u7387\u7ACB\u844E\u63A0\u7565\u5289\u6D41\u6E9C\u7409\u7559\u786B\u7C92\u9686\u7ADC\u9F8D\u4FB6\u616E\u65C5\u865C\u4E86\u4EAE\u50DA\u4E21\u51CC\u5BEE\u6599\u6881\u6DBC\u731F\u7642\u77AD\u7A1C\u7CE7\u826F\u8AD2\u907C\u91CF\u9675\u9818\u529B\u7DD1\u502B\u5398\u6797\u6DCB\u71D0\u7433\u81E8\u8F2A\u96A3\u9C57\u9E9F\u7460\u5841\u6D99\u7D2F\u985E\u4EE4\u4F36\u4F8B\u51B7\u52B1\u5DBA\u601C\u73B2\u793C\u82D3\u9234\u96B7\u96F6\u970A\u9E97\u9F62\u66A6\u6B74\u5217\u52A3\u70C8\u88C2\u5EC9\u604B\u6190\u6F23\u7149\u7C3E\u7DF4\u806F"],
      ["cfa1", "\u84EE\u9023\u932C\u5442\u9B6F\u6AD3\u7089\u8CC2\u8DEF\u9732\u52B4\u5A41\u5ECA\u5F04\u6717\u697C\u6994\u6D6A\u6F0F\u7262\u72FC\u7BED\u8001\u807E\u874B\u90CE\u516D\u9E93\u7984\u808B\u9332\u8AD6\u502D\u548C\u8A71\u6B6A\u8CC4\u8107\u60D1\u67A0\u9DF2\u4E99\u4E98\u9C10\u8A6B\u85C1\u8568\u6900\u6E7E\u7897\u8155"],
      ["d0a1", "\u5F0C\u4E10\u4E15\u4E2A\u4E31\u4E36\u4E3C\u4E3F\u4E42\u4E56\u4E58\u4E82\u4E85\u8C6B\u4E8A\u8212\u5F0D\u4E8E\u4E9E\u4E9F\u4EA0\u4EA2\u4EB0\u4EB3\u4EB6\u4ECE\u4ECD\u4EC4\u4EC6\u4EC2\u4ED7\u4EDE\u4EED\u4EDF\u4EF7\u4F09\u4F5A\u4F30\u4F5B\u4F5D\u4F57\u4F47\u4F76\u4F88\u4F8F\u4F98\u4F7B\u4F69\u4F70\u4F91\u4F6F\u4F86\u4F96\u5118\u4FD4\u4FDF\u4FCE\u4FD8\u4FDB\u4FD1\u4FDA\u4FD0\u4FE4\u4FE5\u501A\u5028\u5014\u502A\u5025\u5005\u4F1C\u4FF6\u5021\u5029\u502C\u4FFE\u4FEF\u5011\u5006\u5043\u5047\u6703\u5055\u5050\u5048\u505A\u5056\u506C\u5078\u5080\u509A\u5085\u50B4\u50B2"],
      ["d1a1", "\u50C9\u50CA\u50B3\u50C2\u50D6\u50DE\u50E5\u50ED\u50E3\u50EE\u50F9\u50F5\u5109\u5101\u5102\u5116\u5115\u5114\u511A\u5121\u513A\u5137\u513C\u513B\u513F\u5140\u5152\u514C\u5154\u5162\u7AF8\u5169\u516A\u516E\u5180\u5182\u56D8\u518C\u5189\u518F\u5191\u5193\u5195\u5196\u51A4\u51A6\u51A2\u51A9\u51AA\u51AB\u51B3\u51B1\u51B2\u51B0\u51B5\u51BD\u51C5\u51C9\u51DB\u51E0\u8655\u51E9\u51ED\u51F0\u51F5\u51FE\u5204\u520B\u5214\u520E\u5227\u522A\u522E\u5233\u5239\u524F\u5244\u524B\u524C\u525E\u5254\u526A\u5274\u5269\u5273\u527F\u527D\u528D\u5294\u5292\u5271\u5288\u5291\u8FA8"],
      ["d2a1", "\u8FA7\u52AC\u52AD\u52BC\u52B5\u52C1\u52CD\u52D7\u52DE\u52E3\u52E6\u98ED\u52E0\u52F3\u52F5\u52F8\u52F9\u5306\u5308\u7538\u530D\u5310\u530F\u5315\u531A\u5323\u532F\u5331\u5333\u5338\u5340\u5346\u5345\u4E17\u5349\u534D\u51D6\u535E\u5369\u536E\u5918\u537B\u5377\u5382\u5396\u53A0\u53A6\u53A5\u53AE\u53B0\u53B6\u53C3\u7C12\u96D9\u53DF\u66FC\u71EE\u53EE\u53E8\u53ED\u53FA\u5401\u543D\u5440\u542C\u542D\u543C\u542E\u5436\u5429\u541D\u544E\u548F\u5475\u548E\u545F\u5471\u5477\u5470\u5492\u547B\u5480\u5476\u5484\u5490\u5486\u54C7\u54A2\u54B8\u54A5\u54AC\u54C4\u54C8\u54A8"],
      ["d3a1", "\u54AB\u54C2\u54A4\u54BE\u54BC\u54D8\u54E5\u54E6\u550F\u5514\u54FD\u54EE\u54ED\u54FA\u54E2\u5539\u5540\u5563\u554C\u552E\u555C\u5545\u5556\u5557\u5538\u5533\u555D\u5599\u5580\u54AF\u558A\u559F\u557B\u557E\u5598\u559E\u55AE\u557C\u5583\u55A9\u5587\u55A8\u55DA\u55C5\u55DF\u55C4\u55DC\u55E4\u55D4\u5614\u55F7\u5616\u55FE\u55FD\u561B\u55F9\u564E\u5650\u71DF\u5634\u5636\u5632\u5638\u566B\u5664\u562F\u566C\u566A\u5686\u5680\u568A\u56A0\u5694\u568F\u56A5\u56AE\u56B6\u56B4\u56C2\u56BC\u56C1\u56C3\u56C0\u56C8\u56CE\u56D1\u56D3\u56D7\u56EE\u56F9\u5700\u56FF\u5704\u5709"],
      ["d4a1", "\u5708\u570B\u570D\u5713\u5718\u5716\u55C7\u571C\u5726\u5737\u5738\u574E\u573B\u5740\u574F\u5769\u57C0\u5788\u5761\u577F\u5789\u5793\u57A0\u57B3\u57A4\u57AA\u57B0\u57C3\u57C6\u57D4\u57D2\u57D3\u580A\u57D6\u57E3\u580B\u5819\u581D\u5872\u5821\u5862\u584B\u5870\u6BC0\u5852\u583D\u5879\u5885\u58B9\u589F\u58AB\u58BA\u58DE\u58BB\u58B8\u58AE\u58C5\u58D3\u58D1\u58D7\u58D9\u58D8\u58E5\u58DC\u58E4\u58DF\u58EF\u58FA\u58F9\u58FB\u58FC\u58FD\u5902\u590A\u5910\u591B\u68A6\u5925\u592C\u592D\u5932\u5938\u593E\u7AD2\u5955\u5950\u594E\u595A\u5958\u5962\u5960\u5967\u596C\u5969"],
      ["d5a1", "\u5978\u5981\u599D\u4F5E\u4FAB\u59A3\u59B2\u59C6\u59E8\u59DC\u598D\u59D9\u59DA\u5A25\u5A1F\u5A11\u5A1C\u5A09\u5A1A\u5A40\u5A6C\u5A49\u5A35\u5A36\u5A62\u5A6A\u5A9A\u5ABC\u5ABE\u5ACB\u5AC2\u5ABD\u5AE3\u5AD7\u5AE6\u5AE9\u5AD6\u5AFA\u5AFB\u5B0C\u5B0B\u5B16\u5B32\u5AD0\u5B2A\u5B36\u5B3E\u5B43\u5B45\u5B40\u5B51\u5B55\u5B5A\u5B5B\u5B65\u5B69\u5B70\u5B73\u5B75\u5B78\u6588\u5B7A\u5B80\u5B83\u5BA6\u5BB8\u5BC3\u5BC7\u5BC9\u5BD4\u5BD0\u5BE4\u5BE6\u5BE2\u5BDE\u5BE5\u5BEB\u5BF0\u5BF6\u5BF3\u5C05\u5C07\u5C08\u5C0D\u5C13\u5C20\u5C22\u5C28\u5C38\u5C39\u5C41\u5C46\u5C4E\u5C53"],
      ["d6a1", "\u5C50\u5C4F\u5B71\u5C6C\u5C6E\u4E62\u5C76\u5C79\u5C8C\u5C91\u5C94\u599B\u5CAB\u5CBB\u5CB6\u5CBC\u5CB7\u5CC5\u5CBE\u5CC7\u5CD9\u5CE9\u5CFD\u5CFA\u5CED\u5D8C\u5CEA\u5D0B\u5D15\u5D17\u5D5C\u5D1F\u5D1B\u5D11\u5D14\u5D22\u5D1A\u5D19\u5D18\u5D4C\u5D52\u5D4E\u5D4B\u5D6C\u5D73\u5D76\u5D87\u5D84\u5D82\u5DA2\u5D9D\u5DAC\u5DAE\u5DBD\u5D90\u5DB7\u5DBC\u5DC9\u5DCD\u5DD3\u5DD2\u5DD6\u5DDB\u5DEB\u5DF2\u5DF5\u5E0B\u5E1A\u5E19\u5E11\u5E1B\u5E36\u5E37\u5E44\u5E43\u5E40\u5E4E\u5E57\u5E54\u5E5F\u5E62\u5E64\u5E47\u5E75\u5E76\u5E7A\u9EBC\u5E7F\u5EA0\u5EC1\u5EC2\u5EC8\u5ED0\u5ECF"],
      ["d7a1", "\u5ED6\u5EE3\u5EDD\u5EDA\u5EDB\u5EE2\u5EE1\u5EE8\u5EE9\u5EEC\u5EF1\u5EF3\u5EF0\u5EF4\u5EF8\u5EFE\u5F03\u5F09\u5F5D\u5F5C\u5F0B\u5F11\u5F16\u5F29\u5F2D\u5F38\u5F41\u5F48\u5F4C\u5F4E\u5F2F\u5F51\u5F56\u5F57\u5F59\u5F61\u5F6D\u5F73\u5F77\u5F83\u5F82\u5F7F\u5F8A\u5F88\u5F91\u5F87\u5F9E\u5F99\u5F98\u5FA0\u5FA8\u5FAD\u5FBC\u5FD6\u5FFB\u5FE4\u5FF8\u5FF1\u5FDD\u60B3\u5FFF\u6021\u6060\u6019\u6010\u6029\u600E\u6031\u601B\u6015\u602B\u6026\u600F\u603A\u605A\u6041\u606A\u6077\u605F\u604A\u6046\u604D\u6063\u6043\u6064\u6042\u606C\u606B\u6059\u6081\u608D\u60E7\u6083\u609A"],
      ["d8a1", "\u6084\u609B\u6096\u6097\u6092\u60A7\u608B\u60E1\u60B8\u60E0\u60D3\u60B4\u5FF0\u60BD\u60C6\u60B5\u60D8\u614D\u6115\u6106\u60F6\u60F7\u6100\u60F4\u60FA\u6103\u6121\u60FB\u60F1\u610D\u610E\u6147\u613E\u6128\u6127\u614A\u613F\u613C\u612C\u6134\u613D\u6142\u6144\u6173\u6177\u6158\u6159\u615A\u616B\u6174\u616F\u6165\u6171\u615F\u615D\u6153\u6175\u6199\u6196\u6187\u61AC\u6194\u619A\u618A\u6191\u61AB\u61AE\u61CC\u61CA\u61C9\u61F7\u61C8\u61C3\u61C6\u61BA\u61CB\u7F79\u61CD\u61E6\u61E3\u61F6\u61FA\u61F4\u61FF\u61FD\u61FC\u61FE\u6200\u6208\u6209\u620D\u620C\u6214\u621B"],
      ["d9a1", "\u621E\u6221\u622A\u622E\u6230\u6232\u6233\u6241\u624E\u625E\u6263\u625B\u6260\u6268\u627C\u6282\u6289\u627E\u6292\u6293\u6296\u62D4\u6283\u6294\u62D7\u62D1\u62BB\u62CF\u62FF\u62C6\u64D4\u62C8\u62DC\u62CC\u62CA\u62C2\u62C7\u629B\u62C9\u630C\u62EE\u62F1\u6327\u6302\u6308\u62EF\u62F5\u6350\u633E\u634D\u641C\u634F\u6396\u638E\u6380\u63AB\u6376\u63A3\u638F\u6389\u639F\u63B5\u636B\u6369\u63BE\u63E9\u63C0\u63C6\u63E3\u63C9\u63D2\u63F6\u63C4\u6416\u6434\u6406\u6413\u6426\u6436\u651D\u6417\u6428\u640F\u6467\u646F\u6476\u644E\u652A\u6495\u6493\u64A5\u64A9\u6488\u64BC"],
      ["daa1", "\u64DA\u64D2\u64C5\u64C7\u64BB\u64D8\u64C2\u64F1\u64E7\u8209\u64E0\u64E1\u62AC\u64E3\u64EF\u652C\u64F6\u64F4\u64F2\u64FA\u6500\u64FD\u6518\u651C\u6505\u6524\u6523\u652B\u6534\u6535\u6537\u6536\u6538\u754B\u6548\u6556\u6555\u654D\u6558\u655E\u655D\u6572\u6578\u6582\u6583\u8B8A\u659B\u659F\u65AB\u65B7\u65C3\u65C6\u65C1\u65C4\u65CC\u65D2\u65DB\u65D9\u65E0\u65E1\u65F1\u6772\u660A\u6603\u65FB\u6773\u6635\u6636\u6634\u661C\u664F\u6644\u6649\u6641\u665E\u665D\u6664\u6667\u6668\u665F\u6662\u6670\u6683\u6688\u668E\u6689\u6684\u6698\u669D\u66C1\u66B9\u66C9\u66BE\u66BC"],
      ["dba1", "\u66C4\u66B8\u66D6\u66DA\u66E0\u663F\u66E6\u66E9\u66F0\u66F5\u66F7\u670F\u6716\u671E\u6726\u6727\u9738\u672E\u673F\u6736\u6741\u6738\u6737\u6746\u675E\u6760\u6759\u6763\u6764\u6789\u6770\u67A9\u677C\u676A\u678C\u678B\u67A6\u67A1\u6785\u67B7\u67EF\u67B4\u67EC\u67B3\u67E9\u67B8\u67E4\u67DE\u67DD\u67E2\u67EE\u67B9\u67CE\u67C6\u67E7\u6A9C\u681E\u6846\u6829\u6840\u684D\u6832\u684E\u68B3\u682B\u6859\u6863\u6877\u687F\u689F\u688F\u68AD\u6894\u689D\u689B\u6883\u6AAE\u68B9\u6874\u68B5\u68A0\u68BA\u690F\u688D\u687E\u6901\u68CA\u6908\u68D8\u6922\u6926\u68E1\u690C\u68CD"],
      ["dca1", "\u68D4\u68E7\u68D5\u6936\u6912\u6904\u68D7\u68E3\u6925\u68F9\u68E0\u68EF\u6928\u692A\u691A\u6923\u6921\u68C6\u6979\u6977\u695C\u6978\u696B\u6954\u697E\u696E\u6939\u6974\u693D\u6959\u6930\u6961\u695E\u695D\u6981\u696A\u69B2\u69AE\u69D0\u69BF\u69C1\u69D3\u69BE\u69CE\u5BE8\u69CA\u69DD\u69BB\u69C3\u69A7\u6A2E\u6991\u69A0\u699C\u6995\u69B4\u69DE\u69E8\u6A02\u6A1B\u69FF\u6B0A\u69F9\u69F2\u69E7\u6A05\u69B1\u6A1E\u69ED\u6A14\u69EB\u6A0A\u6A12\u6AC1\u6A23\u6A13\u6A44\u6A0C\u6A72\u6A36\u6A78\u6A47\u6A62\u6A59\u6A66\u6A48\u6A38\u6A22\u6A90\u6A8D\u6AA0\u6A84\u6AA2\u6AA3"],
      ["dda1", "\u6A97\u8617\u6ABB\u6AC3\u6AC2\u6AB8\u6AB3\u6AAC\u6ADE\u6AD1\u6ADF\u6AAA\u6ADA\u6AEA\u6AFB\u6B05\u8616\u6AFA\u6B12\u6B16\u9B31\u6B1F\u6B38\u6B37\u76DC\u6B39\u98EE\u6B47\u6B43\u6B49\u6B50\u6B59\u6B54\u6B5B\u6B5F\u6B61\u6B78\u6B79\u6B7F\u6B80\u6B84\u6B83\u6B8D\u6B98\u6B95\u6B9E\u6BA4\u6BAA\u6BAB\u6BAF\u6BB2\u6BB1\u6BB3\u6BB7\u6BBC\u6BC6\u6BCB\u6BD3\u6BDF\u6BEC\u6BEB\u6BF3\u6BEF\u9EBE\u6C08\u6C13\u6C14\u6C1B\u6C24\u6C23\u6C5E\u6C55\u6C62\u6C6A\u6C82\u6C8D\u6C9A\u6C81\u6C9B\u6C7E\u6C68\u6C73\u6C92\u6C90\u6CC4\u6CF1\u6CD3\u6CBD\u6CD7\u6CC5\u6CDD\u6CAE\u6CB1\u6CBE"],
      ["dea1", "\u6CBA\u6CDB\u6CEF\u6CD9\u6CEA\u6D1F\u884D\u6D36\u6D2B\u6D3D\u6D38\u6D19\u6D35\u6D33\u6D12\u6D0C\u6D63\u6D93\u6D64\u6D5A\u6D79\u6D59\u6D8E\u6D95\u6FE4\u6D85\u6DF9\u6E15\u6E0A\u6DB5\u6DC7\u6DE6\u6DB8\u6DC6\u6DEC\u6DDE\u6DCC\u6DE8\u6DD2\u6DC5\u6DFA\u6DD9\u6DE4\u6DD5\u6DEA\u6DEE\u6E2D\u6E6E\u6E2E\u6E19\u6E72\u6E5F\u6E3E\u6E23\u6E6B\u6E2B\u6E76\u6E4D\u6E1F\u6E43\u6E3A\u6E4E\u6E24\u6EFF\u6E1D\u6E38\u6E82\u6EAA\u6E98\u6EC9\u6EB7\u6ED3\u6EBD\u6EAF\u6EC4\u6EB2\u6ED4\u6ED5\u6E8F\u6EA5\u6EC2\u6E9F\u6F41\u6F11\u704C\u6EEC\u6EF8\u6EFE\u6F3F\u6EF2\u6F31\u6EEF\u6F32\u6ECC"],
      ["dfa1", "\u6F3E\u6F13\u6EF7\u6F86\u6F7A\u6F78\u6F81\u6F80\u6F6F\u6F5B\u6FF3\u6F6D\u6F82\u6F7C\u6F58\u6F8E\u6F91\u6FC2\u6F66\u6FB3\u6FA3\u6FA1\u6FA4\u6FB9\u6FC6\u6FAA\u6FDF\u6FD5\u6FEC\u6FD4\u6FD8\u6FF1\u6FEE\u6FDB\u7009\u700B\u6FFA\u7011\u7001\u700F\u6FFE\u701B\u701A\u6F74\u701D\u7018\u701F\u7030\u703E\u7032\u7051\u7063\u7099\u7092\u70AF\u70F1\u70AC\u70B8\u70B3\u70AE\u70DF\u70CB\u70DD\u70D9\u7109\u70FD\u711C\u7119\u7165\u7155\u7188\u7166\u7162\u714C\u7156\u716C\u718F\u71FB\u7184\u7195\u71A8\u71AC\u71D7\u71B9\u71BE\u71D2\u71C9\u71D4\u71CE\u71E0\u71EC\u71E7\u71F5\u71FC"],
      ["e0a1", "\u71F9\u71FF\u720D\u7210\u721B\u7228\u722D\u722C\u7230\u7232\u723B\u723C\u723F\u7240\u7246\u724B\u7258\u7274\u727E\u7282\u7281\u7287\u7292\u7296\u72A2\u72A7\u72B9\u72B2\u72C3\u72C6\u72C4\u72CE\u72D2\u72E2\u72E0\u72E1\u72F9\u72F7\u500F\u7317\u730A\u731C\u7316\u731D\u7334\u732F\u7329\u7325\u733E\u734E\u734F\u9ED8\u7357\u736A\u7368\u7370\u7378\u7375\u737B\u737A\u73C8\u73B3\u73CE\u73BB\u73C0\u73E5\u73EE\u73DE\u74A2\u7405\u746F\u7425\u73F8\u7432\u743A\u7455\u743F\u745F\u7459\u7441\u745C\u7469\u7470\u7463\u746A\u7476\u747E\u748B\u749E\u74A7\u74CA\u74CF\u74D4\u73F1"],
      ["e1a1", "\u74E0\u74E3\u74E7\u74E9\u74EE\u74F2\u74F0\u74F1\u74F8\u74F7\u7504\u7503\u7505\u750C\u750E\u750D\u7515\u7513\u751E\u7526\u752C\u753C\u7544\u754D\u754A\u7549\u755B\u7546\u755A\u7569\u7564\u7567\u756B\u756D\u7578\u7576\u7586\u7587\u7574\u758A\u7589\u7582\u7594\u759A\u759D\u75A5\u75A3\u75C2\u75B3\u75C3\u75B5\u75BD\u75B8\u75BC\u75B1\u75CD\u75CA\u75D2\u75D9\u75E3\u75DE\u75FE\u75FF\u75FC\u7601\u75F0\u75FA\u75F2\u75F3\u760B\u760D\u7609\u761F\u7627\u7620\u7621\u7622\u7624\u7634\u7630\u763B\u7647\u7648\u7646\u765C\u7658\u7661\u7662\u7668\u7669\u766A\u7667\u766C\u7670"],
      ["e2a1", "\u7672\u7676\u7678\u767C\u7680\u7683\u7688\u768B\u768E\u7696\u7693\u7699\u769A\u76B0\u76B4\u76B8\u76B9\u76BA\u76C2\u76CD\u76D6\u76D2\u76DE\u76E1\u76E5\u76E7\u76EA\u862F\u76FB\u7708\u7707\u7704\u7729\u7724\u771E\u7725\u7726\u771B\u7737\u7738\u7747\u775A\u7768\u776B\u775B\u7765\u777F\u777E\u7779\u778E\u778B\u7791\u77A0\u779E\u77B0\u77B6\u77B9\u77BF\u77BC\u77BD\u77BB\u77C7\u77CD\u77D7\u77DA\u77DC\u77E3\u77EE\u77FC\u780C\u7812\u7926\u7820\u792A\u7845\u788E\u7874\u7886\u787C\u789A\u788C\u78A3\u78B5\u78AA\u78AF\u78D1\u78C6\u78CB\u78D4\u78BE\u78BC\u78C5\u78CA\u78EC"],
      ["e3a1", "\u78E7\u78DA\u78FD\u78F4\u7907\u7912\u7911\u7919\u792C\u792B\u7940\u7960\u7957\u795F\u795A\u7955\u7953\u797A\u797F\u798A\u799D\u79A7\u9F4B\u79AA\u79AE\u79B3\u79B9\u79BA\u79C9\u79D5\u79E7\u79EC\u79E1\u79E3\u7A08\u7A0D\u7A18\u7A19\u7A20\u7A1F\u7980\u7A31\u7A3B\u7A3E\u7A37\u7A43\u7A57\u7A49\u7A61\u7A62\u7A69\u9F9D\u7A70\u7A79\u7A7D\u7A88\u7A97\u7A95\u7A98\u7A96\u7AA9\u7AC8\u7AB0\u7AB6\u7AC5\u7AC4\u7ABF\u9083\u7AC7\u7ACA\u7ACD\u7ACF\u7AD5\u7AD3\u7AD9\u7ADA\u7ADD\u7AE1\u7AE2\u7AE6\u7AED\u7AF0\u7B02\u7B0F\u7B0A\u7B06\u7B33\u7B18\u7B19\u7B1E\u7B35\u7B28\u7B36\u7B50"],
      ["e4a1", "\u7B7A\u7B04\u7B4D\u7B0B\u7B4C\u7B45\u7B75\u7B65\u7B74\u7B67\u7B70\u7B71\u7B6C\u7B6E\u7B9D\u7B98\u7B9F\u7B8D\u7B9C\u7B9A\u7B8B\u7B92\u7B8F\u7B5D\u7B99\u7BCB\u7BC1\u7BCC\u7BCF\u7BB4\u7BC6\u7BDD\u7BE9\u7C11\u7C14\u7BE6\u7BE5\u7C60\u7C00\u7C07\u7C13\u7BF3\u7BF7\u7C17\u7C0D\u7BF6\u7C23\u7C27\u7C2A\u7C1F\u7C37\u7C2B\u7C3D\u7C4C\u7C43\u7C54\u7C4F\u7C40\u7C50\u7C58\u7C5F\u7C64\u7C56\u7C65\u7C6C\u7C75\u7C83\u7C90\u7CA4\u7CAD\u7CA2\u7CAB\u7CA1\u7CA8\u7CB3\u7CB2\u7CB1\u7CAE\u7CB9\u7CBD\u7CC0\u7CC5\u7CC2\u7CD8\u7CD2\u7CDC\u7CE2\u9B3B\u7CEF\u7CF2\u7CF4\u7CF6\u7CFA\u7D06"],
      ["e5a1", "\u7D02\u7D1C\u7D15\u7D0A\u7D45\u7D4B\u7D2E\u7D32\u7D3F\u7D35\u7D46\u7D73\u7D56\u7D4E\u7D72\u7D68\u7D6E\u7D4F\u7D63\u7D93\u7D89\u7D5B\u7D8F\u7D7D\u7D9B\u7DBA\u7DAE\u7DA3\u7DB5\u7DC7\u7DBD\u7DAB\u7E3D\u7DA2\u7DAF\u7DDC\u7DB8\u7D9F\u7DB0\u7DD8\u7DDD\u7DE4\u7DDE\u7DFB\u7DF2\u7DE1\u7E05\u7E0A\u7E23\u7E21\u7E12\u7E31\u7E1F\u7E09\u7E0B\u7E22\u7E46\u7E66\u7E3B\u7E35\u7E39\u7E43\u7E37\u7E32\u7E3A\u7E67\u7E5D\u7E56\u7E5E\u7E59\u7E5A\u7E79\u7E6A\u7E69\u7E7C\u7E7B\u7E83\u7DD5\u7E7D\u8FAE\u7E7F\u7E88\u7E89\u7E8C\u7E92\u7E90\u7E93\u7E94\u7E96\u7E8E\u7E9B\u7E9C\u7F38\u7F3A"],
      ["e6a1", "\u7F45\u7F4C\u7F4D\u7F4E\u7F50\u7F51\u7F55\u7F54\u7F58\u7F5F\u7F60\u7F68\u7F69\u7F67\u7F78\u7F82\u7F86\u7F83\u7F88\u7F87\u7F8C\u7F94\u7F9E\u7F9D\u7F9A\u7FA3\u7FAF\u7FB2\u7FB9\u7FAE\u7FB6\u7FB8\u8B71\u7FC5\u7FC6\u7FCA\u7FD5\u7FD4\u7FE1\u7FE6\u7FE9\u7FF3\u7FF9\u98DC\u8006\u8004\u800B\u8012\u8018\u8019\u801C\u8021\u8028\u803F\u803B\u804A\u8046\u8052\u8058\u805A\u805F\u8062\u8068\u8073\u8072\u8070\u8076\u8079\u807D\u807F\u8084\u8086\u8085\u809B\u8093\u809A\u80AD\u5190\u80AC\u80DB\u80E5\u80D9\u80DD\u80C4\u80DA\u80D6\u8109\u80EF\u80F1\u811B\u8129\u8123\u812F\u814B"],
      ["e7a1", "\u968B\u8146\u813E\u8153\u8151\u80FC\u8171\u816E\u8165\u8166\u8174\u8183\u8188\u818A\u8180\u8182\u81A0\u8195\u81A4\u81A3\u815F\u8193\u81A9\u81B0\u81B5\u81BE\u81B8\u81BD\u81C0\u81C2\u81BA\u81C9\u81CD\u81D1\u81D9\u81D8\u81C8\u81DA\u81DF\u81E0\u81E7\u81FA\u81FB\u81FE\u8201\u8202\u8205\u8207\u820A\u820D\u8210\u8216\u8229\u822B\u8238\u8233\u8240\u8259\u8258\u825D\u825A\u825F\u8264\u8262\u8268\u826A\u826B\u822E\u8271\u8277\u8278\u827E\u828D\u8292\u82AB\u829F\u82BB\u82AC\u82E1\u82E3\u82DF\u82D2\u82F4\u82F3\u82FA\u8393\u8303\u82FB\u82F9\u82DE\u8306\u82DC\u8309\u82D9"],
      ["e8a1", "\u8335\u8334\u8316\u8332\u8331\u8340\u8339\u8350\u8345\u832F\u832B\u8317\u8318\u8385\u839A\u83AA\u839F\u83A2\u8396\u8323\u838E\u8387\u838A\u837C\u83B5\u8373\u8375\u83A0\u8389\u83A8\u83F4\u8413\u83EB\u83CE\u83FD\u8403\u83D8\u840B\u83C1\u83F7\u8407\u83E0\u83F2\u840D\u8422\u8420\u83BD\u8438\u8506\u83FB\u846D\u842A\u843C\u855A\u8484\u8477\u846B\u84AD\u846E\u8482\u8469\u8446\u842C\u846F\u8479\u8435\u84CA\u8462\u84B9\u84BF\u849F\u84D9\u84CD\u84BB\u84DA\u84D0\u84C1\u84C6\u84D6\u84A1\u8521\u84FF\u84F4\u8517\u8518\u852C\u851F\u8515\u8514\u84FC\u8540\u8563\u8558\u8548"],
      ["e9a1", "\u8541\u8602\u854B\u8555\u8580\u85A4\u8588\u8591\u858A\u85A8\u856D\u8594\u859B\u85EA\u8587\u859C\u8577\u857E\u8590\u85C9\u85BA\u85CF\u85B9\u85D0\u85D5\u85DD\u85E5\u85DC\u85F9\u860A\u8613\u860B\u85FE\u85FA\u8606\u8622\u861A\u8630\u863F\u864D\u4E55\u8654\u865F\u8667\u8671\u8693\u86A3\u86A9\u86AA\u868B\u868C\u86B6\u86AF\u86C4\u86C6\u86B0\u86C9\u8823\u86AB\u86D4\u86DE\u86E9\u86EC\u86DF\u86DB\u86EF\u8712\u8706\u8708\u8700\u8703\u86FB\u8711\u8709\u870D\u86F9\u870A\u8734\u873F\u8737\u873B\u8725\u8729\u871A\u8760\u875F\u8778\u874C\u874E\u8774\u8757\u8768\u876E\u8759"],
      ["eaa1", "\u8753\u8763\u876A\u8805\u87A2\u879F\u8782\u87AF\u87CB\u87BD\u87C0\u87D0\u96D6\u87AB\u87C4\u87B3\u87C7\u87C6\u87BB\u87EF\u87F2\u87E0\u880F\u880D\u87FE\u87F6\u87F7\u880E\u87D2\u8811\u8816\u8815\u8822\u8821\u8831\u8836\u8839\u8827\u883B\u8844\u8842\u8852\u8859\u885E\u8862\u886B\u8881\u887E\u889E\u8875\u887D\u88B5\u8872\u8882\u8897\u8892\u88AE\u8899\u88A2\u888D\u88A4\u88B0\u88BF\u88B1\u88C3\u88C4\u88D4\u88D8\u88D9\u88DD\u88F9\u8902\u88FC\u88F4\u88E8\u88F2\u8904\u890C\u890A\u8913\u8943\u891E\u8925\u892A\u892B\u8941\u8944\u893B\u8936\u8938\u894C\u891D\u8960\u895E"],
      ["eba1", "\u8966\u8964\u896D\u896A\u896F\u8974\u8977\u897E\u8983\u8988\u898A\u8993\u8998\u89A1\u89A9\u89A6\u89AC\u89AF\u89B2\u89BA\u89BD\u89BF\u89C0\u89DA\u89DC\u89DD\u89E7\u89F4\u89F8\u8A03\u8A16\u8A10\u8A0C\u8A1B\u8A1D\u8A25\u8A36\u8A41\u8A5B\u8A52\u8A46\u8A48\u8A7C\u8A6D\u8A6C\u8A62\u8A85\u8A82\u8A84\u8AA8\u8AA1\u8A91\u8AA5\u8AA6\u8A9A\u8AA3\u8AC4\u8ACD\u8AC2\u8ADA\u8AEB\u8AF3\u8AE7\u8AE4\u8AF1\u8B14\u8AE0\u8AE2\u8AF7\u8ADE\u8ADB\u8B0C\u8B07\u8B1A\u8AE1\u8B16\u8B10\u8B17\u8B20\u8B33\u97AB\u8B26\u8B2B\u8B3E\u8B28\u8B41\u8B4C\u8B4F\u8B4E\u8B49\u8B56\u8B5B\u8B5A\u8B6B"],
      ["eca1", "\u8B5F\u8B6C\u8B6F\u8B74\u8B7D\u8B80\u8B8C\u8B8E\u8B92\u8B93\u8B96\u8B99\u8B9A\u8C3A\u8C41\u8C3F\u8C48\u8C4C\u8C4E\u8C50\u8C55\u8C62\u8C6C\u8C78\u8C7A\u8C82\u8C89\u8C85\u8C8A\u8C8D\u8C8E\u8C94\u8C7C\u8C98\u621D\u8CAD\u8CAA\u8CBD\u8CB2\u8CB3\u8CAE\u8CB6\u8CC8\u8CC1\u8CE4\u8CE3\u8CDA\u8CFD\u8CFA\u8CFB\u8D04\u8D05\u8D0A\u8D07\u8D0F\u8D0D\u8D10\u9F4E\u8D13\u8CCD\u8D14\u8D16\u8D67\u8D6D\u8D71\u8D73\u8D81\u8D99\u8DC2\u8DBE\u8DBA\u8DCF\u8DDA\u8DD6\u8DCC\u8DDB\u8DCB\u8DEA\u8DEB\u8DDF\u8DE3\u8DFC\u8E08\u8E09\u8DFF\u8E1D\u8E1E\u8E10\u8E1F\u8E42\u8E35\u8E30\u8E34\u8E4A"],
      ["eda1", "\u8E47\u8E49\u8E4C\u8E50\u8E48\u8E59\u8E64\u8E60\u8E2A\u8E63\u8E55\u8E76\u8E72\u8E7C\u8E81\u8E87\u8E85\u8E84\u8E8B\u8E8A\u8E93\u8E91\u8E94\u8E99\u8EAA\u8EA1\u8EAC\u8EB0\u8EC6\u8EB1\u8EBE\u8EC5\u8EC8\u8ECB\u8EDB\u8EE3\u8EFC\u8EFB\u8EEB\u8EFE\u8F0A\u8F05\u8F15\u8F12\u8F19\u8F13\u8F1C\u8F1F\u8F1B\u8F0C\u8F26\u8F33\u8F3B\u8F39\u8F45\u8F42\u8F3E\u8F4C\u8F49\u8F46\u8F4E\u8F57\u8F5C\u8F62\u8F63\u8F64\u8F9C\u8F9F\u8FA3\u8FAD\u8FAF\u8FB7\u8FDA\u8FE5\u8FE2\u8FEA\u8FEF\u9087\u8FF4\u9005\u8FF9\u8FFA\u9011\u9015\u9021\u900D\u901E\u9016\u900B\u9027\u9036\u9035\u9039\u8FF8"],
      ["eea1", "\u904F\u9050\u9051\u9052\u900E\u9049\u903E\u9056\u9058\u905E\u9068\u906F\u9076\u96A8\u9072\u9082\u907D\u9081\u9080\u908A\u9089\u908F\u90A8\u90AF\u90B1\u90B5\u90E2\u90E4\u6248\u90DB\u9102\u9112\u9119\u9132\u9130\u914A\u9156\u9158\u9163\u9165\u9169\u9173\u9172\u918B\u9189\u9182\u91A2\u91AB\u91AF\u91AA\u91B5\u91B4\u91BA\u91C0\u91C1\u91C9\u91CB\u91D0\u91D6\u91DF\u91E1\u91DB\u91FC\u91F5\u91F6\u921E\u91FF\u9214\u922C\u9215\u9211\u925E\u9257\u9245\u9249\u9264\u9248\u9295\u923F\u924B\u9250\u929C\u9296\u9293\u929B\u925A\u92CF\u92B9\u92B7\u92E9\u930F\u92FA\u9344\u932E"],
      ["efa1", "\u9319\u9322\u931A\u9323\u933A\u9335\u933B\u935C\u9360\u937C\u936E\u9356\u93B0\u93AC\u93AD\u9394\u93B9\u93D6\u93D7\u93E8\u93E5\u93D8\u93C3\u93DD\u93D0\u93C8\u93E4\u941A\u9414\u9413\u9403\u9407\u9410\u9436\u942B\u9435\u9421\u943A\u9441\u9452\u9444\u945B\u9460\u9462\u945E\u946A\u9229\u9470\u9475\u9477\u947D\u945A\u947C\u947E\u9481\u947F\u9582\u9587\u958A\u9594\u9596\u9598\u9599\u95A0\u95A8\u95A7\u95AD\u95BC\u95BB\u95B9\u95BE\u95CA\u6FF6\u95C3\u95CD\u95CC\u95D5\u95D4\u95D6\u95DC\u95E1\u95E5\u95E2\u9621\u9628\u962E\u962F\u9642\u964C\u964F\u964B\u9677\u965C\u965E"],
      ["f0a1", "\u965D\u965F\u9666\u9672\u966C\u968D\u9698\u9695\u9697\u96AA\u96A7\u96B1\u96B2\u96B0\u96B4\u96B6\u96B8\u96B9\u96CE\u96CB\u96C9\u96CD\u894D\u96DC\u970D\u96D5\u96F9\u9704\u9706\u9708\u9713\u970E\u9711\u970F\u9716\u9719\u9724\u972A\u9730\u9739\u973D\u973E\u9744\u9746\u9748\u9742\u9749\u975C\u9760\u9764\u9766\u9768\u52D2\u976B\u9771\u9779\u9785\u977C\u9781\u977A\u9786\u978B\u978F\u9790\u979C\u97A8\u97A6\u97A3\u97B3\u97B4\u97C3\u97C6\u97C8\u97CB\u97DC\u97ED\u9F4F\u97F2\u7ADF\u97F6\u97F5\u980F\u980C\u9838\u9824\u9821\u9837\u983D\u9846\u984F\u984B\u986B\u986F\u9870"],
      ["f1a1", "\u9871\u9874\u9873\u98AA\u98AF\u98B1\u98B6\u98C4\u98C3\u98C6\u98E9\u98EB\u9903\u9909\u9912\u9914\u9918\u9921\u991D\u991E\u9924\u9920\u992C\u992E\u993D\u993E\u9942\u9949\u9945\u9950\u994B\u9951\u9952\u994C\u9955\u9997\u9998\u99A5\u99AD\u99AE\u99BC\u99DF\u99DB\u99DD\u99D8\u99D1\u99ED\u99EE\u99F1\u99F2\u99FB\u99F8\u9A01\u9A0F\u9A05\u99E2\u9A19\u9A2B\u9A37\u9A45\u9A42\u9A40\u9A43\u9A3E\u9A55\u9A4D\u9A5B\u9A57\u9A5F\u9A62\u9A65\u9A64\u9A69\u9A6B\u9A6A\u9AAD\u9AB0\u9ABC\u9AC0\u9ACF\u9AD1\u9AD3\u9AD4\u9ADE\u9ADF\u9AE2\u9AE3\u9AE6\u9AEF\u9AEB\u9AEE\u9AF4\u9AF1\u9AF7"],
      ["f2a1", "\u9AFB\u9B06\u9B18\u9B1A\u9B1F\u9B22\u9B23\u9B25\u9B27\u9B28\u9B29\u9B2A\u9B2E\u9B2F\u9B32\u9B44\u9B43\u9B4F\u9B4D\u9B4E\u9B51\u9B58\u9B74\u9B93\u9B83\u9B91\u9B96\u9B97\u9B9F\u9BA0\u9BA8\u9BB4\u9BC0\u9BCA\u9BB9\u9BC6\u9BCF\u9BD1\u9BD2\u9BE3\u9BE2\u9BE4\u9BD4\u9BE1\u9C3A\u9BF2\u9BF1\u9BF0\u9C15\u9C14\u9C09\u9C13\u9C0C\u9C06\u9C08\u9C12\u9C0A\u9C04\u9C2E\u9C1B\u9C25\u9C24\u9C21\u9C30\u9C47\u9C32\u9C46\u9C3E\u9C5A\u9C60\u9C67\u9C76\u9C78\u9CE7\u9CEC\u9CF0\u9D09\u9D08\u9CEB\u9D03\u9D06\u9D2A\u9D26\u9DAF\u9D23\u9D1F\u9D44\u9D15\u9D12\u9D41\u9D3F\u9D3E\u9D46\u9D48"],
      ["f3a1", "\u9D5D\u9D5E\u9D64\u9D51\u9D50\u9D59\u9D72\u9D89\u9D87\u9DAB\u9D6F\u9D7A\u9D9A\u9DA4\u9DA9\u9DB2\u9DC4\u9DC1\u9DBB\u9DB8\u9DBA\u9DC6\u9DCF\u9DC2\u9DD9\u9DD3\u9DF8\u9DE6\u9DED\u9DEF\u9DFD\u9E1A\u9E1B\u9E1E\u9E75\u9E79\u9E7D\u9E81\u9E88\u9E8B\u9E8C\u9E92\u9E95\u9E91\u9E9D\u9EA5\u9EA9\u9EB8\u9EAA\u9EAD\u9761\u9ECC\u9ECE\u9ECF\u9ED0\u9ED4\u9EDC\u9EDE\u9EDD\u9EE0\u9EE5\u9EE8\u9EEF\u9EF4\u9EF6\u9EF7\u9EF9\u9EFB\u9EFC\u9EFD\u9F07\u9F08\u76B7\u9F15\u9F21\u9F2C\u9F3E\u9F4A\u9F52\u9F54\u9F63\u9F5F\u9F60\u9F61\u9F66\u9F67\u9F6C\u9F6A\u9F77\u9F72\u9F76\u9F95\u9F9C\u9FA0"],
      ["f4a1", "\u582F\u69C7\u9059\u7464\u51DC\u7199"],
      ["f9a1", "\u7E8A\u891C\u9348\u9288\u84DC\u4FC9\u70BB\u6631\u68C8\u92F9\u66FB\u5F45\u4E28\u4EE1\u4EFC\u4F00\u4F03\u4F39\u4F56\u4F92\u4F8A\u4F9A\u4F94\u4FCD\u5040\u5022\u4FFF\u501E\u5046\u5070\u5042\u5094\u50F4\u50D8\u514A\u5164\u519D\u51BE\u51EC\u5215\u529C\u52A6\u52C0\u52DB\u5300\u5307\u5324\u5372\u5393\u53B2\u53DD\uFA0E\u549C\u548A\u54A9\u54FF\u5586\u5759\u5765\u57AC\u57C8\u57C7\uFA0F\uFA10\u589E\u58B2\u590B\u5953\u595B\u595D\u5963\u59A4\u59BA\u5B56\u5BC0\u752F\u5BD8\u5BEC\u5C1E\u5CA6\u5CBA\u5CF5\u5D27\u5D53\uFA11\u5D42\u5D6D\u5DB8\u5DB9\u5DD0\u5F21\u5F34\u5F67\u5FB7"],
      ["faa1", "\u5FDE\u605D\u6085\u608A\u60DE\u60D5\u6120\u60F2\u6111\u6137\u6130\u6198\u6213\u62A6\u63F5\u6460\u649D\u64CE\u654E\u6600\u6615\u663B\u6609\u662E\u661E\u6624\u6665\u6657\u6659\uFA12\u6673\u6699\u66A0\u66B2\u66BF\u66FA\u670E\uF929\u6766\u67BB\u6852\u67C0\u6801\u6844\u68CF\uFA13\u6968\uFA14\u6998\u69E2\u6A30\u6A6B\u6A46\u6A73\u6A7E\u6AE2\u6AE4\u6BD6\u6C3F\u6C5C\u6C86\u6C6F\u6CDA\u6D04\u6D87\u6D6F\u6D96\u6DAC\u6DCF\u6DF8\u6DF2\u6DFC\u6E39\u6E5C\u6E27\u6E3C\u6EBF\u6F88\u6FB5\u6FF5\u7005\u7007\u7028\u7085\u70AB\u710F\u7104\u715C\u7146\u7147\uFA15\u71C1\u71FE\u72B1"],
      ["fba1", "\u72BE\u7324\uFA16\u7377\u73BD\u73C9\u73D6\u73E3\u73D2\u7407\u73F5\u7426\u742A\u7429\u742E\u7462\u7489\u749F\u7501\u756F\u7682\u769C\u769E\u769B\u76A6\uFA17\u7746\u52AF\u7821\u784E\u7864\u787A\u7930\uFA18\uFA19\uFA1A\u7994\uFA1B\u799B\u7AD1\u7AE7\uFA1C\u7AEB\u7B9E\uFA1D\u7D48\u7D5C\u7DB7\u7DA0\u7DD6\u7E52\u7F47\u7FA1\uFA1E\u8301\u8362\u837F\u83C7\u83F6\u8448\u84B4\u8553\u8559\u856B\uFA1F\u85B0\uFA20\uFA21\u8807\u88F5\u8A12\u8A37\u8A79\u8AA7\u8ABE\u8ADF\uFA22\u8AF6\u8B53\u8B7F\u8CF0\u8CF4\u8D12\u8D76\uFA23\u8ECF\uFA24\uFA25\u9067\u90DE\uFA26\u9115\u9127\u91DA"],
      ["fca1", "\u91D7\u91DE\u91ED\u91EE\u91E4\u91E5\u9206\u9210\u920A\u923A\u9240\u923C\u924E\u9259\u9251\u9239\u9267\u92A7\u9277\u9278\u92E7\u92D7\u92D9\u92D0\uFA27\u92D5\u92E0\u92D3\u9325\u9321\u92FB\uFA28\u931E\u92FF\u931D\u9302\u9370\u9357\u93A4\u93C6\u93DE\u93F8\u9431\u9445\u9448\u9592\uF9DC\uFA29\u969D\u96AF\u9733\u973B\u9743\u974D\u974F\u9751\u9755\u9857\u9865\uFA2A\uFA2B\u9927\uFA2C\u999E\u9A4E\u9AD9\u9ADC\u9B75\u9B72\u9B8F\u9BB1\u9BBB\u9C00\u9D70\u9D6B\uFA2D\u9E19\u9ED1"],
      ["fcf1", "\u2170", 9, "\uFFE2\uFFE4\uFF07\uFF02"],
      ["8fa2af", "\u02D8\u02C7\xB8\u02D9\u02DD\xAF\u02DB\u02DA\uFF5E\u0384\u0385"],
      ["8fa2c2", "\xA1\xA6\xBF"],
      ["8fa2eb", "\xBA\xAA\xA9\xAE\u2122\xA4\u2116"],
      ["8fa6e1", "\u0386\u0388\u0389\u038A\u03AA"],
      ["8fa6e7", "\u038C"],
      ["8fa6e9", "\u038E\u03AB"],
      ["8fa6ec", "\u038F"],
      ["8fa6f1", "\u03AC\u03AD\u03AE\u03AF\u03CA\u0390\u03CC\u03C2\u03CD\u03CB\u03B0\u03CE"],
      ["8fa7c2", "\u0402", 10, "\u040E\u040F"],
      ["8fa7f2", "\u0452", 10, "\u045E\u045F"],
      ["8fa9a1", "\xC6\u0110"],
      ["8fa9a4", "\u0126"],
      ["8fa9a6", "\u0132"],
      ["8fa9a8", "\u0141\u013F"],
      ["8fa9ab", "\u014A\xD8\u0152"],
      ["8fa9af", "\u0166\xDE"],
      ["8fa9c1", "\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0142\u0140\u0149\u014B\xF8\u0153\xDF\u0167\xFE"],
      ["8faaa1", "\xC1\xC0\xC4\xC2\u0102\u01CD\u0100\u0104\xC5\xC3\u0106\u0108\u010C\xC7\u010A\u010E\xC9\xC8\xCB\xCA\u011A\u0116\u0112\u0118"],
      ["8faaba", "\u011C\u011E\u0122\u0120\u0124\xCD\xCC\xCF\xCE\u01CF\u0130\u012A\u012E\u0128\u0134\u0136\u0139\u013D\u013B\u0143\u0147\u0145\xD1\xD3\xD2\xD6\xD4\u01D1\u0150\u014C\xD5\u0154\u0158\u0156\u015A\u015C\u0160\u015E\u0164\u0162\xDA\xD9\xDC\xDB\u016C\u01D3\u0170\u016A\u0172\u016E\u0168\u01D7\u01DB\u01D9\u01D5\u0174\xDD\u0178\u0176\u0179\u017D\u017B"],
      ["8faba1", "\xE1\xE0\xE4\xE2\u0103\u01CE\u0101\u0105\xE5\xE3\u0107\u0109\u010D\xE7\u010B\u010F\xE9\xE8\xEB\xEA\u011B\u0117\u0113\u0119\u01F5\u011D\u011F"],
      ["8fabbd", "\u0121\u0125\xED\xEC\xEF\xEE\u01D0"],
      ["8fabc5", "\u012B\u012F\u0129\u0135\u0137\u013A\u013E\u013C\u0144\u0148\u0146\xF1\xF3\xF2\xF6\xF4\u01D2\u0151\u014D\xF5\u0155\u0159\u0157\u015B\u015D\u0161\u015F\u0165\u0163\xFA\xF9\xFC\xFB\u016D\u01D4\u0171\u016B\u0173\u016F\u0169\u01D8\u01DC\u01DA\u01D6\u0175\xFD\xFF\u0177\u017A\u017E\u017C"],
      ["8fb0a1", "\u4E02\u4E04\u4E05\u4E0C\u4E12\u4E1F\u4E23\u4E24\u4E28\u4E2B\u4E2E\u4E2F\u4E30\u4E35\u4E40\u4E41\u4E44\u4E47\u4E51\u4E5A\u4E5C\u4E63\u4E68\u4E69\u4E74\u4E75\u4E79\u4E7F\u4E8D\u4E96\u4E97\u4E9D\u4EAF\u4EB9\u4EC3\u4ED0\u4EDA\u4EDB\u4EE0\u4EE1\u4EE2\u4EE8\u4EEF\u4EF1\u4EF3\u4EF5\u4EFD\u4EFE\u4EFF\u4F00\u4F02\u4F03\u4F08\u4F0B\u4F0C\u4F12\u4F15\u4F16\u4F17\u4F19\u4F2E\u4F31\u4F60\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E\u4F40\u4F42\u4F48\u4F49\u4F4B\u4F4C\u4F52\u4F54\u4F56\u4F58\u4F5F\u4F63\u4F6A\u4F6C\u4F6E\u4F71\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F7E\u4F81\u4F82\u4F84"],
      ["8fb1a1", "\u4F85\u4F89\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F94\u4F97\u4F99\u4F9A\u4F9E\u4F9F\u4FB2\u4FB7\u4FB9\u4FBB\u4FBC\u4FBD\u4FBE\u4FC0\u4FC1\u4FC5\u4FC6\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FCF\u4FD2\u4FDC\u4FE0\u4FE2\u4FF0\u4FF2\u4FFC\u4FFD\u4FFF\u5000\u5001\u5004\u5007\u500A\u500C\u500E\u5010\u5013\u5017\u5018\u501B\u501C\u501D\u501E\u5022\u5027\u502E\u5030\u5032\u5033\u5035\u5040\u5041\u5042\u5045\u5046\u504A\u504C\u504E\u5051\u5052\u5053\u5057\u5059\u505F\u5060\u5062\u5063\u5066\u5067\u506A\u506D\u5070\u5071\u503B\u5081\u5083\u5084\u5086\u508A\u508E\u508F\u5090"],
      ["8fb2a1", "\u5092\u5093\u5094\u5096\u509B\u509C\u509E", 4, "\u50AA\u50AF\u50B0\u50B9\u50BA\u50BD\u50C0\u50C3\u50C4\u50C7\u50CC\u50CE\u50D0\u50D3\u50D4\u50D8\u50DC\u50DD\u50DF\u50E2\u50E4\u50E6\u50E8\u50E9\u50EF\u50F1\u50F6\u50FA\u50FE\u5103\u5106\u5107\u5108\u510B\u510C\u510D\u510E\u50F2\u5110\u5117\u5119\u511B\u511C\u511D\u511E\u5123\u5127\u5128\u512C\u512D\u512F\u5131\u5133\u5134\u5135\u5138\u5139\u5142\u514A\u514F\u5153\u5155\u5157\u5158\u515F\u5164\u5166\u517E\u5183\u5184\u518B\u518E\u5198\u519D\u51A1\u51A3\u51AD\u51B8\u51BA\u51BC\u51BE\u51BF\u51C2"],
      ["8fb3a1", "\u51C8\u51CF\u51D1\u51D2\u51D3\u51D5\u51D8\u51DE\u51E2\u51E5\u51EE\u51F2\u51F3\u51F4\u51F7\u5201\u5202\u5205\u5212\u5213\u5215\u5216\u5218\u5222\u5228\u5231\u5232\u5235\u523C\u5245\u5249\u5255\u5257\u5258\u525A\u525C\u525F\u5260\u5261\u5266\u526E\u5277\u5278\u5279\u5280\u5282\u5285\u528A\u528C\u5293\u5295\u5296\u5297\u5298\u529A\u529C\u52A4\u52A5\u52A6\u52A7\u52AF\u52B0\u52B6\u52B7\u52B8\u52BA\u52BB\u52BD\u52C0\u52C4\u52C6\u52C8\u52CC\u52CF\u52D1\u52D4\u52D6\u52DB\u52DC\u52E1\u52E5\u52E8\u52E9\u52EA\u52EC\u52F0\u52F1\u52F4\u52F6\u52F7\u5300\u5303\u530A\u530B"],
      ["8fb4a1", "\u530C\u5311\u5313\u5318\u531B\u531C\u531E\u531F\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u5330\u5332\u5335\u533C\u533D\u533E\u5342\u534C\u534B\u5359\u535B\u5361\u5363\u5365\u536C\u536D\u5372\u5379\u537E\u5383\u5387\u5388\u538E\u5393\u5394\u5399\u539D\u53A1\u53A4\u53AA\u53AB\u53AF\u53B2\u53B4\u53B5\u53B7\u53B8\u53BA\u53BD\u53C0\u53C5\u53CF\u53D2\u53D3\u53D5\u53DA\u53DD\u53DE\u53E0\u53E6\u53E7\u53F5\u5402\u5413\u541A\u5421\u5427\u5428\u542A\u542F\u5431\u5434\u5435\u5443\u5444\u5447\u544D\u544F\u545E\u5462\u5464\u5466\u5467\u5469\u546B\u546D\u546E\u5474\u547F"],
      ["8fb5a1", "\u5481\u5483\u5485\u5488\u5489\u548D\u5491\u5495\u5496\u549C\u549F\u54A1\u54A6\u54A7\u54A9\u54AA\u54AD\u54AE\u54B1\u54B7\u54B9\u54BA\u54BB\u54BF\u54C6\u54CA\u54CD\u54CE\u54E0\u54EA\u54EC\u54EF\u54F6\u54FC\u54FE\u54FF\u5500\u5501\u5505\u5508\u5509\u550C\u550D\u550E\u5515\u552A\u552B\u5532\u5535\u5536\u553B\u553C\u553D\u5541\u5547\u5549\u554A\u554D\u5550\u5551\u5558\u555A\u555B\u555E\u5560\u5561\u5564\u5566\u557F\u5581\u5582\u5586\u5588\u558E\u558F\u5591\u5592\u5593\u5594\u5597\u55A3\u55A4\u55AD\u55B2\u55BF\u55C1\u55C3\u55C6\u55C9\u55CB\u55CC\u55CE\u55D1\u55D2"],
      ["8fb6a1", "\u55D3\u55D7\u55D8\u55DB\u55DE\u55E2\u55E9\u55F6\u55FF\u5605\u5608\u560A\u560D", 5, "\u5619\u562C\u5630\u5633\u5635\u5637\u5639\u563B\u563C\u563D\u563F\u5640\u5641\u5643\u5644\u5646\u5649\u564B\u564D\u564F\u5654\u565E\u5660\u5661\u5662\u5663\u5666\u5669\u566D\u566F\u5671\u5672\u5675\u5684\u5685\u5688\u568B\u568C\u5695\u5699\u569A\u569D\u569E\u569F\u56A6\u56A7\u56A8\u56A9\u56AB\u56AC\u56AD\u56B1\u56B3\u56B7\u56BE\u56C5\u56C9\u56CA\u56CB\u56CF\u56D0\u56CC\u56CD\u56D9\u56DC\u56DD\u56DF\u56E1\u56E4", 4, "\u56F1\u56EB\u56ED"],
      ["8fb7a1", "\u56F6\u56F7\u5701\u5702\u5707\u570A\u570C\u5711\u5715\u571A\u571B\u571D\u5720\u5722\u5723\u5724\u5725\u5729\u572A\u572C\u572E\u572F\u5733\u5734\u573D\u573E\u573F\u5745\u5746\u574C\u574D\u5752\u5762\u5765\u5767\u5768\u576B\u576D", 4, "\u5773\u5774\u5775\u5777\u5779\u577A\u577B\u577C\u577E\u5781\u5783\u578C\u5794\u5797\u5799\u579A\u579C\u579D\u579E\u579F\u57A1\u5795\u57A7\u57A8\u57A9\u57AC\u57B8\u57BD\u57C7\u57C8\u57CC\u57CF\u57D5\u57DD\u57DE\u57E4\u57E6\u57E7\u57E9\u57ED\u57F0\u57F5\u57F6\u57F8\u57FD\u57FE\u57FF\u5803\u5804\u5808\u5809\u57E1"],
      ["8fb8a1", "\u580C\u580D\u581B\u581E\u581F\u5820\u5826\u5827\u582D\u5832\u5839\u583F\u5849\u584C\u584D\u584F\u5850\u5855\u585F\u5861\u5864\u5867\u5868\u5878\u587C\u587F\u5880\u5881\u5887\u5888\u5889\u588A\u588C\u588D\u588F\u5890\u5894\u5896\u589D\u58A0\u58A1\u58A2\u58A6\u58A9\u58B1\u58B2\u58C4\u58BC\u58C2\u58C8\u58CD\u58CE\u58D0\u58D2\u58D4\u58D6\u58DA\u58DD\u58E1\u58E2\u58E9\u58F3\u5905\u5906\u590B\u590C\u5912\u5913\u5914\u8641\u591D\u5921\u5923\u5924\u5928\u592F\u5930\u5933\u5935\u5936\u593F\u5943\u5946\u5952\u5953\u5959\u595B\u595D\u595E\u595F\u5961\u5963\u596B\u596D"],
      ["8fb9a1", "\u596F\u5972\u5975\u5976\u5979\u597B\u597C\u598B\u598C\u598E\u5992\u5995\u5997\u599F\u59A4\u59A7\u59AD\u59AE\u59AF\u59B0\u59B3\u59B7\u59BA\u59BC\u59C1\u59C3\u59C4\u59C8\u59CA\u59CD\u59D2\u59DD\u59DE\u59DF\u59E3\u59E4\u59E7\u59EE\u59EF\u59F1\u59F2\u59F4\u59F7\u5A00\u5A04\u5A0C\u5A0D\u5A0E\u5A12\u5A13\u5A1E\u5A23\u5A24\u5A27\u5A28\u5A2A\u5A2D\u5A30\u5A44\u5A45\u5A47\u5A48\u5A4C\u5A50\u5A55\u5A5E\u5A63\u5A65\u5A67\u5A6D\u5A77\u5A7A\u5A7B\u5A7E\u5A8B\u5A90\u5A93\u5A96\u5A99\u5A9C\u5A9E\u5A9F\u5AA0\u5AA2\u5AA7\u5AAC\u5AB1\u5AB2\u5AB3\u5AB5\u5AB8\u5ABA\u5ABB\u5ABF"],
      ["8fbaa1", "\u5AC4\u5AC6\u5AC8\u5ACF\u5ADA\u5ADC\u5AE0\u5AE5\u5AEA\u5AEE\u5AF5\u5AF6\u5AFD\u5B00\u5B01\u5B08\u5B17\u5B34\u5B19\u5B1B\u5B1D\u5B21\u5B25\u5B2D\u5B38\u5B41\u5B4B\u5B4C\u5B52\u5B56\u5B5E\u5B68\u5B6E\u5B6F\u5B7C\u5B7D\u5B7E\u5B7F\u5B81\u5B84\u5B86\u5B8A\u5B8E\u5B90\u5B91\u5B93\u5B94\u5B96\u5BA8\u5BA9\u5BAC\u5BAD\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBC\u5BC0\u5BC1\u5BCD\u5BCF\u5BD6", 4, "\u5BE0\u5BEF\u5BF1\u5BF4\u5BFD\u5C0C\u5C17\u5C1E\u5C1F\u5C23\u5C26\u5C29\u5C2B\u5C2C\u5C2E\u5C30\u5C32\u5C35\u5C36\u5C59\u5C5A\u5C5C\u5C62\u5C63\u5C67\u5C68\u5C69"],
      ["8fbba1", "\u5C6D\u5C70\u5C74\u5C75\u5C7A\u5C7B\u5C7C\u5C7D\u5C87\u5C88\u5C8A\u5C8F\u5C92\u5C9D\u5C9F\u5CA0\u5CA2\u5CA3\u5CA6\u5CAA\u5CB2\u5CB4\u5CB5\u5CBA\u5CC9\u5CCB\u5CD2\u5CDD\u5CD7\u5CEE\u5CF1\u5CF2\u5CF4\u5D01\u5D06\u5D0D\u5D12\u5D2B\u5D23\u5D24\u5D26\u5D27\u5D31\u5D34\u5D39\u5D3D\u5D3F\u5D42\u5D43\u5D46\u5D48\u5D55\u5D51\u5D59\u5D4A\u5D5F\u5D60\u5D61\u5D62\u5D64\u5D6A\u5D6D\u5D70\u5D79\u5D7A\u5D7E\u5D7F\u5D81\u5D83\u5D88\u5D8A\u5D92\u5D93\u5D94\u5D95\u5D99\u5D9B\u5D9F\u5DA0\u5DA7\u5DAB\u5DB0\u5DB4\u5DB8\u5DB9\u5DC3\u5DC7\u5DCB\u5DD0\u5DCE\u5DD8\u5DD9\u5DE0\u5DE4"],
      ["8fbca1", "\u5DE9\u5DF8\u5DF9\u5E00\u5E07\u5E0D\u5E12\u5E14\u5E15\u5E18\u5E1F\u5E20\u5E2E\u5E28\u5E32\u5E35\u5E3E\u5E4B\u5E50\u5E49\u5E51\u5E56\u5E58\u5E5B\u5E5C\u5E5E\u5E68\u5E6A", 4, "\u5E70\u5E80\u5E8B\u5E8E\u5EA2\u5EA4\u5EA5\u5EA8\u5EAA\u5EAC\u5EB1\u5EB3\u5EBD\u5EBE\u5EBF\u5EC6\u5ECC\u5ECB\u5ECE\u5ED1\u5ED2\u5ED4\u5ED5\u5EDC\u5EDE\u5EE5\u5EEB\u5F02\u5F06\u5F07\u5F08\u5F0E\u5F19\u5F1C\u5F1D\u5F21\u5F22\u5F23\u5F24\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F34\u5F36\u5F3B\u5F3D\u5F3F\u5F40\u5F44\u5F45\u5F47\u5F4D\u5F50\u5F54\u5F58\u5F5B\u5F60\u5F63\u5F64\u5F67"],
      ["8fbda1", "\u5F6F\u5F72\u5F74\u5F75\u5F78\u5F7A\u5F7D\u5F7E\u5F89\u5F8D\u5F8F\u5F96\u5F9C\u5F9D\u5FA2\u5FA7\u5FAB\u5FA4\u5FAC\u5FAF\u5FB0\u5FB1\u5FB8\u5FC4\u5FC7\u5FC8\u5FC9\u5FCB\u5FD0", 4, "\u5FDE\u5FE1\u5FE2\u5FE8\u5FE9\u5FEA\u5FEC\u5FED\u5FEE\u5FEF\u5FF2\u5FF3\u5FF6\u5FFA\u5FFC\u6007\u600A\u600D\u6013\u6014\u6017\u6018\u601A\u601F\u6024\u602D\u6033\u6035\u6040\u6047\u6048\u6049\u604C\u6051\u6054\u6056\u6057\u605D\u6061\u6067\u6071\u607E\u607F\u6082\u6086\u6088\u608A\u608E\u6091\u6093\u6095\u6098\u609D\u609E\u60A2\u60A4\u60A5\u60A8\u60B0\u60B1\u60B7"],
      ["8fbea1", "\u60BB\u60BE\u60C2\u60C4\u60C8\u60C9\u60CA\u60CB\u60CE\u60CF\u60D4\u60D5\u60D9\u60DB\u60DD\u60DE\u60E2\u60E5\u60F2\u60F5\u60F8\u60FC\u60FD\u6102\u6107\u610A\u610C\u6110", 4, "\u6116\u6117\u6119\u611C\u611E\u6122\u612A\u612B\u6130\u6131\u6135\u6136\u6137\u6139\u6141\u6145\u6146\u6149\u615E\u6160\u616C\u6172\u6178\u617B\u617C\u617F\u6180\u6181\u6183\u6184\u618B\u618D\u6192\u6193\u6197\u6198\u619C\u619D\u619F\u61A0\u61A5\u61A8\u61AA\u61AD\u61B8\u61B9\u61BC\u61C0\u61C1\u61C2\u61CE\u61CF\u61D5\u61DC\u61DD\u61DE\u61DF\u61E1\u61E2\u61E7\u61E9\u61E5"],
      ["8fbfa1", "\u61EC\u61ED\u61EF\u6201\u6203\u6204\u6207\u6213\u6215\u621C\u6220\u6222\u6223\u6227\u6229\u622B\u6239\u623D\u6242\u6243\u6244\u6246\u624C\u6250\u6251\u6252\u6254\u6256\u625A\u625C\u6264\u626D\u626F\u6273\u627A\u627D\u628D\u628E\u628F\u6290\u62A6\u62A8\u62B3\u62B6\u62B7\u62BA\u62BE\u62BF\u62C4\u62CE\u62D5\u62D6\u62DA\u62EA\u62F2\u62F4\u62FC\u62FD\u6303\u6304\u630A\u630B\u630D\u6310\u6313\u6316\u6318\u6329\u632A\u632D\u6335\u6336\u6339\u633C\u6341\u6342\u6343\u6344\u6346\u634A\u634B\u634E\u6352\u6353\u6354\u6358\u635B\u6365\u6366\u636C\u636D\u6371\u6374\u6375"],
      ["8fc0a1", "\u6378\u637C\u637D\u637F\u6382\u6384\u6387\u638A\u6390\u6394\u6395\u6399\u639A\u639E\u63A4\u63A6\u63AD\u63AE\u63AF\u63BD\u63C1\u63C5\u63C8\u63CE\u63D1\u63D3\u63D4\u63D5\u63DC\u63E0\u63E5\u63EA\u63EC\u63F2\u63F3\u63F5\u63F8\u63F9\u6409\u640A\u6410\u6412\u6414\u6418\u641E\u6420\u6422\u6424\u6425\u6429\u642A\u642F\u6430\u6435\u643D\u643F\u644B\u644F\u6451\u6452\u6453\u6454\u645A\u645B\u645C\u645D\u645F\u6460\u6461\u6463\u646D\u6473\u6474\u647B\u647D\u6485\u6487\u648F\u6490\u6491\u6498\u6499\u649B\u649D\u649F\u64A1\u64A3\u64A6\u64A8\u64AC\u64B3\u64BD\u64BE\u64BF"],
      ["8fc1a1", "\u64C4\u64C9\u64CA\u64CB\u64CC\u64CE\u64D0\u64D1\u64D5\u64D7\u64E4\u64E5\u64E9\u64EA\u64ED\u64F0\u64F5\u64F7\u64FB\u64FF\u6501\u6504\u6508\u6509\u650A\u650F\u6513\u6514\u6516\u6519\u651B\u651E\u651F\u6522\u6526\u6529\u652E\u6531\u653A\u653C\u653D\u6543\u6547\u6549\u6550\u6552\u6554\u655F\u6560\u6567\u656B\u657A\u657D\u6581\u6585\u658A\u6592\u6595\u6598\u659D\u65A0\u65A3\u65A6\u65AE\u65B2\u65B3\u65B4\u65BF\u65C2\u65C8\u65C9\u65CE\u65D0\u65D4\u65D6\u65D8\u65DF\u65F0\u65F2\u65F4\u65F5\u65F9\u65FE\u65FF\u6600\u6604\u6608\u6609\u660D\u6611\u6612\u6615\u6616\u661D"],
      ["8fc2a1", "\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6631\u6633\u6639\u6637\u6640\u6645\u6646\u664A\u664C\u6651\u664E\u6657\u6658\u6659\u665B\u665C\u6660\u6661\u66FB\u666A\u666B\u666C\u667E\u6673\u6675\u667F\u6677\u6678\u6679\u667B\u6680\u667C\u668B\u668C\u668D\u6690\u6692\u6699\u669A\u669B\u669C\u669F\u66A0\u66A4\u66AD\u66B1\u66B2\u66B5\u66BB\u66BF\u66C0\u66C2\u66C3\u66C8\u66CC\u66CE\u66CF\u66D4\u66DB\u66DF\u66E8\u66EB\u66EC\u66EE\u66FA\u6705\u6707\u670E\u6713\u6719\u671C\u6720\u6722\u6733\u673E\u6745\u6747\u6748\u674C\u6754\u6755\u675D"],
      ["8fc3a1", "\u6766\u676C\u676E\u6774\u6776\u677B\u6781\u6784\u678E\u678F\u6791\u6793\u6796\u6798\u6799\u679B\u67B0\u67B1\u67B2\u67B5\u67BB\u67BC\u67BD\u67F9\u67C0\u67C2\u67C3\u67C5\u67C8\u67C9\u67D2\u67D7\u67D9\u67DC\u67E1\u67E6\u67F0\u67F2\u67F6\u67F7\u6852\u6814\u6819\u681D\u681F\u6828\u6827\u682C\u682D\u682F\u6830\u6831\u6833\u683B\u683F\u6844\u6845\u684A\u684C\u6855\u6857\u6858\u685B\u686B\u686E", 4, "\u6875\u6879\u687A\u687B\u687C\u6882\u6884\u6886\u6888\u6896\u6898\u689A\u689C\u68A1\u68A3\u68A5\u68A9\u68AA\u68AE\u68B2\u68BB\u68C5\u68C8\u68CC\u68CF"],
      ["8fc4a1", "\u68D0\u68D1\u68D3\u68D6\u68D9\u68DC\u68DD\u68E5\u68E8\u68EA\u68EB\u68EC\u68ED\u68F0\u68F1\u68F5\u68F6\u68FB\u68FC\u68FD\u6906\u6909\u690A\u6910\u6911\u6913\u6916\u6917\u6931\u6933\u6935\u6938\u693B\u6942\u6945\u6949\u694E\u6957\u695B\u6963\u6964\u6965\u6966\u6968\u6969\u696C\u6970\u6971\u6972\u697A\u697B\u697F\u6980\u698D\u6992\u6996\u6998\u69A1\u69A5\u69A6\u69A8\u69AB\u69AD\u69AF\u69B7\u69B8\u69BA\u69BC\u69C5\u69C8\u69D1\u69D6\u69D7\u69E2\u69E5\u69EE\u69EF\u69F1\u69F3\u69F5\u69FE\u6A00\u6A01\u6A03\u6A0F\u6A11\u6A15\u6A1A\u6A1D\u6A20\u6A24\u6A28\u6A30\u6A32"],
      ["8fc5a1", "\u6A34\u6A37\u6A3B\u6A3E\u6A3F\u6A45\u6A46\u6A49\u6A4A\u6A4E\u6A50\u6A51\u6A52\u6A55\u6A56\u6A5B\u6A64\u6A67\u6A6A\u6A71\u6A73\u6A7E\u6A81\u6A83\u6A86\u6A87\u6A89\u6A8B\u6A91\u6A9B\u6A9D\u6A9E\u6A9F\u6AA5\u6AAB\u6AAF\u6AB0\u6AB1\u6AB4\u6ABD\u6ABE\u6ABF\u6AC6\u6AC9\u6AC8\u6ACC\u6AD0\u6AD4\u6AD5\u6AD6\u6ADC\u6ADD\u6AE4\u6AE7\u6AEC\u6AF0\u6AF1\u6AF2\u6AFC\u6AFD\u6B02\u6B03\u6B06\u6B07\u6B09\u6B0F\u6B10\u6B11\u6B17\u6B1B\u6B1E\u6B24\u6B28\u6B2B\u6B2C\u6B2F\u6B35\u6B36\u6B3B\u6B3F\u6B46\u6B4A\u6B4D\u6B52\u6B56\u6B58\u6B5D\u6B60\u6B67\u6B6B\u6B6E\u6B70\u6B75\u6B7D"],
      ["8fc6a1", "\u6B7E\u6B82\u6B85\u6B97\u6B9B\u6B9F\u6BA0\u6BA2\u6BA3\u6BA8\u6BA9\u6BAC\u6BAD\u6BAE\u6BB0\u6BB8\u6BB9\u6BBD\u6BBE\u6BC3\u6BC4\u6BC9\u6BCC\u6BD6\u6BDA\u6BE1\u6BE3\u6BE6\u6BE7\u6BEE\u6BF1\u6BF7\u6BF9\u6BFF\u6C02\u6C04\u6C05\u6C09\u6C0D\u6C0E\u6C10\u6C12\u6C19\u6C1F\u6C26\u6C27\u6C28\u6C2C\u6C2E\u6C33\u6C35\u6C36\u6C3A\u6C3B\u6C3F\u6C4A\u6C4B\u6C4D\u6C4F\u6C52\u6C54\u6C59\u6C5B\u6C5C\u6C6B\u6C6D\u6C6F\u6C74\u6C76\u6C78\u6C79\u6C7B\u6C85\u6C86\u6C87\u6C89\u6C94\u6C95\u6C97\u6C98\u6C9C\u6C9F\u6CB0\u6CB2\u6CB4\u6CC2\u6CC6\u6CCD\u6CCF\u6CD0\u6CD1\u6CD2\u6CD4\u6CD6"],
      ["8fc7a1", "\u6CDA\u6CDC\u6CE0\u6CE7\u6CE9\u6CEB\u6CEC\u6CEE\u6CF2\u6CF4\u6D04\u6D07\u6D0A\u6D0E\u6D0F\u6D11\u6D13\u6D1A\u6D26\u6D27\u6D28\u6C67\u6D2E\u6D2F\u6D31\u6D39\u6D3C\u6D3F\u6D57\u6D5E\u6D5F\u6D61\u6D65\u6D67\u6D6F\u6D70\u6D7C\u6D82\u6D87\u6D91\u6D92\u6D94\u6D96\u6D97\u6D98\u6DAA\u6DAC\u6DB4\u6DB7\u6DB9\u6DBD\u6DBF\u6DC4\u6DC8\u6DCA\u6DCE\u6DCF\u6DD6\u6DDB\u6DDD\u6DDF\u6DE0\u6DE2\u6DE5\u6DE9\u6DEF\u6DF0\u6DF4\u6DF6\u6DFC\u6E00\u6E04\u6E1E\u6E22\u6E27\u6E32\u6E36\u6E39\u6E3B\u6E3C\u6E44\u6E45\u6E48\u6E49\u6E4B\u6E4F\u6E51\u6E52\u6E53\u6E54\u6E57\u6E5C\u6E5D\u6E5E"],
      ["8fc8a1", "\u6E62\u6E63\u6E68\u6E73\u6E7B\u6E7D\u6E8D\u6E93\u6E99\u6EA0\u6EA7\u6EAD\u6EAE\u6EB1\u6EB3\u6EBB\u6EBF\u6EC0\u6EC1\u6EC3\u6EC7\u6EC8\u6ECA\u6ECD\u6ECE\u6ECF\u6EEB\u6EED\u6EEE\u6EF9\u6EFB\u6EFD\u6F04\u6F08\u6F0A\u6F0C\u6F0D\u6F16\u6F18\u6F1A\u6F1B\u6F26\u6F29\u6F2A\u6F2F\u6F30\u6F33\u6F36\u6F3B\u6F3C\u6F2D\u6F4F\u6F51\u6F52\u6F53\u6F57\u6F59\u6F5A\u6F5D\u6F5E\u6F61\u6F62\u6F68\u6F6C\u6F7D\u6F7E\u6F83\u6F87\u6F88\u6F8B\u6F8C\u6F8D\u6F90\u6F92\u6F93\u6F94\u6F96\u6F9A\u6F9F\u6FA0\u6FA5\u6FA6\u6FA7\u6FA8\u6FAE\u6FAF\u6FB0\u6FB5\u6FB6\u6FBC\u6FC5\u6FC7\u6FC8\u6FCA"],
      ["8fc9a1", "\u6FDA\u6FDE\u6FE8\u6FE9\u6FF0\u6FF5\u6FF9\u6FFC\u6FFD\u7000\u7005\u7006\u7007\u700D\u7017\u7020\u7023\u702F\u7034\u7037\u7039\u703C\u7043\u7044\u7048\u7049\u704A\u704B\u7054\u7055\u705D\u705E\u704E\u7064\u7065\u706C\u706E\u7075\u7076\u707E\u7081\u7085\u7086\u7094", 4, "\u709B\u70A4\u70AB\u70B0\u70B1\u70B4\u70B7\u70CA\u70D1\u70D3\u70D4\u70D5\u70D6\u70D8\u70DC\u70E4\u70FA\u7103", 4, "\u710B\u710C\u710F\u711E\u7120\u712B\u712D\u712F\u7130\u7131\u7138\u7141\u7145\u7146\u7147\u714A\u714B\u7150\u7152\u7157\u715A\u715C\u715E\u7160"],
      ["8fcaa1", "\u7168\u7179\u7180\u7185\u7187\u718C\u7192\u719A\u719B\u71A0\u71A2\u71AF\u71B0\u71B2\u71B3\u71BA\u71BF\u71C0\u71C1\u71C4\u71CB\u71CC\u71D3\u71D6\u71D9\u71DA\u71DC\u71F8\u71FE\u7200\u7207\u7208\u7209\u7213\u7217\u721A\u721D\u721F\u7224\u722B\u722F\u7234\u7238\u7239\u7241\u7242\u7243\u7245\u724E\u724F\u7250\u7253\u7255\u7256\u725A\u725C\u725E\u7260\u7263\u7268\u726B\u726E\u726F\u7271\u7277\u7278\u727B\u727C\u727F\u7284\u7289\u728D\u728E\u7293\u729B\u72A8\u72AD\u72AE\u72B1\u72B4\u72BE\u72C1\u72C7\u72C9\u72CC\u72D5\u72D6\u72D8\u72DF\u72E5\u72F3\u72F4\u72FA\u72FB"],
      ["8fcba1", "\u72FE\u7302\u7304\u7305\u7307\u730B\u730D\u7312\u7313\u7318\u7319\u731E\u7322\u7324\u7327\u7328\u732C\u7331\u7332\u7335\u733A\u733B\u733D\u7343\u734D\u7350\u7352\u7356\u7358\u735D\u735E\u735F\u7360\u7366\u7367\u7369\u736B\u736C\u736E\u736F\u7371\u7377\u7379\u737C\u7380\u7381\u7383\u7385\u7386\u738E\u7390\u7393\u7395\u7397\u7398\u739C\u739E\u739F\u73A0\u73A2\u73A5\u73A6\u73AA\u73AB\u73AD\u73B5\u73B7\u73B9\u73BC\u73BD\u73BF\u73C5\u73C6\u73C9\u73CB\u73CC\u73CF\u73D2\u73D3\u73D6\u73D9\u73DD\u73E1\u73E3\u73E6\u73E7\u73E9\u73F4\u73F5\u73F7\u73F9\u73FA\u73FB\u73FD"],
      ["8fcca1", "\u73FF\u7400\u7401\u7404\u7407\u740A\u7411\u741A\u741B\u7424\u7426\u7428", 9, "\u7439\u7440\u7443\u7444\u7446\u7447\u744B\u744D\u7451\u7452\u7457\u745D\u7462\u7466\u7467\u7468\u746B\u746D\u746E\u7471\u7472\u7480\u7481\u7485\u7486\u7487\u7489\u748F\u7490\u7491\u7492\u7498\u7499\u749A\u749C\u749F\u74A0\u74A1\u74A3\u74A6\u74A8\u74A9\u74AA\u74AB\u74AE\u74AF\u74B1\u74B2\u74B5\u74B9\u74BB\u74BF\u74C8\u74C9\u74CC\u74D0\u74D3\u74D8\u74DA\u74DB\u74DE\u74DF\u74E4\u74E8\u74EA\u74EB\u74EF\u74F4\u74FA\u74FB\u74FC\u74FF\u7506"],
      ["8fcda1", "\u7512\u7516\u7517\u7520\u7521\u7524\u7527\u7529\u752A\u752F\u7536\u7539\u753D\u753E\u753F\u7540\u7543\u7547\u7548\u754E\u7550\u7552\u7557\u755E\u755F\u7561\u756F\u7571\u7579", 5, "\u7581\u7585\u7590\u7592\u7593\u7595\u7599\u759C\u75A2\u75A4\u75B4\u75BA\u75BF\u75C0\u75C1\u75C4\u75C6\u75CC\u75CE\u75CF\u75D7\u75DC\u75DF\u75E0\u75E1\u75E4\u75E7\u75EC\u75EE\u75EF\u75F1\u75F9\u7600\u7602\u7603\u7604\u7607\u7608\u760A\u760C\u760F\u7612\u7613\u7615\u7616\u7619\u761B\u761C\u761D\u761E\u7623\u7625\u7626\u7629\u762D\u7632\u7633\u7635\u7638\u7639"],
      ["8fcea1", "\u763A\u763C\u764A\u7640\u7641\u7643\u7644\u7645\u7649\u764B\u7655\u7659\u765F\u7664\u7665\u766D\u766E\u766F\u7671\u7674\u7681\u7685\u768C\u768D\u7695\u769B\u769C\u769D\u769F\u76A0\u76A2", 6, "\u76AA\u76AD\u76BD\u76C1\u76C5\u76C9\u76CB\u76CC\u76CE\u76D4\u76D9\u76E0\u76E6\u76E8\u76EC\u76F0\u76F1\u76F6\u76F9\u76FC\u7700\u7706\u770A\u770E\u7712\u7714\u7715\u7717\u7719\u771A\u771C\u7722\u7728\u772D\u772E\u772F\u7734\u7735\u7736\u7739\u773D\u773E\u7742\u7745\u7746\u774A\u774D\u774E\u774F\u7752\u7756\u7757\u775C\u775E\u775F\u7760\u7762"],
      ["8fcfa1", "\u7764\u7767\u776A\u776C\u7770\u7772\u7773\u7774\u777A\u777D\u7780\u7784\u778C\u778D\u7794\u7795\u7796\u779A\u779F\u77A2\u77A7\u77AA\u77AE\u77AF\u77B1\u77B5\u77BE\u77C3\u77C9\u77D1\u77D2\u77D5\u77D9\u77DE\u77DF\u77E0\u77E4\u77E6\u77EA\u77EC\u77F0\u77F1\u77F4\u77F8\u77FB\u7805\u7806\u7809\u780D\u780E\u7811\u781D\u7821\u7822\u7823\u782D\u782E\u7830\u7835\u7837\u7843\u7844\u7847\u7848\u784C\u784E\u7852\u785C\u785E\u7860\u7861\u7863\u7864\u7868\u786A\u786E\u787A\u787E\u788A\u788F\u7894\u7898\u78A1\u789D\u789E\u789F\u78A4\u78A8\u78AC\u78AD\u78B0\u78B1\u78B2\u78B3"],
      ["8fd0a1", "\u78BB\u78BD\u78BF\u78C7\u78C8\u78C9\u78CC\u78CE\u78D2\u78D3\u78D5\u78D6\u78E4\u78DB\u78DF\u78E0\u78E1\u78E6\u78EA\u78F2\u78F3\u7900\u78F6\u78F7\u78FA\u78FB\u78FF\u7906\u790C\u7910\u791A\u791C\u791E\u791F\u7920\u7925\u7927\u7929\u792D\u7931\u7934\u7935\u793B\u793D\u793F\u7944\u7945\u7946\u794A\u794B\u794F\u7951\u7954\u7958\u795B\u795C\u7967\u7969\u796B\u7972\u7979\u797B\u797C\u797E\u798B\u798C\u7991\u7993\u7994\u7995\u7996\u7998\u799B\u799C\u79A1\u79A8\u79A9\u79AB\u79AF\u79B1\u79B4\u79B8\u79BB\u79C2\u79C4\u79C7\u79C8\u79CA\u79CF\u79D4\u79D6\u79DA\u79DD\u79DE"],
      ["8fd1a1", "\u79E0\u79E2\u79E5\u79EA\u79EB\u79ED\u79F1\u79F8\u79FC\u7A02\u7A03\u7A07\u7A09\u7A0A\u7A0C\u7A11\u7A15\u7A1B\u7A1E\u7A21\u7A27\u7A2B\u7A2D\u7A2F\u7A30\u7A34\u7A35\u7A38\u7A39\u7A3A\u7A44\u7A45\u7A47\u7A48\u7A4C\u7A55\u7A56\u7A59\u7A5C\u7A5D\u7A5F\u7A60\u7A65\u7A67\u7A6A\u7A6D\u7A75\u7A78\u7A7E\u7A80\u7A82\u7A85\u7A86\u7A8A\u7A8B\u7A90\u7A91\u7A94\u7A9E\u7AA0\u7AA3\u7AAC\u7AB3\u7AB5\u7AB9\u7ABB\u7ABC\u7AC6\u7AC9\u7ACC\u7ACE\u7AD1\u7ADB\u7AE8\u7AE9\u7AEB\u7AEC\u7AF1\u7AF4\u7AFB\u7AFD\u7AFE\u7B07\u7B14\u7B1F\u7B23\u7B27\u7B29\u7B2A\u7B2B\u7B2D\u7B2E\u7B2F\u7B30"],
      ["8fd2a1", "\u7B31\u7B34\u7B3D\u7B3F\u7B40\u7B41\u7B47\u7B4E\u7B55\u7B60\u7B64\u7B66\u7B69\u7B6A\u7B6D\u7B6F\u7B72\u7B73\u7B77\u7B84\u7B89\u7B8E\u7B90\u7B91\u7B96\u7B9B\u7B9E\u7BA0\u7BA5\u7BAC\u7BAF\u7BB0\u7BB2\u7BB5\u7BB6\u7BBA\u7BBB\u7BBC\u7BBD\u7BC2\u7BC5\u7BC8\u7BCA\u7BD4\u7BD6\u7BD7\u7BD9\u7BDA\u7BDB\u7BE8\u7BEA\u7BF2\u7BF4\u7BF5\u7BF8\u7BF9\u7BFA\u7BFC\u7BFE\u7C01\u7C02\u7C03\u7C04\u7C06\u7C09\u7C0B\u7C0C\u7C0E\u7C0F\u7C19\u7C1B\u7C20\u7C25\u7C26\u7C28\u7C2C\u7C31\u7C33\u7C34\u7C36\u7C39\u7C3A\u7C46\u7C4A\u7C55\u7C51\u7C52\u7C53\u7C59", 5],
      ["8fd3a1", "\u7C61\u7C63\u7C67\u7C69\u7C6D\u7C6E\u7C70\u7C72\u7C79\u7C7C\u7C7D\u7C86\u7C87\u7C8F\u7C94\u7C9E\u7CA0\u7CA6\u7CB0\u7CB6\u7CB7\u7CBA\u7CBB\u7CBC\u7CBF\u7CC4\u7CC7\u7CC8\u7CC9\u7CCD\u7CCF\u7CD3\u7CD4\u7CD5\u7CD7\u7CD9\u7CDA\u7CDD\u7CE6\u7CE9\u7CEB\u7CF5\u7D03\u7D07\u7D08\u7D09\u7D0F\u7D11\u7D12\u7D13\u7D16\u7D1D\u7D1E\u7D23\u7D26\u7D2A\u7D2D\u7D31\u7D3C\u7D3D\u7D3E\u7D40\u7D41\u7D47\u7D48\u7D4D\u7D51\u7D53\u7D57\u7D59\u7D5A\u7D5C\u7D5D\u7D65\u7D67\u7D6A\u7D70\u7D78\u7D7A\u7D7B\u7D7F\u7D81\u7D82\u7D83\u7D85\u7D86\u7D88\u7D8B\u7D8C\u7D8D\u7D91\u7D96\u7D97\u7D9D"],
      ["8fd4a1", "\u7D9E\u7DA6\u7DA7\u7DAA\u7DB3\u7DB6\u7DB7\u7DB9\u7DC2", 4, "\u7DCC\u7DCD\u7DCE\u7DD7\u7DD9\u7E00\u7DE2\u7DE5\u7DE6\u7DEA\u7DEB\u7DED\u7DF1\u7DF5\u7DF6\u7DF9\u7DFA\u7E08\u7E10\u7E11\u7E15\u7E17\u7E1C\u7E1D\u7E20\u7E27\u7E28\u7E2C\u7E2D\u7E2F\u7E33\u7E36\u7E3F\u7E44\u7E45\u7E47\u7E4E\u7E50\u7E52\u7E58\u7E5F\u7E61\u7E62\u7E65\u7E6B\u7E6E\u7E6F\u7E73\u7E78\u7E7E\u7E81\u7E86\u7E87\u7E8A\u7E8D\u7E91\u7E95\u7E98\u7E9A\u7E9D\u7E9E\u7F3C\u7F3B\u7F3D\u7F3E\u7F3F\u7F43\u7F44\u7F47\u7F4F\u7F52\u7F53\u7F5B\u7F5C\u7F5D\u7F61\u7F63\u7F64\u7F65\u7F66\u7F6D"],
      ["8fd5a1", "\u7F71\u7F7D\u7F7E\u7F7F\u7F80\u7F8B\u7F8D\u7F8F\u7F90\u7F91\u7F96\u7F97\u7F9C\u7FA1\u7FA2\u7FA6\u7FAA\u7FAD\u7FB4\u7FBC\u7FBF\u7FC0\u7FC3\u7FC8\u7FCE\u7FCF\u7FDB\u7FDF\u7FE3\u7FE5\u7FE8\u7FEC\u7FEE\u7FEF\u7FF2\u7FFA\u7FFD\u7FFE\u7FFF\u8007\u8008\u800A\u800D\u800E\u800F\u8011\u8013\u8014\u8016\u801D\u801E\u801F\u8020\u8024\u8026\u802C\u802E\u8030\u8034\u8035\u8037\u8039\u803A\u803C\u803E\u8040\u8044\u8060\u8064\u8066\u806D\u8071\u8075\u8081\u8088\u808E\u809C\u809E\u80A6\u80A7\u80AB\u80B8\u80B9\u80C8\u80CD\u80CF\u80D2\u80D4\u80D5\u80D7\u80D8\u80E0\u80ED\u80EE"],
      ["8fd6a1", "\u80F0\u80F2\u80F3\u80F6\u80F9\u80FA\u80FE\u8103\u810B\u8116\u8117\u8118\u811C\u811E\u8120\u8124\u8127\u812C\u8130\u8135\u813A\u813C\u8145\u8147\u814A\u814C\u8152\u8157\u8160\u8161\u8167\u8168\u8169\u816D\u816F\u8177\u8181\u8190\u8184\u8185\u8186\u818B\u818E\u8196\u8198\u819B\u819E\u81A2\u81AE\u81B2\u81B4\u81BB\u81CB\u81C3\u81C5\u81CA\u81CE\u81CF\u81D5\u81D7\u81DB\u81DD\u81DE\u81E1\u81E4\u81EB\u81EC\u81F0\u81F1\u81F2\u81F5\u81F6\u81F8\u81F9\u81FD\u81FF\u8200\u8203\u820F\u8213\u8214\u8219\u821A\u821D\u8221\u8222\u8228\u8232\u8234\u823A\u8243\u8244\u8245\u8246"],
      ["8fd7a1", "\u824B\u824E\u824F\u8251\u8256\u825C\u8260\u8263\u8267\u826D\u8274\u827B\u827D\u827F\u8280\u8281\u8283\u8284\u8287\u8289\u828A\u828E\u8291\u8294\u8296\u8298\u829A\u829B\u82A0\u82A1\u82A3\u82A4\u82A7\u82A8\u82A9\u82AA\u82AE\u82B0\u82B2\u82B4\u82B7\u82BA\u82BC\u82BE\u82BF\u82C6\u82D0\u82D5\u82DA\u82E0\u82E2\u82E4\u82E8\u82EA\u82ED\u82EF\u82F6\u82F7\u82FD\u82FE\u8300\u8301\u8307\u8308\u830A\u830B\u8354\u831B\u831D\u831E\u831F\u8321\u8322\u832C\u832D\u832E\u8330\u8333\u8337\u833A\u833C\u833D\u8342\u8343\u8344\u8347\u834D\u834E\u8351\u8355\u8356\u8357\u8370\u8378"],
      ["8fd8a1", "\u837D\u837F\u8380\u8382\u8384\u8386\u838D\u8392\u8394\u8395\u8398\u8399\u839B\u839C\u839D\u83A6\u83A7\u83A9\u83AC\u83BE\u83BF\u83C0\u83C7\u83C9\u83CF\u83D0\u83D1\u83D4\u83DD\u8353\u83E8\u83EA\u83F6\u83F8\u83F9\u83FC\u8401\u8406\u840A\u840F\u8411\u8415\u8419\u83AD\u842F\u8439\u8445\u8447\u8448\u844A\u844D\u844F\u8451\u8452\u8456\u8458\u8459\u845A\u845C\u8460\u8464\u8465\u8467\u846A\u8470\u8473\u8474\u8476\u8478\u847C\u847D\u8481\u8485\u8492\u8493\u8495\u849E\u84A6\u84A8\u84A9\u84AA\u84AF\u84B1\u84B4\u84BA\u84BD\u84BE\u84C0\u84C2\u84C7\u84C8\u84CC\u84CF\u84D3"],
      ["8fd9a1", "\u84DC\u84E7\u84EA\u84EF\u84F0\u84F1\u84F2\u84F7\u8532\u84FA\u84FB\u84FD\u8502\u8503\u8507\u850C\u850E\u8510\u851C\u851E\u8522\u8523\u8524\u8525\u8527\u852A\u852B\u852F\u8533\u8534\u8536\u853F\u8546\u854F", 4, "\u8556\u8559\u855C", 6, "\u8564\u856B\u856F\u8579\u857A\u857B\u857D\u857F\u8581\u8585\u8586\u8589\u858B\u858C\u858F\u8593\u8598\u859D\u859F\u85A0\u85A2\u85A5\u85A7\u85B4\u85B6\u85B7\u85B8\u85BC\u85BD\u85BE\u85BF\u85C2\u85C7\u85CA\u85CB\u85CE\u85AD\u85D8\u85DA\u85DF\u85E0\u85E6\u85E8\u85ED\u85F3\u85F6\u85FC"],
      ["8fdaa1", "\u85FF\u8600\u8604\u8605\u860D\u860E\u8610\u8611\u8612\u8618\u8619\u861B\u861E\u8621\u8627\u8629\u8636\u8638\u863A\u863C\u863D\u8640\u8642\u8646\u8652\u8653\u8656\u8657\u8658\u8659\u865D\u8660", 4, "\u8669\u866C\u866F\u8675\u8676\u8677\u867A\u868D\u8691\u8696\u8698\u869A\u869C\u86A1\u86A6\u86A7\u86A8\u86AD\u86B1\u86B3\u86B4\u86B5\u86B7\u86B8\u86B9\u86BF\u86C0\u86C1\u86C3\u86C5\u86D1\u86D2\u86D5\u86D7\u86DA\u86DC\u86E0\u86E3\u86E5\u86E7\u8688\u86FA\u86FC\u86FD\u8704\u8705\u8707\u870B\u870E\u870F\u8710\u8713\u8714\u8719\u871E\u871F\u8721\u8723"],
      ["8fdba1", "\u8728\u872E\u872F\u8731\u8732\u8739\u873A\u873C\u873D\u873E\u8740\u8743\u8745\u874D\u8758\u875D\u8761\u8764\u8765\u876F\u8771\u8772\u877B\u8783", 6, "\u878B\u878C\u8790\u8793\u8795\u8797\u8798\u8799\u879E\u87A0\u87A3\u87A7\u87AC\u87AD\u87AE\u87B1\u87B5\u87BE\u87BF\u87C1\u87C8\u87C9\u87CA\u87CE\u87D5\u87D6\u87D9\u87DA\u87DC\u87DF\u87E2\u87E3\u87E4\u87EA\u87EB\u87ED\u87F1\u87F3\u87F8\u87FA\u87FF\u8801\u8803\u8806\u8809\u880A\u880B\u8810\u8819\u8812\u8813\u8814\u8818\u881A\u881B\u881C\u881E\u881F\u8828\u882D\u882E\u8830\u8832\u8835"],
      ["8fdca1", "\u883A\u883C\u8841\u8843\u8845\u8848\u8849\u884A\u884B\u884E\u8851\u8855\u8856\u8858\u885A\u885C\u885F\u8860\u8864\u8869\u8871\u8879\u887B\u8880\u8898\u889A\u889B\u889C\u889F\u88A0\u88A8\u88AA\u88BA\u88BD\u88BE\u88C0\u88CA", 4, "\u88D1\u88D2\u88D3\u88DB\u88DE\u88E7\u88EF\u88F0\u88F1\u88F5\u88F7\u8901\u8906\u890D\u890E\u890F\u8915\u8916\u8918\u8919\u891A\u891C\u8920\u8926\u8927\u8928\u8930\u8931\u8932\u8935\u8939\u893A\u893E\u8940\u8942\u8945\u8946\u8949\u894F\u8952\u8957\u895A\u895B\u895C\u8961\u8962\u8963\u896B\u896E\u8970\u8973\u8975\u897A"],
      ["8fdda1", "\u897B\u897C\u897D\u8989\u898D\u8990\u8994\u8995\u899B\u899C\u899F\u89A0\u89A5\u89B0\u89B4\u89B5\u89B6\u89B7\u89BC\u89D4", 4, "\u89E5\u89E9\u89EB\u89ED\u89F1\u89F3\u89F6\u89F9\u89FD\u89FF\u8A04\u8A05\u8A07\u8A0F\u8A11\u8A12\u8A14\u8A15\u8A1E\u8A20\u8A22\u8A24\u8A26\u8A2B\u8A2C\u8A2F\u8A35\u8A37\u8A3D\u8A3E\u8A40\u8A43\u8A45\u8A47\u8A49\u8A4D\u8A4E\u8A53\u8A56\u8A57\u8A58\u8A5C\u8A5D\u8A61\u8A65\u8A67\u8A75\u8A76\u8A77\u8A79\u8A7A\u8A7B\u8A7E\u8A7F\u8A80\u8A83\u8A86\u8A8B\u8A8F\u8A90\u8A92\u8A96\u8A97\u8A99\u8A9F\u8AA7\u8AA9\u8AAE\u8AAF\u8AB3"],
      ["8fdea1", "\u8AB6\u8AB7\u8ABB\u8ABE\u8AC3\u8AC6\u8AC8\u8AC9\u8ACA\u8AD1\u8AD3\u8AD4\u8AD5\u8AD7\u8ADD\u8ADF\u8AEC\u8AF0\u8AF4\u8AF5\u8AF6\u8AFC\u8AFF\u8B05\u8B06\u8B0B\u8B11\u8B1C\u8B1E\u8B1F\u8B0A\u8B2D\u8B30\u8B37\u8B3C\u8B42", 4, "\u8B48\u8B52\u8B53\u8B54\u8B59\u8B4D\u8B5E\u8B63\u8B6D\u8B76\u8B78\u8B79\u8B7C\u8B7E\u8B81\u8B84\u8B85\u8B8B\u8B8D\u8B8F\u8B94\u8B95\u8B9C\u8B9E\u8B9F\u8C38\u8C39\u8C3D\u8C3E\u8C45\u8C47\u8C49\u8C4B\u8C4F\u8C51\u8C53\u8C54\u8C57\u8C58\u8C5B\u8C5D\u8C59\u8C63\u8C64\u8C66\u8C68\u8C69\u8C6D\u8C73\u8C75\u8C76\u8C7B\u8C7E\u8C86"],
      ["8fdfa1", "\u8C87\u8C8B\u8C90\u8C92\u8C93\u8C99\u8C9B\u8C9C\u8CA4\u8CB9\u8CBA\u8CC5\u8CC6\u8CC9\u8CCB\u8CCF\u8CD6\u8CD5\u8CD9\u8CDD\u8CE1\u8CE8\u8CEC\u8CEF\u8CF0\u8CF2\u8CF5\u8CF7\u8CF8\u8CFE\u8CFF\u8D01\u8D03\u8D09\u8D12\u8D17\u8D1B\u8D65\u8D69\u8D6C\u8D6E\u8D7F\u8D82\u8D84\u8D88\u8D8D\u8D90\u8D91\u8D95\u8D9E\u8D9F\u8DA0\u8DA6\u8DAB\u8DAC\u8DAF\u8DB2\u8DB5\u8DB7\u8DB9\u8DBB\u8DC0\u8DC5\u8DC6\u8DC7\u8DC8\u8DCA\u8DCE\u8DD1\u8DD4\u8DD5\u8DD7\u8DD9\u8DE4\u8DE5\u8DE7\u8DEC\u8DF0\u8DBC\u8DF1\u8DF2\u8DF4\u8DFD\u8E01\u8E04\u8E05\u8E06\u8E0B\u8E11\u8E14\u8E16\u8E20\u8E21\u8E22"],
      ["8fe0a1", "\u8E23\u8E26\u8E27\u8E31\u8E33\u8E36\u8E37\u8E38\u8E39\u8E3D\u8E40\u8E41\u8E4B\u8E4D\u8E4E\u8E4F\u8E54\u8E5B\u8E5C\u8E5D\u8E5E\u8E61\u8E62\u8E69\u8E6C\u8E6D\u8E6F\u8E70\u8E71\u8E79\u8E7A\u8E7B\u8E82\u8E83\u8E89\u8E90\u8E92\u8E95\u8E9A\u8E9B\u8E9D\u8E9E\u8EA2\u8EA7\u8EA9\u8EAD\u8EAE\u8EB3\u8EB5\u8EBA\u8EBB\u8EC0\u8EC1\u8EC3\u8EC4\u8EC7\u8ECF\u8ED1\u8ED4\u8EDC\u8EE8\u8EEE\u8EF0\u8EF1\u8EF7\u8EF9\u8EFA\u8EED\u8F00\u8F02\u8F07\u8F08\u8F0F\u8F10\u8F16\u8F17\u8F18\u8F1E\u8F20\u8F21\u8F23\u8F25\u8F27\u8F28\u8F2C\u8F2D\u8F2E\u8F34\u8F35\u8F36\u8F37\u8F3A\u8F40\u8F41"],
      ["8fe1a1", "\u8F43\u8F47\u8F4F\u8F51", 4, "\u8F58\u8F5D\u8F5E\u8F65\u8F9D\u8FA0\u8FA1\u8FA4\u8FA5\u8FA6\u8FB5\u8FB6\u8FB8\u8FBE\u8FC0\u8FC1\u8FC6\u8FCA\u8FCB\u8FCD\u8FD0\u8FD2\u8FD3\u8FD5\u8FE0\u8FE3\u8FE4\u8FE8\u8FEE\u8FF1\u8FF5\u8FF6\u8FFB\u8FFE\u9002\u9004\u9008\u900C\u9018\u901B\u9028\u9029\u902F\u902A\u902C\u902D\u9033\u9034\u9037\u903F\u9043\u9044\u904C\u905B\u905D\u9062\u9066\u9067\u906C\u9070\u9074\u9079\u9085\u9088\u908B\u908C\u908E\u9090\u9095\u9097\u9098\u9099\u909B\u90A0\u90A1\u90A2\u90A5\u90B0\u90B2\u90B3\u90B4\u90B6\u90BD\u90CC\u90BE\u90C3"],
      ["8fe2a1", "\u90C4\u90C5\u90C7\u90C8\u90D5\u90D7\u90D8\u90D9\u90DC\u90DD\u90DF\u90E5\u90D2\u90F6\u90EB\u90EF\u90F0\u90F4\u90FE\u90FF\u9100\u9104\u9105\u9106\u9108\u910D\u9110\u9114\u9116\u9117\u9118\u911A\u911C\u911E\u9120\u9125\u9122\u9123\u9127\u9129\u912E\u912F\u9131\u9134\u9136\u9137\u9139\u913A\u913C\u913D\u9143\u9147\u9148\u914F\u9153\u9157\u9159\u915A\u915B\u9161\u9164\u9167\u916D\u9174\u9179\u917A\u917B\u9181\u9183\u9185\u9186\u918A\u918E\u9191\u9193\u9194\u9195\u9198\u919E\u91A1\u91A6\u91A8\u91AC\u91AD\u91AE\u91B0\u91B1\u91B2\u91B3\u91B6\u91BB\u91BC\u91BD\u91BF"],
      ["8fe3a1", "\u91C2\u91C3\u91C5\u91D3\u91D4\u91D7\u91D9\u91DA\u91DE\u91E4\u91E5\u91E9\u91EA\u91EC", 5, "\u91F7\u91F9\u91FB\u91FD\u9200\u9201\u9204\u9205\u9206\u9207\u9209\u920A\u920C\u9210\u9212\u9213\u9216\u9218\u921C\u921D\u9223\u9224\u9225\u9226\u9228\u922E\u922F\u9230\u9233\u9235\u9236\u9238\u9239\u923A\u923C\u923E\u9240\u9242\u9243\u9246\u9247\u924A\u924D\u924E\u924F\u9251\u9258\u9259\u925C\u925D\u9260\u9261\u9265\u9267\u9268\u9269\u926E\u926F\u9270\u9275", 4, "\u927B\u927C\u927D\u927F\u9288\u9289\u928A\u928D\u928E\u9292\u9297"],
      ["8fe4a1", "\u9299\u929F\u92A0\u92A4\u92A5\u92A7\u92A8\u92AB\u92AF\u92B2\u92B6\u92B8\u92BA\u92BB\u92BC\u92BD\u92BF", 4, "\u92C5\u92C6\u92C7\u92C8\u92CB\u92CC\u92CD\u92CE\u92D0\u92D3\u92D5\u92D7\u92D8\u92D9\u92DC\u92DD\u92DF\u92E0\u92E1\u92E3\u92E5\u92E7\u92E8\u92EC\u92EE\u92F0\u92F9\u92FB\u92FF\u9300\u9302\u9308\u930D\u9311\u9314\u9315\u931C\u931D\u931E\u931F\u9321\u9324\u9325\u9327\u9329\u932A\u9333\u9334\u9336\u9337\u9347\u9348\u9349\u9350\u9351\u9352\u9355\u9357\u9358\u935A\u935E\u9364\u9365\u9367\u9369\u936A\u936D\u936F\u9370\u9371\u9373\u9374\u9376"],
      ["8fe5a1", "\u937A\u937D\u937F\u9380\u9381\u9382\u9388\u938A\u938B\u938D\u938F\u9392\u9395\u9398\u939B\u939E\u93A1\u93A3\u93A4\u93A6\u93A8\u93AB\u93B4\u93B5\u93B6\u93BA\u93A9\u93C1\u93C4\u93C5\u93C6\u93C7\u93C9", 4, "\u93D3\u93D9\u93DC\u93DE\u93DF\u93E2\u93E6\u93E7\u93F9\u93F7\u93F8\u93FA\u93FB\u93FD\u9401\u9402\u9404\u9408\u9409\u940D\u940E\u940F\u9415\u9416\u9417\u941F\u942E\u942F\u9431\u9432\u9433\u9434\u943B\u943F\u943D\u9443\u9445\u9448\u944A\u944C\u9455\u9459\u945C\u945F\u9461\u9463\u9468\u946B\u946D\u946E\u946F\u9471\u9472\u9484\u9483\u9578\u9579"],
      ["8fe6a1", "\u957E\u9584\u9588\u958C\u958D\u958E\u959D\u959E\u959F\u95A1\u95A6\u95A9\u95AB\u95AC\u95B4\u95B6\u95BA\u95BD\u95BF\u95C6\u95C8\u95C9\u95CB\u95D0\u95D1\u95D2\u95D3\u95D9\u95DA\u95DD\u95DE\u95DF\u95E0\u95E4\u95E6\u961D\u961E\u9622\u9624\u9625\u9626\u962C\u9631\u9633\u9637\u9638\u9639\u963A\u963C\u963D\u9641\u9652\u9654\u9656\u9657\u9658\u9661\u966E\u9674\u967B\u967C\u967E\u967F\u9681\u9682\u9683\u9684\u9689\u9691\u9696\u969A\u969D\u969F\u96A4\u96A5\u96A6\u96A9\u96AE\u96AF\u96B3\u96BA\u96CA\u96D2\u5DB2\u96D8\u96DA\u96DD\u96DE\u96DF\u96E9\u96EF\u96F1\u96FA\u9702"],
      ["8fe7a1", "\u9703\u9705\u9709\u971A\u971B\u971D\u9721\u9722\u9723\u9728\u9731\u9733\u9741\u9743\u974A\u974E\u974F\u9755\u9757\u9758\u975A\u975B\u9763\u9767\u976A\u976E\u9773\u9776\u9777\u9778\u977B\u977D\u977F\u9780\u9789\u9795\u9796\u9797\u9799\u979A\u979E\u979F\u97A2\u97AC\u97AE\u97B1\u97B2\u97B5\u97B6\u97B8\u97B9\u97BA\u97BC\u97BE\u97BF\u97C1\u97C4\u97C5\u97C7\u97C9\u97CA\u97CC\u97CD\u97CE\u97D0\u97D1\u97D4\u97D7\u97D8\u97D9\u97DD\u97DE\u97E0\u97DB\u97E1\u97E4\u97EF\u97F1\u97F4\u97F7\u97F8\u97FA\u9807\u980A\u9819\u980D\u980E\u9814\u9816\u981C\u981E\u9820\u9823\u9826"],
      ["8fe8a1", "\u982B\u982E\u982F\u9830\u9832\u9833\u9835\u9825\u983E\u9844\u9847\u984A\u9851\u9852\u9853\u9856\u9857\u9859\u985A\u9862\u9863\u9865\u9866\u986A\u986C\u98AB\u98AD\u98AE\u98B0\u98B4\u98B7\u98B8\u98BA\u98BB\u98BF\u98C2\u98C5\u98C8\u98CC\u98E1\u98E3\u98E5\u98E6\u98E7\u98EA\u98F3\u98F6\u9902\u9907\u9908\u9911\u9915\u9916\u9917\u991A\u991B\u991C\u991F\u9922\u9926\u9927\u992B\u9931", 4, "\u9939\u993A\u993B\u993C\u9940\u9941\u9946\u9947\u9948\u994D\u994E\u9954\u9958\u9959\u995B\u995C\u995E\u995F\u9960\u999B\u999D\u999F\u99A6\u99B0\u99B1\u99B2\u99B5"],
      ["8fe9a1", "\u99B9\u99BA\u99BD\u99BF\u99C3\u99C9\u99D3\u99D4\u99D9\u99DA\u99DC\u99DE\u99E7\u99EA\u99EB\u99EC\u99F0\u99F4\u99F5\u99F9\u99FD\u99FE\u9A02\u9A03\u9A04\u9A0B\u9A0C\u9A10\u9A11\u9A16\u9A1E\u9A20\u9A22\u9A23\u9A24\u9A27\u9A2D\u9A2E\u9A33\u9A35\u9A36\u9A38\u9A47\u9A41\u9A44\u9A4A\u9A4B\u9A4C\u9A4E\u9A51\u9A54\u9A56\u9A5D\u9AAA\u9AAC\u9AAE\u9AAF\u9AB2\u9AB4\u9AB5\u9AB6\u9AB9\u9ABB\u9ABE\u9ABF\u9AC1\u9AC3\u9AC6\u9AC8\u9ACE\u9AD0\u9AD2\u9AD5\u9AD6\u9AD7\u9ADB\u9ADC\u9AE0\u9AE4\u9AE5\u9AE7\u9AE9\u9AEC\u9AF2\u9AF3\u9AF5\u9AF9\u9AFA\u9AFD\u9AFF", 4],
      ["8feaa1", "\u9B04\u9B05\u9B08\u9B09\u9B0B\u9B0C\u9B0D\u9B0E\u9B10\u9B12\u9B16\u9B19\u9B1B\u9B1C\u9B20\u9B26\u9B2B\u9B2D\u9B33\u9B34\u9B35\u9B37\u9B39\u9B3A\u9B3D\u9B48\u9B4B\u9B4C\u9B55\u9B56\u9B57\u9B5B\u9B5E\u9B61\u9B63\u9B65\u9B66\u9B68\u9B6A", 4, "\u9B73\u9B75\u9B77\u9B78\u9B79\u9B7F\u9B80\u9B84\u9B85\u9B86\u9B87\u9B89\u9B8A\u9B8B\u9B8D\u9B8F\u9B90\u9B94\u9B9A\u9B9D\u9B9E\u9BA6\u9BA7\u9BA9\u9BAC\u9BB0\u9BB1\u9BB2\u9BB7\u9BB8\u9BBB\u9BBC\u9BBE\u9BBF\u9BC1\u9BC7\u9BC8\u9BCE\u9BD0\u9BD7\u9BD8\u9BDD\u9BDF\u9BE5\u9BE7\u9BEA\u9BEB\u9BEF\u9BF3\u9BF7\u9BF8"],
      ["8feba1", "\u9BF9\u9BFA\u9BFD\u9BFF\u9C00\u9C02\u9C0B\u9C0F\u9C11\u9C16\u9C18\u9C19\u9C1A\u9C1C\u9C1E\u9C22\u9C23\u9C26", 4, "\u9C31\u9C35\u9C36\u9C37\u9C3D\u9C41\u9C43\u9C44\u9C45\u9C49\u9C4A\u9C4E\u9C4F\u9C50\u9C53\u9C54\u9C56\u9C58\u9C5B\u9C5D\u9C5E\u9C5F\u9C63\u9C69\u9C6A\u9C5C\u9C6B\u9C68\u9C6E\u9C70\u9C72\u9C75\u9C77\u9C7B\u9CE6\u9CF2\u9CF7\u9CF9\u9D0B\u9D02\u9D11\u9D17\u9D18\u9D1C\u9D1D\u9D1E\u9D2F\u9D30\u9D32\u9D33\u9D34\u9D3A\u9D3C\u9D45\u9D3D\u9D42\u9D43\u9D47\u9D4A\u9D53\u9D54\u9D5F\u9D63\u9D62\u9D65\u9D69\u9D6A\u9D6B\u9D70\u9D76\u9D77\u9D7B"],
      ["8feca1", "\u9D7C\u9D7E\u9D83\u9D84\u9D86\u9D8A\u9D8D\u9D8E\u9D92\u9D93\u9D95\u9D96\u9D97\u9D98\u9DA1\u9DAA\u9DAC\u9DAE\u9DB1\u9DB5\u9DB9\u9DBC\u9DBF\u9DC3\u9DC7\u9DC9\u9DCA\u9DD4\u9DD5\u9DD6\u9DD7\u9DDA\u9DDE\u9DDF\u9DE0\u9DE5\u9DE7\u9DE9\u9DEB\u9DEE\u9DF0\u9DF3\u9DF4\u9DFE\u9E0A\u9E02\u9E07\u9E0E\u9E10\u9E11\u9E12\u9E15\u9E16\u9E19\u9E1C\u9E1D\u9E7A\u9E7B\u9E7C\u9E80\u9E82\u9E83\u9E84\u9E85\u9E87\u9E8E\u9E8F\u9E96\u9E98\u9E9B\u9E9E\u9EA4\u9EA8\u9EAC\u9EAE\u9EAF\u9EB0\u9EB3\u9EB4\u9EB5\u9EC6\u9EC8\u9ECB\u9ED5\u9EDF\u9EE4\u9EE7\u9EEC\u9EED\u9EEE\u9EF0\u9EF1\u9EF2\u9EF5"],
      ["8feda1", "\u9EF8\u9EFF\u9F02\u9F03\u9F09\u9F0F\u9F10\u9F11\u9F12\u9F14\u9F16\u9F17\u9F19\u9F1A\u9F1B\u9F1F\u9F22\u9F26\u9F2A\u9F2B\u9F2F\u9F31\u9F32\u9F34\u9F37\u9F39\u9F3A\u9F3C\u9F3D\u9F3F\u9F41\u9F43", 4, "\u9F53\u9F55\u9F56\u9F57\u9F58\u9F5A\u9F5D\u9F5E\u9F68\u9F69\u9F6D", 4, "\u9F73\u9F75\u9F7A\u9F7D\u9F8F\u9F90\u9F91\u9F92\u9F94\u9F96\u9F97\u9F9E\u9FA1\u9FA2\u9FA3\u9FA5"]
    ];
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/cp936.json
var require_cp936 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/cp936.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127, "\u20AC"],
      ["8140", "\u4E02\u4E04\u4E05\u4E06\u4E0F\u4E12\u4E17\u4E1F\u4E20\u4E21\u4E23\u4E26\u4E29\u4E2E\u4E2F\u4E31\u4E33\u4E35\u4E37\u4E3C\u4E40\u4E41\u4E42\u4E44\u4E46\u4E4A\u4E51\u4E55\u4E57\u4E5A\u4E5B\u4E62\u4E63\u4E64\u4E65\u4E67\u4E68\u4E6A", 5, "\u4E72\u4E74", 9, "\u4E7F", 6, "\u4E87\u4E8A"],
      ["8180", "\u4E90\u4E96\u4E97\u4E99\u4E9C\u4E9D\u4E9E\u4EA3\u4EAA\u4EAF\u4EB0\u4EB1\u4EB4\u4EB6\u4EB7\u4EB8\u4EB9\u4EBC\u4EBD\u4EBE\u4EC8\u4ECC\u4ECF\u4ED0\u4ED2\u4EDA\u4EDB\u4EDC\u4EE0\u4EE2\u4EE6\u4EE7\u4EE9\u4EED\u4EEE\u4EEF\u4EF1\u4EF4\u4EF8\u4EF9\u4EFA\u4EFC\u4EFE\u4F00\u4F02", 6, "\u4F0B\u4F0C\u4F12", 4, "\u4F1C\u4F1D\u4F21\u4F23\u4F28\u4F29\u4F2C\u4F2D\u4F2E\u4F31\u4F33\u4F35\u4F37\u4F39\u4F3B\u4F3E", 4, "\u4F44\u4F45\u4F47", 5, "\u4F52\u4F54\u4F56\u4F61\u4F62\u4F66\u4F68\u4F6A\u4F6B\u4F6D\u4F6E\u4F71\u4F72\u4F75\u4F77\u4F78\u4F79\u4F7A\u4F7D\u4F80\u4F81\u4F82\u4F85\u4F86\u4F87\u4F8A\u4F8C\u4F8E\u4F90\u4F92\u4F93\u4F95\u4F96\u4F98\u4F99\u4F9A\u4F9C\u4F9E\u4F9F\u4FA1\u4FA2"],
      ["8240", "\u4FA4\u4FAB\u4FAD\u4FB0", 4, "\u4FB6", 8, "\u4FC0\u4FC1\u4FC2\u4FC6\u4FC7\u4FC8\u4FC9\u4FCB\u4FCC\u4FCD\u4FD2", 4, "\u4FD9\u4FDB\u4FE0\u4FE2\u4FE4\u4FE5\u4FE7\u4FEB\u4FEC\u4FF0\u4FF2\u4FF4\u4FF5\u4FF6\u4FF7\u4FF9\u4FFB\u4FFC\u4FFD\u4FFF", 11],
      ["8280", "\u500B\u500E\u5010\u5011\u5013\u5015\u5016\u5017\u501B\u501D\u501E\u5020\u5022\u5023\u5024\u5027\u502B\u502F", 10, "\u503B\u503D\u503F\u5040\u5041\u5042\u5044\u5045\u5046\u5049\u504A\u504B\u504D\u5050", 4, "\u5056\u5057\u5058\u5059\u505B\u505D", 7, "\u5066", 5, "\u506D", 8, "\u5078\u5079\u507A\u507C\u507D\u5081\u5082\u5083\u5084\u5086\u5087\u5089\u508A\u508B\u508C\u508E", 20, "\u50A4\u50A6\u50AA\u50AB\u50AD", 4, "\u50B3", 6, "\u50BC"],
      ["8340", "\u50BD", 17, "\u50D0", 5, "\u50D7\u50D8\u50D9\u50DB", 10, "\u50E8\u50E9\u50EA\u50EB\u50EF\u50F0\u50F1\u50F2\u50F4\u50F6", 4, "\u50FC", 9, "\u5108"],
      ["8380", "\u5109\u510A\u510C", 5, "\u5113", 13, "\u5122", 28, "\u5142\u5147\u514A\u514C\u514E\u514F\u5150\u5152\u5153\u5157\u5158\u5159\u515B\u515D", 4, "\u5163\u5164\u5166\u5167\u5169\u516A\u516F\u5172\u517A\u517E\u517F\u5183\u5184\u5186\u5187\u518A\u518B\u518E\u518F\u5190\u5191\u5193\u5194\u5198\u519A\u519D\u519E\u519F\u51A1\u51A3\u51A6", 4, "\u51AD\u51AE\u51B4\u51B8\u51B9\u51BA\u51BE\u51BF\u51C1\u51C2\u51C3\u51C5\u51C8\u51CA\u51CD\u51CE\u51D0\u51D2", 5],
      ["8440", "\u51D8\u51D9\u51DA\u51DC\u51DE\u51DF\u51E2\u51E3\u51E5", 5, "\u51EC\u51EE\u51F1\u51F2\u51F4\u51F7\u51FE\u5204\u5205\u5209\u520B\u520C\u520F\u5210\u5213\u5214\u5215\u521C\u521E\u521F\u5221\u5222\u5223\u5225\u5226\u5227\u522A\u522C\u522F\u5231\u5232\u5234\u5235\u523C\u523E\u5244", 5, "\u524B\u524E\u524F\u5252\u5253\u5255\u5257\u5258"],
      ["8480", "\u5259\u525A\u525B\u525D\u525F\u5260\u5262\u5263\u5264\u5266\u5268\u526B\u526C\u526D\u526E\u5270\u5271\u5273", 9, "\u527E\u5280\u5283", 4, "\u5289", 6, "\u5291\u5292\u5294", 6, "\u529C\u52A4\u52A5\u52A6\u52A7\u52AE\u52AF\u52B0\u52B4", 9, "\u52C0\u52C1\u52C2\u52C4\u52C5\u52C6\u52C8\u52CA\u52CC\u52CD\u52CE\u52CF\u52D1\u52D3\u52D4\u52D5\u52D7\u52D9", 5, "\u52E0\u52E1\u52E2\u52E3\u52E5", 10, "\u52F1", 7, "\u52FB\u52FC\u52FD\u5301\u5302\u5303\u5304\u5307\u5309\u530A\u530B\u530C\u530E"],
      ["8540", "\u5311\u5312\u5313\u5314\u5318\u531B\u531C\u531E\u531F\u5322\u5324\u5325\u5327\u5328\u5329\u532B\u532C\u532D\u532F", 9, "\u533C\u533D\u5340\u5342\u5344\u5346\u534B\u534C\u534D\u5350\u5354\u5358\u5359\u535B\u535D\u5365\u5368\u536A\u536C\u536D\u5372\u5376\u5379\u537B\u537C\u537D\u537E\u5380\u5381\u5383\u5387\u5388\u538A\u538E\u538F"],
      ["8580", "\u5390", 4, "\u5396\u5397\u5399\u539B\u539C\u539E\u53A0\u53A1\u53A4\u53A7\u53AA\u53AB\u53AC\u53AD\u53AF", 6, "\u53B7\u53B8\u53B9\u53BA\u53BC\u53BD\u53BE\u53C0\u53C3", 4, "\u53CE\u53CF\u53D0\u53D2\u53D3\u53D5\u53DA\u53DC\u53DD\u53DE\u53E1\u53E2\u53E7\u53F4\u53FA\u53FE\u53FF\u5400\u5402\u5405\u5407\u540B\u5414\u5418\u5419\u541A\u541C\u5422\u5424\u5425\u542A\u5430\u5433\u5436\u5437\u543A\u543D\u543F\u5441\u5442\u5444\u5445\u5447\u5449\u544C\u544D\u544E\u544F\u5451\u545A\u545D", 4, "\u5463\u5465\u5467\u5469", 7, "\u5474\u5479\u547A\u547E\u547F\u5481\u5483\u5485\u5487\u5488\u5489\u548A\u548D\u5491\u5493\u5497\u5498\u549C\u549E\u549F\u54A0\u54A1"],
      ["8640", "\u54A2\u54A5\u54AE\u54B0\u54B2\u54B5\u54B6\u54B7\u54B9\u54BA\u54BC\u54BE\u54C3\u54C5\u54CA\u54CB\u54D6\u54D8\u54DB\u54E0", 4, "\u54EB\u54EC\u54EF\u54F0\u54F1\u54F4", 5, "\u54FB\u54FE\u5500\u5502\u5503\u5504\u5505\u5508\u550A", 4, "\u5512\u5513\u5515", 5, "\u551C\u551D\u551E\u551F\u5521\u5525\u5526"],
      ["8680", "\u5528\u5529\u552B\u552D\u5532\u5534\u5535\u5536\u5538\u5539\u553A\u553B\u553D\u5540\u5542\u5545\u5547\u5548\u554B", 4, "\u5551\u5552\u5553\u5554\u5557", 4, "\u555D\u555E\u555F\u5560\u5562\u5563\u5568\u5569\u556B\u556F", 5, "\u5579\u557A\u557D\u557F\u5585\u5586\u558C\u558D\u558E\u5590\u5592\u5593\u5595\u5596\u5597\u559A\u559B\u559E\u55A0", 6, "\u55A8", 8, "\u55B2\u55B4\u55B6\u55B8\u55BA\u55BC\u55BF", 4, "\u55C6\u55C7\u55C8\u55CA\u55CB\u55CE\u55CF\u55D0\u55D5\u55D7", 4, "\u55DE\u55E0\u55E2\u55E7\u55E9\u55ED\u55EE\u55F0\u55F1\u55F4\u55F6\u55F8", 4, "\u55FF\u5602\u5603\u5604\u5605"],
      ["8740", "\u5606\u5607\u560A\u560B\u560D\u5610", 7, "\u5619\u561A\u561C\u561D\u5620\u5621\u5622\u5625\u5626\u5628\u5629\u562A\u562B\u562E\u562F\u5630\u5633\u5635\u5637\u5638\u563A\u563C\u563D\u563E\u5640", 11, "\u564F", 4, "\u5655\u5656\u565A\u565B\u565D", 4],
      ["8780", "\u5663\u5665\u5666\u5667\u566D\u566E\u566F\u5670\u5672\u5673\u5674\u5675\u5677\u5678\u5679\u567A\u567D", 7, "\u5687", 6, "\u5690\u5691\u5692\u5694", 14, "\u56A4", 10, "\u56B0", 6, "\u56B8\u56B9\u56BA\u56BB\u56BD", 12, "\u56CB", 8, "\u56D5\u56D6\u56D8\u56D9\u56DC\u56E3\u56E5", 5, "\u56EC\u56EE\u56EF\u56F2\u56F3\u56F6\u56F7\u56F8\u56FB\u56FC\u5700\u5701\u5702\u5705\u5707\u570B", 6],
      ["8840", "\u5712", 9, "\u571D\u571E\u5720\u5721\u5722\u5724\u5725\u5726\u5727\u572B\u5731\u5732\u5734", 4, "\u573C\u573D\u573F\u5741\u5743\u5744\u5745\u5746\u5748\u5749\u574B\u5752", 4, "\u5758\u5759\u5762\u5763\u5765\u5767\u576C\u576E\u5770\u5771\u5772\u5774\u5775\u5778\u5779\u577A\u577D\u577E\u577F\u5780"],
      ["8880", "\u5781\u5787\u5788\u5789\u578A\u578D", 4, "\u5794", 6, "\u579C\u579D\u579E\u579F\u57A5\u57A8\u57AA\u57AC\u57AF\u57B0\u57B1\u57B3\u57B5\u57B6\u57B7\u57B9", 8, "\u57C4", 6, "\u57CC\u57CD\u57D0\u57D1\u57D3\u57D6\u57D7\u57DB\u57DC\u57DE\u57E1\u57E2\u57E3\u57E5", 7, "\u57EE\u57F0\u57F1\u57F2\u57F3\u57F5\u57F6\u57F7\u57FB\u57FC\u57FE\u57FF\u5801\u5803\u5804\u5805\u5808\u5809\u580A\u580C\u580E\u580F\u5810\u5812\u5813\u5814\u5816\u5817\u5818\u581A\u581B\u581C\u581D\u581F\u5822\u5823\u5825", 4, "\u582B", 4, "\u5831\u5832\u5833\u5834\u5836", 7],
      ["8940", "\u583E", 5, "\u5845", 6, "\u584E\u584F\u5850\u5852\u5853\u5855\u5856\u5857\u5859", 4, "\u585F", 5, "\u5866", 4, "\u586D", 16, "\u587F\u5882\u5884\u5886\u5887\u5888\u588A\u588B\u588C"],
      ["8980", "\u588D", 4, "\u5894", 4, "\u589B\u589C\u589D\u58A0", 7, "\u58AA", 17, "\u58BD\u58BE\u58BF\u58C0\u58C2\u58C3\u58C4\u58C6", 10, "\u58D2\u58D3\u58D4\u58D6", 13, "\u58E5", 5, "\u58ED\u58EF\u58F1\u58F2\u58F4\u58F5\u58F7\u58F8\u58FA", 7, "\u5903\u5905\u5906\u5908", 4, "\u590E\u5910\u5911\u5912\u5913\u5917\u5918\u591B\u591D\u591E\u5920\u5921\u5922\u5923\u5926\u5928\u592C\u5930\u5932\u5933\u5935\u5936\u593B"],
      ["8a40", "\u593D\u593E\u593F\u5940\u5943\u5945\u5946\u594A\u594C\u594D\u5950\u5952\u5953\u5959\u595B", 4, "\u5961\u5963\u5964\u5966", 12, "\u5975\u5977\u597A\u597B\u597C\u597E\u597F\u5980\u5985\u5989\u598B\u598C\u598E\u598F\u5990\u5991\u5994\u5995\u5998\u599A\u599B\u599C\u599D\u599F\u59A0\u59A1\u59A2\u59A6"],
      ["8a80", "\u59A7\u59AC\u59AD\u59B0\u59B1\u59B3", 5, "\u59BA\u59BC\u59BD\u59BF", 6, "\u59C7\u59C8\u59C9\u59CC\u59CD\u59CE\u59CF\u59D5\u59D6\u59D9\u59DB\u59DE", 4, "\u59E4\u59E6\u59E7\u59E9\u59EA\u59EB\u59ED", 11, "\u59FA\u59FC\u59FD\u59FE\u5A00\u5A02\u5A0A\u5A0B\u5A0D\u5A0E\u5A0F\u5A10\u5A12\u5A14\u5A15\u5A16\u5A17\u5A19\u5A1A\u5A1B\u5A1D\u5A1E\u5A21\u5A22\u5A24\u5A26\u5A27\u5A28\u5A2A", 6, "\u5A33\u5A35\u5A37", 4, "\u5A3D\u5A3E\u5A3F\u5A41", 4, "\u5A47\u5A48\u5A4B", 9, "\u5A56\u5A57\u5A58\u5A59\u5A5B", 5],
      ["8b40", "\u5A61\u5A63\u5A64\u5A65\u5A66\u5A68\u5A69\u5A6B", 8, "\u5A78\u5A79\u5A7B\u5A7C\u5A7D\u5A7E\u5A80", 17, "\u5A93", 6, "\u5A9C", 13, "\u5AAB\u5AAC"],
      ["8b80", "\u5AAD", 4, "\u5AB4\u5AB6\u5AB7\u5AB9", 4, "\u5ABF\u5AC0\u5AC3", 5, "\u5ACA\u5ACB\u5ACD", 4, "\u5AD3\u5AD5\u5AD7\u5AD9\u5ADA\u5ADB\u5ADD\u5ADE\u5ADF\u5AE2\u5AE4\u5AE5\u5AE7\u5AE8\u5AEA\u5AEC", 4, "\u5AF2", 22, "\u5B0A", 11, "\u5B18", 25, "\u5B33\u5B35\u5B36\u5B38", 7, "\u5B41", 6],
      ["8c40", "\u5B48", 7, "\u5B52\u5B56\u5B5E\u5B60\u5B61\u5B67\u5B68\u5B6B\u5B6D\u5B6E\u5B6F\u5B72\u5B74\u5B76\u5B77\u5B78\u5B79\u5B7B\u5B7C\u5B7E\u5B7F\u5B82\u5B86\u5B8A\u5B8D\u5B8E\u5B90\u5B91\u5B92\u5B94\u5B96\u5B9F\u5BA7\u5BA8\u5BA9\u5BAC\u5BAD\u5BAE\u5BAF\u5BB1\u5BB2\u5BB7\u5BBA\u5BBB\u5BBC\u5BC0\u5BC1\u5BC3\u5BC8\u5BC9\u5BCA\u5BCB\u5BCD\u5BCE\u5BCF"],
      ["8c80", "\u5BD1\u5BD4", 8, "\u5BE0\u5BE2\u5BE3\u5BE6\u5BE7\u5BE9", 4, "\u5BEF\u5BF1", 6, "\u5BFD\u5BFE\u5C00\u5C02\u5C03\u5C05\u5C07\u5C08\u5C0B\u5C0C\u5C0D\u5C0E\u5C10\u5C12\u5C13\u5C17\u5C19\u5C1B\u5C1E\u5C1F\u5C20\u5C21\u5C23\u5C26\u5C28\u5C29\u5C2A\u5C2B\u5C2D\u5C2E\u5C2F\u5C30\u5C32\u5C33\u5C35\u5C36\u5C37\u5C43\u5C44\u5C46\u5C47\u5C4C\u5C4D\u5C52\u5C53\u5C54\u5C56\u5C57\u5C58\u5C5A\u5C5B\u5C5C\u5C5D\u5C5F\u5C62\u5C64\u5C67", 6, "\u5C70\u5C72", 6, "\u5C7B\u5C7C\u5C7D\u5C7E\u5C80\u5C83", 4, "\u5C89\u5C8A\u5C8B\u5C8E\u5C8F\u5C92\u5C93\u5C95\u5C9D", 4, "\u5CA4", 4],
      ["8d40", "\u5CAA\u5CAE\u5CAF\u5CB0\u5CB2\u5CB4\u5CB6\u5CB9\u5CBA\u5CBB\u5CBC\u5CBE\u5CC0\u5CC2\u5CC3\u5CC5", 5, "\u5CCC", 5, "\u5CD3", 5, "\u5CDA", 6, "\u5CE2\u5CE3\u5CE7\u5CE9\u5CEB\u5CEC\u5CEE\u5CEF\u5CF1", 9, "\u5CFC", 4],
      ["8d80", "\u5D01\u5D04\u5D05\u5D08", 5, "\u5D0F", 4, "\u5D15\u5D17\u5D18\u5D19\u5D1A\u5D1C\u5D1D\u5D1F", 4, "\u5D25\u5D28\u5D2A\u5D2B\u5D2C\u5D2F", 4, "\u5D35", 7, "\u5D3F", 7, "\u5D48\u5D49\u5D4D", 10, "\u5D59\u5D5A\u5D5C\u5D5E", 10, "\u5D6A\u5D6D\u5D6E\u5D70\u5D71\u5D72\u5D73\u5D75", 12, "\u5D83", 21, "\u5D9A\u5D9B\u5D9C\u5D9E\u5D9F\u5DA0"],
      ["8e40", "\u5DA1", 21, "\u5DB8", 12, "\u5DC6", 6, "\u5DCE", 12, "\u5DDC\u5DDF\u5DE0\u5DE3\u5DE4\u5DEA\u5DEC\u5DED"],
      ["8e80", "\u5DF0\u5DF5\u5DF6\u5DF8", 4, "\u5DFF\u5E00\u5E04\u5E07\u5E09\u5E0A\u5E0B\u5E0D\u5E0E\u5E12\u5E13\u5E17\u5E1E", 7, "\u5E28", 4, "\u5E2F\u5E30\u5E32", 4, "\u5E39\u5E3A\u5E3E\u5E3F\u5E40\u5E41\u5E43\u5E46", 5, "\u5E4D", 6, "\u5E56", 4, "\u5E5C\u5E5D\u5E5F\u5E60\u5E63", 14, "\u5E75\u5E77\u5E79\u5E7E\u5E81\u5E82\u5E83\u5E85\u5E88\u5E89\u5E8C\u5E8D\u5E8E\u5E92\u5E98\u5E9B\u5E9D\u5EA1\u5EA2\u5EA3\u5EA4\u5EA8", 4, "\u5EAE", 4, "\u5EB4\u5EBA\u5EBB\u5EBC\u5EBD\u5EBF", 6],
      ["8f40", "\u5EC6\u5EC7\u5EC8\u5ECB", 5, "\u5ED4\u5ED5\u5ED7\u5ED8\u5ED9\u5EDA\u5EDC", 11, "\u5EE9\u5EEB", 8, "\u5EF5\u5EF8\u5EF9\u5EFB\u5EFC\u5EFD\u5F05\u5F06\u5F07\u5F09\u5F0C\u5F0D\u5F0E\u5F10\u5F12\u5F14\u5F16\u5F19\u5F1A\u5F1C\u5F1D\u5F1E\u5F21\u5F22\u5F23\u5F24"],
      ["8f80", "\u5F28\u5F2B\u5F2C\u5F2E\u5F30\u5F32", 6, "\u5F3B\u5F3D\u5F3E\u5F3F\u5F41", 14, "\u5F51\u5F54\u5F59\u5F5A\u5F5B\u5F5C\u5F5E\u5F5F\u5F60\u5F63\u5F65\u5F67\u5F68\u5F6B\u5F6E\u5F6F\u5F72\u5F74\u5F75\u5F76\u5F78\u5F7A\u5F7D\u5F7E\u5F7F\u5F83\u5F86\u5F8D\u5F8E\u5F8F\u5F91\u5F93\u5F94\u5F96\u5F9A\u5F9B\u5F9D\u5F9E\u5F9F\u5FA0\u5FA2", 5, "\u5FA9\u5FAB\u5FAC\u5FAF", 5, "\u5FB6\u5FB8\u5FB9\u5FBA\u5FBB\u5FBE", 4, "\u5FC7\u5FC8\u5FCA\u5FCB\u5FCE\u5FD3\u5FD4\u5FD5\u5FDA\u5FDB\u5FDC\u5FDE\u5FDF\u5FE2\u5FE3\u5FE5\u5FE6\u5FE8\u5FE9\u5FEC\u5FEF\u5FF0\u5FF2\u5FF3\u5FF4\u5FF6\u5FF7\u5FF9\u5FFA\u5FFC\u6007"],
      ["9040", "\u6008\u6009\u600B\u600C\u6010\u6011\u6013\u6017\u6018\u601A\u601E\u601F\u6022\u6023\u6024\u602C\u602D\u602E\u6030", 4, "\u6036", 4, "\u603D\u603E\u6040\u6044", 6, "\u604C\u604E\u604F\u6051\u6053\u6054\u6056\u6057\u6058\u605B\u605C\u605E\u605F\u6060\u6061\u6065\u6066\u606E\u6071\u6072\u6074\u6075\u6077\u607E\u6080"],
      ["9080", "\u6081\u6082\u6085\u6086\u6087\u6088\u608A\u608B\u608E\u608F\u6090\u6091\u6093\u6095\u6097\u6098\u6099\u609C\u609E\u60A1\u60A2\u60A4\u60A5\u60A7\u60A9\u60AA\u60AE\u60B0\u60B3\u60B5\u60B6\u60B7\u60B9\u60BA\u60BD", 7, "\u60C7\u60C8\u60C9\u60CC", 4, "\u60D2\u60D3\u60D4\u60D6\u60D7\u60D9\u60DB\u60DE\u60E1", 4, "\u60EA\u60F1\u60F2\u60F5\u60F7\u60F8\u60FB", 4, "\u6102\u6103\u6104\u6105\u6107\u610A\u610B\u610C\u6110", 4, "\u6116\u6117\u6118\u6119\u611B\u611C\u611D\u611E\u6121\u6122\u6125\u6128\u6129\u612A\u612C", 18, "\u6140", 6],
      ["9140", "\u6147\u6149\u614B\u614D\u614F\u6150\u6152\u6153\u6154\u6156", 6, "\u615E\u615F\u6160\u6161\u6163\u6164\u6165\u6166\u6169", 6, "\u6171\u6172\u6173\u6174\u6176\u6178", 18, "\u618C\u618D\u618F", 4, "\u6195"],
      ["9180", "\u6196", 6, "\u619E", 8, "\u61AA\u61AB\u61AD", 9, "\u61B8", 5, "\u61BF\u61C0\u61C1\u61C3", 4, "\u61C9\u61CC", 4, "\u61D3\u61D5", 16, "\u61E7", 13, "\u61F6", 8, "\u6200", 5, "\u6207\u6209\u6213\u6214\u6219\u621C\u621D\u621E\u6220\u6223\u6226\u6227\u6228\u6229\u622B\u622D\u622F\u6230\u6231\u6232\u6235\u6236\u6238", 4, "\u6242\u6244\u6245\u6246\u624A"],
      ["9240", "\u624F\u6250\u6255\u6256\u6257\u6259\u625A\u625C", 6, "\u6264\u6265\u6268\u6271\u6272\u6274\u6275\u6277\u6278\u627A\u627B\u627D\u6281\u6282\u6283\u6285\u6286\u6287\u6288\u628B", 5, "\u6294\u6299\u629C\u629D\u629E\u62A3\u62A6\u62A7\u62A9\u62AA\u62AD\u62AE\u62AF\u62B0\u62B2\u62B3\u62B4\u62B6\u62B7\u62B8\u62BA\u62BE\u62C0\u62C1"],
      ["9280", "\u62C3\u62CB\u62CF\u62D1\u62D5\u62DD\u62DE\u62E0\u62E1\u62E4\u62EA\u62EB\u62F0\u62F2\u62F5\u62F8\u62F9\u62FA\u62FB\u6300\u6303\u6304\u6305\u6306\u630A\u630B\u630C\u630D\u630F\u6310\u6312\u6313\u6314\u6315\u6317\u6318\u6319\u631C\u6326\u6327\u6329\u632C\u632D\u632E\u6330\u6331\u6333", 5, "\u633B\u633C\u633E\u633F\u6340\u6341\u6344\u6347\u6348\u634A\u6351\u6352\u6353\u6354\u6356", 7, "\u6360\u6364\u6365\u6366\u6368\u636A\u636B\u636C\u636F\u6370\u6372\u6373\u6374\u6375\u6378\u6379\u637C\u637D\u637E\u637F\u6381\u6383\u6384\u6385\u6386\u638B\u638D\u6391\u6393\u6394\u6395\u6397\u6399", 6, "\u63A1\u63A4\u63A6\u63AB\u63AF\u63B1\u63B2\u63B5\u63B6\u63B9\u63BB\u63BD\u63BF\u63C0"],
      ["9340", "\u63C1\u63C2\u63C3\u63C5\u63C7\u63C8\u63CA\u63CB\u63CC\u63D1\u63D3\u63D4\u63D5\u63D7", 6, "\u63DF\u63E2\u63E4", 4, "\u63EB\u63EC\u63EE\u63EF\u63F0\u63F1\u63F3\u63F5\u63F7\u63F9\u63FA\u63FB\u63FC\u63FE\u6403\u6404\u6406", 4, "\u640D\u640E\u6411\u6412\u6415", 5, "\u641D\u641F\u6422\u6423\u6424"],
      ["9380", "\u6425\u6427\u6428\u6429\u642B\u642E", 5, "\u6435", 4, "\u643B\u643C\u643E\u6440\u6442\u6443\u6449\u644B", 6, "\u6453\u6455\u6456\u6457\u6459", 4, "\u645F", 7, "\u6468\u646A\u646B\u646C\u646E", 9, "\u647B", 6, "\u6483\u6486\u6488", 8, "\u6493\u6494\u6497\u6498\u649A\u649B\u649C\u649D\u649F", 4, "\u64A5\u64A6\u64A7\u64A8\u64AA\u64AB\u64AF\u64B1\u64B2\u64B3\u64B4\u64B6\u64B9\u64BB\u64BD\u64BE\u64BF\u64C1\u64C3\u64C4\u64C6", 6, "\u64CF\u64D1\u64D3\u64D4\u64D5\u64D6\u64D9\u64DA"],
      ["9440", "\u64DB\u64DC\u64DD\u64DF\u64E0\u64E1\u64E3\u64E5\u64E7", 24, "\u6501", 7, "\u650A", 7, "\u6513", 4, "\u6519", 8],
      ["9480", "\u6522\u6523\u6524\u6526", 4, "\u652C\u652D\u6530\u6531\u6532\u6533\u6537\u653A\u653C\u653D\u6540", 4, "\u6546\u6547\u654A\u654B\u654D\u654E\u6550\u6552\u6553\u6554\u6557\u6558\u655A\u655C\u655F\u6560\u6561\u6564\u6565\u6567\u6568\u6569\u656A\u656D\u656E\u656F\u6571\u6573\u6575\u6576\u6578", 14, "\u6588\u6589\u658A\u658D\u658E\u658F\u6592\u6594\u6595\u6596\u6598\u659A\u659D\u659E\u65A0\u65A2\u65A3\u65A6\u65A8\u65AA\u65AC\u65AE\u65B1", 7, "\u65BA\u65BB\u65BE\u65BF\u65C0\u65C2\u65C7\u65C8\u65C9\u65CA\u65CD\u65D0\u65D1\u65D3\u65D4\u65D5\u65D8", 7, "\u65E1\u65E3\u65E4\u65EA\u65EB"],
      ["9540", "\u65F2\u65F3\u65F4\u65F5\u65F8\u65F9\u65FB", 4, "\u6601\u6604\u6605\u6607\u6608\u6609\u660B\u660D\u6610\u6611\u6612\u6616\u6617\u6618\u661A\u661B\u661C\u661E\u6621\u6622\u6623\u6624\u6626\u6629\u662A\u662B\u662C\u662E\u6630\u6632\u6633\u6637", 4, "\u663D\u663F\u6640\u6642\u6644", 6, "\u664D\u664E\u6650\u6651\u6658"],
      ["9580", "\u6659\u665B\u665C\u665D\u665E\u6660\u6662\u6663\u6665\u6667\u6669", 4, "\u6671\u6672\u6673\u6675\u6678\u6679\u667B\u667C\u667D\u667F\u6680\u6681\u6683\u6685\u6686\u6688\u6689\u668A\u668B\u668D\u668E\u668F\u6690\u6692\u6693\u6694\u6695\u6698", 4, "\u669E", 8, "\u66A9", 4, "\u66AF", 4, "\u66B5\u66B6\u66B7\u66B8\u66BA\u66BB\u66BC\u66BD\u66BF", 25, "\u66DA\u66DE", 7, "\u66E7\u66E8\u66EA", 5, "\u66F1\u66F5\u66F6\u66F8\u66FA\u66FB\u66FD\u6701\u6702\u6703"],
      ["9640", "\u6704\u6705\u6706\u6707\u670C\u670E\u670F\u6711\u6712\u6713\u6716\u6718\u6719\u671A\u671C\u671E\u6720", 5, "\u6727\u6729\u672E\u6730\u6732\u6733\u6736\u6737\u6738\u6739\u673B\u673C\u673E\u673F\u6741\u6744\u6745\u6747\u674A\u674B\u674D\u6752\u6754\u6755\u6757", 4, "\u675D\u6762\u6763\u6764\u6766\u6767\u676B\u676C\u676E\u6771\u6774\u6776"],
      ["9680", "\u6778\u6779\u677A\u677B\u677D\u6780\u6782\u6783\u6785\u6786\u6788\u678A\u678C\u678D\u678E\u678F\u6791\u6792\u6793\u6794\u6796\u6799\u679B\u679F\u67A0\u67A1\u67A4\u67A6\u67A9\u67AC\u67AE\u67B1\u67B2\u67B4\u67B9", 7, "\u67C2\u67C5", 9, "\u67D5\u67D6\u67D7\u67DB\u67DF\u67E1\u67E3\u67E4\u67E6\u67E7\u67E8\u67EA\u67EB\u67ED\u67EE\u67F2\u67F5", 7, "\u67FE\u6801\u6802\u6803\u6804\u6806\u680D\u6810\u6812\u6814\u6815\u6818", 4, "\u681E\u681F\u6820\u6822", 6, "\u682B", 6, "\u6834\u6835\u6836\u683A\u683B\u683F\u6847\u684B\u684D\u684F\u6852\u6856", 5],
      ["9740", "\u685C\u685D\u685E\u685F\u686A\u686C", 7, "\u6875\u6878", 8, "\u6882\u6884\u6887", 7, "\u6890\u6891\u6892\u6894\u6895\u6896\u6898", 9, "\u68A3\u68A4\u68A5\u68A9\u68AA\u68AB\u68AC\u68AE\u68B1\u68B2\u68B4\u68B6\u68B7\u68B8"],
      ["9780", "\u68B9", 6, "\u68C1\u68C3", 5, "\u68CA\u68CC\u68CE\u68CF\u68D0\u68D1\u68D3\u68D4\u68D6\u68D7\u68D9\u68DB", 4, "\u68E1\u68E2\u68E4", 9, "\u68EF\u68F2\u68F3\u68F4\u68F6\u68F7\u68F8\u68FB\u68FD\u68FE\u68FF\u6900\u6902\u6903\u6904\u6906", 4, "\u690C\u690F\u6911\u6913", 11, "\u6921\u6922\u6923\u6925", 7, "\u692E\u692F\u6931\u6932\u6933\u6935\u6936\u6937\u6938\u693A\u693B\u693C\u693E\u6940\u6941\u6943", 16, "\u6955\u6956\u6958\u6959\u695B\u695C\u695F"],
      ["9840", "\u6961\u6962\u6964\u6965\u6967\u6968\u6969\u696A\u696C\u696D\u696F\u6970\u6972", 4, "\u697A\u697B\u697D\u697E\u697F\u6981\u6983\u6985\u698A\u698B\u698C\u698E", 5, "\u6996\u6997\u6999\u699A\u699D", 9, "\u69A9\u69AA\u69AC\u69AE\u69AF\u69B0\u69B2\u69B3\u69B5\u69B6\u69B8\u69B9\u69BA\u69BC\u69BD"],
      ["9880", "\u69BE\u69BF\u69C0\u69C2", 7, "\u69CB\u69CD\u69CF\u69D1\u69D2\u69D3\u69D5", 5, "\u69DC\u69DD\u69DE\u69E1", 11, "\u69EE\u69EF\u69F0\u69F1\u69F3", 9, "\u69FE\u6A00", 9, "\u6A0B", 11, "\u6A19", 5, "\u6A20\u6A22", 5, "\u6A29\u6A2B\u6A2C\u6A2D\u6A2E\u6A30\u6A32\u6A33\u6A34\u6A36", 6, "\u6A3F", 4, "\u6A45\u6A46\u6A48", 7, "\u6A51", 6, "\u6A5A"],
      ["9940", "\u6A5C", 4, "\u6A62\u6A63\u6A64\u6A66", 10, "\u6A72", 6, "\u6A7A\u6A7B\u6A7D\u6A7E\u6A7F\u6A81\u6A82\u6A83\u6A85", 8, "\u6A8F\u6A92", 4, "\u6A98", 7, "\u6AA1", 5],
      ["9980", "\u6AA7\u6AA8\u6AAA\u6AAD", 114, "\u6B25\u6B26\u6B28", 6],
      ["9a40", "\u6B2F\u6B30\u6B31\u6B33\u6B34\u6B35\u6B36\u6B38\u6B3B\u6B3C\u6B3D\u6B3F\u6B40\u6B41\u6B42\u6B44\u6B45\u6B48\u6B4A\u6B4B\u6B4D", 11, "\u6B5A", 7, "\u6B68\u6B69\u6B6B", 13, "\u6B7A\u6B7D\u6B7E\u6B7F\u6B80\u6B85\u6B88"],
      ["9a80", "\u6B8C\u6B8E\u6B8F\u6B90\u6B91\u6B94\u6B95\u6B97\u6B98\u6B99\u6B9C", 4, "\u6BA2", 7, "\u6BAB", 7, "\u6BB6\u6BB8", 6, "\u6BC0\u6BC3\u6BC4\u6BC6", 4, "\u6BCC\u6BCE\u6BD0\u6BD1\u6BD8\u6BDA\u6BDC", 4, "\u6BE2", 7, "\u6BEC\u6BED\u6BEE\u6BF0\u6BF1\u6BF2\u6BF4\u6BF6\u6BF7\u6BF8\u6BFA\u6BFB\u6BFC\u6BFE", 6, "\u6C08", 4, "\u6C0E\u6C12\u6C17\u6C1C\u6C1D\u6C1E\u6C20\u6C23\u6C25\u6C2B\u6C2C\u6C2D\u6C31\u6C33\u6C36\u6C37\u6C39\u6C3A\u6C3B\u6C3C\u6C3E\u6C3F\u6C43\u6C44\u6C45\u6C48\u6C4B", 4, "\u6C51\u6C52\u6C53\u6C56\u6C58"],
      ["9b40", "\u6C59\u6C5A\u6C62\u6C63\u6C65\u6C66\u6C67\u6C6B", 4, "\u6C71\u6C73\u6C75\u6C77\u6C78\u6C7A\u6C7B\u6C7C\u6C7F\u6C80\u6C84\u6C87\u6C8A\u6C8B\u6C8D\u6C8E\u6C91\u6C92\u6C95\u6C96\u6C97\u6C98\u6C9A\u6C9C\u6C9D\u6C9E\u6CA0\u6CA2\u6CA8\u6CAC\u6CAF\u6CB0\u6CB4\u6CB5\u6CB6\u6CB7\u6CBA\u6CC0\u6CC1\u6CC2\u6CC3\u6CC6\u6CC7\u6CC8\u6CCB\u6CCD\u6CCE\u6CCF\u6CD1\u6CD2\u6CD8"],
      ["9b80", "\u6CD9\u6CDA\u6CDC\u6CDD\u6CDF\u6CE4\u6CE6\u6CE7\u6CE9\u6CEC\u6CED\u6CF2\u6CF4\u6CF9\u6CFF\u6D00\u6D02\u6D03\u6D05\u6D06\u6D08\u6D09\u6D0A\u6D0D\u6D0F\u6D10\u6D11\u6D13\u6D14\u6D15\u6D16\u6D18\u6D1C\u6D1D\u6D1F", 5, "\u6D26\u6D28\u6D29\u6D2C\u6D2D\u6D2F\u6D30\u6D34\u6D36\u6D37\u6D38\u6D3A\u6D3F\u6D40\u6D42\u6D44\u6D49\u6D4C\u6D50\u6D55\u6D56\u6D57\u6D58\u6D5B\u6D5D\u6D5F\u6D61\u6D62\u6D64\u6D65\u6D67\u6D68\u6D6B\u6D6C\u6D6D\u6D70\u6D71\u6D72\u6D73\u6D75\u6D76\u6D79\u6D7A\u6D7B\u6D7D", 4, "\u6D83\u6D84\u6D86\u6D87\u6D8A\u6D8B\u6D8D\u6D8F\u6D90\u6D92\u6D96", 4, "\u6D9C\u6DA2\u6DA5\u6DAC\u6DAD\u6DB0\u6DB1\u6DB3\u6DB4\u6DB6\u6DB7\u6DB9", 5, "\u6DC1\u6DC2\u6DC3\u6DC8\u6DC9\u6DCA"],
      ["9c40", "\u6DCD\u6DCE\u6DCF\u6DD0\u6DD2\u6DD3\u6DD4\u6DD5\u6DD7\u6DDA\u6DDB\u6DDC\u6DDF\u6DE2\u6DE3\u6DE5\u6DE7\u6DE8\u6DE9\u6DEA\u6DED\u6DEF\u6DF0\u6DF2\u6DF4\u6DF5\u6DF6\u6DF8\u6DFA\u6DFD", 7, "\u6E06\u6E07\u6E08\u6E09\u6E0B\u6E0F\u6E12\u6E13\u6E15\u6E18\u6E19\u6E1B\u6E1C\u6E1E\u6E1F\u6E22\u6E26\u6E27\u6E28\u6E2A\u6E2C\u6E2E\u6E30\u6E31\u6E33\u6E35"],
      ["9c80", "\u6E36\u6E37\u6E39\u6E3B", 7, "\u6E45", 7, "\u6E4F\u6E50\u6E51\u6E52\u6E55\u6E57\u6E59\u6E5A\u6E5C\u6E5D\u6E5E\u6E60", 10, "\u6E6C\u6E6D\u6E6F", 14, "\u6E80\u6E81\u6E82\u6E84\u6E87\u6E88\u6E8A", 4, "\u6E91", 6, "\u6E99\u6E9A\u6E9B\u6E9D\u6E9E\u6EA0\u6EA1\u6EA3\u6EA4\u6EA6\u6EA8\u6EA9\u6EAB\u6EAC\u6EAD\u6EAE\u6EB0\u6EB3\u6EB5\u6EB8\u6EB9\u6EBC\u6EBE\u6EBF\u6EC0\u6EC3\u6EC4\u6EC5\u6EC6\u6EC8\u6EC9\u6ECA\u6ECC\u6ECD\u6ECE\u6ED0\u6ED2\u6ED6\u6ED8\u6ED9\u6EDB\u6EDC\u6EDD\u6EE3\u6EE7\u6EEA", 5],
      ["9d40", "\u6EF0\u6EF1\u6EF2\u6EF3\u6EF5\u6EF6\u6EF7\u6EF8\u6EFA", 7, "\u6F03\u6F04\u6F05\u6F07\u6F08\u6F0A", 4, "\u6F10\u6F11\u6F12\u6F16", 9, "\u6F21\u6F22\u6F23\u6F25\u6F26\u6F27\u6F28\u6F2C\u6F2E\u6F30\u6F32\u6F34\u6F35\u6F37", 6, "\u6F3F\u6F40\u6F41\u6F42"],
      ["9d80", "\u6F43\u6F44\u6F45\u6F48\u6F49\u6F4A\u6F4C\u6F4E", 9, "\u6F59\u6F5A\u6F5B\u6F5D\u6F5F\u6F60\u6F61\u6F63\u6F64\u6F65\u6F67", 5, "\u6F6F\u6F70\u6F71\u6F73\u6F75\u6F76\u6F77\u6F79\u6F7B\u6F7D", 6, "\u6F85\u6F86\u6F87\u6F8A\u6F8B\u6F8F", 12, "\u6F9D\u6F9E\u6F9F\u6FA0\u6FA2", 4, "\u6FA8", 10, "\u6FB4\u6FB5\u6FB7\u6FB8\u6FBA", 5, "\u6FC1\u6FC3", 5, "\u6FCA", 6, "\u6FD3", 10, "\u6FDF\u6FE2\u6FE3\u6FE4\u6FE5"],
      ["9e40", "\u6FE6", 7, "\u6FF0", 32, "\u7012", 7, "\u701C", 6, "\u7024", 6],
      ["9e80", "\u702B", 9, "\u7036\u7037\u7038\u703A", 17, "\u704D\u704E\u7050", 13, "\u705F", 11, "\u706E\u7071\u7072\u7073\u7074\u7077\u7079\u707A\u707B\u707D\u7081\u7082\u7083\u7084\u7086\u7087\u7088\u708B\u708C\u708D\u708F\u7090\u7091\u7093\u7097\u7098\u709A\u709B\u709E", 12, "\u70B0\u70B2\u70B4\u70B5\u70B6\u70BA\u70BE\u70BF\u70C4\u70C5\u70C6\u70C7\u70C9\u70CB", 12, "\u70DA"],
      ["9f40", "\u70DC\u70DD\u70DE\u70E0\u70E1\u70E2\u70E3\u70E5\u70EA\u70EE\u70F0", 6, "\u70F8\u70FA\u70FB\u70FC\u70FE", 10, "\u710B", 4, "\u7111\u7112\u7114\u7117\u711B", 10, "\u7127", 7, "\u7132\u7133\u7134"],
      ["9f80", "\u7135\u7137", 13, "\u7146\u7147\u7148\u7149\u714B\u714D\u714F", 12, "\u715D\u715F", 4, "\u7165\u7169", 4, "\u716F\u7170\u7171\u7174\u7175\u7176\u7177\u7179\u717B\u717C\u717E", 5, "\u7185", 4, "\u718B\u718C\u718D\u718E\u7190\u7191\u7192\u7193\u7195\u7196\u7197\u719A", 4, "\u71A1", 6, "\u71A9\u71AA\u71AB\u71AD", 5, "\u71B4\u71B6\u71B7\u71B8\u71BA", 8, "\u71C4", 9, "\u71CF", 4],
      ["a040", "\u71D6", 9, "\u71E1\u71E2\u71E3\u71E4\u71E6\u71E8", 5, "\u71EF", 9, "\u71FA", 11, "\u7207", 19],
      ["a080", "\u721B\u721C\u721E", 9, "\u7229\u722B\u722D\u722E\u722F\u7232\u7233\u7234\u723A\u723C\u723E\u7240", 6, "\u7249\u724A\u724B\u724E\u724F\u7250\u7251\u7253\u7254\u7255\u7257\u7258\u725A\u725C\u725E\u7260\u7263\u7264\u7265\u7268\u726A\u726B\u726C\u726D\u7270\u7271\u7273\u7274\u7276\u7277\u7278\u727B\u727C\u727D\u7282\u7283\u7285", 4, "\u728C\u728E\u7290\u7291\u7293", 11, "\u72A0", 11, "\u72AE\u72B1\u72B2\u72B3\u72B5\u72BA", 6, "\u72C5\u72C6\u72C7\u72C9\u72CA\u72CB\u72CC\u72CF\u72D1\u72D3\u72D4\u72D5\u72D6\u72D8\u72DA\u72DB"],
      ["a1a1", "\u3000\u3001\u3002\xB7\u02C9\u02C7\xA8\u3003\u3005\u2014\uFF5E\u2016\u2026\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 7, "\u3016\u3017\u3010\u3011\xB1\xD7\xF7\u2236\u2227\u2228\u2211\u220F\u222A\u2229\u2208\u2237\u221A\u22A5\u2225\u2220\u2312\u2299\u222B\u222E\u2261\u224C\u2248\u223D\u221D\u2260\u226E\u226F\u2264\u2265\u221E\u2235\u2234\u2642\u2640\xB0\u2032\u2033\u2103\uFF04\xA4\uFFE0\uFFE1\u2030\xA7\u2116\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u203B\u2192\u2190\u2191\u2193\u3013"],
      ["a2a1", "\u2170", 9],
      ["a2b1", "\u2488", 19, "\u2474", 19, "\u2460", 9],
      ["a2e5", "\u3220", 9],
      ["a2f1", "\u2160", 11],
      ["a3a1", "\uFF01\uFF02\uFF03\uFFE5\uFF05", 88, "\uFFE3"],
      ["a4a1", "\u3041", 82],
      ["a5a1", "\u30A1", 85],
      ["a6a1", "\u0391", 16, "\u03A3", 6],
      ["a6c1", "\u03B1", 16, "\u03C3", 6],
      ["a6e0", "\uFE35\uFE36\uFE39\uFE3A\uFE3F\uFE40\uFE3D\uFE3E\uFE41\uFE42\uFE43\uFE44"],
      ["a6ee", "\uFE3B\uFE3C\uFE37\uFE38\uFE31"],
      ["a6f4", "\uFE33\uFE34"],
      ["a7a1", "\u0410", 5, "\u0401\u0416", 25],
      ["a7d1", "\u0430", 5, "\u0451\u0436", 25],
      ["a840", "\u02CA\u02CB\u02D9\u2013\u2015\u2025\u2035\u2105\u2109\u2196\u2197\u2198\u2199\u2215\u221F\u2223\u2252\u2266\u2267\u22BF\u2550", 35, "\u2581", 6],
      ["a880", "\u2588", 7, "\u2593\u2594\u2595\u25BC\u25BD\u25E2\u25E3\u25E4\u25E5\u2609\u2295\u3012\u301D\u301E"],
      ["a8a1", "\u0101\xE1\u01CE\xE0\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA\u01DC\xFC\xEA\u0251"],
      ["a8bd", "\u0144\u0148"],
      ["a8c0", "\u0261"],
      ["a8c5", "\u3105", 36],
      ["a940", "\u3021", 8, "\u32A3\u338E\u338F\u339C\u339D\u339E\u33A1\u33C4\u33CE\u33D1\u33D2\u33D5\uFE30\uFFE2\uFFE4"],
      ["a959", "\u2121\u3231"],
      ["a95c", "\u2010"],
      ["a960", "\u30FC\u309B\u309C\u30FD\u30FE\u3006\u309D\u309E\uFE49", 9, "\uFE54\uFE55\uFE56\uFE57\uFE59", 8],
      ["a980", "\uFE62", 4, "\uFE68\uFE69\uFE6A\uFE6B"],
      ["a996", "\u3007"],
      ["a9a4", "\u2500", 75],
      ["aa40", "\u72DC\u72DD\u72DF\u72E2", 5, "\u72EA\u72EB\u72F5\u72F6\u72F9\u72FD\u72FE\u72FF\u7300\u7302\u7304", 5, "\u730B\u730C\u730D\u730F\u7310\u7311\u7312\u7314\u7318\u7319\u731A\u731F\u7320\u7323\u7324\u7326\u7327\u7328\u732D\u732F\u7330\u7332\u7333\u7335\u7336\u733A\u733B\u733C\u733D\u7340", 8],
      ["aa80", "\u7349\u734A\u734B\u734C\u734E\u734F\u7351\u7353\u7354\u7355\u7356\u7358", 7, "\u7361", 10, "\u736E\u7370\u7371"],
      ["ab40", "\u7372", 11, "\u737F", 4, "\u7385\u7386\u7388\u738A\u738C\u738D\u738F\u7390\u7392\u7393\u7394\u7395\u7397\u7398\u7399\u739A\u739C\u739D\u739E\u73A0\u73A1\u73A3", 5, "\u73AA\u73AC\u73AD\u73B1\u73B4\u73B5\u73B6\u73B8\u73B9\u73BC\u73BD\u73BE\u73BF\u73C1\u73C3", 4],
      ["ab80", "\u73CB\u73CC\u73CE\u73D2", 6, "\u73DA\u73DB\u73DC\u73DD\u73DF\u73E1\u73E2\u73E3\u73E4\u73E6\u73E8\u73EA\u73EB\u73EC\u73EE\u73EF\u73F0\u73F1\u73F3", 4],
      ["ac40", "\u73F8", 10, "\u7404\u7407\u7408\u740B\u740C\u740D\u740E\u7411", 8, "\u741C", 5, "\u7423\u7424\u7427\u7429\u742B\u742D\u742F\u7431\u7432\u7437", 4, "\u743D\u743E\u743F\u7440\u7442", 11],
      ["ac80", "\u744E", 6, "\u7456\u7458\u745D\u7460", 12, "\u746E\u746F\u7471", 4, "\u7478\u7479\u747A"],
      ["ad40", "\u747B\u747C\u747D\u747F\u7482\u7484\u7485\u7486\u7488\u7489\u748A\u748C\u748D\u748F\u7491", 10, "\u749D\u749F", 7, "\u74AA", 15, "\u74BB", 12],
      ["ad80", "\u74C8", 9, "\u74D3", 8, "\u74DD\u74DF\u74E1\u74E5\u74E7", 6, "\u74F0\u74F1\u74F2"],
      ["ae40", "\u74F3\u74F5\u74F8", 6, "\u7500\u7501\u7502\u7503\u7505", 7, "\u750E\u7510\u7512\u7514\u7515\u7516\u7517\u751B\u751D\u751E\u7520", 4, "\u7526\u7527\u752A\u752E\u7534\u7536\u7539\u753C\u753D\u753F\u7541\u7542\u7543\u7544\u7546\u7547\u7549\u754A\u754D\u7550\u7551\u7552\u7553\u7555\u7556\u7557\u7558"],
      ["ae80", "\u755D", 7, "\u7567\u7568\u7569\u756B", 6, "\u7573\u7575\u7576\u7577\u757A", 4, "\u7580\u7581\u7582\u7584\u7585\u7587"],
      ["af40", "\u7588\u7589\u758A\u758C\u758D\u758E\u7590\u7593\u7595\u7598\u759B\u759C\u759E\u75A2\u75A6", 4, "\u75AD\u75B6\u75B7\u75BA\u75BB\u75BF\u75C0\u75C1\u75C6\u75CB\u75CC\u75CE\u75CF\u75D0\u75D1\u75D3\u75D7\u75D9\u75DA\u75DC\u75DD\u75DF\u75E0\u75E1\u75E5\u75E9\u75EC\u75ED\u75EE\u75EF\u75F2\u75F3\u75F5\u75F6\u75F7\u75F8\u75FA\u75FB\u75FD\u75FE\u7602\u7604\u7606\u7607"],
      ["af80", "\u7608\u7609\u760B\u760D\u760E\u760F\u7611\u7612\u7613\u7614\u7616\u761A\u761C\u761D\u761E\u7621\u7623\u7627\u7628\u762C\u762E\u762F\u7631\u7632\u7636\u7637\u7639\u763A\u763B\u763D\u7641\u7642\u7644"],
      ["b040", "\u7645", 6, "\u764E", 5, "\u7655\u7657", 4, "\u765D\u765F\u7660\u7661\u7662\u7664", 6, "\u766C\u766D\u766E\u7670", 7, "\u7679\u767A\u767C\u767F\u7680\u7681\u7683\u7685\u7689\u768A\u768C\u768D\u768F\u7690\u7692\u7694\u7695\u7697\u7698\u769A\u769B"],
      ["b080", "\u769C", 7, "\u76A5", 8, "\u76AF\u76B0\u76B3\u76B5", 9, "\u76C0\u76C1\u76C3\u554A\u963F\u57C3\u6328\u54CE\u5509\u54C0\u7691\u764C\u853C\u77EE\u827E\u788D\u7231\u9698\u978D\u6C28\u5B89\u4FFA\u6309\u6697\u5CB8\u80FA\u6848\u80AE\u6602\u76CE\u51F9\u6556\u71AC\u7FF1\u8884\u50B2\u5965\u61CA\u6FB3\u82AD\u634C\u6252\u53ED\u5427\u7B06\u516B\u75A4\u5DF4\u62D4\u8DCB\u9776\u628A\u8019\u575D\u9738\u7F62\u7238\u767D\u67CF\u767E\u6446\u4F70\u8D25\u62DC\u7A17\u6591\u73ED\u642C\u6273\u822C\u9881\u677F\u7248\u626E\u62CC\u4F34\u74E3\u534A\u529E\u7ECA\u90A6\u5E2E\u6886\u699C\u8180\u7ED1\u68D2\u78C5\u868C\u9551\u508D\u8C24\u82DE\u80DE\u5305\u8912\u5265"],
      ["b140", "\u76C4\u76C7\u76C9\u76CB\u76CC\u76D3\u76D5\u76D9\u76DA\u76DC\u76DD\u76DE\u76E0", 4, "\u76E6", 7, "\u76F0\u76F3\u76F5\u76F6\u76F7\u76FA\u76FB\u76FD\u76FF\u7700\u7702\u7703\u7705\u7706\u770A\u770C\u770E", 10, "\u771B\u771C\u771D\u771E\u7721\u7723\u7724\u7725\u7727\u772A\u772B"],
      ["b180", "\u772C\u772E\u7730", 4, "\u7739\u773B\u773D\u773E\u773F\u7742\u7744\u7745\u7746\u7748", 7, "\u7752", 7, "\u775C\u8584\u96F9\u4FDD\u5821\u9971\u5B9D\u62B1\u62A5\u66B4\u8C79\u9C8D\u7206\u676F\u7891\u60B2\u5351\u5317\u8F88\u80CC\u8D1D\u94A1\u500D\u72C8\u5907\u60EB\u7119\u88AB\u5954\u82EF\u672C\u7B28\u5D29\u7EF7\u752D\u6CF5\u8E66\u8FF8\u903C\u9F3B\u6BD4\u9119\u7B14\u5F7C\u78A7\u84D6\u853D\u6BD5\u6BD9\u6BD6\u5E01\u5E87\u75F9\u95ED\u655D\u5F0A\u5FC5\u8F9F\u58C1\u81C2\u907F\u965B\u97AD\u8FB9\u7F16\u8D2C\u6241\u4FBF\u53D8\u535E\u8FA8\u8FA9\u8FAB\u904D\u6807\u5F6A\u8198\u8868\u9CD6\u618B\u522B\u762A\u5F6C\u658C\u6FD2\u6EE8\u5BBE\u6448\u5175\u51B0\u67C4\u4E19\u79C9\u997C\u70B3"],
      ["b240", "\u775D\u775E\u775F\u7760\u7764\u7767\u7769\u776A\u776D", 11, "\u777A\u777B\u777C\u7781\u7782\u7783\u7786", 5, "\u778F\u7790\u7793", 11, "\u77A1\u77A3\u77A4\u77A6\u77A8\u77AB\u77AD\u77AE\u77AF\u77B1\u77B2\u77B4\u77B6", 4],
      ["b280", "\u77BC\u77BE\u77C0", 12, "\u77CE", 8, "\u77D8\u77D9\u77DA\u77DD", 4, "\u77E4\u75C5\u5E76\u73BB\u83E0\u64AD\u62E8\u94B5\u6CE2\u535A\u52C3\u640F\u94C2\u7B94\u4F2F\u5E1B\u8236\u8116\u818A\u6E24\u6CCA\u9A73\u6355\u535C\u54FA\u8865\u57E0\u4E0D\u5E03\u6B65\u7C3F\u90E8\u6016\u64E6\u731C\u88C1\u6750\u624D\u8D22\u776C\u8E29\u91C7\u5F69\u83DC\u8521\u9910\u53C2\u8695\u6B8B\u60ED\u60E8\u707F\u82CD\u8231\u4ED3\u6CA7\u85CF\u64CD\u7CD9\u69FD\u66F9\u8349\u5395\u7B56\u4FA7\u518C\u6D4B\u5C42\u8E6D\u63D2\u53C9\u832C\u8336\u67E5\u78B4\u643D\u5BDF\u5C94\u5DEE\u8BE7\u62C6\u67F4\u8C7A\u6400\u63BA\u8749\u998B\u8C17\u7F20\u94F2\u4EA7\u9610\u98A4\u660C\u7316"],
      ["b340", "\u77E6\u77E8\u77EA\u77EF\u77F0\u77F1\u77F2\u77F4\u77F5\u77F7\u77F9\u77FA\u77FB\u77FC\u7803", 5, "\u780A\u780B\u780E\u780F\u7810\u7813\u7815\u7819\u781B\u781E\u7820\u7821\u7822\u7824\u7828\u782A\u782B\u782E\u782F\u7831\u7832\u7833\u7835\u7836\u783D\u783F\u7841\u7842\u7843\u7844\u7846\u7848\u7849\u784A\u784B\u784D\u784F\u7851\u7853\u7854\u7858\u7859\u785A"],
      ["b380", "\u785B\u785C\u785E", 11, "\u786F", 7, "\u7878\u7879\u787A\u787B\u787D", 6, "\u573A\u5C1D\u5E38\u957F\u507F\u80A0\u5382\u655E\u7545\u5531\u5021\u8D85\u6284\u949E\u671D\u5632\u6F6E\u5DE2\u5435\u7092\u8F66\u626F\u64A4\u63A3\u5F7B\u6F88\u90F4\u81E3\u8FB0\u5C18\u6668\u5FF1\u6C89\u9648\u8D81\u886C\u6491\u79F0\u57CE\u6A59\u6210\u5448\u4E58\u7A0B\u60E9\u6F84\u8BDA\u627F\u901E\u9A8B\u79E4\u5403\u75F4\u6301\u5319\u6C60\u8FDF\u5F1B\u9A70\u803B\u9F7F\u4F88\u5C3A\u8D64\u7FC5\u65A5\u70BD\u5145\u51B2\u866B\u5D07\u5BA0\u62BD\u916C\u7574\u8E0C\u7A20\u6101\u7B79\u4EC7\u7EF8\u7785\u4E11\u81ED\u521D\u51FA\u6A71\u53A8\u8E87\u9504\u96CF\u6EC1\u9664\u695A"],
      ["b440", "\u7884\u7885\u7886\u7888\u788A\u788B\u788F\u7890\u7892\u7894\u7895\u7896\u7899\u789D\u789E\u78A0\u78A2\u78A4\u78A6\u78A8", 7, "\u78B5\u78B6\u78B7\u78B8\u78BA\u78BB\u78BC\u78BD\u78BF\u78C0\u78C2\u78C3\u78C4\u78C6\u78C7\u78C8\u78CC\u78CD\u78CE\u78CF\u78D1\u78D2\u78D3\u78D6\u78D7\u78D8\u78DA", 9],
      ["b480", "\u78E4\u78E5\u78E6\u78E7\u78E9\u78EA\u78EB\u78ED", 4, "\u78F3\u78F5\u78F6\u78F8\u78F9\u78FB", 5, "\u7902\u7903\u7904\u7906", 6, "\u7840\u50A8\u77D7\u6410\u89E6\u5904\u63E3\u5DDD\u7A7F\u693D\u4F20\u8239\u5598\u4E32\u75AE\u7A97\u5E62\u5E8A\u95EF\u521B\u5439\u708A\u6376\u9524\u5782\u6625\u693F\u9187\u5507\u6DF3\u7EAF\u8822\u6233\u7EF0\u75B5\u8328\u78C1\u96CC\u8F9E\u6148\u74F7\u8BCD\u6B64\u523A\u8D50\u6B21\u806A\u8471\u56F1\u5306\u4ECE\u4E1B\u51D1\u7C97\u918B\u7C07\u4FC3\u8E7F\u7BE1\u7A9C\u6467\u5D14\u50AC\u8106\u7601\u7CB9\u6DEC\u7FE0\u6751\u5B58\u5BF8\u78CB\u64AE\u6413\u63AA\u632B\u9519\u642D\u8FBE\u7B54\u7629\u6253\u5927\u5446\u6B79\u50A3\u6234\u5E26\u6B86\u4EE3\u8D37\u888B\u5F85\u902E"],
      ["b540", "\u790D", 5, "\u7914", 9, "\u791F", 4, "\u7925", 14, "\u7935", 4, "\u793D\u793F\u7942\u7943\u7944\u7945\u7947\u794A", 8, "\u7954\u7955\u7958\u7959\u7961\u7963"],
      ["b580", "\u7964\u7966\u7969\u796A\u796B\u796C\u796E\u7970", 6, "\u7979\u797B", 4, "\u7982\u7983\u7986\u7987\u7988\u7989\u798B\u798C\u798D\u798E\u7990\u7991\u7992\u6020\u803D\u62C5\u4E39\u5355\u90F8\u63B8\u80C6\u65E6\u6C2E\u4F46\u60EE\u6DE1\u8BDE\u5F39\u86CB\u5F53\u6321\u515A\u8361\u6863\u5200\u6363\u8E48\u5012\u5C9B\u7977\u5BFC\u5230\u7A3B\u60BC\u9053\u76D7\u5FB7\u5F97\u7684\u8E6C\u706F\u767B\u7B49\u77AA\u51F3\u9093\u5824\u4F4E\u6EF4\u8FEA\u654C\u7B1B\u72C4\u6DA4\u7FDF\u5AE1\u62B5\u5E95\u5730\u8482\u7B2C\u5E1D\u5F1F\u9012\u7F14\u98A0\u6382\u6EC7\u7898\u70B9\u5178\u975B\u57AB\u7535\u4F43\u7538\u5E97\u60E6\u5960\u6DC0\u6BBF\u7889\u53FC\u96D5\u51CB\u5201\u6389\u540A\u9493\u8C03\u8DCC\u7239\u789F\u8776\u8FED\u8C0D\u53E0"],
      ["b640", "\u7993", 6, "\u799B", 11, "\u79A8", 10, "\u79B4", 4, "\u79BC\u79BF\u79C2\u79C4\u79C5\u79C7\u79C8\u79CA\u79CC\u79CE\u79CF\u79D0\u79D3\u79D4\u79D6\u79D7\u79D9", 5, "\u79E0\u79E1\u79E2\u79E5\u79E8\u79EA"],
      ["b680", "\u79EC\u79EE\u79F1", 6, "\u79F9\u79FA\u79FC\u79FE\u79FF\u7A01\u7A04\u7A05\u7A07\u7A08\u7A09\u7A0A\u7A0C\u7A0F", 4, "\u7A15\u7A16\u7A18\u7A19\u7A1B\u7A1C\u4E01\u76EF\u53EE\u9489\u9876\u9F0E\u952D\u5B9A\u8BA2\u4E22\u4E1C\u51AC\u8463\u61C2\u52A8\u680B\u4F97\u606B\u51BB\u6D1E\u515C\u6296\u6597\u9661\u8C46\u9017\u75D8\u90FD\u7763\u6BD2\u728A\u72EC\u8BFB\u5835\u7779\u8D4C\u675C\u9540\u809A\u5EA6\u6E21\u5992\u7AEF\u77ED\u953B\u6BB5\u65AD\u7F0E\u5806\u5151\u961F\u5BF9\u58A9\u5428\u8E72\u6566\u987F\u56E4\u949D\u76FE\u9041\u6387\u54C6\u591A\u593A\u579B\u8EB2\u6735\u8DFA\u8235\u5241\u60F0\u5815\u86FE\u5CE8\u9E45\u4FC4\u989D\u8BB9\u5A25\u6076\u5384\u627C\u904F\u9102\u997F\u6069\u800C\u513F\u8033\u5C14\u9975\u6D31\u4E8C"],
      ["b740", "\u7A1D\u7A1F\u7A21\u7A22\u7A24", 14, "\u7A34\u7A35\u7A36\u7A38\u7A3A\u7A3E\u7A40", 5, "\u7A47", 9, "\u7A52", 4, "\u7A58", 16],
      ["b780", "\u7A69", 6, "\u7A71\u7A72\u7A73\u7A75\u7A7B\u7A7C\u7A7D\u7A7E\u7A82\u7A85\u7A87\u7A89\u7A8A\u7A8B\u7A8C\u7A8E\u7A8F\u7A90\u7A93\u7A94\u7A99\u7A9A\u7A9B\u7A9E\u7AA1\u7AA2\u8D30\u53D1\u7F5A\u7B4F\u4F10\u4E4F\u9600\u6CD5\u73D0\u85E9\u5E06\u756A\u7FFB\u6A0A\u77FE\u9492\u7E41\u51E1\u70E6\u53CD\u8FD4\u8303\u8D29\u72AF\u996D\u6CDB\u574A\u82B3\u65B9\u80AA\u623F\u9632\u59A8\u4EFF\u8BBF\u7EBA\u653E\u83F2\u975E\u5561\u98DE\u80A5\u532A\u8BFD\u5420\u80BA\u5E9F\u6CB8\u8D39\u82AC\u915A\u5429\u6C1B\u5206\u7EB7\u575F\u711A\u6C7E\u7C89\u594B\u4EFD\u5FFF\u6124\u7CAA\u4E30\u5C01\u67AB\u8702\u5CF0\u950B\u98CE\u75AF\u70FD\u9022\u51AF\u7F1D\u8BBD\u5949\u51E4\u4F5B\u5426\u592B\u6577\u80A4\u5B75\u6276\u62C2\u8F90\u5E45\u6C1F\u7B26\u4F0F\u4FD8\u670D"],
      ["b840", "\u7AA3\u7AA4\u7AA7\u7AA9\u7AAA\u7AAB\u7AAE", 4, "\u7AB4", 10, "\u7AC0", 10, "\u7ACC", 9, "\u7AD7\u7AD8\u7ADA\u7ADB\u7ADC\u7ADD\u7AE1\u7AE2\u7AE4\u7AE7", 5, "\u7AEE\u7AF0\u7AF1\u7AF2\u7AF3"],
      ["b880", "\u7AF4", 4, "\u7AFB\u7AFC\u7AFE\u7B00\u7B01\u7B02\u7B05\u7B07\u7B09\u7B0C\u7B0D\u7B0E\u7B10\u7B12\u7B13\u7B16\u7B17\u7B18\u7B1A\u7B1C\u7B1D\u7B1F\u7B21\u7B22\u7B23\u7B27\u7B29\u7B2D\u6D6E\u6DAA\u798F\u88B1\u5F17\u752B\u629A\u8F85\u4FEF\u91DC\u65A7\u812F\u8151\u5E9C\u8150\u8D74\u526F\u8986\u8D4B\u590D\u5085\u4ED8\u961C\u7236\u8179\u8D1F\u5BCC\u8BA3\u9644\u5987\u7F1A\u5490\u5676\u560E\u8BE5\u6539\u6982\u9499\u76D6\u6E89\u5E72\u7518\u6746\u67D1\u7AFF\u809D\u8D76\u611F\u79C6\u6562\u8D63\u5188\u521A\u94A2\u7F38\u809B\u7EB2\u5C97\u6E2F\u6760\u7BD9\u768B\u9AD8\u818F\u7F94\u7CD5\u641E\u9550\u7A3F\u544A\u54E5\u6B4C\u6401\u6208\u9E3D\u80F3\u7599\u5272\u9769\u845B\u683C\u86E4\u9601\u9694\u94EC\u4E2A\u5404\u7ED9\u6839\u8DDF\u8015\u66F4\u5E9A\u7FB9"],
      ["b940", "\u7B2F\u7B30\u7B32\u7B34\u7B35\u7B36\u7B37\u7B39\u7B3B\u7B3D\u7B3F", 5, "\u7B46\u7B48\u7B4A\u7B4D\u7B4E\u7B53\u7B55\u7B57\u7B59\u7B5C\u7B5E\u7B5F\u7B61\u7B63", 10, "\u7B6F\u7B70\u7B73\u7B74\u7B76\u7B78\u7B7A\u7B7C\u7B7D\u7B7F\u7B81\u7B82\u7B83\u7B84\u7B86", 6, "\u7B8E\u7B8F"],
      ["b980", "\u7B91\u7B92\u7B93\u7B96\u7B98\u7B99\u7B9A\u7B9B\u7B9E\u7B9F\u7BA0\u7BA3\u7BA4\u7BA5\u7BAE\u7BAF\u7BB0\u7BB2\u7BB3\u7BB5\u7BB6\u7BB7\u7BB9", 7, "\u7BC2\u7BC3\u7BC4\u57C2\u803F\u6897\u5DE5\u653B\u529F\u606D\u9F9A\u4F9B\u8EAC\u516C\u5BAB\u5F13\u5DE9\u6C5E\u62F1\u8D21\u5171\u94A9\u52FE\u6C9F\u82DF\u72D7\u57A2\u6784\u8D2D\u591F\u8F9C\u83C7\u5495\u7B8D\u4F30\u6CBD\u5B64\u59D1\u9F13\u53E4\u86CA\u9AA8\u8C37\u80A1\u6545\u987E\u56FA\u96C7\u522E\u74DC\u5250\u5BE1\u6302\u8902\u4E56\u62D0\u602A\u68FA\u5173\u5B98\u51A0\u89C2\u7BA1\u9986\u7F50\u60EF\u704C\u8D2F\u5149\u5E7F\u901B\u7470\u89C4\u572D\u7845\u5F52\u9F9F\u95FA\u8F68\u9B3C\u8BE1\u7678\u6842\u67DC\u8DEA\u8D35\u523D\u8F8A\u6EDA\u68CD\u9505\u90ED\u56FD\u679C\u88F9\u8FC7\u54C8"],
      ["ba40", "\u7BC5\u7BC8\u7BC9\u7BCA\u7BCB\u7BCD\u7BCE\u7BCF\u7BD0\u7BD2\u7BD4", 4, "\u7BDB\u7BDC\u7BDE\u7BDF\u7BE0\u7BE2\u7BE3\u7BE4\u7BE7\u7BE8\u7BE9\u7BEB\u7BEC\u7BED\u7BEF\u7BF0\u7BF2", 4, "\u7BF8\u7BF9\u7BFA\u7BFB\u7BFD\u7BFF", 7, "\u7C08\u7C09\u7C0A\u7C0D\u7C0E\u7C10", 5, "\u7C17\u7C18\u7C19"],
      ["ba80", "\u7C1A", 4, "\u7C20", 5, "\u7C28\u7C29\u7C2B", 12, "\u7C39", 5, "\u7C42\u9AB8\u5B69\u6D77\u6C26\u4EA5\u5BB3\u9A87\u9163\u61A8\u90AF\u97E9\u542B\u6DB5\u5BD2\u51FD\u558A\u7F55\u7FF0\u64BC\u634D\u65F1\u61BE\u608D\u710A\u6C57\u6C49\u592F\u676D\u822A\u58D5\u568E\u8C6A\u6BEB\u90DD\u597D\u8017\u53F7\u6D69\u5475\u559D\u8377\u83CF\u6838\u79BE\u548C\u4F55\u5408\u76D2\u8C89\u9602\u6CB3\u6DB8\u8D6B\u8910\u9E64\u8D3A\u563F\u9ED1\u75D5\u5F88\u72E0\u6068\u54FC\u4EA8\u6A2A\u8861\u6052\u8F70\u54C4\u70D8\u8679\u9E3F\u6D2A\u5B8F\u5F18\u7EA2\u5589\u4FAF\u7334\u543C\u539A\u5019\u540E\u547C\u4E4E\u5FFD\u745A\u58F6\u846B\u80E1\u8774\u72D0\u7CCA\u6E56"],
      ["bb40", "\u7C43", 9, "\u7C4E", 36, "\u7C75", 5, "\u7C7E", 9],
      ["bb80", "\u7C88\u7C8A", 6, "\u7C93\u7C94\u7C96\u7C99\u7C9A\u7C9B\u7CA0\u7CA1\u7CA3\u7CA6\u7CA7\u7CA8\u7CA9\u7CAB\u7CAC\u7CAD\u7CAF\u7CB0\u7CB4", 4, "\u7CBA\u7CBB\u5F27\u864E\u552C\u62A4\u4E92\u6CAA\u6237\u82B1\u54D7\u534E\u733E\u6ED1\u753B\u5212\u5316\u8BDD\u69D0\u5F8A\u6000\u6DEE\u574F\u6B22\u73AF\u6853\u8FD8\u7F13\u6362\u60A3\u5524\u75EA\u8C62\u7115\u6DA3\u5BA6\u5E7B\u8352\u614C\u9EC4\u78FA\u8757\u7C27\u7687\u51F0\u60F6\u714C\u6643\u5E4C\u604D\u8C0E\u7070\u6325\u8F89\u5FBD\u6062\u86D4\u56DE\u6BC1\u6094\u6167\u5349\u60E0\u6666\u8D3F\u79FD\u4F1A\u70E9\u6C47\u8BB3\u8BF2\u7ED8\u8364\u660F\u5A5A\u9B42\u6D51\u6DF7\u8C41\u6D3B\u4F19\u706B\u83B7\u6216\u60D1\u970D\u8D27\u7978\u51FB\u573E\u57FA\u673A\u7578\u7A3D\u79EF\u7B95"],
      ["bc40", "\u7CBF\u7CC0\u7CC2\u7CC3\u7CC4\u7CC6\u7CC9\u7CCB\u7CCE", 6, "\u7CD8\u7CDA\u7CDB\u7CDD\u7CDE\u7CE1", 6, "\u7CE9", 5, "\u7CF0", 7, "\u7CF9\u7CFA\u7CFC", 13, "\u7D0B", 5],
      ["bc80", "\u7D11", 14, "\u7D21\u7D23\u7D24\u7D25\u7D26\u7D28\u7D29\u7D2A\u7D2C\u7D2D\u7D2E\u7D30", 6, "\u808C\u9965\u8FF9\u6FC0\u8BA5\u9E21\u59EC\u7EE9\u7F09\u5409\u6781\u68D8\u8F91\u7C4D\u96C6\u53CA\u6025\u75BE\u6C72\u5373\u5AC9\u7EA7\u6324\u51E0\u810A\u5DF1\u84DF\u6280\u5180\u5B63\u4F0E\u796D\u5242\u60B8\u6D4E\u5BC4\u5BC2\u8BA1\u8BB0\u65E2\u5FCC\u9645\u5993\u7EE7\u7EAA\u5609\u67B7\u5939\u4F73\u5BB6\u52A0\u835A\u988A\u8D3E\u7532\u94BE\u5047\u7A3C\u4EF7\u67B6\u9A7E\u5AC1\u6B7C\u76D1\u575A\u5C16\u7B3A\u95F4\u714E\u517C\u80A9\u8270\u5978\u7F04\u8327\u68C0\u67EC\u78B1\u7877\u62E3\u6361\u7B80\u4FED\u526A\u51CF\u8350\u69DB\u9274\u8DF5\u8D31\u89C1\u952E\u7BAD\u4EF6"],
      ["bd40", "\u7D37", 54, "\u7D6F", 7],
      ["bd80", "\u7D78", 32, "\u5065\u8230\u5251\u996F\u6E10\u6E85\u6DA7\u5EFA\u50F5\u59DC\u5C06\u6D46\u6C5F\u7586\u848B\u6868\u5956\u8BB2\u5320\u9171\u964D\u8549\u6912\u7901\u7126\u80F6\u4EA4\u90CA\u6D47\u9A84\u5A07\u56BC\u6405\u94F0\u77EB\u4FA5\u811A\u72E1\u89D2\u997A\u7F34\u7EDE\u527F\u6559\u9175\u8F7F\u8F83\u53EB\u7A96\u63ED\u63A5\u7686\u79F8\u8857\u9636\u622A\u52AB\u8282\u6854\u6770\u6377\u776B\u7AED\u6D01\u7ED3\u89E3\u59D0\u6212\u85C9\u82A5\u754C\u501F\u4ECB\u75A5\u8BEB\u5C4A\u5DFE\u7B4B\u65A4\u91D1\u4ECA\u6D25\u895F\u7D27\u9526\u4EC5\u8C28\u8FDB\u9773\u664B\u7981\u8FD1\u70EC\u6D78"],
      ["be40", "\u7D99", 12, "\u7DA7", 6, "\u7DAF", 42],
      ["be80", "\u7DDA", 32, "\u5C3D\u52B2\u8346\u5162\u830E\u775B\u6676\u9CB8\u4EAC\u60CA\u7CBE\u7CB3\u7ECF\u4E95\u8B66\u666F\u9888\u9759\u5883\u656C\u955C\u5F84\u75C9\u9756\u7ADF\u7ADE\u51C0\u70AF\u7A98\u63EA\u7A76\u7EA0\u7396\u97ED\u4E45\u7078\u4E5D\u9152\u53A9\u6551\u65E7\u81FC\u8205\u548E\u5C31\u759A\u97A0\u62D8\u72D9\u75BD\u5C45\u9A79\u83CA\u5C40\u5480\u77E9\u4E3E\u6CAE\u805A\u62D2\u636E\u5DE8\u5177\u8DDD\u8E1E\u952F\u4FF1\u53E5\u60E7\u70AC\u5267\u6350\u9E43\u5A1F\u5026\u7737\u5377\u7EE2\u6485\u652B\u6289\u6398\u5014\u7235\u89C9\u51B3\u8BC0\u7EDD\u5747\u83CC\u94A7\u519B\u541B\u5CFB"],
      ["bf40", "\u7DFB", 62],
      ["bf80", "\u7E3A\u7E3C", 4, "\u7E42", 4, "\u7E48", 21, "\u4FCA\u7AE3\u6D5A\u90E1\u9A8F\u5580\u5496\u5361\u54AF\u5F00\u63E9\u6977\u51EF\u6168\u520A\u582A\u52D8\u574E\u780D\u770B\u5EB7\u6177\u7CE0\u625B\u6297\u4EA2\u7095\u8003\u62F7\u70E4\u9760\u5777\u82DB\u67EF\u68F5\u78D5\u9897\u79D1\u58F3\u54B3\u53EF\u6E34\u514B\u523B\u5BA2\u8BFE\u80AF\u5543\u57A6\u6073\u5751\u542D\u7A7A\u6050\u5B54\u63A7\u62A0\u53E3\u6263\u5BC7\u67AF\u54ED\u7A9F\u82E6\u9177\u5E93\u88E4\u5938\u57AE\u630E\u8DE8\u80EF\u5757\u7B77\u4FA9\u5FEB\u5BBD\u6B3E\u5321\u7B50\u72C2\u6846\u77FF\u7736\u65F7\u51B5\u4E8F\u76D4\u5CBF\u7AA5\u8475\u594E\u9B41\u5080"],
      ["c040", "\u7E5E", 35, "\u7E83", 23, "\u7E9C\u7E9D\u7E9E"],
      ["c080", "\u7EAE\u7EB4\u7EBB\u7EBC\u7ED6\u7EE4\u7EEC\u7EF9\u7F0A\u7F10\u7F1E\u7F37\u7F39\u7F3B", 6, "\u7F43\u7F46", 9, "\u7F52\u7F53\u9988\u6127\u6E83\u5764\u6606\u6346\u56F0\u62EC\u6269\u5ED3\u9614\u5783\u62C9\u5587\u8721\u814A\u8FA3\u5566\u83B1\u6765\u8D56\u84DD\u5A6A\u680F\u62E6\u7BEE\u9611\u5170\u6F9C\u8C30\u63FD\u89C8\u61D2\u7F06\u70C2\u6EE5\u7405\u6994\u72FC\u5ECA\u90CE\u6717\u6D6A\u635E\u52B3\u7262\u8001\u4F6C\u59E5\u916A\u70D9\u6D9D\u52D2\u4E50\u96F7\u956D\u857E\u78CA\u7D2F\u5121\u5792\u64C2\u808B\u7C7B\u6CEA\u68F1\u695E\u51B7\u5398\u68A8\u7281\u9ECE\u7BF1\u72F8\u79BB\u6F13\u7406\u674E\u91CC\u9CA4\u793C\u8389\u8354\u540F\u6817\u4E3D\u5389\u52B1\u783E\u5386\u5229\u5088\u4F8B\u4FD0"],
      ["c140", "\u7F56\u7F59\u7F5B\u7F5C\u7F5D\u7F5E\u7F60\u7F63", 4, "\u7F6B\u7F6C\u7F6D\u7F6F\u7F70\u7F73\u7F75\u7F76\u7F77\u7F78\u7F7A\u7F7B\u7F7C\u7F7D\u7F7F\u7F80\u7F82", 7, "\u7F8B\u7F8D\u7F8F", 4, "\u7F95", 4, "\u7F9B\u7F9C\u7FA0\u7FA2\u7FA3\u7FA5\u7FA6\u7FA8", 6, "\u7FB1"],
      ["c180", "\u7FB3", 4, "\u7FBA\u7FBB\u7FBE\u7FC0\u7FC2\u7FC3\u7FC4\u7FC6\u7FC7\u7FC8\u7FC9\u7FCB\u7FCD\u7FCF", 4, "\u7FD6\u7FD7\u7FD9", 5, "\u7FE2\u7FE3\u75E2\u7ACB\u7C92\u6CA5\u96B6\u529B\u7483\u54E9\u4FE9\u8054\u83B2\u8FDE\u9570\u5EC9\u601C\u6D9F\u5E18\u655B\u8138\u94FE\u604B\u70BC\u7EC3\u7CAE\u51C9\u6881\u7CB1\u826F\u4E24\u8F86\u91CF\u667E\u4EAE\u8C05\u64A9\u804A\u50DA\u7597\u71CE\u5BE5\u8FBD\u6F66\u4E86\u6482\u9563\u5ED6\u6599\u5217\u88C2\u70C8\u52A3\u730E\u7433\u6797\u78F7\u9716\u4E34\u90BB\u9CDE\u6DCB\u51DB\u8D41\u541D\u62CE\u73B2\u83F1\u96F6\u9F84\u94C3\u4F36\u7F9A\u51CC\u7075\u9675\u5CAD\u9886\u53E6\u4EE4\u6E9C\u7409\u69B4\u786B\u998F\u7559\u5218\u7624\u6D41\u67F3\u516D\u9F99\u804B\u5499\u7B3C\u7ABF"],
      ["c240", "\u7FE4\u7FE7\u7FE8\u7FEA\u7FEB\u7FEC\u7FED\u7FEF\u7FF2\u7FF4", 6, "\u7FFD\u7FFE\u7FFF\u8002\u8007\u8008\u8009\u800A\u800E\u800F\u8011\u8013\u801A\u801B\u801D\u801E\u801F\u8021\u8023\u8024\u802B", 5, "\u8032\u8034\u8039\u803A\u803C\u803E\u8040\u8041\u8044\u8045\u8047\u8048\u8049\u804E\u804F\u8050\u8051\u8053\u8055\u8056\u8057"],
      ["c280", "\u8059\u805B", 13, "\u806B", 5, "\u8072", 11, "\u9686\u5784\u62E2\u9647\u697C\u5A04\u6402\u7BD3\u6F0F\u964B\u82A6\u5362\u9885\u5E90\u7089\u63B3\u5364\u864F\u9C81\u9E93\u788C\u9732\u8DEF\u8D42\u9E7F\u6F5E\u7984\u5F55\u9646\u622E\u9A74\u5415\u94DD\u4FA3\u65C5\u5C65\u5C61\u7F15\u8651\u6C2F\u5F8B\u7387\u6EE4\u7EFF\u5CE6\u631B\u5B6A\u6EE6\u5375\u4E71\u63A0\u7565\u62A1\u8F6E\u4F26\u4ED1\u6CA6\u7EB6\u8BBA\u841D\u87BA\u7F57\u903B\u9523\u7BA9\u9AA1\u88F8\u843D\u6D1B\u9A86\u7EDC\u5988\u9EBB\u739B\u7801\u8682\u9A6C\u9A82\u561B\u5417\u57CB\u4E70\u9EA6\u5356\u8FC8\u8109\u7792\u9992\u86EE\u6EE1\u8513\u66FC\u6162\u6F2B"],
      ["c340", "\u807E\u8081\u8082\u8085\u8088\u808A\u808D", 5, "\u8094\u8095\u8097\u8099\u809E\u80A3\u80A6\u80A7\u80A8\u80AC\u80B0\u80B3\u80B5\u80B6\u80B8\u80B9\u80BB\u80C5\u80C7", 4, "\u80CF", 6, "\u80D8\u80DF\u80E0\u80E2\u80E3\u80E6\u80EE\u80F5\u80F7\u80F9\u80FB\u80FE\u80FF\u8100\u8101\u8103\u8104\u8105\u8107\u8108\u810B"],
      ["c380", "\u810C\u8115\u8117\u8119\u811B\u811C\u811D\u811F", 12, "\u812D\u812E\u8130\u8133\u8134\u8135\u8137\u8139", 4, "\u813F\u8C29\u8292\u832B\u76F2\u6C13\u5FD9\u83BD\u732B\u8305\u951A\u6BDB\u77DB\u94C6\u536F\u8302\u5192\u5E3D\u8C8C\u8D38\u4E48\u73AB\u679A\u6885\u9176\u9709\u7164\u6CA1\u7709\u5A92\u9541\u6BCF\u7F8E\u6627\u5BD0\u59B9\u5A9A\u95E8\u95F7\u4EEC\u840C\u8499\u6AAC\u76DF\u9530\u731B\u68A6\u5B5F\u772F\u919A\u9761\u7CDC\u8FF7\u8C1C\u5F25\u7C73\u79D8\u89C5\u6CCC\u871C\u5BC6\u5E42\u68C9\u7720\u7EF5\u5195\u514D\u52C9\u5A29\u7F05\u9762\u82D7\u63CF\u7784\u85D0\u79D2\u6E3A\u5E99\u5999\u8511\u706D\u6C11\u62BF\u76BF\u654F\u60AF\u95FD\u660E\u879F\u9E23\u94ED\u540D\u547D\u8C2C\u6478"],
      ["c440", "\u8140", 5, "\u8147\u8149\u814D\u814E\u814F\u8152\u8156\u8157\u8158\u815B", 4, "\u8161\u8162\u8163\u8164\u8166\u8168\u816A\u816B\u816C\u816F\u8172\u8173\u8175\u8176\u8177\u8178\u8181\u8183", 4, "\u8189\u818B\u818C\u818D\u818E\u8190\u8192", 5, "\u8199\u819A\u819E", 4, "\u81A4\u81A5"],
      ["c480", "\u81A7\u81A9\u81AB", 7, "\u81B4", 5, "\u81BC\u81BD\u81BE\u81BF\u81C4\u81C5\u81C7\u81C8\u81C9\u81CB\u81CD", 6, "\u6479\u8611\u6A21\u819C\u78E8\u6469\u9B54\u62B9\u672B\u83AB\u58A8\u9ED8\u6CAB\u6F20\u5BDE\u964C\u8C0B\u725F\u67D0\u62C7\u7261\u4EA9\u59C6\u6BCD\u5893\u66AE\u5E55\u52DF\u6155\u6728\u76EE\u7766\u7267\u7A46\u62FF\u54EA\u5450\u94A0\u90A3\u5A1C\u7EB3\u6C16\u4E43\u5976\u8010\u5948\u5357\u7537\u96BE\u56CA\u6320\u8111\u607C\u95F9\u6DD6\u5462\u9981\u5185\u5AE9\u80FD\u59AE\u9713\u502A\u6CE5\u5C3C\u62DF\u4F60\u533F\u817B\u9006\u6EBA\u852B\u62C8\u5E74\u78BE\u64B5\u637B\u5FF5\u5A18\u917F\u9E1F\u5C3F\u634F\u8042\u5B7D\u556E\u954A\u954D\u6D85\u60A8\u67E0\u72DE\u51DD\u5B81"],
      ["c540", "\u81D4", 14, "\u81E4\u81E5\u81E6\u81E8\u81E9\u81EB\u81EE", 4, "\u81F5", 5, "\u81FD\u81FF\u8203\u8207", 4, "\u820E\u820F\u8211\u8213\u8215", 5, "\u821D\u8220\u8224\u8225\u8226\u8227\u8229\u822E\u8232\u823A\u823C\u823D\u823F"],
      ["c580", "\u8240\u8241\u8242\u8243\u8245\u8246\u8248\u824A\u824C\u824D\u824E\u8250", 7, "\u8259\u825B\u825C\u825D\u825E\u8260", 7, "\u8269\u62E7\u6CDE\u725B\u626D\u94AE\u7EBD\u8113\u6D53\u519C\u5F04\u5974\u52AA\u6012\u5973\u6696\u8650\u759F\u632A\u61E6\u7CEF\u8BFA\u54E6\u6B27\u9E25\u6BB4\u85D5\u5455\u5076\u6CA4\u556A\u8DB4\u722C\u5E15\u6015\u7436\u62CD\u6392\u724C\u5F98\u6E43\u6D3E\u6500\u6F58\u76D8\u78D0\u76FC\u7554\u5224\u53DB\u4E53\u5E9E\u65C1\u802A\u80D6\u629B\u5486\u5228\u70AE\u888D\u8DD1\u6CE1\u5478\u80DA\u57F9\u88F4\u8D54\u966A\u914D\u4F69\u6C9B\u55B7\u76C6\u7830\u62A8\u70F9\u6F8E\u5F6D\u84EC\u68DA\u787C\u7BF7\u81A8\u670B\u9E4F\u6367\u78B0\u576F\u7812\u9739\u6279\u62AB\u5288\u7435\u6BD7"],
      ["c640", "\u826A\u826B\u826C\u826D\u8271\u8275\u8276\u8277\u8278\u827B\u827C\u8280\u8281\u8283\u8285\u8286\u8287\u8289\u828C\u8290\u8293\u8294\u8295\u8296\u829A\u829B\u829E\u82A0\u82A2\u82A3\u82A7\u82B2\u82B5\u82B6\u82BA\u82BB\u82BC\u82BF\u82C0\u82C2\u82C3\u82C5\u82C6\u82C9\u82D0\u82D6\u82D9\u82DA\u82DD\u82E2\u82E7\u82E8\u82E9\u82EA\u82EC\u82ED\u82EE\u82F0\u82F2\u82F3\u82F5\u82F6\u82F8"],
      ["c680", "\u82FA\u82FC", 4, "\u830A\u830B\u830D\u8310\u8312\u8313\u8316\u8318\u8319\u831D", 9, "\u8329\u832A\u832E\u8330\u8332\u8337\u833B\u833D\u5564\u813E\u75B2\u76AE\u5339\u75DE\u50FB\u5C41\u8B6C\u7BC7\u504F\u7247\u9A97\u98D8\u6F02\u74E2\u7968\u6487\u77A5\u62FC\u9891\u8D2B\u54C1\u8058\u4E52\u576A\u82F9\u840D\u5E73\u51ED\u74F6\u8BC4\u5C4F\u5761\u6CFC\u9887\u5A46\u7834\u9B44\u8FEB\u7C95\u5256\u6251\u94FA\u4EC6\u8386\u8461\u83E9\u84B2\u57D4\u6734\u5703\u666E\u6D66\u8C31\u66DD\u7011\u671F\u6B3A\u6816\u621A\u59BB\u4E03\u51C4\u6F06\u67D2\u6C8F\u5176\u68CB\u5947\u6B67\u7566\u5D0E\u8110\u9F50\u65D7\u7948\u7941\u9A91\u8D77\u5C82\u4E5E\u4F01\u542F\u5951\u780C\u5668\u6C14\u8FC4\u5F03\u6C7D\u6CE3\u8BAB\u6390"],
      ["c740", "\u833E\u833F\u8341\u8342\u8344\u8345\u8348\u834A", 4, "\u8353\u8355", 4, "\u835D\u8362\u8370", 6, "\u8379\u837A\u837E", 6, "\u8387\u8388\u838A\u838B\u838C\u838D\u838F\u8390\u8391\u8394\u8395\u8396\u8397\u8399\u839A\u839D\u839F\u83A1", 6, "\u83AC\u83AD\u83AE"],
      ["c780", "\u83AF\u83B5\u83BB\u83BE\u83BF\u83C2\u83C3\u83C4\u83C6\u83C8\u83C9\u83CB\u83CD\u83CE\u83D0\u83D1\u83D2\u83D3\u83D5\u83D7\u83D9\u83DA\u83DB\u83DE\u83E2\u83E3\u83E4\u83E6\u83E7\u83E8\u83EB\u83EC\u83ED\u6070\u6D3D\u7275\u6266\u948E\u94C5\u5343\u8FC1\u7B7E\u4EDF\u8C26\u4E7E\u9ED4\u94B1\u94B3\u524D\u6F5C\u9063\u6D45\u8C34\u5811\u5D4C\u6B20\u6B49\u67AA\u545B\u8154\u7F8C\u5899\u8537\u5F3A\u62A2\u6A47\u9539\u6572\u6084\u6865\u77A7\u4E54\u4FA8\u5DE7\u9798\u64AC\u7FD8\u5CED\u4FCF\u7A8D\u5207\u8304\u4E14\u602F\u7A83\u94A6\u4FB5\u4EB2\u79E6\u7434\u52E4\u82B9\u64D2\u79BD\u5BDD\u6C81\u9752\u8F7B\u6C22\u503E\u537F\u6E05\u64CE\u6674\u6C30\u60C5\u9877\u8BF7\u5E86\u743C\u7A77\u79CB\u4E18\u90B1\u7403\u6C42\u56DA\u914B\u6CC5\u8D8B\u533A\u86C6\u66F2\u8EAF\u5C48\u9A71\u6E20"],
      ["c840", "\u83EE\u83EF\u83F3", 4, "\u83FA\u83FB\u83FC\u83FE\u83FF\u8400\u8402\u8405\u8407\u8408\u8409\u840A\u8410\u8412", 5, "\u8419\u841A\u841B\u841E", 5, "\u8429", 7, "\u8432", 5, "\u8439\u843A\u843B\u843E", 7, "\u8447\u8448\u8449"],
      ["c880", "\u844A", 6, "\u8452", 4, "\u8458\u845D\u845E\u845F\u8460\u8462\u8464", 4, "\u846A\u846E\u846F\u8470\u8472\u8474\u8477\u8479\u847B\u847C\u53D6\u5A36\u9F8B\u8DA3\u53BB\u5708\u98A7\u6743\u919B\u6CC9\u5168\u75CA\u62F3\u72AC\u5238\u529D\u7F3A\u7094\u7638\u5374\u9E4A\u69B7\u786E\u96C0\u88D9\u7FA4\u7136\u71C3\u5189\u67D3\u74E4\u58E4\u6518\u56B7\u8BA9\u9976\u6270\u7ED5\u60F9\u70ED\u58EC\u4EC1\u4EBA\u5FCD\u97E7\u4EFB\u8BA4\u5203\u598A\u7EAB\u6254\u4ECD\u65E5\u620E\u8338\u84C9\u8363\u878D\u7194\u6EB6\u5BB9\u7ED2\u5197\u63C9\u67D4\u8089\u8339\u8815\u5112\u5B7A\u5982\u8FB1\u4E73\u6C5D\u5165\u8925\u8F6F\u962E\u854A\u745E\u9510\u95F0\u6DA6\u82E5\u5F31\u6492\u6D12\u8428\u816E\u9CC3\u585E\u8D5B\u4E09\u53C1"],
      ["c940", "\u847D", 4, "\u8483\u8484\u8485\u8486\u848A\u848D\u848F", 7, "\u8498\u849A\u849B\u849D\u849E\u849F\u84A0\u84A2", 12, "\u84B0\u84B1\u84B3\u84B5\u84B6\u84B7\u84BB\u84BC\u84BE\u84C0\u84C2\u84C3\u84C5\u84C6\u84C7\u84C8\u84CB\u84CC\u84CE\u84CF\u84D2\u84D4\u84D5\u84D7"],
      ["c980", "\u84D8", 4, "\u84DE\u84E1\u84E2\u84E4\u84E7", 4, "\u84ED\u84EE\u84EF\u84F1", 10, "\u84FD\u84FE\u8500\u8501\u8502\u4F1E\u6563\u6851\u55D3\u4E27\u6414\u9A9A\u626B\u5AC2\u745F\u8272\u6DA9\u68EE\u50E7\u838E\u7802\u6740\u5239\u6C99\u7EB1\u50BB\u5565\u715E\u7B5B\u6652\u73CA\u82EB\u6749\u5C71\u5220\u717D\u886B\u95EA\u9655\u64C5\u8D61\u81B3\u5584\u6C55\u6247\u7F2E\u5892\u4F24\u5546\u8D4F\u664C\u4E0A\u5C1A\u88F3\u68A2\u634E\u7A0D\u70E7\u828D\u52FA\u97F6\u5C11\u54E8\u90B5\u7ECD\u5962\u8D4A\u86C7\u820C\u820D\u8D66\u6444\u5C04\u6151\u6D89\u793E\u8BBE\u7837\u7533\u547B\u4F38\u8EAB\u6DF1\u5A20\u7EC5\u795E\u6C88\u5BA1\u5A76\u751A\u80BE\u614E\u6E17\u58F0\u751F\u7525\u7272\u5347\u7EF3"],
      ["ca40", "\u8503", 8, "\u850D\u850E\u850F\u8510\u8512\u8514\u8515\u8516\u8518\u8519\u851B\u851C\u851D\u851E\u8520\u8522", 8, "\u852D", 9, "\u853E", 4, "\u8544\u8545\u8546\u8547\u854B", 10],
      ["ca80", "\u8557\u8558\u855A\u855B\u855C\u855D\u855F", 4, "\u8565\u8566\u8567\u8569", 8, "\u8573\u8575\u8576\u8577\u8578\u857C\u857D\u857F\u8580\u8581\u7701\u76DB\u5269\u80DC\u5723\u5E08\u5931\u72EE\u65BD\u6E7F\u8BD7\u5C38\u8671\u5341\u77F3\u62FE\u65F6\u4EC0\u98DF\u8680\u5B9E\u8BC6\u53F2\u77E2\u4F7F\u5C4E\u9A76\u59CB\u5F0F\u793A\u58EB\u4E16\u67FF\u4E8B\u62ED\u8A93\u901D\u52BF\u662F\u55DC\u566C\u9002\u4ED5\u4F8D\u91CA\u9970\u6C0F\u5E02\u6043\u5BA4\u89C6\u8BD5\u6536\u624B\u9996\u5B88\u5BFF\u6388\u552E\u53D7\u7626\u517D\u852C\u67A2\u68B3\u6B8A\u6292\u8F93\u53D4\u8212\u6DD1\u758F\u4E66\u8D4E\u5B70\u719F\u85AF\u6691\u66D9\u7F72\u8700\u9ECD\u9F20\u5C5E\u672F\u8FF0\u6811\u675F\u620D\u7AD6\u5885\u5EB6\u6570\u6F31"],
      ["cb40", "\u8582\u8583\u8586\u8588", 6, "\u8590", 10, "\u859D", 6, "\u85A5\u85A6\u85A7\u85A9\u85AB\u85AC\u85AD\u85B1", 5, "\u85B8\u85BA", 6, "\u85C2", 6, "\u85CA", 4, "\u85D1\u85D2"],
      ["cb80", "\u85D4\u85D6", 5, "\u85DD", 6, "\u85E5\u85E6\u85E7\u85E8\u85EA", 14, "\u6055\u5237\u800D\u6454\u8870\u7529\u5E05\u6813\u62F4\u971C\u53CC\u723D\u8C01\u6C34\u7761\u7A0E\u542E\u77AC\u987A\u821C\u8BF4\u7855\u6714\u70C1\u65AF\u6495\u5636\u601D\u79C1\u53F8\u4E1D\u6B7B\u8086\u5BFA\u55E3\u56DB\u4F3A\u4F3C\u9972\u5DF3\u677E\u8038\u6002\u9882\u9001\u5B8B\u8BBC\u8BF5\u641C\u8258\u64DE\u55FD\u82CF\u9165\u4FD7\u7D20\u901F\u7C9F\u50F3\u5851\u6EAF\u5BBF\u8BC9\u8083\u9178\u849C\u7B97\u867D\u968B\u968F\u7EE5\u9AD3\u788E\u5C81\u7A57\u9042\u96A7\u795F\u5B59\u635F\u7B0B\u84D1\u68AD\u5506\u7F29\u7410\u7D22\u9501\u6240\u584C\u4ED6\u5B83\u5979\u5854"],
      ["cc40", "\u85F9\u85FA\u85FC\u85FD\u85FE\u8600", 4, "\u8606", 10, "\u8612\u8613\u8614\u8615\u8617", 15, "\u8628\u862A", 13, "\u8639\u863A\u863B\u863D\u863E\u863F\u8640"],
      ["cc80", "\u8641", 11, "\u8652\u8653\u8655", 4, "\u865B\u865C\u865D\u865F\u8660\u8661\u8663", 7, "\u736D\u631E\u8E4B\u8E0F\u80CE\u82D4\u62AC\u53F0\u6CF0\u915E\u592A\u6001\u6C70\u574D\u644A\u8D2A\u762B\u6EE9\u575B\u6A80\u75F0\u6F6D\u8C2D\u8C08\u5766\u6BEF\u8892\u78B3\u63A2\u53F9\u70AD\u6C64\u5858\u642A\u5802\u68E0\u819B\u5510\u7CD6\u5018\u8EBA\u6DCC\u8D9F\u70EB\u638F\u6D9B\u6ED4\u7EE6\u8404\u6843\u9003\u6DD8\u9676\u8BA8\u5957\u7279\u85E4\u817E\u75BC\u8A8A\u68AF\u5254\u8E22\u9511\u63D0\u9898\u8E44\u557C\u4F53\u66FF\u568F\u60D5\u6D95\u5243\u5C49\u5929\u6DFB\u586B\u7530\u751C\u606C\u8214\u8146\u6311\u6761\u8FE2\u773A\u8DF3\u8D34\u94C1\u5E16\u5385\u542C\u70C3"],
      ["cd40", "\u866D\u866F\u8670\u8672", 6, "\u8683", 6, "\u868E", 4, "\u8694\u8696", 5, "\u869E", 4, "\u86A5\u86A6\u86AB\u86AD\u86AE\u86B2\u86B3\u86B7\u86B8\u86B9\u86BB", 4, "\u86C1\u86C2\u86C3\u86C5\u86C8\u86CC\u86CD\u86D2\u86D3\u86D5\u86D6\u86D7\u86DA\u86DC"],
      ["cd80", "\u86DD\u86E0\u86E1\u86E2\u86E3\u86E5\u86E6\u86E7\u86E8\u86EA\u86EB\u86EC\u86EF\u86F5\u86F6\u86F7\u86FA\u86FB\u86FC\u86FD\u86FF\u8701\u8704\u8705\u8706\u870B\u870C\u870E\u870F\u8710\u8711\u8714\u8716\u6C40\u5EF7\u505C\u4EAD\u5EAD\u633A\u8247\u901A\u6850\u916E\u77B3\u540C\u94DC\u5F64\u7AE5\u6876\u6345\u7B52\u7EDF\u75DB\u5077\u6295\u5934\u900F\u51F8\u79C3\u7A81\u56FE\u5F92\u9014\u6D82\u5C60\u571F\u5410\u5154\u6E4D\u56E2\u63A8\u9893\u817F\u8715\u892A\u9000\u541E\u5C6F\u81C0\u62D6\u6258\u8131\u9E35\u9640\u9A6E\u9A7C\u692D\u59A5\u62D3\u553E\u6316\u54C7\u86D9\u6D3C\u5A03\u74E6\u889C\u6B6A\u5916\u8C4C\u5F2F\u6E7E\u73A9\u987D\u4E38\u70F7\u5B8C\u7897\u633D\u665A\u7696\u60CB\u5B9B\u5A49\u4E07\u8155\u6C6A\u738B\u4EA1\u6789\u7F51\u5F80\u65FA\u671B\u5FD8\u5984\u5A01"],
      ["ce40", "\u8719\u871B\u871D\u871F\u8720\u8724\u8726\u8727\u8728\u872A\u872B\u872C\u872D\u872F\u8730\u8732\u8733\u8735\u8736\u8738\u8739\u873A\u873C\u873D\u8740", 6, "\u874A\u874B\u874D\u874F\u8750\u8751\u8752\u8754\u8755\u8756\u8758\u875A", 5, "\u8761\u8762\u8766", 7, "\u876F\u8771\u8772\u8773\u8775"],
      ["ce80", "\u8777\u8778\u8779\u877A\u877F\u8780\u8781\u8784\u8786\u8787\u8789\u878A\u878C\u878E", 4, "\u8794\u8795\u8796\u8798", 6, "\u87A0", 4, "\u5DCD\u5FAE\u5371\u97E6\u8FDD\u6845\u56F4\u552F\u60DF\u4E3A\u6F4D\u7EF4\u82C7\u840E\u59D4\u4F1F\u4F2A\u5C3E\u7EAC\u672A\u851A\u5473\u754F\u80C3\u5582\u9B4F\u4F4D\u6E2D\u8C13\u5C09\u6170\u536B\u761F\u6E29\u868A\u6587\u95FB\u7EB9\u543B\u7A33\u7D0A\u95EE\u55E1\u7FC1\u74EE\u631D\u8717\u6DA1\u7A9D\u6211\u65A1\u5367\u63E1\u6C83\u5DEB\u545C\u94A8\u4E4C\u6C61\u8BEC\u5C4B\u65E0\u829C\u68A7\u543E\u5434\u6BCB\u6B66\u4E94\u6342\u5348\u821E\u4F0D\u4FAE\u575E\u620A\u96FE\u6664\u7269\u52FF\u52A1\u609F\u8BEF\u6614\u7199\u6790\u897F\u7852\u77FD\u6670\u563B\u5438\u9521\u727A"],
      ["cf40", "\u87A5\u87A6\u87A7\u87A9\u87AA\u87AE\u87B0\u87B1\u87B2\u87B4\u87B6\u87B7\u87B8\u87B9\u87BB\u87BC\u87BE\u87BF\u87C1", 4, "\u87C7\u87C8\u87C9\u87CC", 4, "\u87D4", 6, "\u87DC\u87DD\u87DE\u87DF\u87E1\u87E2\u87E3\u87E4\u87E6\u87E7\u87E8\u87E9\u87EB\u87EC\u87ED\u87EF", 9],
      ["cf80", "\u87FA\u87FB\u87FC\u87FD\u87FF\u8800\u8801\u8802\u8804", 5, "\u880B", 7, "\u8814\u8817\u8818\u8819\u881A\u881C", 4, "\u8823\u7A00\u606F\u5E0C\u6089\u819D\u5915\u60DC\u7184\u70EF\u6EAA\u6C50\u7280\u6A84\u88AD\u5E2D\u4E60\u5AB3\u559C\u94E3\u6D17\u7CFB\u9699\u620F\u7EC6\u778E\u867E\u5323\u971E\u8F96\u6687\u5CE1\u4FA0\u72ED\u4E0B\u53A6\u590F\u5413\u6380\u9528\u5148\u4ED9\u9C9C\u7EA4\u54B8\u8D24\u8854\u8237\u95F2\u6D8E\u5F26\u5ACC\u663E\u9669\u73B0\u732E\u53BF\u817A\u9985\u7FA1\u5BAA\u9677\u9650\u7EBF\u76F8\u53A2\u9576\u9999\u7BB1\u8944\u6E58\u4E61\u7FD4\u7965\u8BE6\u60F3\u54CD\u4EAB\u9879\u5DF7\u6A61\u50CF\u5411\u8C61\u8427\u785D\u9704\u524A\u54EE\u56A3\u9500\u6D88\u5BB5\u6DC6\u6653"],
      ["d040", "\u8824", 13, "\u8833", 5, "\u883A\u883B\u883D\u883E\u883F\u8841\u8842\u8843\u8846", 5, "\u884E", 5, "\u8855\u8856\u8858\u885A", 6, "\u8866\u8867\u886A\u886D\u886F\u8871\u8873\u8874\u8875\u8876\u8878\u8879\u887A"],
      ["d080", "\u887B\u887C\u8880\u8883\u8886\u8887\u8889\u888A\u888C\u888E\u888F\u8890\u8891\u8893\u8894\u8895\u8897", 4, "\u889D", 4, "\u88A3\u88A5", 5, "\u5C0F\u5B5D\u6821\u8096\u5578\u7B11\u6548\u6954\u4E9B\u6B47\u874E\u978B\u534F\u631F\u643A\u90AA\u659C\u80C1\u8C10\u5199\u68B0\u5378\u87F9\u61C8\u6CC4\u6CFB\u8C22\u5C51\u85AA\u82AF\u950C\u6B23\u8F9B\u65B0\u5FFB\u5FC3\u4FE1\u8845\u661F\u8165\u7329\u60FA\u5174\u5211\u578B\u5F62\u90A2\u884C\u9192\u5E78\u674F\u6027\u59D3\u5144\u51F6\u80F8\u5308\u6C79\u96C4\u718A\u4F11\u4FEE\u7F9E\u673D\u55C5\u9508\u79C0\u8896\u7EE3\u589F\u620C\u9700\u865A\u5618\u987B\u5F90\u8BB8\u84C4\u9157\u53D9\u65ED\u5E8F\u755C\u6064\u7D6E\u5A7F\u7EEA\u7EED\u8F69\u55A7\u5BA3\u60AC\u65CB\u7384"],
      ["d140", "\u88AC\u88AE\u88AF\u88B0\u88B2", 4, "\u88B8\u88B9\u88BA\u88BB\u88BD\u88BE\u88BF\u88C0\u88C3\u88C4\u88C7\u88C8\u88CA\u88CB\u88CC\u88CD\u88CF\u88D0\u88D1\u88D3\u88D6\u88D7\u88DA", 4, "\u88E0\u88E1\u88E6\u88E7\u88E9", 6, "\u88F2\u88F5\u88F6\u88F7\u88FA\u88FB\u88FD\u88FF\u8900\u8901\u8903", 5],
      ["d180", "\u8909\u890B", 4, "\u8911\u8914", 4, "\u891C", 4, "\u8922\u8923\u8924\u8926\u8927\u8928\u8929\u892C\u892D\u892E\u892F\u8931\u8932\u8933\u8935\u8937\u9009\u7663\u7729\u7EDA\u9774\u859B\u5B66\u7A74\u96EA\u8840\u52CB\u718F\u5FAA\u65EC\u8BE2\u5BFB\u9A6F\u5DE1\u6B89\u6C5B\u8BAD\u8BAF\u900A\u8FC5\u538B\u62BC\u9E26\u9E2D\u5440\u4E2B\u82BD\u7259\u869C\u5D16\u8859\u6DAF\u96C5\u54D1\u4E9A\u8BB6\u7109\u54BD\u9609\u70DF\u6DF9\u76D0\u4E25\u7814\u8712\u5CA9\u5EF6\u8A00\u989C\u960E\u708E\u6CBF\u5944\u63A9\u773C\u884D\u6F14\u8273\u5830\u71D5\u538C\u781A\u96C1\u5501\u5F66\u7130\u5BB4\u8C1A\u9A8C\u6B83\u592E\u9E2F\u79E7\u6768\u626C\u4F6F\u75A1\u7F8A\u6D0B\u9633\u6C27\u4EF0\u75D2\u517B\u6837\u6F3E\u9080\u8170\u5996\u7476"],
      ["d240", "\u8938", 8, "\u8942\u8943\u8945", 24, "\u8960", 5, "\u8967", 19, "\u897C"],
      ["d280", "\u897D\u897E\u8980\u8982\u8984\u8985\u8987", 26, "\u6447\u5C27\u9065\u7A91\u8C23\u59DA\u54AC\u8200\u836F\u8981\u8000\u6930\u564E\u8036\u7237\u91CE\u51B6\u4E5F\u9875\u6396\u4E1A\u53F6\u66F3\u814B\u591C\u6DB2\u4E00\u58F9\u533B\u63D6\u94F1\u4F9D\u4F0A\u8863\u9890\u5937\u9057\u79FB\u4EEA\u80F0\u7591\u6C82\u5B9C\u59E8\u5F5D\u6905\u8681\u501A\u5DF2\u4E59\u77E3\u4EE5\u827A\u6291\u6613\u9091\u5C79\u4EBF\u5F79\u81C6\u9038\u8084\u75AB\u4EA6\u88D4\u610F\u6BC5\u5FC6\u4E49\u76CA\u6EA2\u8BE3\u8BAE\u8C0A\u8BD1\u5F02\u7FFC\u7FCC\u7ECE\u8335\u836B\u56E0\u6BB7\u97F3\u9634\u59FB\u541F\u94F6\u6DEB\u5BC5\u996E\u5C39\u5F15\u9690"],
      ["d340", "\u89A2", 30, "\u89C3\u89CD\u89D3\u89D4\u89D5\u89D7\u89D8\u89D9\u89DB\u89DD\u89DF\u89E0\u89E1\u89E2\u89E4\u89E7\u89E8\u89E9\u89EA\u89EC\u89ED\u89EE\u89F0\u89F1\u89F2\u89F4", 6],
      ["d380", "\u89FB", 4, "\u8A01", 5, "\u8A08", 21, "\u5370\u82F1\u6A31\u5A74\u9E70\u5E94\u7F28\u83B9\u8424\u8425\u8367\u8747\u8FCE\u8D62\u76C8\u5F71\u9896\u786C\u6620\u54DF\u62E5\u4F63\u81C3\u75C8\u5EB8\u96CD\u8E0A\u86F9\u548F\u6CF3\u6D8C\u6C38\u607F\u52C7\u7528\u5E7D\u4F18\u60A0\u5FE7\u5C24\u7531\u90AE\u94C0\u72B9\u6CB9\u6E38\u9149\u6709\u53CB\u53F3\u4F51\u91C9\u8BF1\u53C8\u5E7C\u8FC2\u6DE4\u4E8E\u76C2\u6986\u865E\u611A\u8206\u4F59\u4FDE\u903E\u9C7C\u6109\u6E1D\u6E14\u9685\u4E88\u5A31\u96E8\u4E0E\u5C7F\u79B9\u5B87\u8BED\u7FBD\u7389\u57DF\u828B\u90C1\u5401\u9047\u55BB\u5CEA\u5FA1\u6108\u6B32\u72F1\u80B2\u8A89"],
      ["d440", "\u8A1E", 31, "\u8A3F", 8, "\u8A49", 21],
      ["d480", "\u8A5F", 25, "\u8A7A", 6, "\u6D74\u5BD3\u88D5\u9884\u8C6B\u9A6D\u9E33\u6E0A\u51A4\u5143\u57A3\u8881\u539F\u63F4\u8F95\u56ED\u5458\u5706\u733F\u6E90\u7F18\u8FDC\u82D1\u613F\u6028\u9662\u66F0\u7EA6\u8D8A\u8DC3\u94A5\u5CB3\u7CA4\u6708\u60A6\u9605\u8018\u4E91\u90E7\u5300\u9668\u5141\u8FD0\u8574\u915D\u6655\u97F5\u5B55\u531D\u7838\u6742\u683D\u54C9\u707E\u5BB0\u8F7D\u518D\u5728\u54B1\u6512\u6682\u8D5E\u8D43\u810F\u846C\u906D\u7CDF\u51FF\u85FB\u67A3\u65E9\u6FA1\u86A4\u8E81\u566A\u9020\u7682\u7076\u71E5\u8D23\u62E9\u5219\u6CFD\u8D3C\u600E\u589E\u618E\u66FE\u8D60\u624E\u55B3\u6E23\u672D\u8F67"],
      ["d540", "\u8A81", 7, "\u8A8B", 7, "\u8A94", 46],
      ["d580", "\u8AC3", 32, "\u94E1\u95F8\u7728\u6805\u69A8\u548B\u4E4D\u70B8\u8BC8\u6458\u658B\u5B85\u7A84\u503A\u5BE8\u77BB\u6BE1\u8A79\u7C98\u6CBE\u76CF\u65A9\u8F97\u5D2D\u5C55\u8638\u6808\u5360\u6218\u7AD9\u6E5B\u7EFD\u6A1F\u7AE0\u5F70\u6F33\u5F20\u638C\u6DA8\u6756\u4E08\u5E10\u8D26\u4ED7\u80C0\u7634\u969C\u62DB\u662D\u627E\u6CBC\u8D75\u7167\u7F69\u5146\u8087\u53EC\u906E\u6298\u54F2\u86F0\u8F99\u8005\u9517\u8517\u8FD9\u6D59\u73CD\u659F\u771F\u7504\u7827\u81FB\u8D1E\u9488\u4FA6\u6795\u75B9\u8BCA\u9707\u632F\u9547\u9635\u84B8\u6323\u7741\u5F81\u72F0\u4E89\u6014\u6574\u62EF\u6B63\u653F"],
      ["d640", "\u8AE4", 34, "\u8B08", 27],
      ["d680", "\u8B24\u8B25\u8B27", 30, "\u5E27\u75C7\u90D1\u8BC1\u829D\u679D\u652F\u5431\u8718\u77E5\u80A2\u8102\u6C41\u4E4B\u7EC7\u804C\u76F4\u690D\u6B96\u6267\u503C\u4F84\u5740\u6307\u6B62\u8DBE\u53EA\u65E8\u7EB8\u5FD7\u631A\u63B7\u81F3\u81F4\u7F6E\u5E1C\u5CD9\u5236\u667A\u79E9\u7A1A\u8D28\u7099\u75D4\u6EDE\u6CBB\u7A92\u4E2D\u76C5\u5FE0\u949F\u8877\u7EC8\u79CD\u80BF\u91CD\u4EF2\u4F17\u821F\u5468\u5DDE\u6D32\u8BCC\u7CA5\u8F74\u8098\u5E1A\u5492\u76B1\u5B99\u663C\u9AA4\u73E0\u682A\u86DB\u6731\u732A\u8BF8\u8BDB\u9010\u7AF9\u70DB\u716E\u62C4\u77A9\u5631\u4E3B\u8457\u67F1\u52A9\u86C0\u8D2E\u94F8\u7B51"],
      ["d740", "\u8B46", 31, "\u8B67", 4, "\u8B6D", 25],
      ["d780", "\u8B87", 24, "\u8BAC\u8BB1\u8BBB\u8BC7\u8BD0\u8BEA\u8C09\u8C1E\u4F4F\u6CE8\u795D\u9A7B\u6293\u722A\u62FD\u4E13\u7816\u8F6C\u64B0\u8D5A\u7BC6\u6869\u5E84\u88C5\u5986\u649E\u58EE\u72B6\u690E\u9525\u8FFD\u8D58\u5760\u7F00\u8C06\u51C6\u6349\u62D9\u5353\u684C\u7422\u8301\u914C\u5544\u7740\u707C\u6D4A\u5179\u54A8\u8D44\u59FF\u6ECB\u6DC4\u5B5C\u7D2B\u4ED4\u7C7D\u6ED3\u5B50\u81EA\u6E0D\u5B57\u9B03\u68D5\u8E2A\u5B97\u7EFC\u603B\u7EB5\u90B9\u8D70\u594F\u63CD\u79DF\u8DB3\u5352\u65CF\u7956\u8BC5\u963B\u7EC4\u94BB\u7E82\u5634\u9189\u6700\u7F6A\u5C0A\u9075\u6628\u5DE6\u4F50\u67DE\u505A\u4F5C\u5750\u5EA7"],
      ["d840", "\u8C38", 8, "\u8C42\u8C43\u8C44\u8C45\u8C48\u8C4A\u8C4B\u8C4D", 7, "\u8C56\u8C57\u8C58\u8C59\u8C5B", 5, "\u8C63", 6, "\u8C6C", 6, "\u8C74\u8C75\u8C76\u8C77\u8C7B", 6, "\u8C83\u8C84\u8C86\u8C87"],
      ["d880", "\u8C88\u8C8B\u8C8D", 6, "\u8C95\u8C96\u8C97\u8C99", 20, "\u4E8D\u4E0C\u5140\u4E10\u5EFF\u5345\u4E15\u4E98\u4E1E\u9B32\u5B6C\u5669\u4E28\u79BA\u4E3F\u5315\u4E47\u592D\u723B\u536E\u6C10\u56DF\u80E4\u9997\u6BD3\u777E\u9F17\u4E36\u4E9F\u9F10\u4E5C\u4E69\u4E93\u8288\u5B5B\u556C\u560F\u4EC4\u538D\u539D\u53A3\u53A5\u53AE\u9765\u8D5D\u531A\u53F5\u5326\u532E\u533E\u8D5C\u5366\u5363\u5202\u5208\u520E\u522D\u5233\u523F\u5240\u524C\u525E\u5261\u525C\u84AF\u527D\u5282\u5281\u5290\u5293\u5182\u7F54\u4EBB\u4EC3\u4EC9\u4EC2\u4EE8\u4EE1\u4EEB\u4EDE\u4F1B\u4EF3\u4F22\u4F64\u4EF5\u4F25\u4F27\u4F09\u4F2B\u4F5E\u4F67\u6538\u4F5A\u4F5D"],
      ["d940", "\u8CAE", 62],
      ["d980", "\u8CED", 32, "\u4F5F\u4F57\u4F32\u4F3D\u4F76\u4F74\u4F91\u4F89\u4F83\u4F8F\u4F7E\u4F7B\u4FAA\u4F7C\u4FAC\u4F94\u4FE6\u4FE8\u4FEA\u4FC5\u4FDA\u4FE3\u4FDC\u4FD1\u4FDF\u4FF8\u5029\u504C\u4FF3\u502C\u500F\u502E\u502D\u4FFE\u501C\u500C\u5025\u5028\u507E\u5043\u5055\u5048\u504E\u506C\u507B\u50A5\u50A7\u50A9\u50BA\u50D6\u5106\u50ED\u50EC\u50E6\u50EE\u5107\u510B\u4EDD\u6C3D\u4F58\u4F65\u4FCE\u9FA0\u6C46\u7C74\u516E\u5DFD\u9EC9\u9998\u5181\u5914\u52F9\u530D\u8A07\u5310\u51EB\u5919\u5155\u4EA0\u5156\u4EB3\u886E\u88A4\u4EB5\u8114\u88D2\u7980\u5B34\u8803\u7FB8\u51AB\u51B1\u51BD\u51BC"],
      ["da40", "\u8D0E", 14, "\u8D20\u8D51\u8D52\u8D57\u8D5F\u8D65\u8D68\u8D69\u8D6A\u8D6C\u8D6E\u8D6F\u8D71\u8D72\u8D78", 8, "\u8D82\u8D83\u8D86\u8D87\u8D88\u8D89\u8D8C", 4, "\u8D92\u8D93\u8D95", 9, "\u8DA0\u8DA1"],
      ["da80", "\u8DA2\u8DA4", 12, "\u8DB2\u8DB6\u8DB7\u8DB9\u8DBB\u8DBD\u8DC0\u8DC1\u8DC2\u8DC5\u8DC7\u8DC8\u8DC9\u8DCA\u8DCD\u8DD0\u8DD2\u8DD3\u8DD4\u51C7\u5196\u51A2\u51A5\u8BA0\u8BA6\u8BA7\u8BAA\u8BB4\u8BB5\u8BB7\u8BC2\u8BC3\u8BCB\u8BCF\u8BCE\u8BD2\u8BD3\u8BD4\u8BD6\u8BD8\u8BD9\u8BDC\u8BDF\u8BE0\u8BE4\u8BE8\u8BE9\u8BEE\u8BF0\u8BF3\u8BF6\u8BF9\u8BFC\u8BFF\u8C00\u8C02\u8C04\u8C07\u8C0C\u8C0F\u8C11\u8C12\u8C14\u8C15\u8C16\u8C19\u8C1B\u8C18\u8C1D\u8C1F\u8C20\u8C21\u8C25\u8C27\u8C2A\u8C2B\u8C2E\u8C2F\u8C32\u8C33\u8C35\u8C36\u5369\u537A\u961D\u9622\u9621\u9631\u962A\u963D\u963C\u9642\u9649\u9654\u965F\u9667\u966C\u9672\u9674\u9688\u968D\u9697\u96B0\u9097\u909B\u909D\u9099\u90AC\u90A1\u90B4\u90B3\u90B6\u90BA"],
      ["db40", "\u8DD5\u8DD8\u8DD9\u8DDC\u8DE0\u8DE1\u8DE2\u8DE5\u8DE6\u8DE7\u8DE9\u8DED\u8DEE\u8DF0\u8DF1\u8DF2\u8DF4\u8DF6\u8DFC\u8DFE", 6, "\u8E06\u8E07\u8E08\u8E0B\u8E0D\u8E0E\u8E10\u8E11\u8E12\u8E13\u8E15", 7, "\u8E20\u8E21\u8E24", 4, "\u8E2B\u8E2D\u8E30\u8E32\u8E33\u8E34\u8E36\u8E37\u8E38\u8E3B\u8E3C\u8E3E"],
      ["db80", "\u8E3F\u8E43\u8E45\u8E46\u8E4C", 4, "\u8E53", 5, "\u8E5A", 11, "\u8E67\u8E68\u8E6A\u8E6B\u8E6E\u8E71\u90B8\u90B0\u90CF\u90C5\u90BE\u90D0\u90C4\u90C7\u90D3\u90E6\u90E2\u90DC\u90D7\u90DB\u90EB\u90EF\u90FE\u9104\u9122\u911E\u9123\u9131\u912F\u9139\u9143\u9146\u520D\u5942\u52A2\u52AC\u52AD\u52BE\u54FF\u52D0\u52D6\u52F0\u53DF\u71EE\u77CD\u5EF4\u51F5\u51FC\u9B2F\u53B6\u5F01\u755A\u5DEF\u574C\u57A9\u57A1\u587E\u58BC\u58C5\u58D1\u5729\u572C\u572A\u5733\u5739\u572E\u572F\u575C\u573B\u5742\u5769\u5785\u576B\u5786\u577C\u577B\u5768\u576D\u5776\u5773\u57AD\u57A4\u578C\u57B2\u57CF\u57A7\u57B4\u5793\u57A0\u57D5\u57D8\u57DA\u57D9\u57D2\u57B8\u57F4\u57EF\u57F8\u57E4\u57DD"],
      ["dc40", "\u8E73\u8E75\u8E77", 4, "\u8E7D\u8E7E\u8E80\u8E82\u8E83\u8E84\u8E86\u8E88", 6, "\u8E91\u8E92\u8E93\u8E95", 6, "\u8E9D\u8E9F", 11, "\u8EAD\u8EAE\u8EB0\u8EB1\u8EB3", 6, "\u8EBB", 7],
      ["dc80", "\u8EC3", 10, "\u8ECF", 21, "\u580B\u580D\u57FD\u57ED\u5800\u581E\u5819\u5844\u5820\u5865\u586C\u5881\u5889\u589A\u5880\u99A8\u9F19\u61FF\u8279\u827D\u827F\u828F\u828A\u82A8\u8284\u828E\u8291\u8297\u8299\u82AB\u82B8\u82BE\u82B0\u82C8\u82CA\u82E3\u8298\u82B7\u82AE\u82CB\u82CC\u82C1\u82A9\u82B4\u82A1\u82AA\u829F\u82C4\u82CE\u82A4\u82E1\u8309\u82F7\u82E4\u830F\u8307\u82DC\u82F4\u82D2\u82D8\u830C\u82FB\u82D3\u8311\u831A\u8306\u8314\u8315\u82E0\u82D5\u831C\u8351\u835B\u835C\u8308\u8392\u833C\u8334\u8331\u839B\u835E\u832F\u834F\u8347\u8343\u835F\u8340\u8317\u8360\u832D\u833A\u8333\u8366\u8365"],
      ["dd40", "\u8EE5", 62],
      ["dd80", "\u8F24", 32, "\u8368\u831B\u8369\u836C\u836A\u836D\u836E\u83B0\u8378\u83B3\u83B4\u83A0\u83AA\u8393\u839C\u8385\u837C\u83B6\u83A9\u837D\u83B8\u837B\u8398\u839E\u83A8\u83BA\u83BC\u83C1\u8401\u83E5\u83D8\u5807\u8418\u840B\u83DD\u83FD\u83D6\u841C\u8438\u8411\u8406\u83D4\u83DF\u840F\u8403\u83F8\u83F9\u83EA\u83C5\u83C0\u8426\u83F0\u83E1\u845C\u8451\u845A\u8459\u8473\u8487\u8488\u847A\u8489\u8478\u843C\u8446\u8469\u8476\u848C\u848E\u8431\u846D\u84C1\u84CD\u84D0\u84E6\u84BD\u84D3\u84CA\u84BF\u84BA\u84E0\u84A1\u84B9\u84B4\u8497\u84E5\u84E3\u850C\u750D\u8538\u84F0\u8539\u851F\u853A"],
      ["de40", "\u8F45", 32, "\u8F6A\u8F80\u8F8C\u8F92\u8F9D\u8FA0\u8FA1\u8FA2\u8FA4\u8FA5\u8FA6\u8FA7\u8FAA\u8FAC\u8FAD\u8FAE\u8FAF\u8FB2\u8FB3\u8FB4\u8FB5\u8FB7\u8FB8\u8FBA\u8FBB\u8FBC\u8FBF\u8FC0\u8FC3\u8FC6"],
      ["de80", "\u8FC9", 4, "\u8FCF\u8FD2\u8FD6\u8FD7\u8FDA\u8FE0\u8FE1\u8FE3\u8FE7\u8FEC\u8FEF\u8FF1\u8FF2\u8FF4\u8FF5\u8FF6\u8FFA\u8FFB\u8FFC\u8FFE\u8FFF\u9007\u9008\u900C\u900E\u9013\u9015\u9018\u8556\u853B\u84FF\u84FC\u8559\u8548\u8568\u8564\u855E\u857A\u77A2\u8543\u8572\u857B\u85A4\u85A8\u8587\u858F\u8579\u85AE\u859C\u8585\u85B9\u85B7\u85B0\u85D3\u85C1\u85DC\u85FF\u8627\u8605\u8629\u8616\u863C\u5EFE\u5F08\u593C\u5941\u8037\u5955\u595A\u5958\u530F\u5C22\u5C25\u5C2C\u5C34\u624C\u626A\u629F\u62BB\u62CA\u62DA\u62D7\u62EE\u6322\u62F6\u6339\u634B\u6343\u63AD\u63F6\u6371\u637A\u638E\u63B4\u636D\u63AC\u638A\u6369\u63AE\u63BC\u63F2\u63F8\u63E0\u63FF\u63C4\u63DE\u63CE\u6452\u63C6\u63BE\u6445\u6441\u640B\u641B\u6420\u640C\u6426\u6421\u645E\u6484\u646D\u6496"],
      ["df40", "\u9019\u901C\u9023\u9024\u9025\u9027", 5, "\u9030", 4, "\u9037\u9039\u903A\u903D\u903F\u9040\u9043\u9045\u9046\u9048", 4, "\u904E\u9054\u9055\u9056\u9059\u905A\u905C", 5, "\u9064\u9066\u9067\u9069\u906A\u906B\u906C\u906F", 4, "\u9076", 6, "\u907E\u9081"],
      ["df80", "\u9084\u9085\u9086\u9087\u9089\u908A\u908C", 4, "\u9092\u9094\u9096\u9098\u909A\u909C\u909E\u909F\u90A0\u90A4\u90A5\u90A7\u90A8\u90A9\u90AB\u90AD\u90B2\u90B7\u90BC\u90BD\u90BF\u90C0\u647A\u64B7\u64B8\u6499\u64BA\u64C0\u64D0\u64D7\u64E4\u64E2\u6509\u6525\u652E\u5F0B\u5FD2\u7519\u5F11\u535F\u53F1\u53FD\u53E9\u53E8\u53FB\u5412\u5416\u5406\u544B\u5452\u5453\u5454\u5456\u5443\u5421\u5457\u5459\u5423\u5432\u5482\u5494\u5477\u5471\u5464\u549A\u549B\u5484\u5476\u5466\u549D\u54D0\u54AD\u54C2\u54B4\u54D2\u54A7\u54A6\u54D3\u54D4\u5472\u54A3\u54D5\u54BB\u54BF\u54CC\u54D9\u54DA\u54DC\u54A9\u54AA\u54A4\u54DD\u54CF\u54DE\u551B\u54E7\u5520\u54FD\u5514\u54F3\u5522\u5523\u550F\u5511\u5527\u552A\u5567\u558F\u55B5\u5549\u556D\u5541\u5555\u553F\u5550\u553C"],
      ["e040", "\u90C2\u90C3\u90C6\u90C8\u90C9\u90CB\u90CC\u90CD\u90D2\u90D4\u90D5\u90D6\u90D8\u90D9\u90DA\u90DE\u90DF\u90E0\u90E3\u90E4\u90E5\u90E9\u90EA\u90EC\u90EE\u90F0\u90F1\u90F2\u90F3\u90F5\u90F6\u90F7\u90F9\u90FA\u90FB\u90FC\u90FF\u9100\u9101\u9103\u9105", 19, "\u911A\u911B\u911C"],
      ["e080", "\u911D\u911F\u9120\u9121\u9124", 10, "\u9130\u9132", 6, "\u913A", 8, "\u9144\u5537\u5556\u5575\u5576\u5577\u5533\u5530\u555C\u558B\u55D2\u5583\u55B1\u55B9\u5588\u5581\u559F\u557E\u55D6\u5591\u557B\u55DF\u55BD\u55BE\u5594\u5599\u55EA\u55F7\u55C9\u561F\u55D1\u55EB\u55EC\u55D4\u55E6\u55DD\u55C4\u55EF\u55E5\u55F2\u55F3\u55CC\u55CD\u55E8\u55F5\u55E4\u8F94\u561E\u5608\u560C\u5601\u5624\u5623\u55FE\u5600\u5627\u562D\u5658\u5639\u5657\u562C\u564D\u5662\u5659\u565C\u564C\u5654\u5686\u5664\u5671\u566B\u567B\u567C\u5685\u5693\u56AF\u56D4\u56D7\u56DD\u56E1\u56F5\u56EB\u56F9\u56FF\u5704\u570A\u5709\u571C\u5E0F\u5E19\u5E14\u5E11\u5E31\u5E3B\u5E3C"],
      ["e140", "\u9145\u9147\u9148\u9151\u9153\u9154\u9155\u9156\u9158\u9159\u915B\u915C\u915F\u9160\u9166\u9167\u9168\u916B\u916D\u9173\u917A\u917B\u917C\u9180", 4, "\u9186\u9188\u918A\u918E\u918F\u9193", 6, "\u919C", 5, "\u91A4", 5, "\u91AB\u91AC\u91B0\u91B1\u91B2\u91B3\u91B6\u91B7\u91B8\u91B9\u91BB"],
      ["e180", "\u91BC", 10, "\u91C8\u91CB\u91D0\u91D2", 9, "\u91DD", 8, "\u5E37\u5E44\u5E54\u5E5B\u5E5E\u5E61\u5C8C\u5C7A\u5C8D\u5C90\u5C96\u5C88\u5C98\u5C99\u5C91\u5C9A\u5C9C\u5CB5\u5CA2\u5CBD\u5CAC\u5CAB\u5CB1\u5CA3\u5CC1\u5CB7\u5CC4\u5CD2\u5CE4\u5CCB\u5CE5\u5D02\u5D03\u5D27\u5D26\u5D2E\u5D24\u5D1E\u5D06\u5D1B\u5D58\u5D3E\u5D34\u5D3D\u5D6C\u5D5B\u5D6F\u5D5D\u5D6B\u5D4B\u5D4A\u5D69\u5D74\u5D82\u5D99\u5D9D\u8C73\u5DB7\u5DC5\u5F73\u5F77\u5F82\u5F87\u5F89\u5F8C\u5F95\u5F99\u5F9C\u5FA8\u5FAD\u5FB5\u5FBC\u8862\u5F61\u72AD\u72B0\u72B4\u72B7\u72B8\u72C3\u72C1\u72CE\u72CD\u72D2\u72E8\u72EF\u72E9\u72F2\u72F4\u72F7\u7301\u72F3\u7303\u72FA"],
      ["e240", "\u91E6", 62],
      ["e280", "\u9225", 32, "\u72FB\u7317\u7313\u7321\u730A\u731E\u731D\u7315\u7322\u7339\u7325\u732C\u7338\u7331\u7350\u734D\u7357\u7360\u736C\u736F\u737E\u821B\u5925\u98E7\u5924\u5902\u9963\u9967", 5, "\u9974\u9977\u997D\u9980\u9984\u9987\u998A\u998D\u9990\u9991\u9993\u9994\u9995\u5E80\u5E91\u5E8B\u5E96\u5EA5\u5EA0\u5EB9\u5EB5\u5EBE\u5EB3\u8D53\u5ED2\u5ED1\u5EDB\u5EE8\u5EEA\u81BA\u5FC4\u5FC9\u5FD6\u5FCF\u6003\u5FEE\u6004\u5FE1\u5FE4\u5FFE\u6005\u6006\u5FEA\u5FED\u5FF8\u6019\u6035\u6026\u601B\u600F\u600D\u6029\u602B\u600A\u603F\u6021\u6078\u6079\u607B\u607A\u6042"],
      ["e340", "\u9246", 45, "\u9275", 16],
      ["e380", "\u9286", 7, "\u928F", 24, "\u606A\u607D\u6096\u609A\u60AD\u609D\u6083\u6092\u608C\u609B\u60EC\u60BB\u60B1\u60DD\u60D8\u60C6\u60DA\u60B4\u6120\u6126\u6115\u6123\u60F4\u6100\u610E\u612B\u614A\u6175\u61AC\u6194\u61A7\u61B7\u61D4\u61F5\u5FDD\u96B3\u95E9\u95EB\u95F1\u95F3\u95F5\u95F6\u95FC\u95FE\u9603\u9604\u9606\u9608\u960A\u960B\u960C\u960D\u960F\u9612\u9615\u9616\u9617\u9619\u961A\u4E2C\u723F\u6215\u6C35\u6C54\u6C5C\u6C4A\u6CA3\u6C85\u6C90\u6C94\u6C8C\u6C68\u6C69\u6C74\u6C76\u6C86\u6CA9\u6CD0\u6CD4\u6CAD\u6CF7\u6CF8\u6CF1\u6CD7\u6CB2\u6CE0\u6CD6\u6CFA\u6CEB\u6CEE\u6CB1\u6CD3\u6CEF\u6CFE"],
      ["e440", "\u92A8", 5, "\u92AF", 24, "\u92C9", 31],
      ["e480", "\u92E9", 32, "\u6D39\u6D27\u6D0C\u6D43\u6D48\u6D07\u6D04\u6D19\u6D0E\u6D2B\u6D4D\u6D2E\u6D35\u6D1A\u6D4F\u6D52\u6D54\u6D33\u6D91\u6D6F\u6D9E\u6DA0\u6D5E\u6D93\u6D94\u6D5C\u6D60\u6D7C\u6D63\u6E1A\u6DC7\u6DC5\u6DDE\u6E0E\u6DBF\u6DE0\u6E11\u6DE6\u6DDD\u6DD9\u6E16\u6DAB\u6E0C\u6DAE\u6E2B\u6E6E\u6E4E\u6E6B\u6EB2\u6E5F\u6E86\u6E53\u6E54\u6E32\u6E25\u6E44\u6EDF\u6EB1\u6E98\u6EE0\u6F2D\u6EE2\u6EA5\u6EA7\u6EBD\u6EBB\u6EB7\u6ED7\u6EB4\u6ECF\u6E8F\u6EC2\u6E9F\u6F62\u6F46\u6F47\u6F24\u6F15\u6EF9\u6F2F\u6F36\u6F4B\u6F74\u6F2A\u6F09\u6F29\u6F89\u6F8D\u6F8C\u6F78\u6F72\u6F7C\u6F7A\u6FD1"],
      ["e540", "\u930A", 51, "\u933F", 10],
      ["e580", "\u934A", 31, "\u936B\u6FC9\u6FA7\u6FB9\u6FB6\u6FC2\u6FE1\u6FEE\u6FDE\u6FE0\u6FEF\u701A\u7023\u701B\u7039\u7035\u704F\u705E\u5B80\u5B84\u5B95\u5B93\u5BA5\u5BB8\u752F\u9A9E\u6434\u5BE4\u5BEE\u8930\u5BF0\u8E47\u8B07\u8FB6\u8FD3\u8FD5\u8FE5\u8FEE\u8FE4\u8FE9\u8FE6\u8FF3\u8FE8\u9005\u9004\u900B\u9026\u9011\u900D\u9016\u9021\u9035\u9036\u902D\u902F\u9044\u9051\u9052\u9050\u9068\u9058\u9062\u905B\u66B9\u9074\u907D\u9082\u9088\u9083\u908B\u5F50\u5F57\u5F56\u5F58\u5C3B\u54AB\u5C50\u5C59\u5B71\u5C63\u5C66\u7FBC\u5F2A\u5F29\u5F2D\u8274\u5F3C\u9B3B\u5C6E\u5981\u5983\u598D\u59A9\u59AA\u59A3"],
      ["e640", "\u936C", 34, "\u9390", 27],
      ["e680", "\u93AC", 29, "\u93CB\u93CC\u93CD\u5997\u59CA\u59AB\u599E\u59A4\u59D2\u59B2\u59AF\u59D7\u59BE\u5A05\u5A06\u59DD\u5A08\u59E3\u59D8\u59F9\u5A0C\u5A09\u5A32\u5A34\u5A11\u5A23\u5A13\u5A40\u5A67\u5A4A\u5A55\u5A3C\u5A62\u5A75\u80EC\u5AAA\u5A9B\u5A77\u5A7A\u5ABE\u5AEB\u5AB2\u5AD2\u5AD4\u5AB8\u5AE0\u5AE3\u5AF1\u5AD6\u5AE6\u5AD8\u5ADC\u5B09\u5B17\u5B16\u5B32\u5B37\u5B40\u5C15\u5C1C\u5B5A\u5B65\u5B73\u5B51\u5B53\u5B62\u9A75\u9A77\u9A78\u9A7A\u9A7F\u9A7D\u9A80\u9A81\u9A85\u9A88\u9A8A\u9A90\u9A92\u9A93\u9A96\u9A98\u9A9B\u9A9C\u9A9D\u9A9F\u9AA0\u9AA2\u9AA3\u9AA5\u9AA7\u7E9F\u7EA1\u7EA3\u7EA5\u7EA8\u7EA9"],
      ["e740", "\u93CE", 7, "\u93D7", 54],
      ["e780", "\u940E", 32, "\u7EAD\u7EB0\u7EBE\u7EC0\u7EC1\u7EC2\u7EC9\u7ECB\u7ECC\u7ED0\u7ED4\u7ED7\u7EDB\u7EE0\u7EE1\u7EE8\u7EEB\u7EEE\u7EEF\u7EF1\u7EF2\u7F0D\u7EF6\u7EFA\u7EFB\u7EFE\u7F01\u7F02\u7F03\u7F07\u7F08\u7F0B\u7F0C\u7F0F\u7F11\u7F12\u7F17\u7F19\u7F1C\u7F1B\u7F1F\u7F21", 6, "\u7F2A\u7F2B\u7F2C\u7F2D\u7F2F", 4, "\u7F35\u5E7A\u757F\u5DDB\u753E\u9095\u738E\u7391\u73AE\u73A2\u739F\u73CF\u73C2\u73D1\u73B7\u73B3\u73C0\u73C9\u73C8\u73E5\u73D9\u987C\u740A\u73E9\u73E7\u73DE\u73BA\u73F2\u740F\u742A\u745B\u7426\u7425\u7428\u7430\u742E\u742C"],
      ["e840", "\u942F", 14, "\u943F", 43, "\u946C\u946D\u946E\u946F"],
      ["e880", "\u9470", 20, "\u9491\u9496\u9498\u94C7\u94CF\u94D3\u94D4\u94DA\u94E6\u94FB\u951C\u9520\u741B\u741A\u7441\u745C\u7457\u7455\u7459\u7477\u746D\u747E\u749C\u748E\u7480\u7481\u7487\u748B\u749E\u74A8\u74A9\u7490\u74A7\u74D2\u74BA\u97EA\u97EB\u97EC\u674C\u6753\u675E\u6748\u6769\u67A5\u6787\u676A\u6773\u6798\u67A7\u6775\u67A8\u679E\u67AD\u678B\u6777\u677C\u67F0\u6809\u67D8\u680A\u67E9\u67B0\u680C\u67D9\u67B5\u67DA\u67B3\u67DD\u6800\u67C3\u67B8\u67E2\u680E\u67C1\u67FD\u6832\u6833\u6860\u6861\u684E\u6862\u6844\u6864\u6883\u681D\u6855\u6866\u6841\u6867\u6840\u683E\u684A\u6849\u6829\u68B5\u688F\u6874\u6877\u6893\u686B\u68C2\u696E\u68FC\u691F\u6920\u68F9"],
      ["e940", "\u9527\u9533\u953D\u9543\u9548\u954B\u9555\u955A\u9560\u956E\u9574\u9575\u9577", 7, "\u9580", 42],
      ["e980", "\u95AB", 32, "\u6924\u68F0\u690B\u6901\u6957\u68E3\u6910\u6971\u6939\u6960\u6942\u695D\u6984\u696B\u6980\u6998\u6978\u6934\u69CC\u6987\u6988\u69CE\u6989\u6966\u6963\u6979\u699B\u69A7\u69BB\u69AB\u69AD\u69D4\u69B1\u69C1\u69CA\u69DF\u6995\u69E0\u698D\u69FF\u6A2F\u69ED\u6A17\u6A18\u6A65\u69F2\u6A44\u6A3E\u6AA0\u6A50\u6A5B\u6A35\u6A8E\u6A79\u6A3D\u6A28\u6A58\u6A7C\u6A91\u6A90\u6AA9\u6A97\u6AAB\u7337\u7352\u6B81\u6B82\u6B87\u6B84\u6B92\u6B93\u6B8D\u6B9A\u6B9B\u6BA1\u6BAA\u8F6B\u8F6D\u8F71\u8F72\u8F73\u8F75\u8F76\u8F78\u8F77\u8F79\u8F7A\u8F7C\u8F7E\u8F81\u8F82\u8F84\u8F87\u8F8B"],
      ["ea40", "\u95CC", 27, "\u95EC\u95FF\u9607\u9613\u9618\u961B\u961E\u9620\u9623", 6, "\u962B\u962C\u962D\u962F\u9630\u9637\u9638\u9639\u963A\u963E\u9641\u9643\u964A\u964E\u964F\u9651\u9652\u9653\u9656\u9657"],
      ["ea80", "\u9658\u9659\u965A\u965C\u965D\u965E\u9660\u9663\u9665\u9666\u966B\u966D", 4, "\u9673\u9678", 12, "\u9687\u9689\u968A\u8F8D\u8F8E\u8F8F\u8F98\u8F9A\u8ECE\u620B\u6217\u621B\u621F\u6222\u6221\u6225\u6224\u622C\u81E7\u74EF\u74F4\u74FF\u750F\u7511\u7513\u6534\u65EE\u65EF\u65F0\u660A\u6619\u6772\u6603\u6615\u6600\u7085\u66F7\u661D\u6634\u6631\u6636\u6635\u8006\u665F\u6654\u6641\u664F\u6656\u6661\u6657\u6677\u6684\u668C\u66A7\u669D\u66BE\u66DB\u66DC\u66E6\u66E9\u8D32\u8D33\u8D36\u8D3B\u8D3D\u8D40\u8D45\u8D46\u8D48\u8D49\u8D47\u8D4D\u8D55\u8D59\u89C7\u89CA\u89CB\u89CC\u89CE\u89CF\u89D0\u89D1\u726E\u729F\u725D\u7266\u726F\u727E\u727F\u7284\u728B\u728D\u728F\u7292\u6308\u6332\u63B0"],
      ["eb40", "\u968C\u968E\u9691\u9692\u9693\u9695\u9696\u969A\u969B\u969D", 9, "\u96A8", 7, "\u96B1\u96B2\u96B4\u96B5\u96B7\u96B8\u96BA\u96BB\u96BF\u96C2\u96C3\u96C8\u96CA\u96CB\u96D0\u96D1\u96D3\u96D4\u96D6", 9, "\u96E1", 6, "\u96EB"],
      ["eb80", "\u96EC\u96ED\u96EE\u96F0\u96F1\u96F2\u96F4\u96F5\u96F8\u96FA\u96FB\u96FC\u96FD\u96FF\u9702\u9703\u9705\u970A\u970B\u970C\u9710\u9711\u9712\u9714\u9715\u9717", 4, "\u971D\u971F\u9720\u643F\u64D8\u8004\u6BEA\u6BF3\u6BFD\u6BF5\u6BF9\u6C05\u6C07\u6C06\u6C0D\u6C15\u6C18\u6C19\u6C1A\u6C21\u6C29\u6C24\u6C2A\u6C32\u6535\u6555\u656B\u724D\u7252\u7256\u7230\u8662\u5216\u809F\u809C\u8093\u80BC\u670A\u80BD\u80B1\u80AB\u80AD\u80B4\u80B7\u80E7\u80E8\u80E9\u80EA\u80DB\u80C2\u80C4\u80D9\u80CD\u80D7\u6710\u80DD\u80EB\u80F1\u80F4\u80ED\u810D\u810E\u80F2\u80FC\u6715\u8112\u8C5A\u8136\u811E\u812C\u8118\u8132\u8148\u814C\u8153\u8174\u8159\u815A\u8171\u8160\u8169\u817C\u817D\u816D\u8167\u584D\u5AB5\u8188\u8182\u8191\u6ED5\u81A3\u81AA\u81CC\u6726\u81CA\u81BB"],
      ["ec40", "\u9721", 8, "\u972B\u972C\u972E\u972F\u9731\u9733", 4, "\u973A\u973B\u973C\u973D\u973F", 18, "\u9754\u9755\u9757\u9758\u975A\u975C\u975D\u975F\u9763\u9764\u9766\u9767\u9768\u976A", 7],
      ["ec80", "\u9772\u9775\u9777", 4, "\u977D", 7, "\u9786", 4, "\u978C\u978E\u978F\u9790\u9793\u9795\u9796\u9797\u9799", 4, "\u81C1\u81A6\u6B24\u6B37\u6B39\u6B43\u6B46\u6B59\u98D1\u98D2\u98D3\u98D5\u98D9\u98DA\u6BB3\u5F40\u6BC2\u89F3\u6590\u9F51\u6593\u65BC\u65C6\u65C4\u65C3\u65CC\u65CE\u65D2\u65D6\u7080\u709C\u7096\u709D\u70BB\u70C0\u70B7\u70AB\u70B1\u70E8\u70CA\u7110\u7113\u7116\u712F\u7131\u7173\u715C\u7168\u7145\u7172\u714A\u7178\u717A\u7198\u71B3\u71B5\u71A8\u71A0\u71E0\u71D4\u71E7\u71F9\u721D\u7228\u706C\u7118\u7166\u71B9\u623E\u623D\u6243\u6248\u6249\u793B\u7940\u7946\u7949\u795B\u795C\u7953\u795A\u7962\u7957\u7960\u796F\u7967\u797A\u7985\u798A\u799A\u79A7\u79B3\u5FD1\u5FD0"],
      ["ed40", "\u979E\u979F\u97A1\u97A2\u97A4", 6, "\u97AC\u97AE\u97B0\u97B1\u97B3\u97B5", 46],
      ["ed80", "\u97E4\u97E5\u97E8\u97EE", 4, "\u97F4\u97F7", 23, "\u603C\u605D\u605A\u6067\u6041\u6059\u6063\u60AB\u6106\u610D\u615D\u61A9\u619D\u61CB\u61D1\u6206\u8080\u807F\u6C93\u6CF6\u6DFC\u77F6\u77F8\u7800\u7809\u7817\u7818\u7811\u65AB\u782D\u781C\u781D\u7839\u783A\u783B\u781F\u783C\u7825\u782C\u7823\u7829\u784E\u786D\u7856\u7857\u7826\u7850\u7847\u784C\u786A\u789B\u7893\u789A\u7887\u789C\u78A1\u78A3\u78B2\u78B9\u78A5\u78D4\u78D9\u78C9\u78EC\u78F2\u7905\u78F4\u7913\u7924\u791E\u7934\u9F9B\u9EF9\u9EFB\u9EFC\u76F1\u7704\u770D\u76F9\u7707\u7708\u771A\u7722\u7719\u772D\u7726\u7735\u7738\u7750\u7751\u7747\u7743\u775A\u7768"],
      ["ee40", "\u980F", 62],
      ["ee80", "\u984E", 32, "\u7762\u7765\u777F\u778D\u777D\u7780\u778C\u7791\u779F\u77A0\u77B0\u77B5\u77BD\u753A\u7540\u754E\u754B\u7548\u755B\u7572\u7579\u7583\u7F58\u7F61\u7F5F\u8A48\u7F68\u7F74\u7F71\u7F79\u7F81\u7F7E\u76CD\u76E5\u8832\u9485\u9486\u9487\u948B\u948A\u948C\u948D\u948F\u9490\u9494\u9497\u9495\u949A\u949B\u949C\u94A3\u94A4\u94AB\u94AA\u94AD\u94AC\u94AF\u94B0\u94B2\u94B4\u94B6", 4, "\u94BC\u94BD\u94BF\u94C4\u94C8", 6, "\u94D0\u94D1\u94D2\u94D5\u94D6\u94D7\u94D9\u94D8\u94DB\u94DE\u94DF\u94E0\u94E2\u94E4\u94E5\u94E7\u94E8\u94EA"],
      ["ef40", "\u986F", 5, "\u988B\u988E\u9892\u9895\u9899\u98A3\u98A8", 37, "\u98CF\u98D0\u98D4\u98D6\u98D7\u98DB\u98DC\u98DD\u98E0", 4],
      ["ef80", "\u98E5\u98E6\u98E9", 30, "\u94E9\u94EB\u94EE\u94EF\u94F3\u94F4\u94F5\u94F7\u94F9\u94FC\u94FD\u94FF\u9503\u9502\u9506\u9507\u9509\u950A\u950D\u950E\u950F\u9512", 4, "\u9518\u951B\u951D\u951E\u951F\u9522\u952A\u952B\u9529\u952C\u9531\u9532\u9534\u9536\u9537\u9538\u953C\u953E\u953F\u9542\u9535\u9544\u9545\u9546\u9549\u954C\u954E\u954F\u9552\u9553\u9554\u9556\u9557\u9558\u9559\u955B\u955E\u955F\u955D\u9561\u9562\u9564", 8, "\u956F\u9571\u9572\u9573\u953A\u77E7\u77EC\u96C9\u79D5\u79ED\u79E3\u79EB\u7A06\u5D47\u7A03\u7A02\u7A1E\u7A14"],
      ["f040", "\u9908", 4, "\u990E\u990F\u9911", 28, "\u992F", 26],
      ["f080", "\u994A", 9, "\u9956", 12, "\u9964\u9966\u9973\u9978\u9979\u997B\u997E\u9982\u9983\u9989\u7A39\u7A37\u7A51\u9ECF\u99A5\u7A70\u7688\u768E\u7693\u7699\u76A4\u74DE\u74E0\u752C\u9E20\u9E22\u9E28", 4, "\u9E32\u9E31\u9E36\u9E38\u9E37\u9E39\u9E3A\u9E3E\u9E41\u9E42\u9E44\u9E46\u9E47\u9E48\u9E49\u9E4B\u9E4C\u9E4E\u9E51\u9E55\u9E57\u9E5A\u9E5B\u9E5C\u9E5E\u9E63\u9E66", 6, "\u9E71\u9E6D\u9E73\u7592\u7594\u7596\u75A0\u759D\u75AC\u75A3\u75B3\u75B4\u75B8\u75C4\u75B1\u75B0\u75C3\u75C2\u75D6\u75CD\u75E3\u75E8\u75E6\u75E4\u75EB\u75E7\u7603\u75F1\u75FC\u75FF\u7610\u7600\u7605\u760C\u7617\u760A\u7625\u7618\u7615\u7619"],
      ["f140", "\u998C\u998E\u999A", 10, "\u99A6\u99A7\u99A9", 47],
      ["f180", "\u99D9", 32, "\u761B\u763C\u7622\u7620\u7640\u762D\u7630\u763F\u7635\u7643\u763E\u7633\u764D\u765E\u7654\u765C\u7656\u766B\u766F\u7FCA\u7AE6\u7A78\u7A79\u7A80\u7A86\u7A88\u7A95\u7AA6\u7AA0\u7AAC\u7AA8\u7AAD\u7AB3\u8864\u8869\u8872\u887D\u887F\u8882\u88A2\u88C6\u88B7\u88BC\u88C9\u88E2\u88CE\u88E3\u88E5\u88F1\u891A\u88FC\u88E8\u88FE\u88F0\u8921\u8919\u8913\u891B\u890A\u8934\u892B\u8936\u8941\u8966\u897B\u758B\u80E5\u76B2\u76B4\u77DC\u8012\u8014\u8016\u801C\u8020\u8022\u8025\u8026\u8027\u8029\u8028\u8031\u800B\u8035\u8043\u8046\u804D\u8052\u8069\u8071\u8983\u9878\u9880\u9883"],
      ["f240", "\u99FA", 62],
      ["f280", "\u9A39", 32, "\u9889\u988C\u988D\u988F\u9894\u989A\u989B\u989E\u989F\u98A1\u98A2\u98A5\u98A6\u864D\u8654\u866C\u866E\u867F\u867A\u867C\u867B\u86A8\u868D\u868B\u86AC\u869D\u86A7\u86A3\u86AA\u8693\u86A9\u86B6\u86C4\u86B5\u86CE\u86B0\u86BA\u86B1\u86AF\u86C9\u86CF\u86B4\u86E9\u86F1\u86F2\u86ED\u86F3\u86D0\u8713\u86DE\u86F4\u86DF\u86D8\u86D1\u8703\u8707\u86F8\u8708\u870A\u870D\u8709\u8723\u873B\u871E\u8725\u872E\u871A\u873E\u8748\u8734\u8731\u8729\u8737\u873F\u8782\u8722\u877D\u877E\u877B\u8760\u8770\u874C\u876E\u878B\u8753\u8763\u877C\u8764\u8759\u8765\u8793\u87AF\u87A8\u87D2"],
      ["f340", "\u9A5A", 17, "\u9A72\u9A83\u9A89\u9A8D\u9A8E\u9A94\u9A95\u9A99\u9AA6\u9AA9", 6, "\u9AB2\u9AB3\u9AB4\u9AB5\u9AB9\u9ABB\u9ABD\u9ABE\u9ABF\u9AC3\u9AC4\u9AC6", 4, "\u9ACD\u9ACE\u9ACF\u9AD0\u9AD2\u9AD4\u9AD5\u9AD6\u9AD7\u9AD9\u9ADA\u9ADB\u9ADC"],
      ["f380", "\u9ADD\u9ADE\u9AE0\u9AE2\u9AE3\u9AE4\u9AE5\u9AE7\u9AE8\u9AE9\u9AEA\u9AEC\u9AEE\u9AF0", 8, "\u9AFA\u9AFC", 6, "\u9B04\u9B05\u9B06\u87C6\u8788\u8785\u87AD\u8797\u8783\u87AB\u87E5\u87AC\u87B5\u87B3\u87CB\u87D3\u87BD\u87D1\u87C0\u87CA\u87DB\u87EA\u87E0\u87EE\u8816\u8813\u87FE\u880A\u881B\u8821\u8839\u883C\u7F36\u7F42\u7F44\u7F45\u8210\u7AFA\u7AFD\u7B08\u7B03\u7B04\u7B15\u7B0A\u7B2B\u7B0F\u7B47\u7B38\u7B2A\u7B19\u7B2E\u7B31\u7B20\u7B25\u7B24\u7B33\u7B3E\u7B1E\u7B58\u7B5A\u7B45\u7B75\u7B4C\u7B5D\u7B60\u7B6E\u7B7B\u7B62\u7B72\u7B71\u7B90\u7BA6\u7BA7\u7BB8\u7BAC\u7B9D\u7BA8\u7B85\u7BAA\u7B9C\u7BA2\u7BAB\u7BB4\u7BD1\u7BC1\u7BCC\u7BDD\u7BDA\u7BE5\u7BE6\u7BEA\u7C0C\u7BFE\u7BFC\u7C0F\u7C16\u7C0B"],
      ["f440", "\u9B07\u9B09", 5, "\u9B10\u9B11\u9B12\u9B14", 10, "\u9B20\u9B21\u9B22\u9B24", 10, "\u9B30\u9B31\u9B33", 7, "\u9B3D\u9B3E\u9B3F\u9B40\u9B46\u9B4A\u9B4B\u9B4C\u9B4E\u9B50\u9B52\u9B53\u9B55", 5],
      ["f480", "\u9B5B", 32, "\u7C1F\u7C2A\u7C26\u7C38\u7C41\u7C40\u81FE\u8201\u8202\u8204\u81EC\u8844\u8221\u8222\u8223\u822D\u822F\u8228\u822B\u8238\u823B\u8233\u8234\u823E\u8244\u8249\u824B\u824F\u825A\u825F\u8268\u887E\u8885\u8888\u88D8\u88DF\u895E\u7F9D\u7F9F\u7FA7\u7FAF\u7FB0\u7FB2\u7C7C\u6549\u7C91\u7C9D\u7C9C\u7C9E\u7CA2\u7CB2\u7CBC\u7CBD\u7CC1\u7CC7\u7CCC\u7CCD\u7CC8\u7CC5\u7CD7\u7CE8\u826E\u66A8\u7FBF\u7FCE\u7FD5\u7FE5\u7FE1\u7FE6\u7FE9\u7FEE\u7FF3\u7CF8\u7D77\u7DA6\u7DAE\u7E47\u7E9B\u9EB8\u9EB4\u8D73\u8D84\u8D94\u8D91\u8DB1\u8D67\u8D6D\u8C47\u8C49\u914A\u9150\u914E\u914F\u9164"],
      ["f540", "\u9B7C", 62],
      ["f580", "\u9BBB", 32, "\u9162\u9161\u9170\u9169\u916F\u917D\u917E\u9172\u9174\u9179\u918C\u9185\u9190\u918D\u9191\u91A2\u91A3\u91AA\u91AD\u91AE\u91AF\u91B5\u91B4\u91BA\u8C55\u9E7E\u8DB8\u8DEB\u8E05\u8E59\u8E69\u8DB5\u8DBF\u8DBC\u8DBA\u8DC4\u8DD6\u8DD7\u8DDA\u8DDE\u8DCE\u8DCF\u8DDB\u8DC6\u8DEC\u8DF7\u8DF8\u8DE3\u8DF9\u8DFB\u8DE4\u8E09\u8DFD\u8E14\u8E1D\u8E1F\u8E2C\u8E2E\u8E23\u8E2F\u8E3A\u8E40\u8E39\u8E35\u8E3D\u8E31\u8E49\u8E41\u8E42\u8E51\u8E52\u8E4A\u8E70\u8E76\u8E7C\u8E6F\u8E74\u8E85\u8E8F\u8E94\u8E90\u8E9C\u8E9E\u8C78\u8C82\u8C8A\u8C85\u8C98\u8C94\u659B\u89D6\u89DE\u89DA\u89DC"],
      ["f640", "\u9BDC", 62],
      ["f680", "\u9C1B", 32, "\u89E5\u89EB\u89EF\u8A3E\u8B26\u9753\u96E9\u96F3\u96EF\u9706\u9701\u9708\u970F\u970E\u972A\u972D\u9730\u973E\u9F80\u9F83\u9F85", 5, "\u9F8C\u9EFE\u9F0B\u9F0D\u96B9\u96BC\u96BD\u96CE\u96D2\u77BF\u96E0\u928E\u92AE\u92C8\u933E\u936A\u93CA\u938F\u943E\u946B\u9C7F\u9C82\u9C85\u9C86\u9C87\u9C88\u7A23\u9C8B\u9C8E\u9C90\u9C91\u9C92\u9C94\u9C95\u9C9A\u9C9B\u9C9E", 5, "\u9CA5", 4, "\u9CAB\u9CAD\u9CAE\u9CB0", 7, "\u9CBA\u9CBB\u9CBC\u9CBD\u9CC4\u9CC5\u9CC6\u9CC7\u9CCA\u9CCB"],
      ["f740", "\u9C3C", 62],
      ["f780", "\u9C7B\u9C7D\u9C7E\u9C80\u9C83\u9C84\u9C89\u9C8A\u9C8C\u9C8F\u9C93\u9C96\u9C97\u9C98\u9C99\u9C9D\u9CAA\u9CAC\u9CAF\u9CB9\u9CBE", 4, "\u9CC8\u9CC9\u9CD1\u9CD2\u9CDA\u9CDB\u9CE0\u9CE1\u9CCC", 4, "\u9CD3\u9CD4\u9CD5\u9CD7\u9CD8\u9CD9\u9CDC\u9CDD\u9CDF\u9CE2\u977C\u9785\u9791\u9792\u9794\u97AF\u97AB\u97A3\u97B2\u97B4\u9AB1\u9AB0\u9AB7\u9E58\u9AB6\u9ABA\u9ABC\u9AC1\u9AC0\u9AC5\u9AC2\u9ACB\u9ACC\u9AD1\u9B45\u9B43\u9B47\u9B49\u9B48\u9B4D\u9B51\u98E8\u990D\u992E\u9955\u9954\u9ADF\u9AE1\u9AE6\u9AEF\u9AEB\u9AFB\u9AED\u9AF9\u9B08\u9B0F\u9B13\u9B1F\u9B23\u9EBD\u9EBE\u7E3B\u9E82\u9E87\u9E88\u9E8B\u9E92\u93D6\u9E9D\u9E9F\u9EDB\u9EDC\u9EDD\u9EE0\u9EDF\u9EE2\u9EE9\u9EE7\u9EE5\u9EEA\u9EEF\u9F22\u9F2C\u9F2F\u9F39\u9F37\u9F3D\u9F3E\u9F44"],
      ["f840", "\u9CE3", 62],
      ["f880", "\u9D22", 32],
      ["f940", "\u9D43", 62],
      ["f980", "\u9D82", 32],
      ["fa40", "\u9DA3", 62],
      ["fa80", "\u9DE2", 32],
      ["fb40", "\u9E03", 27, "\u9E24\u9E27\u9E2E\u9E30\u9E34\u9E3B\u9E3C\u9E40\u9E4D\u9E50\u9E52\u9E53\u9E54\u9E56\u9E59\u9E5D\u9E5F\u9E60\u9E61\u9E62\u9E65\u9E6E\u9E6F\u9E72\u9E74", 9, "\u9E80"],
      ["fb80", "\u9E81\u9E83\u9E84\u9E85\u9E86\u9E89\u9E8A\u9E8C", 5, "\u9E94", 8, "\u9E9E\u9EA0", 5, "\u9EA7\u9EA8\u9EA9\u9EAA"],
      ["fc40", "\u9EAB", 8, "\u9EB5\u9EB6\u9EB7\u9EB9\u9EBA\u9EBC\u9EBF", 4, "\u9EC5\u9EC6\u9EC7\u9EC8\u9ECA\u9ECB\u9ECC\u9ED0\u9ED2\u9ED3\u9ED5\u9ED6\u9ED7\u9ED9\u9EDA\u9EDE\u9EE1\u9EE3\u9EE4\u9EE6\u9EE8\u9EEB\u9EEC\u9EED\u9EEE\u9EF0", 8, "\u9EFA\u9EFD\u9EFF", 6],
      ["fc80", "\u9F06", 4, "\u9F0C\u9F0F\u9F11\u9F12\u9F14\u9F15\u9F16\u9F18\u9F1A", 5, "\u9F21\u9F23", 8, "\u9F2D\u9F2E\u9F30\u9F31"],
      ["fd40", "\u9F32", 4, "\u9F38\u9F3A\u9F3C\u9F3F", 4, "\u9F45", 10, "\u9F52", 38],
      ["fd80", "\u9F79", 5, "\u9F81\u9F82\u9F8D", 11, "\u9F9C\u9F9D\u9F9E\u9FA1", 4, "\uF92C\uF979\uF995\uF9E7\uF9F1"],
      ["fe40", "\uFA0C\uFA0D\uFA0E\uFA0F\uFA11\uFA13\uFA14\uFA18\uFA1F\uFA20\uFA21\uFA23\uFA24\uFA27\uFA28\uFA29"]
    ];
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/gbk-added.json
var require_gbk_added = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/gbk-added.json"(exports2, module2) {
    module2.exports = [
      ["a140", "\uE4C6", 62],
      ["a180", "\uE505", 32],
      ["a240", "\uE526", 62],
      ["a280", "\uE565", 32],
      ["a2ab", "\uE766", 5],
      ["a2e3", "\u20AC\uE76D"],
      ["a2ef", "\uE76E\uE76F"],
      ["a2fd", "\uE770\uE771"],
      ["a340", "\uE586", 62],
      ["a380", "\uE5C5", 31, "\u3000"],
      ["a440", "\uE5E6", 62],
      ["a480", "\uE625", 32],
      ["a4f4", "\uE772", 10],
      ["a540", "\uE646", 62],
      ["a580", "\uE685", 32],
      ["a5f7", "\uE77D", 7],
      ["a640", "\uE6A6", 62],
      ["a680", "\uE6E5", 32],
      ["a6b9", "\uE785", 7],
      ["a6d9", "\uE78D", 6],
      ["a6ec", "\uE794\uE795"],
      ["a6f3", "\uE796"],
      ["a6f6", "\uE797", 8],
      ["a740", "\uE706", 62],
      ["a780", "\uE745", 32],
      ["a7c2", "\uE7A0", 14],
      ["a7f2", "\uE7AF", 12],
      ["a896", "\uE7BC", 10],
      ["a8bc", "\u1E3F"],
      ["a8bf", "\u01F9"],
      ["a8c1", "\uE7C9\uE7CA\uE7CB\uE7CC"],
      ["a8ea", "\uE7CD", 20],
      ["a958", "\uE7E2"],
      ["a95b", "\uE7E3"],
      ["a95d", "\uE7E4\uE7E5\uE7E6"],
      ["a989", "\u303E\u2FF0", 11],
      ["a997", "\uE7F4", 12],
      ["a9f0", "\uE801", 14],
      ["aaa1", "\uE000", 93],
      ["aba1", "\uE05E", 93],
      ["aca1", "\uE0BC", 93],
      ["ada1", "\uE11A", 93],
      ["aea1", "\uE178", 93],
      ["afa1", "\uE1D6", 93],
      ["d7fa", "\uE810", 4],
      ["f8a1", "\uE234", 93],
      ["f9a1", "\uE292", 93],
      ["faa1", "\uE2F0", 93],
      ["fba1", "\uE34E", 93],
      ["fca1", "\uE3AC", 93],
      ["fda1", "\uE40A", 93],
      ["fe50", "\u2E81\uE816\uE817\uE818\u2E84\u3473\u3447\u2E88\u2E8B\uE81E\u359E\u361A\u360E\u2E8C\u2E97\u396E\u3918\uE826\u39CF\u39DF\u3A73\u39D0\uE82B\uE82C\u3B4E\u3C6E\u3CE0\u2EA7\uE831\uE832\u2EAA\u4056\u415F\u2EAE\u4337\u2EB3\u2EB6\u2EB7\uE83B\u43B1\u43AC\u2EBB\u43DD\u44D6\u4661\u464C\uE843"],
      ["fe80", "\u4723\u4729\u477C\u478D\u2ECA\u4947\u497A\u497D\u4982\u4983\u4985\u4986\u499F\u499B\u49B7\u49B6\uE854\uE855\u4CA3\u4C9F\u4CA0\u4CA1\u4C77\u4CA2\u4D13", 6, "\u4DAE\uE864\uE468", 93],
      ["8135f437", "\uE7C7"]
    ];
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json
var require_gb18030_ranges = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/gb18030-ranges.json"(exports2, module2) {
    module2.exports = { uChars: [128, 165, 169, 178, 184, 216, 226, 235, 238, 244, 248, 251, 253, 258, 276, 284, 300, 325, 329, 334, 364, 463, 465, 467, 469, 471, 473, 475, 477, 506, 594, 610, 712, 716, 730, 930, 938, 962, 970, 1026, 1104, 1106, 8209, 8215, 8218, 8222, 8231, 8241, 8244, 8246, 8252, 8365, 8452, 8454, 8458, 8471, 8482, 8556, 8570, 8596, 8602, 8713, 8720, 8722, 8726, 8731, 8737, 8740, 8742, 8748, 8751, 8760, 8766, 8777, 8781, 8787, 8802, 8808, 8816, 8854, 8858, 8870, 8896, 8979, 9322, 9372, 9548, 9588, 9616, 9622, 9634, 9652, 9662, 9672, 9676, 9680, 9702, 9735, 9738, 9793, 9795, 11906, 11909, 11913, 11917, 11928, 11944, 11947, 11951, 11956, 11960, 11964, 11979, 12284, 12292, 12312, 12319, 12330, 12351, 12436, 12447, 12535, 12543, 12586, 12842, 12850, 12964, 13200, 13215, 13218, 13253, 13263, 13267, 13270, 13384, 13428, 13727, 13839, 13851, 14617, 14703, 14801, 14816, 14964, 15183, 15471, 15585, 16471, 16736, 17208, 17325, 17330, 17374, 17623, 17997, 18018, 18212, 18218, 18301, 18318, 18760, 18811, 18814, 18820, 18823, 18844, 18848, 18872, 19576, 19620, 19738, 19887, 40870, 59244, 59336, 59367, 59413, 59417, 59423, 59431, 59437, 59443, 59452, 59460, 59478, 59493, 63789, 63866, 63894, 63976, 63986, 64016, 64018, 64021, 64025, 64034, 64037, 64042, 65074, 65093, 65107, 65112, 65127, 65132, 65375, 65510, 65536], gbChars: [0, 36, 38, 45, 50, 81, 89, 95, 96, 100, 103, 104, 105, 109, 126, 133, 148, 172, 175, 179, 208, 306, 307, 308, 309, 310, 311, 312, 313, 341, 428, 443, 544, 545, 558, 741, 742, 749, 750, 805, 819, 820, 7922, 7924, 7925, 7927, 7934, 7943, 7944, 7945, 7950, 8062, 8148, 8149, 8152, 8164, 8174, 8236, 8240, 8262, 8264, 8374, 8380, 8381, 8384, 8388, 8390, 8392, 8393, 8394, 8396, 8401, 8406, 8416, 8419, 8424, 8437, 8439, 8445, 8482, 8485, 8496, 8521, 8603, 8936, 8946, 9046, 9050, 9063, 9066, 9076, 9092, 9100, 9108, 9111, 9113, 9131, 9162, 9164, 9218, 9219, 11329, 11331, 11334, 11336, 11346, 11361, 11363, 11366, 11370, 11372, 11375, 11389, 11682, 11686, 11687, 11692, 11694, 11714, 11716, 11723, 11725, 11730, 11736, 11982, 11989, 12102, 12336, 12348, 12350, 12384, 12393, 12395, 12397, 12510, 12553, 12851, 12962, 12973, 13738, 13823, 13919, 13933, 14080, 14298, 14585, 14698, 15583, 15847, 16318, 16434, 16438, 16481, 16729, 17102, 17122, 17315, 17320, 17402, 17418, 17859, 17909, 17911, 17915, 17916, 17936, 17939, 17961, 18664, 18703, 18814, 18962, 19043, 33469, 33470, 33471, 33484, 33485, 33490, 33497, 33501, 33505, 33513, 33520, 33536, 33550, 37845, 37921, 37948, 38029, 38038, 38064, 38065, 38066, 38069, 38075, 38076, 38078, 39108, 39109, 39113, 39114, 39115, 39116, 39265, 39394, 189e3] };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/cp949.json
var require_cp949 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/cp949.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["8141", "\uAC02\uAC03\uAC05\uAC06\uAC0B", 4, "\uAC18\uAC1E\uAC1F\uAC21\uAC22\uAC23\uAC25", 6, "\uAC2E\uAC32\uAC33\uAC34"],
      ["8161", "\uAC35\uAC36\uAC37\uAC3A\uAC3B\uAC3D\uAC3E\uAC3F\uAC41", 9, "\uAC4C\uAC4E", 5, "\uAC55"],
      ["8181", "\uAC56\uAC57\uAC59\uAC5A\uAC5B\uAC5D", 18, "\uAC72\uAC73\uAC75\uAC76\uAC79\uAC7B", 4, "\uAC82\uAC87\uAC88\uAC8D\uAC8E\uAC8F\uAC91\uAC92\uAC93\uAC95", 6, "\uAC9E\uACA2", 5, "\uACAB\uACAD\uACAE\uACB1", 6, "\uACBA\uACBE\uACBF\uACC0\uACC2\uACC3\uACC5\uACC6\uACC7\uACC9\uACCA\uACCB\uACCD", 7, "\uACD6\uACD8", 7, "\uACE2\uACE3\uACE5\uACE6\uACE9\uACEB\uACED\uACEE\uACF2\uACF4\uACF7", 4, "\uACFE\uACFF\uAD01\uAD02\uAD03\uAD05\uAD07", 4, "\uAD0E\uAD10\uAD12\uAD13"],
      ["8241", "\uAD14\uAD15\uAD16\uAD17\uAD19\uAD1A\uAD1B\uAD1D\uAD1E\uAD1F\uAD21", 7, "\uAD2A\uAD2B\uAD2E", 5],
      ["8261", "\uAD36\uAD37\uAD39\uAD3A\uAD3B\uAD3D", 6, "\uAD46\uAD48\uAD4A", 5, "\uAD51\uAD52\uAD53\uAD55\uAD56\uAD57"],
      ["8281", "\uAD59", 7, "\uAD62\uAD64", 7, "\uAD6E\uAD6F\uAD71\uAD72\uAD77\uAD78\uAD79\uAD7A\uAD7E\uAD80\uAD83", 4, "\uAD8A\uAD8B\uAD8D\uAD8E\uAD8F\uAD91", 10, "\uAD9E", 5, "\uADA5", 17, "\uADB8", 7, "\uADC2\uADC3\uADC5\uADC6\uADC7\uADC9", 6, "\uADD2\uADD4", 7, "\uADDD\uADDE\uADDF\uADE1\uADE2\uADE3\uADE5", 18],
      ["8341", "\uADFA\uADFB\uADFD\uADFE\uAE02", 5, "\uAE0A\uAE0C\uAE0E", 5, "\uAE15", 7],
      ["8361", "\uAE1D", 18, "\uAE32\uAE33\uAE35\uAE36\uAE39\uAE3B\uAE3C"],
      ["8381", "\uAE3D\uAE3E\uAE3F\uAE42\uAE44\uAE47\uAE48\uAE49\uAE4B\uAE4F\uAE51\uAE52\uAE53\uAE55\uAE57", 4, "\uAE5E\uAE62\uAE63\uAE64\uAE66\uAE67\uAE6A\uAE6B\uAE6D\uAE6E\uAE6F\uAE71", 6, "\uAE7A\uAE7E", 5, "\uAE86", 5, "\uAE8D", 46, "\uAEBF\uAEC1\uAEC2\uAEC3\uAEC5", 6, "\uAECE\uAED2", 5, "\uAEDA\uAEDB\uAEDD", 8],
      ["8441", "\uAEE6\uAEE7\uAEE9\uAEEA\uAEEC\uAEEE", 5, "\uAEF5\uAEF6\uAEF7\uAEF9\uAEFA\uAEFB\uAEFD", 8],
      ["8461", "\uAF06\uAF09\uAF0A\uAF0B\uAF0C\uAF0E\uAF0F\uAF11", 18],
      ["8481", "\uAF24", 7, "\uAF2E\uAF2F\uAF31\uAF33\uAF35", 6, "\uAF3E\uAF40\uAF44\uAF45\uAF46\uAF47\uAF4A", 5, "\uAF51", 10, "\uAF5E", 5, "\uAF66", 18, "\uAF7A", 5, "\uAF81\uAF82\uAF83\uAF85\uAF86\uAF87\uAF89", 6, "\uAF92\uAF93\uAF94\uAF96", 5, "\uAF9D", 26, "\uAFBA\uAFBB\uAFBD\uAFBE"],
      ["8541", "\uAFBF\uAFC1", 5, "\uAFCA\uAFCC\uAFCF", 4, "\uAFD5", 6, "\uAFDD", 4],
      ["8561", "\uAFE2", 5, "\uAFEA", 5, "\uAFF2\uAFF3\uAFF5\uAFF6\uAFF7\uAFF9", 6, "\uB002\uB003"],
      ["8581", "\uB005", 6, "\uB00D\uB00E\uB00F\uB011\uB012\uB013\uB015", 6, "\uB01E", 9, "\uB029", 26, "\uB046\uB047\uB049\uB04B\uB04D\uB04F\uB050\uB051\uB052\uB056\uB058\uB05A\uB05B\uB05C\uB05E", 29, "\uB07E\uB07F\uB081\uB082\uB083\uB085", 6, "\uB08E\uB090\uB092", 5, "\uB09B\uB09D\uB09E\uB0A3\uB0A4"],
      ["8641", "\uB0A5\uB0A6\uB0A7\uB0AA\uB0B0\uB0B2\uB0B6\uB0B7\uB0B9\uB0BA\uB0BB\uB0BD", 6, "\uB0C6\uB0CA", 5, "\uB0D2"],
      ["8661", "\uB0D3\uB0D5\uB0D6\uB0D7\uB0D9", 6, "\uB0E1\uB0E2\uB0E3\uB0E4\uB0E6", 10],
      ["8681", "\uB0F1", 22, "\uB10A\uB10D\uB10E\uB10F\uB111\uB114\uB115\uB116\uB117\uB11A\uB11E", 4, "\uB126\uB127\uB129\uB12A\uB12B\uB12D", 6, "\uB136\uB13A", 5, "\uB142\uB143\uB145\uB146\uB147\uB149", 6, "\uB152\uB153\uB156\uB157\uB159\uB15A\uB15B\uB15D\uB15E\uB15F\uB161", 22, "\uB17A\uB17B\uB17D\uB17E\uB17F\uB181\uB183", 4, "\uB18A\uB18C\uB18E\uB18F\uB190\uB191\uB195\uB196\uB197\uB199\uB19A\uB19B\uB19D"],
      ["8741", "\uB19E", 9, "\uB1A9", 15],
      ["8761", "\uB1B9", 18, "\uB1CD\uB1CE\uB1CF\uB1D1\uB1D2\uB1D3\uB1D5"],
      ["8781", "\uB1D6", 5, "\uB1DE\uB1E0", 7, "\uB1EA\uB1EB\uB1ED\uB1EE\uB1EF\uB1F1", 7, "\uB1FA\uB1FC\uB1FE", 5, "\uB206\uB207\uB209\uB20A\uB20D", 6, "\uB216\uB218\uB21A", 5, "\uB221", 18, "\uB235", 6, "\uB23D", 26, "\uB259\uB25A\uB25B\uB25D\uB25E\uB25F\uB261", 6, "\uB26A", 4],
      ["8841", "\uB26F", 4, "\uB276", 5, "\uB27D", 6, "\uB286\uB287\uB288\uB28A", 4],
      ["8861", "\uB28F\uB292\uB293\uB295\uB296\uB297\uB29B", 4, "\uB2A2\uB2A4\uB2A7\uB2A8\uB2A9\uB2AB\uB2AD\uB2AE\uB2AF\uB2B1\uB2B2\uB2B3\uB2B5\uB2B6\uB2B7"],
      ["8881", "\uB2B8", 15, "\uB2CA\uB2CB\uB2CD\uB2CE\uB2CF\uB2D1\uB2D3", 4, "\uB2DA\uB2DC\uB2DE\uB2DF\uB2E0\uB2E1\uB2E3\uB2E7\uB2E9\uB2EA\uB2F0\uB2F1\uB2F2\uB2F6\uB2FC\uB2FD\uB2FE\uB302\uB303\uB305\uB306\uB307\uB309", 6, "\uB312\uB316", 5, "\uB31D", 54, "\uB357\uB359\uB35A\uB35D\uB360\uB361\uB362\uB363"],
      ["8941", "\uB366\uB368\uB36A\uB36C\uB36D\uB36F\uB372\uB373\uB375\uB376\uB377\uB379", 6, "\uB382\uB386", 5, "\uB38D"],
      ["8961", "\uB38E\uB38F\uB391\uB392\uB393\uB395", 10, "\uB3A2", 5, "\uB3A9\uB3AA\uB3AB\uB3AD"],
      ["8981", "\uB3AE", 21, "\uB3C6\uB3C7\uB3C9\uB3CA\uB3CD\uB3CF\uB3D1\uB3D2\uB3D3\uB3D6\uB3D8\uB3DA\uB3DC\uB3DE\uB3DF\uB3E1\uB3E2\uB3E3\uB3E5\uB3E6\uB3E7\uB3E9", 18, "\uB3FD", 18, "\uB411", 6, "\uB419\uB41A\uB41B\uB41D\uB41E\uB41F\uB421", 6, "\uB42A\uB42C", 7, "\uB435", 15],
      ["8a41", "\uB445", 10, "\uB452\uB453\uB455\uB456\uB457\uB459", 6, "\uB462\uB464\uB466"],
      ["8a61", "\uB467", 4, "\uB46D", 18, "\uB481\uB482"],
      ["8a81", "\uB483", 4, "\uB489", 19, "\uB49E", 5, "\uB4A5\uB4A6\uB4A7\uB4A9\uB4AA\uB4AB\uB4AD", 7, "\uB4B6\uB4B8\uB4BA", 5, "\uB4C1\uB4C2\uB4C3\uB4C5\uB4C6\uB4C7\uB4C9", 6, "\uB4D1\uB4D2\uB4D3\uB4D4\uB4D6", 5, "\uB4DE\uB4DF\uB4E1\uB4E2\uB4E5\uB4E7", 4, "\uB4EE\uB4F0\uB4F2", 5, "\uB4F9", 26, "\uB516\uB517\uB519\uB51A\uB51D"],
      ["8b41", "\uB51E", 5, "\uB526\uB52B", 4, "\uB532\uB533\uB535\uB536\uB537\uB539", 6, "\uB542\uB546"],
      ["8b61", "\uB547\uB548\uB549\uB54A\uB54E\uB54F\uB551\uB552\uB553\uB555", 6, "\uB55E\uB562", 8],
      ["8b81", "\uB56B", 52, "\uB5A2\uB5A3\uB5A5\uB5A6\uB5A7\uB5A9\uB5AC\uB5AD\uB5AE\uB5AF\uB5B2\uB5B6", 4, "\uB5BE\uB5BF\uB5C1\uB5C2\uB5C3\uB5C5", 6, "\uB5CE\uB5D2", 5, "\uB5D9", 18, "\uB5ED", 18],
      ["8c41", "\uB600", 15, "\uB612\uB613\uB615\uB616\uB617\uB619", 4],
      ["8c61", "\uB61E", 6, "\uB626", 5, "\uB62D", 6, "\uB635", 5],
      ["8c81", "\uB63B", 12, "\uB649", 26, "\uB665\uB666\uB667\uB669", 50, "\uB69E\uB69F\uB6A1\uB6A2\uB6A3\uB6A5", 5, "\uB6AD\uB6AE\uB6AF\uB6B0\uB6B2", 16],
      ["8d41", "\uB6C3", 16, "\uB6D5", 8],
      ["8d61", "\uB6DE", 17, "\uB6F1\uB6F2\uB6F3\uB6F5\uB6F6\uB6F7\uB6F9\uB6FA"],
      ["8d81", "\uB6FB", 4, "\uB702\uB703\uB704\uB706", 33, "\uB72A\uB72B\uB72D\uB72E\uB731", 6, "\uB73A\uB73C", 7, "\uB745\uB746\uB747\uB749\uB74A\uB74B\uB74D", 6, "\uB756", 9, "\uB761\uB762\uB763\uB765\uB766\uB767\uB769", 6, "\uB772\uB774\uB776", 5, "\uB77E\uB77F\uB781\uB782\uB783\uB785", 6, "\uB78E\uB793\uB794\uB795\uB79A\uB79B\uB79D\uB79E"],
      ["8e41", "\uB79F\uB7A1", 6, "\uB7AA\uB7AE", 5, "\uB7B6\uB7B7\uB7B9", 8],
      ["8e61", "\uB7C2", 4, "\uB7C8\uB7CA", 19],
      ["8e81", "\uB7DE", 13, "\uB7EE\uB7EF\uB7F1\uB7F2\uB7F3\uB7F5", 6, "\uB7FE\uB802", 4, "\uB80A\uB80B\uB80D\uB80E\uB80F\uB811", 6, "\uB81A\uB81C\uB81E", 5, "\uB826\uB827\uB829\uB82A\uB82B\uB82D", 6, "\uB836\uB83A", 5, "\uB841\uB842\uB843\uB845", 11, "\uB852\uB854", 7, "\uB85E\uB85F\uB861\uB862\uB863\uB865", 6, "\uB86E\uB870\uB872", 5, "\uB879\uB87A\uB87B\uB87D", 7],
      ["8f41", "\uB885", 7, "\uB88E", 17],
      ["8f61", "\uB8A0", 7, "\uB8A9", 6, "\uB8B1\uB8B2\uB8B3\uB8B5\uB8B6\uB8B7\uB8B9", 4],
      ["8f81", "\uB8BE\uB8BF\uB8C2\uB8C4\uB8C6", 5, "\uB8CD\uB8CE\uB8CF\uB8D1\uB8D2\uB8D3\uB8D5", 7, "\uB8DE\uB8E0\uB8E2", 5, "\uB8EA\uB8EB\uB8ED\uB8EE\uB8EF\uB8F1", 6, "\uB8FA\uB8FC\uB8FE", 5, "\uB905", 18, "\uB919", 6, "\uB921", 26, "\uB93E\uB93F\uB941\uB942\uB943\uB945", 6, "\uB94D\uB94E\uB950\uB952", 5],
      ["9041", "\uB95A\uB95B\uB95D\uB95E\uB95F\uB961", 6, "\uB96A\uB96C\uB96E", 5, "\uB976\uB977\uB979\uB97A\uB97B\uB97D"],
      ["9061", "\uB97E", 5, "\uB986\uB988\uB98B\uB98C\uB98F", 15],
      ["9081", "\uB99F", 12, "\uB9AE\uB9AF\uB9B1\uB9B2\uB9B3\uB9B5", 6, "\uB9BE\uB9C0\uB9C2", 5, "\uB9CA\uB9CB\uB9CD\uB9D3", 4, "\uB9DA\uB9DC\uB9DF\uB9E0\uB9E2\uB9E6\uB9E7\uB9E9\uB9EA\uB9EB\uB9ED", 6, "\uB9F6\uB9FB", 4, "\uBA02", 5, "\uBA09", 11, "\uBA16", 33, "\uBA3A\uBA3B\uBA3D\uBA3E\uBA3F\uBA41\uBA43\uBA44\uBA45\uBA46"],
      ["9141", "\uBA47\uBA4A\uBA4C\uBA4F\uBA50\uBA51\uBA52\uBA56\uBA57\uBA59\uBA5A\uBA5B\uBA5D", 6, "\uBA66\uBA6A", 5],
      ["9161", "\uBA72\uBA73\uBA75\uBA76\uBA77\uBA79", 9, "\uBA86\uBA88\uBA89\uBA8A\uBA8B\uBA8D", 5],
      ["9181", "\uBA93", 20, "\uBAAA\uBAAD\uBAAE\uBAAF\uBAB1\uBAB3", 4, "\uBABA\uBABC\uBABE", 5, "\uBAC5\uBAC6\uBAC7\uBAC9", 14, "\uBADA", 33, "\uBAFD\uBAFE\uBAFF\uBB01\uBB02\uBB03\uBB05", 7, "\uBB0E\uBB10\uBB12", 5, "\uBB19\uBB1A\uBB1B\uBB1D\uBB1E\uBB1F\uBB21", 6],
      ["9241", "\uBB28\uBB2A\uBB2C", 7, "\uBB37\uBB39\uBB3A\uBB3F", 4, "\uBB46\uBB48\uBB4A\uBB4B\uBB4C\uBB4E\uBB51\uBB52"],
      ["9261", "\uBB53\uBB55\uBB56\uBB57\uBB59", 7, "\uBB62\uBB64", 7, "\uBB6D", 4],
      ["9281", "\uBB72", 21, "\uBB89\uBB8A\uBB8B\uBB8D\uBB8E\uBB8F\uBB91", 18, "\uBBA5\uBBA6\uBBA7\uBBA9\uBBAA\uBBAB\uBBAD", 6, "\uBBB5\uBBB6\uBBB8", 7, "\uBBC1\uBBC2\uBBC3\uBBC5\uBBC6\uBBC7\uBBC9", 6, "\uBBD1\uBBD2\uBBD4", 35, "\uBBFA\uBBFB\uBBFD\uBBFE\uBC01"],
      ["9341", "\uBC03", 4, "\uBC0A\uBC0E\uBC10\uBC12\uBC13\uBC19\uBC1A\uBC20\uBC21\uBC22\uBC23\uBC26\uBC28\uBC2A\uBC2B\uBC2C\uBC2E\uBC2F\uBC32\uBC33\uBC35"],
      ["9361", "\uBC36\uBC37\uBC39", 6, "\uBC42\uBC46\uBC47\uBC48\uBC4A\uBC4B\uBC4E\uBC4F\uBC51", 8],
      ["9381", "\uBC5A\uBC5B\uBC5C\uBC5E", 37, "\uBC86\uBC87\uBC89\uBC8A\uBC8D\uBC8F", 4, "\uBC96\uBC98\uBC9B", 4, "\uBCA2\uBCA3\uBCA5\uBCA6\uBCA9", 6, "\uBCB2\uBCB6", 5, "\uBCBE\uBCBF\uBCC1\uBCC2\uBCC3\uBCC5", 7, "\uBCCE\uBCD2\uBCD3\uBCD4\uBCD6\uBCD7\uBCD9\uBCDA\uBCDB\uBCDD", 22, "\uBCF7\uBCF9\uBCFA\uBCFB\uBCFD"],
      ["9441", "\uBCFE", 5, "\uBD06\uBD08\uBD0A", 5, "\uBD11\uBD12\uBD13\uBD15", 8],
      ["9461", "\uBD1E", 5, "\uBD25", 6, "\uBD2D", 12],
      ["9481", "\uBD3A", 5, "\uBD41", 6, "\uBD4A\uBD4B\uBD4D\uBD4E\uBD4F\uBD51", 6, "\uBD5A", 9, "\uBD65\uBD66\uBD67\uBD69", 22, "\uBD82\uBD83\uBD85\uBD86\uBD8B", 4, "\uBD92\uBD94\uBD96\uBD97\uBD98\uBD9B\uBD9D", 6, "\uBDA5", 10, "\uBDB1", 6, "\uBDB9", 24],
      ["9541", "\uBDD2\uBDD3\uBDD6\uBDD7\uBDD9\uBDDA\uBDDB\uBDDD", 11, "\uBDEA", 5, "\uBDF1"],
      ["9561", "\uBDF2\uBDF3\uBDF5\uBDF6\uBDF7\uBDF9", 6, "\uBE01\uBE02\uBE04\uBE06", 5, "\uBE0E\uBE0F\uBE11\uBE12\uBE13"],
      ["9581", "\uBE15", 6, "\uBE1E\uBE20", 35, "\uBE46\uBE47\uBE49\uBE4A\uBE4B\uBE4D\uBE4F", 4, "\uBE56\uBE58\uBE5C\uBE5D\uBE5E\uBE5F\uBE62\uBE63\uBE65\uBE66\uBE67\uBE69\uBE6B", 4, "\uBE72\uBE76", 4, "\uBE7E\uBE7F\uBE81\uBE82\uBE83\uBE85", 6, "\uBE8E\uBE92", 5, "\uBE9A", 13, "\uBEA9", 14],
      ["9641", "\uBEB8", 23, "\uBED2\uBED3"],
      ["9661", "\uBED5\uBED6\uBED9", 6, "\uBEE1\uBEE2\uBEE6", 5, "\uBEED", 8],
      ["9681", "\uBEF6", 10, "\uBF02", 5, "\uBF0A", 13, "\uBF1A\uBF1E", 33, "\uBF42\uBF43\uBF45\uBF46\uBF47\uBF49", 6, "\uBF52\uBF53\uBF54\uBF56", 44],
      ["9741", "\uBF83", 16, "\uBF95", 8],
      ["9761", "\uBF9E", 17, "\uBFB1", 7],
      ["9781", "\uBFB9", 11, "\uBFC6", 5, "\uBFCE\uBFCF\uBFD1\uBFD2\uBFD3\uBFD5", 6, "\uBFDD\uBFDE\uBFE0\uBFE2", 89, "\uC03D\uC03E\uC03F"],
      ["9841", "\uC040", 16, "\uC052", 5, "\uC059\uC05A\uC05B"],
      ["9861", "\uC05D\uC05E\uC05F\uC061", 6, "\uC06A", 15],
      ["9881", "\uC07A", 21, "\uC092\uC093\uC095\uC096\uC097\uC099", 6, "\uC0A2\uC0A4\uC0A6", 5, "\uC0AE\uC0B1\uC0B2\uC0B7", 4, "\uC0BE\uC0C2\uC0C3\uC0C4\uC0C6\uC0C7\uC0CA\uC0CB\uC0CD\uC0CE\uC0CF\uC0D1", 6, "\uC0DA\uC0DE", 5, "\uC0E6\uC0E7\uC0E9\uC0EA\uC0EB\uC0ED", 6, "\uC0F6\uC0F8\uC0FA", 5, "\uC101\uC102\uC103\uC105\uC106\uC107\uC109", 6, "\uC111\uC112\uC113\uC114\uC116", 5, "\uC121\uC122\uC125\uC128\uC129\uC12A\uC12B\uC12E"],
      ["9941", "\uC132\uC133\uC134\uC135\uC137\uC13A\uC13B\uC13D\uC13E\uC13F\uC141", 6, "\uC14A\uC14E", 5, "\uC156\uC157"],
      ["9961", "\uC159\uC15A\uC15B\uC15D", 6, "\uC166\uC16A", 5, "\uC171\uC172\uC173\uC175\uC176\uC177\uC179\uC17A\uC17B"],
      ["9981", "\uC17C", 8, "\uC186", 5, "\uC18F\uC191\uC192\uC193\uC195\uC197", 4, "\uC19E\uC1A0\uC1A2\uC1A3\uC1A4\uC1A6\uC1A7\uC1AA\uC1AB\uC1AD\uC1AE\uC1AF\uC1B1", 11, "\uC1BE", 5, "\uC1C5\uC1C6\uC1C7\uC1C9\uC1CA\uC1CB\uC1CD", 6, "\uC1D5\uC1D6\uC1D9", 6, "\uC1E1\uC1E2\uC1E3\uC1E5\uC1E6\uC1E7\uC1E9", 6, "\uC1F2\uC1F4", 7, "\uC1FE\uC1FF\uC201\uC202\uC203\uC205", 6, "\uC20E\uC210\uC212", 5, "\uC21A\uC21B\uC21D\uC21E\uC221\uC222\uC223"],
      ["9a41", "\uC224\uC225\uC226\uC227\uC22A\uC22C\uC22E\uC230\uC233\uC235", 16],
      ["9a61", "\uC246\uC247\uC249", 6, "\uC252\uC253\uC255\uC256\uC257\uC259", 6, "\uC261\uC262\uC263\uC264\uC266"],
      ["9a81", "\uC267", 4, "\uC26E\uC26F\uC271\uC272\uC273\uC275", 6, "\uC27E\uC280\uC282", 5, "\uC28A", 5, "\uC291", 6, "\uC299\uC29A\uC29C\uC29E", 5, "\uC2A6\uC2A7\uC2A9\uC2AA\uC2AB\uC2AE", 5, "\uC2B6\uC2B8\uC2BA", 33, "\uC2DE\uC2DF\uC2E1\uC2E2\uC2E5", 5, "\uC2EE\uC2F0\uC2F2\uC2F3\uC2F4\uC2F5\uC2F7\uC2FA\uC2FD\uC2FE\uC2FF\uC301", 6, "\uC30A\uC30B\uC30E\uC30F"],
      ["9b41", "\uC310\uC311\uC312\uC316\uC317\uC319\uC31A\uC31B\uC31D", 6, "\uC326\uC327\uC32A", 8],
      ["9b61", "\uC333", 17, "\uC346", 7],
      ["9b81", "\uC34E", 25, "\uC36A\uC36B\uC36D\uC36E\uC36F\uC371\uC373", 4, "\uC37A\uC37B\uC37E", 5, "\uC385\uC386\uC387\uC389\uC38A\uC38B\uC38D", 50, "\uC3C1", 22, "\uC3DA"],
      ["9c41", "\uC3DB\uC3DD\uC3DE\uC3E1\uC3E3", 4, "\uC3EA\uC3EB\uC3EC\uC3EE", 5, "\uC3F6\uC3F7\uC3F9", 5],
      ["9c61", "\uC3FF", 8, "\uC409", 6, "\uC411", 9],
      ["9c81", "\uC41B", 8, "\uC425", 6, "\uC42D\uC42E\uC42F\uC431\uC432\uC433\uC435", 6, "\uC43E", 9, "\uC449", 26, "\uC466\uC467\uC469\uC46A\uC46B\uC46D", 6, "\uC476\uC477\uC478\uC47A", 5, "\uC481", 18, "\uC495", 6, "\uC49D", 12],
      ["9d41", "\uC4AA", 13, "\uC4B9\uC4BA\uC4BB\uC4BD", 8],
      ["9d61", "\uC4C6", 25],
      ["9d81", "\uC4E0", 8, "\uC4EA", 5, "\uC4F2\uC4F3\uC4F5\uC4F6\uC4F7\uC4F9\uC4FB\uC4FC\uC4FD\uC4FE\uC502", 9, "\uC50D\uC50E\uC50F\uC511\uC512\uC513\uC515", 6, "\uC51D", 10, "\uC52A\uC52B\uC52D\uC52E\uC52F\uC531", 6, "\uC53A\uC53C\uC53E", 5, "\uC546\uC547\uC54B\uC54F\uC550\uC551\uC552\uC556\uC55A\uC55B\uC55C\uC55F\uC562\uC563\uC565\uC566\uC567\uC569", 6, "\uC572\uC576", 5, "\uC57E\uC57F\uC581\uC582\uC583\uC585\uC586\uC588\uC589\uC58A\uC58B\uC58E\uC590\uC592\uC593\uC594"],
      ["9e41", "\uC596\uC599\uC59A\uC59B\uC59D\uC59E\uC59F\uC5A1", 7, "\uC5AA", 9, "\uC5B6"],
      ["9e61", "\uC5B7\uC5BA\uC5BF", 4, "\uC5CB\uC5CD\uC5CF\uC5D2\uC5D3\uC5D5\uC5D6\uC5D7\uC5D9", 6, "\uC5E2\uC5E4\uC5E6\uC5E7"],
      ["9e81", "\uC5E8\uC5E9\uC5EA\uC5EB\uC5EF\uC5F1\uC5F2\uC5F3\uC5F5\uC5F8\uC5F9\uC5FA\uC5FB\uC602\uC603\uC604\uC609\uC60A\uC60B\uC60D\uC60E\uC60F\uC611", 6, "\uC61A\uC61D", 6, "\uC626\uC627\uC629\uC62A\uC62B\uC62F\uC631\uC632\uC636\uC638\uC63A\uC63C\uC63D\uC63E\uC63F\uC642\uC643\uC645\uC646\uC647\uC649", 6, "\uC652\uC656", 5, "\uC65E\uC65F\uC661", 10, "\uC66D\uC66E\uC670\uC672", 5, "\uC67A\uC67B\uC67D\uC67E\uC67F\uC681", 6, "\uC68A\uC68C\uC68E", 5, "\uC696\uC697\uC699\uC69A\uC69B\uC69D", 6, "\uC6A6"],
      ["9f41", "\uC6A8\uC6AA", 5, "\uC6B2\uC6B3\uC6B5\uC6B6\uC6B7\uC6BB", 4, "\uC6C2\uC6C4\uC6C6", 5, "\uC6CE"],
      ["9f61", "\uC6CF\uC6D1\uC6D2\uC6D3\uC6D5", 6, "\uC6DE\uC6DF\uC6E2", 5, "\uC6EA\uC6EB\uC6ED\uC6EE\uC6EF\uC6F1\uC6F2"],
      ["9f81", "\uC6F3", 4, "\uC6FA\uC6FB\uC6FC\uC6FE", 5, "\uC706\uC707\uC709\uC70A\uC70B\uC70D", 6, "\uC716\uC718\uC71A", 5, "\uC722\uC723\uC725\uC726\uC727\uC729", 6, "\uC732\uC734\uC736\uC738\uC739\uC73A\uC73B\uC73E\uC73F\uC741\uC742\uC743\uC745", 4, "\uC74B\uC74E\uC750\uC759\uC75A\uC75B\uC75D\uC75E\uC75F\uC761", 6, "\uC769\uC76A\uC76C", 7, "\uC776\uC777\uC779\uC77A\uC77B\uC77F\uC780\uC781\uC782\uC786\uC78B\uC78C\uC78D\uC78F\uC792\uC793\uC795\uC799\uC79B", 4, "\uC7A2\uC7A7", 4, "\uC7AE\uC7AF\uC7B1\uC7B2\uC7B3\uC7B5\uC7B6\uC7B7"],
      ["a041", "\uC7B8\uC7B9\uC7BA\uC7BB\uC7BE\uC7C2", 5, "\uC7CA\uC7CB\uC7CD\uC7CF\uC7D1", 6, "\uC7D9\uC7DA\uC7DB\uC7DC"],
      ["a061", "\uC7DE", 5, "\uC7E5\uC7E6\uC7E7\uC7E9\uC7EA\uC7EB\uC7ED", 13],
      ["a081", "\uC7FB", 4, "\uC802\uC803\uC805\uC806\uC807\uC809\uC80B", 4, "\uC812\uC814\uC817", 4, "\uC81E\uC81F\uC821\uC822\uC823\uC825", 6, "\uC82E\uC830\uC832", 5, "\uC839\uC83A\uC83B\uC83D\uC83E\uC83F\uC841", 6, "\uC84A\uC84B\uC84E", 5, "\uC855", 26, "\uC872\uC873\uC875\uC876\uC877\uC879\uC87B", 4, "\uC882\uC884\uC888\uC889\uC88A\uC88E", 5, "\uC895", 7, "\uC89E\uC8A0\uC8A2\uC8A3\uC8A4"],
      ["a141", "\uC8A5\uC8A6\uC8A7\uC8A9", 18, "\uC8BE\uC8BF\uC8C0\uC8C1"],
      ["a161", "\uC8C2\uC8C3\uC8C5\uC8C6\uC8C7\uC8C9\uC8CA\uC8CB\uC8CD", 6, "\uC8D6\uC8D8\uC8DA", 5, "\uC8E2\uC8E3\uC8E5"],
      ["a181", "\uC8E6", 14, "\uC8F6", 5, "\uC8FE\uC8FF\uC901\uC902\uC903\uC907", 4, "\uC90E\u3000\u3001\u3002\xB7\u2025\u2026\xA8\u3003\xAD\u2015\u2225\uFF3C\u223C\u2018\u2019\u201C\u201D\u3014\u3015\u3008", 9, "\xB1\xD7\xF7\u2260\u2264\u2265\u221E\u2234\xB0\u2032\u2033\u2103\u212B\uFFE0\uFFE1\uFFE5\u2642\u2640\u2220\u22A5\u2312\u2202\u2207\u2261\u2252\xA7\u203B\u2606\u2605\u25CB\u25CF\u25CE\u25C7\u25C6\u25A1\u25A0\u25B3\u25B2\u25BD\u25BC\u2192\u2190\u2191\u2193\u2194\u3013\u226A\u226B\u221A\u223D\u221D\u2235\u222B\u222C\u2208\u220B\u2286\u2287\u2282\u2283\u222A\u2229\u2227\u2228\uFFE2"],
      ["a241", "\uC910\uC912", 5, "\uC919", 18],
      ["a261", "\uC92D", 6, "\uC935", 18],
      ["a281", "\uC948", 7, "\uC952\uC953\uC955\uC956\uC957\uC959", 6, "\uC962\uC964", 7, "\uC96D\uC96E\uC96F\u21D2\u21D4\u2200\u2203\xB4\uFF5E\u02C7\u02D8\u02DD\u02DA\u02D9\xB8\u02DB\xA1\xBF\u02D0\u222E\u2211\u220F\xA4\u2109\u2030\u25C1\u25C0\u25B7\u25B6\u2664\u2660\u2661\u2665\u2667\u2663\u2299\u25C8\u25A3\u25D0\u25D1\u2592\u25A4\u25A5\u25A8\u25A7\u25A6\u25A9\u2668\u260F\u260E\u261C\u261E\xB6\u2020\u2021\u2195\u2197\u2199\u2196\u2198\u266D\u2669\u266A\u266C\u327F\u321C\u2116\u33C7\u2122\u33C2\u33D8\u2121\u20AC\xAE"],
      ["a341", "\uC971\uC972\uC973\uC975", 6, "\uC97D", 10, "\uC98A\uC98B\uC98D\uC98E\uC98F"],
      ["a361", "\uC991", 6, "\uC99A\uC99C\uC99E", 16],
      ["a381", "\uC9AF", 16, "\uC9C2\uC9C3\uC9C5\uC9C6\uC9C9\uC9CB", 4, "\uC9D2\uC9D4\uC9D7\uC9D8\uC9DB\uFF01", 58, "\uFFE6\uFF3D", 32, "\uFFE3"],
      ["a441", "\uC9DE\uC9DF\uC9E1\uC9E3\uC9E5\uC9E6\uC9E8\uC9E9\uC9EA\uC9EB\uC9EE\uC9F2", 5, "\uC9FA\uC9FB\uC9FD\uC9FE\uC9FF\uCA01\uCA02\uCA03\uCA04"],
      ["a461", "\uCA05\uCA06\uCA07\uCA0A\uCA0E", 5, "\uCA15\uCA16\uCA17\uCA19", 12],
      ["a481", "\uCA26\uCA27\uCA28\uCA2A", 28, "\u3131", 93],
      ["a541", "\uCA47", 4, "\uCA4E\uCA4F\uCA51\uCA52\uCA53\uCA55", 6, "\uCA5E\uCA62", 5, "\uCA69\uCA6A"],
      ["a561", "\uCA6B", 17, "\uCA7E", 5, "\uCA85\uCA86"],
      ["a581", "\uCA87", 16, "\uCA99", 14, "\u2170", 9],
      ["a5b0", "\u2160", 9],
      ["a5c1", "\u0391", 16, "\u03A3", 6],
      ["a5e1", "\u03B1", 16, "\u03C3", 6],
      ["a641", "\uCAA8", 19, "\uCABE\uCABF\uCAC1\uCAC2\uCAC3\uCAC5"],
      ["a661", "\uCAC6", 5, "\uCACE\uCAD0\uCAD2\uCAD4\uCAD5\uCAD6\uCAD7\uCADA", 5, "\uCAE1", 6],
      ["a681", "\uCAE8\uCAE9\uCAEA\uCAEB\uCAED", 6, "\uCAF5", 18, "\uCB09\uCB0A\u2500\u2502\u250C\u2510\u2518\u2514\u251C\u252C\u2524\u2534\u253C\u2501\u2503\u250F\u2513\u251B\u2517\u2523\u2533\u252B\u253B\u254B\u2520\u252F\u2528\u2537\u253F\u251D\u2530\u2525\u2538\u2542\u2512\u2511\u251A\u2519\u2516\u2515\u250E\u250D\u251E\u251F\u2521\u2522\u2526\u2527\u2529\u252A\u252D\u252E\u2531\u2532\u2535\u2536\u2539\u253A\u253D\u253E\u2540\u2541\u2543", 7],
      ["a741", "\uCB0B", 4, "\uCB11\uCB12\uCB13\uCB15\uCB16\uCB17\uCB19", 6, "\uCB22", 7],
      ["a761", "\uCB2A", 22, "\uCB42\uCB43\uCB44"],
      ["a781", "\uCB45\uCB46\uCB47\uCB4A\uCB4B\uCB4D\uCB4E\uCB4F\uCB51", 6, "\uCB5A\uCB5B\uCB5C\uCB5E", 5, "\uCB65", 7, "\u3395\u3396\u3397\u2113\u3398\u33C4\u33A3\u33A4\u33A5\u33A6\u3399", 9, "\u33CA\u338D\u338E\u338F\u33CF\u3388\u3389\u33C8\u33A7\u33A8\u33B0", 9, "\u3380", 4, "\u33BA", 5, "\u3390", 4, "\u2126\u33C0\u33C1\u338A\u338B\u338C\u33D6\u33C5\u33AD\u33AE\u33AF\u33DB\u33A9\u33AA\u33AB\u33AC\u33DD\u33D0\u33D3\u33C3\u33C9\u33DC\u33C6"],
      ["a841", "\uCB6D", 10, "\uCB7A", 14],
      ["a861", "\uCB89", 18, "\uCB9D", 6],
      ["a881", "\uCBA4", 19, "\uCBB9", 11, "\xC6\xD0\xAA\u0126"],
      ["a8a6", "\u0132"],
      ["a8a8", "\u013F\u0141\xD8\u0152\xBA\xDE\u0166\u014A"],
      ["a8b1", "\u3260", 27, "\u24D0", 25, "\u2460", 14, "\xBD\u2153\u2154\xBC\xBE\u215B\u215C\u215D\u215E"],
      ["a941", "\uCBC5", 14, "\uCBD5", 10],
      ["a961", "\uCBE0\uCBE1\uCBE2\uCBE3\uCBE5\uCBE6\uCBE8\uCBEA", 18],
      ["a981", "\uCBFD", 14, "\uCC0E\uCC0F\uCC11\uCC12\uCC13\uCC15", 6, "\uCC1E\uCC1F\uCC20\uCC23\uCC24\xE6\u0111\xF0\u0127\u0131\u0133\u0138\u0140\u0142\xF8\u0153\xDF\xFE\u0167\u014B\u0149\u3200", 27, "\u249C", 25, "\u2474", 14, "\xB9\xB2\xB3\u2074\u207F\u2081\u2082\u2083\u2084"],
      ["aa41", "\uCC25\uCC26\uCC2A\uCC2B\uCC2D\uCC2F\uCC31", 6, "\uCC3A\uCC3F", 4, "\uCC46\uCC47\uCC49\uCC4A\uCC4B\uCC4D\uCC4E"],
      ["aa61", "\uCC4F", 4, "\uCC56\uCC5A", 5, "\uCC61\uCC62\uCC63\uCC65\uCC67\uCC69", 6, "\uCC71\uCC72"],
      ["aa81", "\uCC73\uCC74\uCC76", 29, "\u3041", 82],
      ["ab41", "\uCC94\uCC95\uCC96\uCC97\uCC9A\uCC9B\uCC9D\uCC9E\uCC9F\uCCA1", 6, "\uCCAA\uCCAE", 5, "\uCCB6\uCCB7\uCCB9"],
      ["ab61", "\uCCBA\uCCBB\uCCBD", 6, "\uCCC6\uCCC8\uCCCA", 5, "\uCCD1\uCCD2\uCCD3\uCCD5", 5],
      ["ab81", "\uCCDB", 8, "\uCCE5", 6, "\uCCED\uCCEE\uCCEF\uCCF1", 12, "\u30A1", 85],
      ["ac41", "\uCCFE\uCCFF\uCD00\uCD02", 5, "\uCD0A\uCD0B\uCD0D\uCD0E\uCD0F\uCD11", 6, "\uCD1A\uCD1C\uCD1E\uCD1F\uCD20"],
      ["ac61", "\uCD21\uCD22\uCD23\uCD25\uCD26\uCD27\uCD29\uCD2A\uCD2B\uCD2D", 11, "\uCD3A", 4],
      ["ac81", "\uCD3F", 28, "\uCD5D\uCD5E\uCD5F\u0410", 5, "\u0401\u0416", 25],
      ["acd1", "\u0430", 5, "\u0451\u0436", 25],
      ["ad41", "\uCD61\uCD62\uCD63\uCD65", 6, "\uCD6E\uCD70\uCD72", 5, "\uCD79", 7],
      ["ad61", "\uCD81", 6, "\uCD89", 10, "\uCD96\uCD97\uCD99\uCD9A\uCD9B\uCD9D\uCD9E\uCD9F"],
      ["ad81", "\uCDA0\uCDA1\uCDA2\uCDA3\uCDA6\uCDA8\uCDAA", 5, "\uCDB1", 18, "\uCDC5"],
      ["ae41", "\uCDC6", 5, "\uCDCD\uCDCE\uCDCF\uCDD1", 16],
      ["ae61", "\uCDE2", 5, "\uCDE9\uCDEA\uCDEB\uCDED\uCDEE\uCDEF\uCDF1", 6, "\uCDFA\uCDFC\uCDFE", 4],
      ["ae81", "\uCE03\uCE05\uCE06\uCE07\uCE09\uCE0A\uCE0B\uCE0D", 6, "\uCE15\uCE16\uCE17\uCE18\uCE1A", 5, "\uCE22\uCE23\uCE25\uCE26\uCE27\uCE29\uCE2A\uCE2B"],
      ["af41", "\uCE2C\uCE2D\uCE2E\uCE2F\uCE32\uCE34\uCE36", 19],
      ["af61", "\uCE4A", 13, "\uCE5A\uCE5B\uCE5D\uCE5E\uCE62", 5, "\uCE6A\uCE6C"],
      ["af81", "\uCE6E", 5, "\uCE76\uCE77\uCE79\uCE7A\uCE7B\uCE7D", 6, "\uCE86\uCE88\uCE8A", 5, "\uCE92\uCE93\uCE95\uCE96\uCE97\uCE99"],
      ["b041", "\uCE9A", 5, "\uCEA2\uCEA6", 5, "\uCEAE", 12],
      ["b061", "\uCEBB", 5, "\uCEC2", 19],
      ["b081", "\uCED6", 13, "\uCEE6\uCEE7\uCEE9\uCEEA\uCEED", 6, "\uCEF6\uCEFA", 5, "\uAC00\uAC01\uAC04\uAC07\uAC08\uAC09\uAC0A\uAC10", 7, "\uAC19", 4, "\uAC20\uAC24\uAC2C\uAC2D\uAC2F\uAC30\uAC31\uAC38\uAC39\uAC3C\uAC40\uAC4B\uAC4D\uAC54\uAC58\uAC5C\uAC70\uAC71\uAC74\uAC77\uAC78\uAC7A\uAC80\uAC81\uAC83\uAC84\uAC85\uAC86\uAC89\uAC8A\uAC8B\uAC8C\uAC90\uAC94\uAC9C\uAC9D\uAC9F\uACA0\uACA1\uACA8\uACA9\uACAA\uACAC\uACAF\uACB0\uACB8\uACB9\uACBB\uACBC\uACBD\uACC1\uACC4\uACC8\uACCC\uACD5\uACD7\uACE0\uACE1\uACE4\uACE7\uACE8\uACEA\uACEC\uACEF\uACF0\uACF1\uACF3\uACF5\uACF6\uACFC\uACFD\uAD00\uAD04\uAD06"],
      ["b141", "\uCF02\uCF03\uCF05\uCF06\uCF07\uCF09", 6, "\uCF12\uCF14\uCF16", 5, "\uCF1D\uCF1E\uCF1F\uCF21\uCF22\uCF23"],
      ["b161", "\uCF25", 6, "\uCF2E\uCF32", 5, "\uCF39", 11],
      ["b181", "\uCF45", 14, "\uCF56\uCF57\uCF59\uCF5A\uCF5B\uCF5D", 6, "\uCF66\uCF68\uCF6A\uCF6B\uCF6C\uAD0C\uAD0D\uAD0F\uAD11\uAD18\uAD1C\uAD20\uAD29\uAD2C\uAD2D\uAD34\uAD35\uAD38\uAD3C\uAD44\uAD45\uAD47\uAD49\uAD50\uAD54\uAD58\uAD61\uAD63\uAD6C\uAD6D\uAD70\uAD73\uAD74\uAD75\uAD76\uAD7B\uAD7C\uAD7D\uAD7F\uAD81\uAD82\uAD88\uAD89\uAD8C\uAD90\uAD9C\uAD9D\uADA4\uADB7\uADC0\uADC1\uADC4\uADC8\uADD0\uADD1\uADD3\uADDC\uADE0\uADE4\uADF8\uADF9\uADFC\uADFF\uAE00\uAE01\uAE08\uAE09\uAE0B\uAE0D\uAE14\uAE30\uAE31\uAE34\uAE37\uAE38\uAE3A\uAE40\uAE41\uAE43\uAE45\uAE46\uAE4A\uAE4C\uAE4D\uAE4E\uAE50\uAE54\uAE56\uAE5C\uAE5D\uAE5F\uAE60\uAE61\uAE65\uAE68\uAE69\uAE6C\uAE70\uAE78"],
      ["b241", "\uCF6D\uCF6E\uCF6F\uCF72\uCF73\uCF75\uCF76\uCF77\uCF79", 6, "\uCF81\uCF82\uCF83\uCF84\uCF86", 5, "\uCF8D"],
      ["b261", "\uCF8E", 18, "\uCFA2", 5, "\uCFA9"],
      ["b281", "\uCFAA", 5, "\uCFB1", 18, "\uCFC5", 6, "\uAE79\uAE7B\uAE7C\uAE7D\uAE84\uAE85\uAE8C\uAEBC\uAEBD\uAEBE\uAEC0\uAEC4\uAECC\uAECD\uAECF\uAED0\uAED1\uAED8\uAED9\uAEDC\uAEE8\uAEEB\uAEED\uAEF4\uAEF8\uAEFC\uAF07\uAF08\uAF0D\uAF10\uAF2C\uAF2D\uAF30\uAF32\uAF34\uAF3C\uAF3D\uAF3F\uAF41\uAF42\uAF43\uAF48\uAF49\uAF50\uAF5C\uAF5D\uAF64\uAF65\uAF79\uAF80\uAF84\uAF88\uAF90\uAF91\uAF95\uAF9C\uAFB8\uAFB9\uAFBC\uAFC0\uAFC7\uAFC8\uAFC9\uAFCB\uAFCD\uAFCE\uAFD4\uAFDC\uAFE8\uAFE9\uAFF0\uAFF1\uAFF4\uAFF8\uB000\uB001\uB004\uB00C\uB010\uB014\uB01C\uB01D\uB028\uB044\uB045\uB048\uB04A\uB04C\uB04E\uB053\uB054\uB055\uB057\uB059"],
      ["b341", "\uCFCC", 19, "\uCFE2\uCFE3\uCFE5\uCFE6\uCFE7\uCFE9"],
      ["b361", "\uCFEA", 5, "\uCFF2\uCFF4\uCFF6", 5, "\uCFFD\uCFFE\uCFFF\uD001\uD002\uD003\uD005", 5],
      ["b381", "\uD00B", 5, "\uD012", 5, "\uD019", 19, "\uB05D\uB07C\uB07D\uB080\uB084\uB08C\uB08D\uB08F\uB091\uB098\uB099\uB09A\uB09C\uB09F\uB0A0\uB0A1\uB0A2\uB0A8\uB0A9\uB0AB", 4, "\uB0B1\uB0B3\uB0B4\uB0B5\uB0B8\uB0BC\uB0C4\uB0C5\uB0C7\uB0C8\uB0C9\uB0D0\uB0D1\uB0D4\uB0D8\uB0E0\uB0E5\uB108\uB109\uB10B\uB10C\uB110\uB112\uB113\uB118\uB119\uB11B\uB11C\uB11D\uB123\uB124\uB125\uB128\uB12C\uB134\uB135\uB137\uB138\uB139\uB140\uB141\uB144\uB148\uB150\uB151\uB154\uB155\uB158\uB15C\uB160\uB178\uB179\uB17C\uB180\uB182\uB188\uB189\uB18B\uB18D\uB192\uB193\uB194\uB198\uB19C\uB1A8\uB1CC\uB1D0\uB1D4\uB1DC\uB1DD"],
      ["b441", "\uD02E", 5, "\uD036\uD037\uD039\uD03A\uD03B\uD03D", 6, "\uD046\uD048\uD04A", 5],
      ["b461", "\uD051\uD052\uD053\uD055\uD056\uD057\uD059", 6, "\uD061", 10, "\uD06E\uD06F"],
      ["b481", "\uD071\uD072\uD073\uD075", 6, "\uD07E\uD07F\uD080\uD082", 18, "\uB1DF\uB1E8\uB1E9\uB1EC\uB1F0\uB1F9\uB1FB\uB1FD\uB204\uB205\uB208\uB20B\uB20C\uB214\uB215\uB217\uB219\uB220\uB234\uB23C\uB258\uB25C\uB260\uB268\uB269\uB274\uB275\uB27C\uB284\uB285\uB289\uB290\uB291\uB294\uB298\uB299\uB29A\uB2A0\uB2A1\uB2A3\uB2A5\uB2A6\uB2AA\uB2AC\uB2B0\uB2B4\uB2C8\uB2C9\uB2CC\uB2D0\uB2D2\uB2D8\uB2D9\uB2DB\uB2DD\uB2E2\uB2E4\uB2E5\uB2E6\uB2E8\uB2EB", 4, "\uB2F3\uB2F4\uB2F5\uB2F7", 4, "\uB2FF\uB300\uB301\uB304\uB308\uB310\uB311\uB313\uB314\uB315\uB31C\uB354\uB355\uB356\uB358\uB35B\uB35C\uB35E\uB35F\uB364\uB365"],
      ["b541", "\uD095", 14, "\uD0A6\uD0A7\uD0A9\uD0AA\uD0AB\uD0AD", 5],
      ["b561", "\uD0B3\uD0B6\uD0B8\uD0BA", 5, "\uD0C2\uD0C3\uD0C5\uD0C6\uD0C7\uD0CA", 5, "\uD0D2\uD0D6", 4],
      ["b581", "\uD0DB\uD0DE\uD0DF\uD0E1\uD0E2\uD0E3\uD0E5", 6, "\uD0EE\uD0F2", 5, "\uD0F9", 11, "\uB367\uB369\uB36B\uB36E\uB370\uB371\uB374\uB378\uB380\uB381\uB383\uB384\uB385\uB38C\uB390\uB394\uB3A0\uB3A1\uB3A8\uB3AC\uB3C4\uB3C5\uB3C8\uB3CB\uB3CC\uB3CE\uB3D0\uB3D4\uB3D5\uB3D7\uB3D9\uB3DB\uB3DD\uB3E0\uB3E4\uB3E8\uB3FC\uB410\uB418\uB41C\uB420\uB428\uB429\uB42B\uB434\uB450\uB451\uB454\uB458\uB460\uB461\uB463\uB465\uB46C\uB480\uB488\uB49D\uB4A4\uB4A8\uB4AC\uB4B5\uB4B7\uB4B9\uB4C0\uB4C4\uB4C8\uB4D0\uB4D5\uB4DC\uB4DD\uB4E0\uB4E3\uB4E4\uB4E6\uB4EC\uB4ED\uB4EF\uB4F1\uB4F8\uB514\uB515\uB518\uB51B\uB51C\uB524\uB525\uB527\uB528\uB529\uB52A\uB530\uB531\uB534\uB538"],
      ["b641", "\uD105", 7, "\uD10E", 17],
      ["b661", "\uD120", 15, "\uD132\uD133\uD135\uD136\uD137\uD139\uD13B\uD13C\uD13D\uD13E"],
      ["b681", "\uD13F\uD142\uD146", 5, "\uD14E\uD14F\uD151\uD152\uD153\uD155", 6, "\uD15E\uD160\uD162", 5, "\uD169\uD16A\uD16B\uD16D\uB540\uB541\uB543\uB544\uB545\uB54B\uB54C\uB54D\uB550\uB554\uB55C\uB55D\uB55F\uB560\uB561\uB5A0\uB5A1\uB5A4\uB5A8\uB5AA\uB5AB\uB5B0\uB5B1\uB5B3\uB5B4\uB5B5\uB5BB\uB5BC\uB5BD\uB5C0\uB5C4\uB5CC\uB5CD\uB5CF\uB5D0\uB5D1\uB5D8\uB5EC\uB610\uB611\uB614\uB618\uB625\uB62C\uB634\uB648\uB664\uB668\uB69C\uB69D\uB6A0\uB6A4\uB6AB\uB6AC\uB6B1\uB6D4\uB6F0\uB6F4\uB6F8\uB700\uB701\uB705\uB728\uB729\uB72C\uB72F\uB730\uB738\uB739\uB73B\uB744\uB748\uB74C\uB754\uB755\uB760\uB764\uB768\uB770\uB771\uB773\uB775\uB77C\uB77D\uB780\uB784\uB78C\uB78D\uB78F\uB790\uB791\uB792\uB796\uB797"],
      ["b741", "\uD16E", 13, "\uD17D", 6, "\uD185\uD186\uD187\uD189\uD18A"],
      ["b761", "\uD18B", 20, "\uD1A2\uD1A3\uD1A5\uD1A6\uD1A7"],
      ["b781", "\uD1A9", 6, "\uD1B2\uD1B4\uD1B6\uD1B7\uD1B8\uD1B9\uD1BB\uD1BD\uD1BE\uD1BF\uD1C1", 14, "\uB798\uB799\uB79C\uB7A0\uB7A8\uB7A9\uB7AB\uB7AC\uB7AD\uB7B4\uB7B5\uB7B8\uB7C7\uB7C9\uB7EC\uB7ED\uB7F0\uB7F4\uB7FC\uB7FD\uB7FF\uB800\uB801\uB807\uB808\uB809\uB80C\uB810\uB818\uB819\uB81B\uB81D\uB824\uB825\uB828\uB82C\uB834\uB835\uB837\uB838\uB839\uB840\uB844\uB851\uB853\uB85C\uB85D\uB860\uB864\uB86C\uB86D\uB86F\uB871\uB878\uB87C\uB88D\uB8A8\uB8B0\uB8B4\uB8B8\uB8C0\uB8C1\uB8C3\uB8C5\uB8CC\uB8D0\uB8D4\uB8DD\uB8DF\uB8E1\uB8E8\uB8E9\uB8EC\uB8F0\uB8F8\uB8F9\uB8FB\uB8FD\uB904\uB918\uB920\uB93C\uB93D\uB940\uB944\uB94C\uB94F\uB951\uB958\uB959\uB95C\uB960\uB968\uB969"],
      ["b841", "\uD1D0", 7, "\uD1D9", 17],
      ["b861", "\uD1EB", 8, "\uD1F5\uD1F6\uD1F7\uD1F9", 13],
      ["b881", "\uD208\uD20A", 5, "\uD211", 24, "\uB96B\uB96D\uB974\uB975\uB978\uB97C\uB984\uB985\uB987\uB989\uB98A\uB98D\uB98E\uB9AC\uB9AD\uB9B0\uB9B4\uB9BC\uB9BD\uB9BF\uB9C1\uB9C8\uB9C9\uB9CC\uB9CE", 4, "\uB9D8\uB9D9\uB9DB\uB9DD\uB9DE\uB9E1\uB9E3\uB9E4\uB9E5\uB9E8\uB9EC\uB9F4\uB9F5\uB9F7\uB9F8\uB9F9\uB9FA\uBA00\uBA01\uBA08\uBA15\uBA38\uBA39\uBA3C\uBA40\uBA42\uBA48\uBA49\uBA4B\uBA4D\uBA4E\uBA53\uBA54\uBA55\uBA58\uBA5C\uBA64\uBA65\uBA67\uBA68\uBA69\uBA70\uBA71\uBA74\uBA78\uBA83\uBA84\uBA85\uBA87\uBA8C\uBAA8\uBAA9\uBAAB\uBAAC\uBAB0\uBAB2\uBAB8\uBAB9\uBABB\uBABD\uBAC4\uBAC8\uBAD8\uBAD9\uBAFC"],
      ["b941", "\uD22A\uD22B\uD22E\uD22F\uD231\uD232\uD233\uD235", 6, "\uD23E\uD240\uD242", 5, "\uD249\uD24A\uD24B\uD24C"],
      ["b961", "\uD24D", 14, "\uD25D", 6, "\uD265\uD266\uD267\uD268"],
      ["b981", "\uD269", 22, "\uD282\uD283\uD285\uD286\uD287\uD289\uD28A\uD28B\uD28C\uBB00\uBB04\uBB0D\uBB0F\uBB11\uBB18\uBB1C\uBB20\uBB29\uBB2B\uBB34\uBB35\uBB36\uBB38\uBB3B\uBB3C\uBB3D\uBB3E\uBB44\uBB45\uBB47\uBB49\uBB4D\uBB4F\uBB50\uBB54\uBB58\uBB61\uBB63\uBB6C\uBB88\uBB8C\uBB90\uBBA4\uBBA8\uBBAC\uBBB4\uBBB7\uBBC0\uBBC4\uBBC8\uBBD0\uBBD3\uBBF8\uBBF9\uBBFC\uBBFF\uBC00\uBC02\uBC08\uBC09\uBC0B\uBC0C\uBC0D\uBC0F\uBC11\uBC14", 4, "\uBC1B", 4, "\uBC24\uBC25\uBC27\uBC29\uBC2D\uBC30\uBC31\uBC34\uBC38\uBC40\uBC41\uBC43\uBC44\uBC45\uBC49\uBC4C\uBC4D\uBC50\uBC5D\uBC84\uBC85\uBC88\uBC8B\uBC8C\uBC8E\uBC94\uBC95\uBC97"],
      ["ba41", "\uD28D\uD28E\uD28F\uD292\uD293\uD294\uD296", 5, "\uD29D\uD29E\uD29F\uD2A1\uD2A2\uD2A3\uD2A5", 6, "\uD2AD"],
      ["ba61", "\uD2AE\uD2AF\uD2B0\uD2B2", 5, "\uD2BA\uD2BB\uD2BD\uD2BE\uD2C1\uD2C3", 4, "\uD2CA\uD2CC", 5],
      ["ba81", "\uD2D2\uD2D3\uD2D5\uD2D6\uD2D7\uD2D9\uD2DA\uD2DB\uD2DD", 6, "\uD2E6", 9, "\uD2F2\uD2F3\uD2F5\uD2F6\uD2F7\uD2F9\uD2FA\uBC99\uBC9A\uBCA0\uBCA1\uBCA4\uBCA7\uBCA8\uBCB0\uBCB1\uBCB3\uBCB4\uBCB5\uBCBC\uBCBD\uBCC0\uBCC4\uBCCD\uBCCF\uBCD0\uBCD1\uBCD5\uBCD8\uBCDC\uBCF4\uBCF5\uBCF6\uBCF8\uBCFC\uBD04\uBD05\uBD07\uBD09\uBD10\uBD14\uBD24\uBD2C\uBD40\uBD48\uBD49\uBD4C\uBD50\uBD58\uBD59\uBD64\uBD68\uBD80\uBD81\uBD84\uBD87\uBD88\uBD89\uBD8A\uBD90\uBD91\uBD93\uBD95\uBD99\uBD9A\uBD9C\uBDA4\uBDB0\uBDB8\uBDD4\uBDD5\uBDD8\uBDDC\uBDE9\uBDF0\uBDF4\uBDF8\uBE00\uBE03\uBE05\uBE0C\uBE0D\uBE10\uBE14\uBE1C\uBE1D\uBE1F\uBE44\uBE45\uBE48\uBE4C\uBE4E\uBE54\uBE55\uBE57\uBE59\uBE5A\uBE5B\uBE60\uBE61\uBE64"],
      ["bb41", "\uD2FB", 4, "\uD302\uD304\uD306", 5, "\uD30F\uD311\uD312\uD313\uD315\uD317", 4, "\uD31E\uD322\uD323"],
      ["bb61", "\uD324\uD326\uD327\uD32A\uD32B\uD32D\uD32E\uD32F\uD331", 6, "\uD33A\uD33E", 5, "\uD346\uD347\uD348\uD349"],
      ["bb81", "\uD34A", 31, "\uBE68\uBE6A\uBE70\uBE71\uBE73\uBE74\uBE75\uBE7B\uBE7C\uBE7D\uBE80\uBE84\uBE8C\uBE8D\uBE8F\uBE90\uBE91\uBE98\uBE99\uBEA8\uBED0\uBED1\uBED4\uBED7\uBED8\uBEE0\uBEE3\uBEE4\uBEE5\uBEEC\uBF01\uBF08\uBF09\uBF18\uBF19\uBF1B\uBF1C\uBF1D\uBF40\uBF41\uBF44\uBF48\uBF50\uBF51\uBF55\uBF94\uBFB0\uBFC5\uBFCC\uBFCD\uBFD0\uBFD4\uBFDC\uBFDF\uBFE1\uC03C\uC051\uC058\uC05C\uC060\uC068\uC069\uC090\uC091\uC094\uC098\uC0A0\uC0A1\uC0A3\uC0A5\uC0AC\uC0AD\uC0AF\uC0B0\uC0B3\uC0B4\uC0B5\uC0B6\uC0BC\uC0BD\uC0BF\uC0C0\uC0C1\uC0C5\uC0C8\uC0C9\uC0CC\uC0D0\uC0D8\uC0D9\uC0DB\uC0DC\uC0DD\uC0E4"],
      ["bc41", "\uD36A", 17, "\uD37E\uD37F\uD381\uD382\uD383\uD385\uD386\uD387"],
      ["bc61", "\uD388\uD389\uD38A\uD38B\uD38E\uD392", 5, "\uD39A\uD39B\uD39D\uD39E\uD39F\uD3A1", 6, "\uD3AA\uD3AC\uD3AE"],
      ["bc81", "\uD3AF", 4, "\uD3B5\uD3B6\uD3B7\uD3B9\uD3BA\uD3BB\uD3BD", 6, "\uD3C6\uD3C7\uD3CA", 5, "\uD3D1", 5, "\uC0E5\uC0E8\uC0EC\uC0F4\uC0F5\uC0F7\uC0F9\uC100\uC104\uC108\uC110\uC115\uC11C", 4, "\uC123\uC124\uC126\uC127\uC12C\uC12D\uC12F\uC130\uC131\uC136\uC138\uC139\uC13C\uC140\uC148\uC149\uC14B\uC14C\uC14D\uC154\uC155\uC158\uC15C\uC164\uC165\uC167\uC168\uC169\uC170\uC174\uC178\uC185\uC18C\uC18D\uC18E\uC190\uC194\uC196\uC19C\uC19D\uC19F\uC1A1\uC1A5\uC1A8\uC1A9\uC1AC\uC1B0\uC1BD\uC1C4\uC1C8\uC1CC\uC1D4\uC1D7\uC1D8\uC1E0\uC1E4\uC1E8\uC1F0\uC1F1\uC1F3\uC1FC\uC1FD\uC200\uC204\uC20C\uC20D\uC20F\uC211\uC218\uC219\uC21C\uC21F\uC220\uC228\uC229\uC22B\uC22D"],
      ["bd41", "\uD3D7\uD3D9", 7, "\uD3E2\uD3E4", 7, "\uD3EE\uD3EF\uD3F1\uD3F2\uD3F3\uD3F5\uD3F6\uD3F7"],
      ["bd61", "\uD3F8\uD3F9\uD3FA\uD3FB\uD3FE\uD400\uD402", 5, "\uD409", 13],
      ["bd81", "\uD417", 5, "\uD41E", 25, "\uC22F\uC231\uC232\uC234\uC248\uC250\uC251\uC254\uC258\uC260\uC265\uC26C\uC26D\uC270\uC274\uC27C\uC27D\uC27F\uC281\uC288\uC289\uC290\uC298\uC29B\uC29D\uC2A4\uC2A5\uC2A8\uC2AC\uC2AD\uC2B4\uC2B5\uC2B7\uC2B9\uC2DC\uC2DD\uC2E0\uC2E3\uC2E4\uC2EB\uC2EC\uC2ED\uC2EF\uC2F1\uC2F6\uC2F8\uC2F9\uC2FB\uC2FC\uC300\uC308\uC309\uC30C\uC30D\uC313\uC314\uC315\uC318\uC31C\uC324\uC325\uC328\uC329\uC345\uC368\uC369\uC36C\uC370\uC372\uC378\uC379\uC37C\uC37D\uC384\uC388\uC38C\uC3C0\uC3D8\uC3D9\uC3DC\uC3DF\uC3E0\uC3E2\uC3E8\uC3E9\uC3ED\uC3F4\uC3F5\uC3F8\uC408\uC410\uC424\uC42C\uC430"],
      ["be41", "\uD438", 7, "\uD441\uD442\uD443\uD445", 14],
      ["be61", "\uD454", 7, "\uD45D\uD45E\uD45F\uD461\uD462\uD463\uD465", 7, "\uD46E\uD470\uD471\uD472"],
      ["be81", "\uD473", 4, "\uD47A\uD47B\uD47D\uD47E\uD481\uD483", 4, "\uD48A\uD48C\uD48E", 5, "\uD495", 8, "\uC434\uC43C\uC43D\uC448\uC464\uC465\uC468\uC46C\uC474\uC475\uC479\uC480\uC494\uC49C\uC4B8\uC4BC\uC4E9\uC4F0\uC4F1\uC4F4\uC4F8\uC4FA\uC4FF\uC500\uC501\uC50C\uC510\uC514\uC51C\uC528\uC529\uC52C\uC530\uC538\uC539\uC53B\uC53D\uC544\uC545\uC548\uC549\uC54A\uC54C\uC54D\uC54E\uC553\uC554\uC555\uC557\uC558\uC559\uC55D\uC55E\uC560\uC561\uC564\uC568\uC570\uC571\uC573\uC574\uC575\uC57C\uC57D\uC580\uC584\uC587\uC58C\uC58D\uC58F\uC591\uC595\uC597\uC598\uC59C\uC5A0\uC5A9\uC5B4\uC5B5\uC5B8\uC5B9\uC5BB\uC5BC\uC5BD\uC5BE\uC5C4", 6, "\uC5CC\uC5CE"],
      ["bf41", "\uD49E", 10, "\uD4AA", 14],
      ["bf61", "\uD4B9", 18, "\uD4CD\uD4CE\uD4CF\uD4D1\uD4D2\uD4D3\uD4D5"],
      ["bf81", "\uD4D6", 5, "\uD4DD\uD4DE\uD4E0", 7, "\uD4E9\uD4EA\uD4EB\uD4ED\uD4EE\uD4EF\uD4F1", 6, "\uD4F9\uD4FA\uD4FC\uC5D0\uC5D1\uC5D4\uC5D8\uC5E0\uC5E1\uC5E3\uC5E5\uC5EC\uC5ED\uC5EE\uC5F0\uC5F4\uC5F6\uC5F7\uC5FC", 5, "\uC605\uC606\uC607\uC608\uC60C\uC610\uC618\uC619\uC61B\uC61C\uC624\uC625\uC628\uC62C\uC62D\uC62E\uC630\uC633\uC634\uC635\uC637\uC639\uC63B\uC640\uC641\uC644\uC648\uC650\uC651\uC653\uC654\uC655\uC65C\uC65D\uC660\uC66C\uC66F\uC671\uC678\uC679\uC67C\uC680\uC688\uC689\uC68B\uC68D\uC694\uC695\uC698\uC69C\uC6A4\uC6A5\uC6A7\uC6A9\uC6B0\uC6B1\uC6B4\uC6B8\uC6B9\uC6BA\uC6C0\uC6C1\uC6C3\uC6C5\uC6CC\uC6CD\uC6D0\uC6D4\uC6DC\uC6DD\uC6E0\uC6E1\uC6E8"],
      ["c041", "\uD4FE", 5, "\uD505\uD506\uD507\uD509\uD50A\uD50B\uD50D", 6, "\uD516\uD518", 5],
      ["c061", "\uD51E", 25],
      ["c081", "\uD538\uD539\uD53A\uD53B\uD53E\uD53F\uD541\uD542\uD543\uD545", 6, "\uD54E\uD550\uD552", 5, "\uD55A\uD55B\uD55D\uD55E\uD55F\uD561\uD562\uD563\uC6E9\uC6EC\uC6F0\uC6F8\uC6F9\uC6FD\uC704\uC705\uC708\uC70C\uC714\uC715\uC717\uC719\uC720\uC721\uC724\uC728\uC730\uC731\uC733\uC735\uC737\uC73C\uC73D\uC740\uC744\uC74A\uC74C\uC74D\uC74F\uC751", 7, "\uC75C\uC760\uC768\uC76B\uC774\uC775\uC778\uC77C\uC77D\uC77E\uC783\uC784\uC785\uC787\uC788\uC789\uC78A\uC78E\uC790\uC791\uC794\uC796\uC797\uC798\uC79A\uC7A0\uC7A1\uC7A3\uC7A4\uC7A5\uC7A6\uC7AC\uC7AD\uC7B0\uC7B4\uC7BC\uC7BD\uC7BF\uC7C0\uC7C1\uC7C8\uC7C9\uC7CC\uC7CE\uC7D0\uC7D8\uC7DD\uC7E4\uC7E8\uC7EC\uC800\uC801\uC804\uC808\uC80A"],
      ["c141", "\uD564\uD566\uD567\uD56A\uD56C\uD56E", 5, "\uD576\uD577\uD579\uD57A\uD57B\uD57D", 6, "\uD586\uD58A\uD58B"],
      ["c161", "\uD58C\uD58D\uD58E\uD58F\uD591", 19, "\uD5A6\uD5A7"],
      ["c181", "\uD5A8", 31, "\uC810\uC811\uC813\uC815\uC816\uC81C\uC81D\uC820\uC824\uC82C\uC82D\uC82F\uC831\uC838\uC83C\uC840\uC848\uC849\uC84C\uC84D\uC854\uC870\uC871\uC874\uC878\uC87A\uC880\uC881\uC883\uC885\uC886\uC887\uC88B\uC88C\uC88D\uC894\uC89D\uC89F\uC8A1\uC8A8\uC8BC\uC8BD\uC8C4\uC8C8\uC8CC\uC8D4\uC8D5\uC8D7\uC8D9\uC8E0\uC8E1\uC8E4\uC8F5\uC8FC\uC8FD\uC900\uC904\uC905\uC906\uC90C\uC90D\uC90F\uC911\uC918\uC92C\uC934\uC950\uC951\uC954\uC958\uC960\uC961\uC963\uC96C\uC970\uC974\uC97C\uC988\uC989\uC98C\uC990\uC998\uC999\uC99B\uC99D\uC9C0\uC9C1\uC9C4\uC9C7\uC9C8\uC9CA\uC9D0\uC9D1\uC9D3"],
      ["c241", "\uD5CA\uD5CB\uD5CD\uD5CE\uD5CF\uD5D1\uD5D3", 4, "\uD5DA\uD5DC\uD5DE", 5, "\uD5E6\uD5E7\uD5E9\uD5EA\uD5EB\uD5ED\uD5EE"],
      ["c261", "\uD5EF", 4, "\uD5F6\uD5F8\uD5FA", 5, "\uD602\uD603\uD605\uD606\uD607\uD609", 6, "\uD612"],
      ["c281", "\uD616", 5, "\uD61D\uD61E\uD61F\uD621\uD622\uD623\uD625", 7, "\uD62E", 9, "\uD63A\uD63B\uC9D5\uC9D6\uC9D9\uC9DA\uC9DC\uC9DD\uC9E0\uC9E2\uC9E4\uC9E7\uC9EC\uC9ED\uC9EF\uC9F0\uC9F1\uC9F8\uC9F9\uC9FC\uCA00\uCA08\uCA09\uCA0B\uCA0C\uCA0D\uCA14\uCA18\uCA29\uCA4C\uCA4D\uCA50\uCA54\uCA5C\uCA5D\uCA5F\uCA60\uCA61\uCA68\uCA7D\uCA84\uCA98\uCABC\uCABD\uCAC0\uCAC4\uCACC\uCACD\uCACF\uCAD1\uCAD3\uCAD8\uCAD9\uCAE0\uCAEC\uCAF4\uCB08\uCB10\uCB14\uCB18\uCB20\uCB21\uCB41\uCB48\uCB49\uCB4C\uCB50\uCB58\uCB59\uCB5D\uCB64\uCB78\uCB79\uCB9C\uCBB8\uCBD4\uCBE4\uCBE7\uCBE9\uCC0C\uCC0D\uCC10\uCC14\uCC1C\uCC1D\uCC21\uCC22\uCC27\uCC28\uCC29\uCC2C\uCC2E\uCC30\uCC38\uCC39\uCC3B"],
      ["c341", "\uD63D\uD63E\uD63F\uD641\uD642\uD643\uD644\uD646\uD647\uD64A\uD64C\uD64E\uD64F\uD650\uD652\uD653\uD656\uD657\uD659\uD65A\uD65B\uD65D", 4],
      ["c361", "\uD662", 4, "\uD668\uD66A", 5, "\uD672\uD673\uD675", 11],
      ["c381", "\uD681\uD682\uD684\uD686", 5, "\uD68E\uD68F\uD691\uD692\uD693\uD695", 7, "\uD69E\uD6A0\uD6A2", 5, "\uD6A9\uD6AA\uCC3C\uCC3D\uCC3E\uCC44\uCC45\uCC48\uCC4C\uCC54\uCC55\uCC57\uCC58\uCC59\uCC60\uCC64\uCC66\uCC68\uCC70\uCC75\uCC98\uCC99\uCC9C\uCCA0\uCCA8\uCCA9\uCCAB\uCCAC\uCCAD\uCCB4\uCCB5\uCCB8\uCCBC\uCCC4\uCCC5\uCCC7\uCCC9\uCCD0\uCCD4\uCCE4\uCCEC\uCCF0\uCD01\uCD08\uCD09\uCD0C\uCD10\uCD18\uCD19\uCD1B\uCD1D\uCD24\uCD28\uCD2C\uCD39\uCD5C\uCD60\uCD64\uCD6C\uCD6D\uCD6F\uCD71\uCD78\uCD88\uCD94\uCD95\uCD98\uCD9C\uCDA4\uCDA5\uCDA7\uCDA9\uCDB0\uCDC4\uCDCC\uCDD0\uCDE8\uCDEC\uCDF0\uCDF8\uCDF9\uCDFB\uCDFD\uCE04\uCE08\uCE0C\uCE14\uCE19\uCE20\uCE21\uCE24\uCE28\uCE30\uCE31\uCE33\uCE35"],
      ["c441", "\uD6AB\uD6AD\uD6AE\uD6AF\uD6B1", 7, "\uD6BA\uD6BC", 7, "\uD6C6\uD6C7\uD6C9\uD6CA\uD6CB"],
      ["c461", "\uD6CD\uD6CE\uD6CF\uD6D0\uD6D2\uD6D3\uD6D5\uD6D6\uD6D8\uD6DA", 5, "\uD6E1\uD6E2\uD6E3\uD6E5\uD6E6\uD6E7\uD6E9", 4],
      ["c481", "\uD6EE\uD6EF\uD6F1\uD6F2\uD6F3\uD6F4\uD6F6", 5, "\uD6FE\uD6FF\uD701\uD702\uD703\uD705", 11, "\uD712\uD713\uD714\uCE58\uCE59\uCE5C\uCE5F\uCE60\uCE61\uCE68\uCE69\uCE6B\uCE6D\uCE74\uCE75\uCE78\uCE7C\uCE84\uCE85\uCE87\uCE89\uCE90\uCE91\uCE94\uCE98\uCEA0\uCEA1\uCEA3\uCEA4\uCEA5\uCEAC\uCEAD\uCEC1\uCEE4\uCEE5\uCEE8\uCEEB\uCEEC\uCEF4\uCEF5\uCEF7\uCEF8\uCEF9\uCF00\uCF01\uCF04\uCF08\uCF10\uCF11\uCF13\uCF15\uCF1C\uCF20\uCF24\uCF2C\uCF2D\uCF2F\uCF30\uCF31\uCF38\uCF54\uCF55\uCF58\uCF5C\uCF64\uCF65\uCF67\uCF69\uCF70\uCF71\uCF74\uCF78\uCF80\uCF85\uCF8C\uCFA1\uCFA8\uCFB0\uCFC4\uCFE0\uCFE1\uCFE4\uCFE8\uCFF0\uCFF1\uCFF3\uCFF5\uCFFC\uD000\uD004\uD011\uD018\uD02D\uD034\uD035\uD038\uD03C"],
      ["c541", "\uD715\uD716\uD717\uD71A\uD71B\uD71D\uD71E\uD71F\uD721", 6, "\uD72A\uD72C\uD72E", 5, "\uD736\uD737\uD739"],
      ["c561", "\uD73A\uD73B\uD73D", 6, "\uD745\uD746\uD748\uD74A", 5, "\uD752\uD753\uD755\uD75A", 4],
      ["c581", "\uD75F\uD762\uD764\uD766\uD767\uD768\uD76A\uD76B\uD76D\uD76E\uD76F\uD771\uD772\uD773\uD775", 6, "\uD77E\uD77F\uD780\uD782", 5, "\uD78A\uD78B\uD044\uD045\uD047\uD049\uD050\uD054\uD058\uD060\uD06C\uD06D\uD070\uD074\uD07C\uD07D\uD081\uD0A4\uD0A5\uD0A8\uD0AC\uD0B4\uD0B5\uD0B7\uD0B9\uD0C0\uD0C1\uD0C4\uD0C8\uD0C9\uD0D0\uD0D1\uD0D3\uD0D4\uD0D5\uD0DC\uD0DD\uD0E0\uD0E4\uD0EC\uD0ED\uD0EF\uD0F0\uD0F1\uD0F8\uD10D\uD130\uD131\uD134\uD138\uD13A\uD140\uD141\uD143\uD144\uD145\uD14C\uD14D\uD150\uD154\uD15C\uD15D\uD15F\uD161\uD168\uD16C\uD17C\uD184\uD188\uD1A0\uD1A1\uD1A4\uD1A8\uD1B0\uD1B1\uD1B3\uD1B5\uD1BA\uD1BC\uD1C0\uD1D8\uD1F4\uD1F8\uD207\uD209\uD210\uD22C\uD22D\uD230\uD234\uD23C\uD23D\uD23F\uD241\uD248\uD25C"],
      ["c641", "\uD78D\uD78E\uD78F\uD791", 6, "\uD79A\uD79C\uD79E", 5],
      ["c6a1", "\uD264\uD280\uD281\uD284\uD288\uD290\uD291\uD295\uD29C\uD2A0\uD2A4\uD2AC\uD2B1\uD2B8\uD2B9\uD2BC\uD2BF\uD2C0\uD2C2\uD2C8\uD2C9\uD2CB\uD2D4\uD2D8\uD2DC\uD2E4\uD2E5\uD2F0\uD2F1\uD2F4\uD2F8\uD300\uD301\uD303\uD305\uD30C\uD30D\uD30E\uD310\uD314\uD316\uD31C\uD31D\uD31F\uD320\uD321\uD325\uD328\uD329\uD32C\uD330\uD338\uD339\uD33B\uD33C\uD33D\uD344\uD345\uD37C\uD37D\uD380\uD384\uD38C\uD38D\uD38F\uD390\uD391\uD398\uD399\uD39C\uD3A0\uD3A8\uD3A9\uD3AB\uD3AD\uD3B4\uD3B8\uD3BC\uD3C4\uD3C5\uD3C8\uD3C9\uD3D0\uD3D8\uD3E1\uD3E3\uD3EC\uD3ED\uD3F0\uD3F4\uD3FC\uD3FD\uD3FF\uD401"],
      ["c7a1", "\uD408\uD41D\uD440\uD444\uD45C\uD460\uD464\uD46D\uD46F\uD478\uD479\uD47C\uD47F\uD480\uD482\uD488\uD489\uD48B\uD48D\uD494\uD4A9\uD4CC\uD4D0\uD4D4\uD4DC\uD4DF\uD4E8\uD4EC\uD4F0\uD4F8\uD4FB\uD4FD\uD504\uD508\uD50C\uD514\uD515\uD517\uD53C\uD53D\uD540\uD544\uD54C\uD54D\uD54F\uD551\uD558\uD559\uD55C\uD560\uD565\uD568\uD569\uD56B\uD56D\uD574\uD575\uD578\uD57C\uD584\uD585\uD587\uD588\uD589\uD590\uD5A5\uD5C8\uD5C9\uD5CC\uD5D0\uD5D2\uD5D8\uD5D9\uD5DB\uD5DD\uD5E4\uD5E5\uD5E8\uD5EC\uD5F4\uD5F5\uD5F7\uD5F9\uD600\uD601\uD604\uD608\uD610\uD611\uD613\uD614\uD615\uD61C\uD620"],
      ["c8a1", "\uD624\uD62D\uD638\uD639\uD63C\uD640\uD645\uD648\uD649\uD64B\uD64D\uD651\uD654\uD655\uD658\uD65C\uD667\uD669\uD670\uD671\uD674\uD683\uD685\uD68C\uD68D\uD690\uD694\uD69D\uD69F\uD6A1\uD6A8\uD6AC\uD6B0\uD6B9\uD6BB\uD6C4\uD6C5\uD6C8\uD6CC\uD6D1\uD6D4\uD6D7\uD6D9\uD6E0\uD6E4\uD6E8\uD6F0\uD6F5\uD6FC\uD6FD\uD700\uD704\uD711\uD718\uD719\uD71C\uD720\uD728\uD729\uD72B\uD72D\uD734\uD735\uD738\uD73C\uD744\uD747\uD749\uD750\uD751\uD754\uD756\uD757\uD758\uD759\uD760\uD761\uD763\uD765\uD769\uD76C\uD770\uD774\uD77C\uD77D\uD781\uD788\uD789\uD78C\uD790\uD798\uD799\uD79B\uD79D"],
      ["caa1", "\u4F3D\u4F73\u5047\u50F9\u52A0\u53EF\u5475\u54E5\u5609\u5AC1\u5BB6\u6687\u67B6\u67B7\u67EF\u6B4C\u73C2\u75C2\u7A3C\u82DB\u8304\u8857\u8888\u8A36\u8CC8\u8DCF\u8EFB\u8FE6\u99D5\u523B\u5374\u5404\u606A\u6164\u6BBC\u73CF\u811A\u89BA\u89D2\u95A3\u4F83\u520A\u58BE\u5978\u59E6\u5E72\u5E79\u61C7\u63C0\u6746\u67EC\u687F\u6F97\u764E\u770B\u78F5\u7A08\u7AFF\u7C21\u809D\u826E\u8271\u8AEB\u9593\u4E6B\u559D\u66F7\u6E34\u78A3\u7AED\u845B\u8910\u874E\u97A8\u52D8\u574E\u582A\u5D4C\u611F\u61BE\u6221\u6562\u67D1\u6A44\u6E1B\u7518\u75B3\u76E3\u77B0\u7D3A\u90AF\u9451\u9452\u9F95"],
      ["cba1", "\u5323\u5CAC\u7532\u80DB\u9240\u9598\u525B\u5808\u59DC\u5CA1\u5D17\u5EB7\u5F3A\u5F4A\u6177\u6C5F\u757A\u7586\u7CE0\u7D73\u7DB1\u7F8C\u8154\u8221\u8591\u8941\u8B1B\u92FC\u964D\u9C47\u4ECB\u4EF7\u500B\u51F1\u584F\u6137\u613E\u6168\u6539\u69EA\u6F11\u75A5\u7686\u76D6\u7B87\u82A5\u84CB\uF900\u93A7\u958B\u5580\u5BA2\u5751\uF901\u7CB3\u7FB9\u91B5\u5028\u53BB\u5C45\u5DE8\u62D2\u636E\u64DA\u64E7\u6E20\u70AC\u795B\u8DDD\u8E1E\uF902\u907D\u9245\u92F8\u4E7E\u4EF6\u5065\u5DFE\u5EFA\u6106\u6957\u8171\u8654\u8E47\u9375\u9A2B\u4E5E\u5091\u6770\u6840\u5109\u528D\u5292\u6AA2"],
      ["cca1", "\u77BC\u9210\u9ED4\u52AB\u602F\u8FF2\u5048\u61A9\u63ED\u64CA\u683C\u6A84\u6FC0\u8188\u89A1\u9694\u5805\u727D\u72AC\u7504\u7D79\u7E6D\u80A9\u898B\u8B74\u9063\u9D51\u6289\u6C7A\u6F54\u7D50\u7F3A\u8A23\u517C\u614A\u7B9D\u8B19\u9257\u938C\u4EAC\u4FD3\u501E\u50BE\u5106\u52C1\u52CD\u537F\u5770\u5883\u5E9A\u5F91\u6176\u61AC\u64CE\u656C\u666F\u66BB\u66F4\u6897\u6D87\u7085\u70F1\u749F\u74A5\u74CA\u75D9\u786C\u78EC\u7ADF\u7AF6\u7D45\u7D93\u8015\u803F\u811B\u8396\u8B66\u8F15\u9015\u93E1\u9803\u9838\u9A5A\u9BE8\u4FC2\u5553\u583A\u5951\u5B63\u5C46\u60B8\u6212\u6842\u68B0"],
      ["cda1", "\u68E8\u6EAA\u754C\u7678\u78CE\u7A3D\u7CFB\u7E6B\u7E7C\u8A08\u8AA1\u8C3F\u968E\u9DC4\u53E4\u53E9\u544A\u5471\u56FA\u59D1\u5B64\u5C3B\u5EAB\u62F7\u6537\u6545\u6572\u66A0\u67AF\u69C1\u6CBD\u75FC\u7690\u777E\u7A3F\u7F94\u8003\u80A1\u818F\u82E6\u82FD\u83F0\u85C1\u8831\u88B4\u8AA5\uF903\u8F9C\u932E\u96C7\u9867\u9AD8\u9F13\u54ED\u659B\u66F2\u688F\u7A40\u8C37\u9D60\u56F0\u5764\u5D11\u6606\u68B1\u68CD\u6EFE\u7428\u889E\u9BE4\u6C68\uF904\u9AA8\u4F9B\u516C\u5171\u529F\u5B54\u5DE5\u6050\u606D\u62F1\u63A7\u653B\u73D9\u7A7A\u86A3\u8CA2\u978F\u4E32\u5BE1\u6208\u679C\u74DC"],
      ["cea1", "\u79D1\u83D3\u8A87\u8AB2\u8DE8\u904E\u934B\u9846\u5ED3\u69E8\u85FF\u90ED\uF905\u51A0\u5B98\u5BEC\u6163\u68FA\u6B3E\u704C\u742F\u74D8\u7BA1\u7F50\u83C5\u89C0\u8CAB\u95DC\u9928\u522E\u605D\u62EC\u9002\u4F8A\u5149\u5321\u58D9\u5EE3\u66E0\u6D38\u709A\u72C2\u73D6\u7B50\u80F1\u945B\u5366\u639B\u7F6B\u4E56\u5080\u584A\u58DE\u602A\u6127\u62D0\u69D0\u9B41\u5B8F\u7D18\u80B1\u8F5F\u4EA4\u50D1\u54AC\u55AC\u5B0C\u5DA0\u5DE7\u652A\u654E\u6821\u6A4B\u72E1\u768E\u77EF\u7D5E\u7FF9\u81A0\u854E\u86DF\u8F03\u8F4E\u90CA\u9903\u9A55\u9BAB\u4E18\u4E45\u4E5D\u4EC7\u4FF1\u5177\u52FE"],
      ["cfa1", "\u5340\u53E3\u53E5\u548E\u5614\u5775\u57A2\u5BC7\u5D87\u5ED0\u61FC\u62D8\u6551\u67B8\u67E9\u69CB\u6B50\u6BC6\u6BEC\u6C42\u6E9D\u7078\u72D7\u7396\u7403\u77BF\u77E9\u7A76\u7D7F\u8009\u81FC\u8205\u820A\u82DF\u8862\u8B33\u8CFC\u8EC0\u9011\u90B1\u9264\u92B6\u99D2\u9A45\u9CE9\u9DD7\u9F9C\u570B\u5C40\u83CA\u97A0\u97AB\u9EB4\u541B\u7A98\u7FA4\u88D9\u8ECD\u90E1\u5800\u5C48\u6398\u7A9F\u5BAE\u5F13\u7A79\u7AAE\u828E\u8EAC\u5026\u5238\u52F8\u5377\u5708\u62F3\u6372\u6B0A\u6DC3\u7737\u53A5\u7357\u8568\u8E76\u95D5\u673A\u6AC3\u6F70\u8A6D\u8ECC\u994B\uF906\u6677\u6B78\u8CB4"],
      ["d0a1", "\u9B3C\uF907\u53EB\u572D\u594E\u63C6\u69FB\u73EA\u7845\u7ABA\u7AC5\u7CFE\u8475\u898F\u8D73\u9035\u95A8\u52FB\u5747\u7547\u7B60\u83CC\u921E\uF908\u6A58\u514B\u524B\u5287\u621F\u68D8\u6975\u9699\u50C5\u52A4\u52E4\u61C3\u65A4\u6839\u69FF\u747E\u7B4B\u82B9\u83EB\u89B2\u8B39\u8FD1\u9949\uF909\u4ECA\u5997\u64D2\u6611\u6A8E\u7434\u7981\u79BD\u82A9\u887E\u887F\u895F\uF90A\u9326\u4F0B\u53CA\u6025\u6271\u6C72\u7D1A\u7D66\u4E98\u5162\u77DC\u80AF\u4F01\u4F0E\u5176\u5180\u55DC\u5668\u573B\u57FA\u57FC\u5914\u5947\u5993\u5BC4\u5C90\u5D0E\u5DF1\u5E7E\u5FCC\u6280\u65D7\u65E3"],
      ["d1a1", "\u671E\u671F\u675E\u68CB\u68C4\u6A5F\u6B3A\u6C23\u6C7D\u6C82\u6DC7\u7398\u7426\u742A\u7482\u74A3\u7578\u757F\u7881\u78EF\u7941\u7947\u7948\u797A\u7B95\u7D00\u7DBA\u7F88\u8006\u802D\u808C\u8A18\u8B4F\u8C48\u8D77\u9321\u9324\u98E2\u9951\u9A0E\u9A0F\u9A65\u9E92\u7DCA\u4F76\u5409\u62EE\u6854\u91D1\u55AB\u513A\uF90B\uF90C\u5A1C\u61E6\uF90D\u62CF\u62FF\uF90E", 5, "\u90A3\uF914", 4, "\u8AFE\uF919\uF91A\uF91B\uF91C\u6696\uF91D\u7156\uF91E\uF91F\u96E3\uF920\u634F\u637A\u5357\uF921\u678F\u6960\u6E73\uF922\u7537\uF923\uF924\uF925"],
      ["d2a1", "\u7D0D\uF926\uF927\u8872\u56CA\u5A18\uF928", 4, "\u4E43\uF92D\u5167\u5948\u67F0\u8010\uF92E\u5973\u5E74\u649A\u79CA\u5FF5\u606C\u62C8\u637B\u5BE7\u5BD7\u52AA\uF92F\u5974\u5F29\u6012\uF930\uF931\uF932\u7459\uF933", 5, "\u99D1\uF939", 10, "\u6FC3\uF944\uF945\u81BF\u8FB2\u60F1\uF946\uF947\u8166\uF948\uF949\u5C3F\uF94A", 7, "\u5AE9\u8A25\u677B\u7D10\uF952", 5, "\u80FD\uF958\uF959\u5C3C\u6CE5\u533F\u6EBA\u591A\u8336"],
      ["d3a1", "\u4E39\u4EB6\u4F46\u55AE\u5718\u58C7\u5F56\u65B7\u65E6\u6A80\u6BB5\u6E4D\u77ED\u7AEF\u7C1E\u7DDE\u86CB\u8892\u9132\u935B\u64BB\u6FBE\u737A\u75B8\u9054\u5556\u574D\u61BA\u64D4\u66C7\u6DE1\u6E5B\u6F6D\u6FB9\u75F0\u8043\u81BD\u8541\u8983\u8AC7\u8B5A\u931F\u6C93\u7553\u7B54\u8E0F\u905D\u5510\u5802\u5858\u5E62\u6207\u649E\u68E0\u7576\u7CD6\u87B3\u9EE8\u4EE3\u5788\u576E\u5927\u5C0D\u5CB1\u5E36\u5F85\u6234\u64E1\u73B3\u81FA\u888B\u8CB8\u968A\u9EDB\u5B85\u5FB7\u60B3\u5012\u5200\u5230\u5716\u5835\u5857\u5C0E\u5C60\u5CF6\u5D8B\u5EA6\u5F92\u60BC\u6311\u6389\u6417\u6843"],
      ["d4a1", "\u68F9\u6AC2\u6DD8\u6E21\u6ED4\u6FE4\u71FE\u76DC\u7779\u79B1\u7A3B\u8404\u89A9\u8CED\u8DF3\u8E48\u9003\u9014\u9053\u90FD\u934D\u9676\u97DC\u6BD2\u7006\u7258\u72A2\u7368\u7763\u79BF\u7BE4\u7E9B\u8B80\u58A9\u60C7\u6566\u65FD\u66BE\u6C8C\u711E\u71C9\u8C5A\u9813\u4E6D\u7A81\u4EDD\u51AC\u51CD\u52D5\u540C\u61A7\u6771\u6850\u68DF\u6D1E\u6F7C\u75BC\u77B3\u7AE5\u80F4\u8463\u9285\u515C\u6597\u675C\u6793\u75D8\u7AC7\u8373\uF95A\u8C46\u9017\u982D\u5C6F\u81C0\u829A\u9041\u906F\u920D\u5F97\u5D9D\u6A59\u71C8\u767B\u7B49\u85E4\u8B04\u9127\u9A30\u5587\u61F6\uF95B\u7669\u7F85"],
      ["d5a1", "\u863F\u87BA\u88F8\u908F\uF95C\u6D1B\u70D9\u73DE\u7D61\u843D\uF95D\u916A\u99F1\uF95E\u4E82\u5375\u6B04\u6B12\u703E\u721B\u862D\u9E1E\u524C\u8FA3\u5D50\u64E5\u652C\u6B16\u6FEB\u7C43\u7E9C\u85CD\u8964\u89BD\u62C9\u81D8\u881F\u5ECA\u6717\u6D6A\u72FC\u7405\u746F\u8782\u90DE\u4F86\u5D0D\u5FA0\u840A\u51B7\u63A0\u7565\u4EAE\u5006\u5169\u51C9\u6881\u6A11\u7CAE\u7CB1\u7CE7\u826F\u8AD2\u8F1B\u91CF\u4FB6\u5137\u52F5\u5442\u5EEC\u616E\u623E\u65C5\u6ADA\u6FFE\u792A\u85DC\u8823\u95AD\u9A62\u9A6A\u9E97\u9ECE\u529B\u66C6\u6B77\u701D\u792B\u8F62\u9742\u6190\u6200\u6523\u6F23"],
      ["d6a1", "\u7149\u7489\u7DF4\u806F\u84EE\u8F26\u9023\u934A\u51BD\u5217\u52A3\u6D0C\u70C8\u88C2\u5EC9\u6582\u6BAE\u6FC2\u7C3E\u7375\u4EE4\u4F36\u56F9\uF95F\u5CBA\u5DBA\u601C\u73B2\u7B2D\u7F9A\u7FCE\u8046\u901E\u9234\u96F6\u9748\u9818\u9F61\u4F8B\u6FA7\u79AE\u91B4\u96B7\u52DE\uF960\u6488\u64C4\u6AD3\u6F5E\u7018\u7210\u76E7\u8001\u8606\u865C\u8DEF\u8F05\u9732\u9B6F\u9DFA\u9E75\u788C\u797F\u7DA0\u83C9\u9304\u9E7F\u9E93\u8AD6\u58DF\u5F04\u6727\u7027\u74CF\u7C60\u807E\u5121\u7028\u7262\u78CA\u8CC2\u8CDA\u8CF4\u96F7\u4E86\u50DA\u5BEE\u5ED6\u6599\u71CE\u7642\u77AD\u804A\u84FC"],
      ["d7a1", "\u907C\u9B27\u9F8D\u58D8\u5A41\u5C62\u6A13\u6DDA\u6F0F\u763B\u7D2F\u7E37\u851E\u8938\u93E4\u964B\u5289\u65D2\u67F3\u69B4\u6D41\u6E9C\u700F\u7409\u7460\u7559\u7624\u786B\u8B2C\u985E\u516D\u622E\u9678\u4F96\u502B\u5D19\u6DEA\u7DB8\u8F2A\u5F8B\u6144\u6817\uF961\u9686\u52D2\u808B\u51DC\u51CC\u695E\u7A1C\u7DBE\u83F1\u9675\u4FDA\u5229\u5398\u540F\u550E\u5C65\u60A7\u674E\u68A8\u6D6C\u7281\u72F8\u7406\u7483\uF962\u75E2\u7C6C\u7F79\u7FB8\u8389\u88CF\u88E1\u91CC\u91D0\u96E2\u9BC9\u541D\u6F7E\u71D0\u7498\u85FA\u8EAA\u96A3\u9C57\u9E9F\u6797\u6DCB\u7433\u81E8\u9716\u782C"],
      ["d8a1", "\u7ACB\u7B20\u7C92\u6469\u746A\u75F2\u78BC\u78E8\u99AC\u9B54\u9EBB\u5BDE\u5E55\u6F20\u819C\u83AB\u9088\u4E07\u534D\u5A29\u5DD2\u5F4E\u6162\u633D\u6669\u66FC\u6EFF\u6F2B\u7063\u779E\u842C\u8513\u883B\u8F13\u9945\u9C3B\u551C\u62B9\u672B\u6CAB\u8309\u896A\u977A\u4EA1\u5984\u5FD8\u5FD9\u671B\u7DB2\u7F54\u8292\u832B\u83BD\u8F1E\u9099\u57CB\u59B9\u5A92\u5BD0\u6627\u679A\u6885\u6BCF\u7164\u7F75\u8CB7\u8CE3\u9081\u9B45\u8108\u8C8A\u964C\u9A40\u9EA5\u5B5F\u6C13\u731B\u76F2\u76DF\u840C\u51AA\u8993\u514D\u5195\u52C9\u68C9\u6C94\u7704\u7720\u7DBF\u7DEC\u9762\u9EB5\u6EC5"],
      ["d9a1", "\u8511\u51A5\u540D\u547D\u660E\u669D\u6927\u6E9F\u76BF\u7791\u8317\u84C2\u879F\u9169\u9298\u9CF4\u8882\u4FAE\u5192\u52DF\u59C6\u5E3D\u6155\u6478\u6479\u66AE\u67D0\u6A21\u6BCD\u6BDB\u725F\u7261\u7441\u7738\u77DB\u8017\u82BC\u8305\u8B00\u8B28\u8C8C\u6728\u6C90\u7267\u76EE\u7766\u7A46\u9DA9\u6B7F\u6C92\u5922\u6726\u8499\u536F\u5893\u5999\u5EDF\u63CF\u6634\u6773\u6E3A\u732B\u7AD7\u82D7\u9328\u52D9\u5DEB\u61AE\u61CB\u620A\u62C7\u64AB\u65E0\u6959\u6B66\u6BCB\u7121\u73F7\u755D\u7E46\u821E\u8302\u856A\u8AA3\u8CBF\u9727\u9D61\u58A8\u9ED8\u5011\u520E\u543B\u554F\u6587"],
      ["daa1", "\u6C76\u7D0A\u7D0B\u805E\u868A\u9580\u96EF\u52FF\u6C95\u7269\u5473\u5A9A\u5C3E\u5D4B\u5F4C\u5FAE\u672A\u68B6\u6963\u6E3C\u6E44\u7709\u7C73\u7F8E\u8587\u8B0E\u8FF7\u9761\u9EF4\u5CB7\u60B6\u610D\u61AB\u654F\u65FB\u65FC\u6C11\u6CEF\u739F\u73C9\u7DE1\u9594\u5BC6\u871C\u8B10\u525D\u535A\u62CD\u640F\u64B2\u6734\u6A38\u6CCA\u73C0\u749E\u7B94\u7C95\u7E1B\u818A\u8236\u8584\u8FEB\u96F9\u99C1\u4F34\u534A\u53CD\u53DB\u62CC\u642C\u6500\u6591\u69C3\u6CEE\u6F58\u73ED\u7554\u7622\u76E4\u76FC\u78D0\u78FB\u792C\u7D46\u822C\u87E0\u8FD4\u9812\u98EF\u52C3\u62D4\u64A5\u6E24\u6F51"],
      ["dba1", "\u767C\u8DCB\u91B1\u9262\u9AEE\u9B43\u5023\u508D\u574A\u59A8\u5C28\u5E47\u5F77\u623F\u653E\u65B9\u65C1\u6609\u678B\u699C\u6EC2\u78C5\u7D21\u80AA\u8180\u822B\u82B3\u84A1\u868C\u8A2A\u8B17\u90A6\u9632\u9F90\u500D\u4FF3\uF963\u57F9\u5F98\u62DC\u6392\u676F\u6E43\u7119\u76C3\u80CC\u80DA\u88F4\u88F5\u8919\u8CE0\u8F29\u914D\u966A\u4F2F\u4F70\u5E1B\u67CF\u6822\u767D\u767E\u9B44\u5E61\u6A0A\u7169\u71D4\u756A\uF964\u7E41\u8543\u85E9\u98DC\u4F10\u7B4F\u7F70\u95A5\u51E1\u5E06\u68B5\u6C3E\u6C4E\u6CDB\u72AF\u7BC4\u8303\u6CD5\u743A\u50FB\u5288\u58C1\u64D8\u6A97\u74A7\u7656"],
      ["dca1", "\u78A7\u8617\u95E2\u9739\uF965\u535E\u5F01\u8B8A\u8FA8\u8FAF\u908A\u5225\u77A5\u9C49\u9F08\u4E19\u5002\u5175\u5C5B\u5E77\u661E\u663A\u67C4\u68C5\u70B3\u7501\u75C5\u79C9\u7ADD\u8F27\u9920\u9A08\u4FDD\u5821\u5831\u5BF6\u666E\u6B65\u6D11\u6E7A\u6F7D\u73E4\u752B\u83E9\u88DC\u8913\u8B5C\u8F14\u4F0F\u50D5\u5310\u535C\u5B93\u5FA9\u670D\u798F\u8179\u832F\u8514\u8907\u8986\u8F39\u8F3B\u99A5\u9C12\u672C\u4E76\u4FF8\u5949\u5C01\u5CEF\u5CF0\u6367\u68D2\u70FD\u71A2\u742B\u7E2B\u84EC\u8702\u9022\u92D2\u9CF3\u4E0D\u4ED8\u4FEF\u5085\u5256\u526F\u5426\u5490\u57E0\u592B\u5A66"],
      ["dda1", "\u5B5A\u5B75\u5BCC\u5E9C\uF966\u6276\u6577\u65A7\u6D6E\u6EA5\u7236\u7B26\u7C3F\u7F36\u8150\u8151\u819A\u8240\u8299\u83A9\u8A03\u8CA0\u8CE6\u8CFB\u8D74\u8DBA\u90E8\u91DC\u961C\u9644\u99D9\u9CE7\u5317\u5206\u5429\u5674\u58B3\u5954\u596E\u5FFF\u61A4\u626E\u6610\u6C7E\u711A\u76C6\u7C89\u7CDE\u7D1B\u82AC\u8CC1\u96F0\uF967\u4F5B\u5F17\u5F7F\u62C2\u5D29\u670B\u68DA\u787C\u7E43\u9D6C\u4E15\u5099\u5315\u532A\u5351\u5983\u5A62\u5E87\u60B2\u618A\u6249\u6279\u6590\u6787\u69A7\u6BD4\u6BD6\u6BD7\u6BD8\u6CB8\uF968\u7435\u75FA\u7812\u7891\u79D5\u79D8\u7C83\u7DCB\u7FE1\u80A5"],
      ["dea1", "\u813E\u81C2\u83F2\u871A\u88E8\u8AB9\u8B6C\u8CBB\u9119\u975E\u98DB\u9F3B\u56AC\u5B2A\u5F6C\u658C\u6AB3\u6BAF\u6D5C\u6FF1\u7015\u725D\u73AD\u8CA7\u8CD3\u983B\u6191\u6C37\u8058\u9A01\u4E4D\u4E8B\u4E9B\u4ED5\u4F3A\u4F3C\u4F7F\u4FDF\u50FF\u53F2\u53F8\u5506\u55E3\u56DB\u58EB\u5962\u5A11\u5BEB\u5BFA\u5C04\u5DF3\u5E2B\u5F99\u601D\u6368\u659C\u65AF\u67F6\u67FB\u68AD\u6B7B\u6C99\u6CD7\u6E23\u7009\u7345\u7802\u793E\u7940\u7960\u79C1\u7BE9\u7D17\u7D72\u8086\u820D\u838E\u84D1\u86C7\u88DF\u8A50\u8A5E\u8B1D\u8CDC\u8D66\u8FAD\u90AA\u98FC\u99DF\u9E9D\u524A\uF969\u6714\uF96A"],
      ["dfa1", "\u5098\u522A\u5C71\u6563\u6C55\u73CA\u7523\u759D\u7B97\u849C\u9178\u9730\u4E77\u6492\u6BBA\u715E\u85A9\u4E09\uF96B\u6749\u68EE\u6E17\u829F\u8518\u886B\u63F7\u6F81\u9212\u98AF\u4E0A\u50B7\u50CF\u511F\u5546\u55AA\u5617\u5B40\u5C19\u5CE0\u5E38\u5E8A\u5EA0\u5EC2\u60F3\u6851\u6A61\u6E58\u723D\u7240\u72C0\u76F8\u7965\u7BB1\u7FD4\u88F3\u89F4\u8A73\u8C61\u8CDE\u971C\u585E\u74BD\u8CFD\u55C7\uF96C\u7A61\u7D22\u8272\u7272\u751F\u7525\uF96D\u7B19\u5885\u58FB\u5DBC\u5E8F\u5EB6\u5F90\u6055\u6292\u637F\u654D\u6691\u66D9\u66F8\u6816\u68F2\u7280\u745E\u7B6E\u7D6E\u7DD6\u7F72"],
      ["e0a1", "\u80E5\u8212\u85AF\u897F\u8A93\u901D\u92E4\u9ECD\u9F20\u5915\u596D\u5E2D\u60DC\u6614\u6673\u6790\u6C50\u6DC5\u6F5F\u77F3\u78A9\u84C6\u91CB\u932B\u4ED9\u50CA\u5148\u5584\u5B0B\u5BA3\u6247\u657E\u65CB\u6E32\u717D\u7401\u7444\u7487\u74BF\u766C\u79AA\u7DDA\u7E55\u7FA8\u817A\u81B3\u8239\u861A\u87EC\u8A75\u8DE3\u9078\u9291\u9425\u994D\u9BAE\u5368\u5C51\u6954\u6CC4\u6D29\u6E2B\u820C\u859B\u893B\u8A2D\u8AAA\u96EA\u9F67\u5261\u66B9\u6BB2\u7E96\u87FE\u8D0D\u9583\u965D\u651D\u6D89\u71EE\uF96E\u57CE\u59D3\u5BAC\u6027\u60FA\u6210\u661F\u665F\u7329\u73F9\u76DB\u7701\u7B6C"],
      ["e1a1", "\u8056\u8072\u8165\u8AA0\u9192\u4E16\u52E2\u6B72\u6D17\u7A05\u7B39\u7D30\uF96F\u8CB0\u53EC\u562F\u5851\u5BB5\u5C0F\u5C11\u5DE2\u6240\u6383\u6414\u662D\u68B3\u6CBC\u6D88\u6EAF\u701F\u70A4\u71D2\u7526\u758F\u758E\u7619\u7B11\u7BE0\u7C2B\u7D20\u7D39\u852C\u856D\u8607\u8A34\u900D\u9061\u90B5\u92B7\u97F6\u9A37\u4FD7\u5C6C\u675F\u6D91\u7C9F\u7E8C\u8B16\u8D16\u901F\u5B6B\u5DFD\u640D\u84C0\u905C\u98E1\u7387\u5B8B\u609A\u677E\u6DDE\u8A1F\u8AA6\u9001\u980C\u5237\uF970\u7051\u788E\u9396\u8870\u91D7\u4FEE\u53D7\u55FD\u56DA\u5782\u58FD\u5AC2\u5B88\u5CAB\u5CC0\u5E25\u6101"],
      ["e2a1", "\u620D\u624B\u6388\u641C\u6536\u6578\u6A39\u6B8A\u6C34\u6D19\u6F31\u71E7\u72E9\u7378\u7407\u74B2\u7626\u7761\u79C0\u7A57\u7AEA\u7CB9\u7D8F\u7DAC\u7E61\u7F9E\u8129\u8331\u8490\u84DA\u85EA\u8896\u8AB0\u8B90\u8F38\u9042\u9083\u916C\u9296\u92B9\u968B\u96A7\u96A8\u96D6\u9700\u9808\u9996\u9AD3\u9B1A\u53D4\u587E\u5919\u5B70\u5BBF\u6DD1\u6F5A\u719F\u7421\u74B9\u8085\u83FD\u5DE1\u5F87\u5FAA\u6042\u65EC\u6812\u696F\u6A53\u6B89\u6D35\u6DF3\u73E3\u76FE\u77AC\u7B4D\u7D14\u8123\u821C\u8340\u84F4\u8563\u8A62\u8AC4\u9187\u931E\u9806\u99B4\u620C\u8853\u8FF0\u9265\u5D07\u5D27"],
      ["e3a1", "\u5D69\u745F\u819D\u8768\u6FD5\u62FE\u7FD2\u8936\u8972\u4E1E\u4E58\u50E7\u52DD\u5347\u627F\u6607\u7E69\u8805\u965E\u4F8D\u5319\u5636\u59CB\u5AA4\u5C38\u5C4E\u5C4D\u5E02\u5F11\u6043\u65BD\u662F\u6642\u67BE\u67F4\u731C\u77E2\u793A\u7FC5\u8494\u84CD\u8996\u8A66\u8A69\u8AE1\u8C55\u8C7A\u57F4\u5BD4\u5F0F\u606F\u62ED\u690D\u6B96\u6E5C\u7184\u7BD2\u8755\u8B58\u8EFE\u98DF\u98FE\u4F38\u4F81\u4FE1\u547B\u5A20\u5BB8\u613C\u65B0\u6668\u71FC\u7533\u795E\u7D33\u814E\u81E3\u8398\u85AA\u85CE\u8703\u8A0A\u8EAB\u8F9B\uF971\u8FC5\u5931\u5BA4\u5BE6\u6089\u5BE9\u5C0B\u5FC3\u6C81"],
      ["e4a1", "\uF972\u6DF1\u700B\u751A\u82AF\u8AF6\u4EC0\u5341\uF973\u96D9\u6C0F\u4E9E\u4FC4\u5152\u555E\u5A25\u5CE8\u6211\u7259\u82BD\u83AA\u86FE\u8859\u8A1D\u963F\u96C5\u9913\u9D09\u9D5D\u580A\u5CB3\u5DBD\u5E44\u60E1\u6115\u63E1\u6A02\u6E25\u9102\u9354\u984E\u9C10\u9F77\u5B89\u5CB8\u6309\u664F\u6848\u773C\u96C1\u978D\u9854\u9B9F\u65A1\u8B01\u8ECB\u95BC\u5535\u5CA9\u5DD6\u5EB5\u6697\u764C\u83F4\u95C7\u58D3\u62BC\u72CE\u9D28\u4EF0\u592E\u600F\u663B\u6B83\u79E7\u9D26\u5393\u54C0\u57C3\u5D16\u611B\u66D6\u6DAF\u788D\u827E\u9698\u9744\u5384\u627C\u6396\u6DB2\u7E0A\u814B\u984D"],
      ["e5a1", "\u6AFB\u7F4C\u9DAF\u9E1A\u4E5F\u503B\u51B6\u591C\u60F9\u63F6\u6930\u723A\u8036\uF974\u91CE\u5F31\uF975\uF976\u7D04\u82E5\u846F\u84BB\u85E5\u8E8D\uF977\u4F6F\uF978\uF979\u58E4\u5B43\u6059\u63DA\u6518\u656D\u6698\uF97A\u694A\u6A23\u6D0B\u7001\u716C\u75D2\u760D\u79B3\u7A70\uF97B\u7F8A\uF97C\u8944\uF97D\u8B93\u91C0\u967D\uF97E\u990A\u5704\u5FA1\u65BC\u6F01\u7600\u79A6\u8A9E\u99AD\u9B5A\u9F6C\u5104\u61B6\u6291\u6A8D\u81C6\u5043\u5830\u5F66\u7109\u8A00\u8AFA\u5B7C\u8616\u4FFA\u513C\u56B4\u5944\u63A9\u6DF9\u5DAA\u696D\u5186\u4E88\u4F59\uF97F\uF980\uF981\u5982\uF982"],
      ["e6a1", "\uF983\u6B5F\u6C5D\uF984\u74B5\u7916\uF985\u8207\u8245\u8339\u8F3F\u8F5D\uF986\u9918\uF987\uF988\uF989\u4EA6\uF98A\u57DF\u5F79\u6613\uF98B\uF98C\u75AB\u7E79\u8B6F\uF98D\u9006\u9A5B\u56A5\u5827\u59F8\u5A1F\u5BB4\uF98E\u5EF6\uF98F\uF990\u6350\u633B\uF991\u693D\u6C87\u6CBF\u6D8E\u6D93\u6DF5\u6F14\uF992\u70DF\u7136\u7159\uF993\u71C3\u71D5\uF994\u784F\u786F\uF995\u7B75\u7DE3\uF996\u7E2F\uF997\u884D\u8EDF\uF998\uF999\uF99A\u925B\uF99B\u9CF6\uF99C\uF99D\uF99E\u6085\u6D85\uF99F\u71B1\uF9A0\uF9A1\u95B1\u53AD\uF9A2\uF9A3\uF9A4\u67D3\uF9A5\u708E\u7130\u7430\u8276\u82D2"],
      ["e7a1", "\uF9A6\u95BB\u9AE5\u9E7D\u66C4\uF9A7\u71C1\u8449\uF9A8\uF9A9\u584B\uF9AA\uF9AB\u5DB8\u5F71\uF9AC\u6620\u668E\u6979\u69AE\u6C38\u6CF3\u6E36\u6F41\u6FDA\u701B\u702F\u7150\u71DF\u7370\uF9AD\u745B\uF9AE\u74D4\u76C8\u7A4E\u7E93\uF9AF\uF9B0\u82F1\u8A60\u8FCE\uF9B1\u9348\uF9B2\u9719\uF9B3\uF9B4\u4E42\u502A\uF9B5\u5208\u53E1\u66F3\u6C6D\u6FCA\u730A\u777F\u7A62\u82AE\u85DD\u8602\uF9B6\u88D4\u8A63\u8B7D\u8C6B\uF9B7\u92B3\uF9B8\u9713\u9810\u4E94\u4F0D\u4FC9\u50B2\u5348\u543E\u5433\u55DA\u5862\u58BA\u5967\u5A1B\u5BE4\u609F\uF9B9\u61CA\u6556\u65FF\u6664\u68A7\u6C5A\u6FB3"],
      ["e8a1", "\u70CF\u71AC\u7352\u7B7D\u8708\u8AA4\u9C32\u9F07\u5C4B\u6C83\u7344\u7389\u923A\u6EAB\u7465\u761F\u7A69\u7E15\u860A\u5140\u58C5\u64C1\u74EE\u7515\u7670\u7FC1\u9095\u96CD\u9954\u6E26\u74E6\u7AA9\u7AAA\u81E5\u86D9\u8778\u8A1B\u5A49\u5B8C\u5B9B\u68A1\u6900\u6D63\u73A9\u7413\u742C\u7897\u7DE9\u7FEB\u8118\u8155\u839E\u8C4C\u962E\u9811\u66F0\u5F80\u65FA\u6789\u6C6A\u738B\u502D\u5A03\u6B6A\u77EE\u5916\u5D6C\u5DCD\u7325\u754F\uF9BA\uF9BB\u50E5\u51F9\u582F\u592D\u5996\u59DA\u5BE5\uF9BC\uF9BD\u5DA2\u62D7\u6416\u6493\u64FE\uF9BE\u66DC\uF9BF\u6A48\uF9C0\u71FF\u7464\uF9C1"],
      ["e9a1", "\u7A88\u7AAF\u7E47\u7E5E\u8000\u8170\uF9C2\u87EF\u8981\u8B20\u9059\uF9C3\u9080\u9952\u617E\u6B32\u6D74\u7E1F\u8925\u8FB1\u4FD1\u50AD\u5197\u52C7\u57C7\u5889\u5BB9\u5EB8\u6142\u6995\u6D8C\u6E67\u6EB6\u7194\u7462\u7528\u752C\u8073\u8338\u84C9\u8E0A\u9394\u93DE\uF9C4\u4E8E\u4F51\u5076\u512A\u53C8\u53CB\u53F3\u5B87\u5BD3\u5C24\u611A\u6182\u65F4\u725B\u7397\u7440\u76C2\u7950\u7991\u79B9\u7D06\u7FBD\u828B\u85D5\u865E\u8FC2\u9047\u90F5\u91EA\u9685\u96E8\u96E9\u52D6\u5F67\u65ED\u6631\u682F\u715C\u7A36\u90C1\u980A\u4E91\uF9C5\u6A52\u6B9E\u6F90\u7189\u8018\u82B8\u8553"],
      ["eaa1", "\u904B\u9695\u96F2\u97FB\u851A\u9B31\u4E90\u718A\u96C4\u5143\u539F\u54E1\u5713\u5712\u57A3\u5A9B\u5AC4\u5BC3\u6028\u613F\u63F4\u6C85\u6D39\u6E72\u6E90\u7230\u733F\u7457\u82D1\u8881\u8F45\u9060\uF9C6\u9662\u9858\u9D1B\u6708\u8D8A\u925E\u4F4D\u5049\u50DE\u5371\u570D\u59D4\u5A01\u5C09\u6170\u6690\u6E2D\u7232\u744B\u7DEF\u80C3\u840E\u8466\u853F\u875F\u885B\u8918\u8B02\u9055\u97CB\u9B4F\u4E73\u4F91\u5112\u516A\uF9C7\u552F\u55A9\u5B7A\u5BA5\u5E7C\u5E7D\u5EBE\u60A0\u60DF\u6108\u6109\u63C4\u6538\u6709\uF9C8\u67D4\u67DA\uF9C9\u6961\u6962\u6CB9\u6D27\uF9CA\u6E38\uF9CB"],
      ["eba1", "\u6FE1\u7336\u7337\uF9CC\u745C\u7531\uF9CD\u7652\uF9CE\uF9CF\u7DAD\u81FE\u8438\u88D5\u8A98\u8ADB\u8AED\u8E30\u8E42\u904A\u903E\u907A\u9149\u91C9\u936E\uF9D0\uF9D1\u5809\uF9D2\u6BD3\u8089\u80B2\uF9D3\uF9D4\u5141\u596B\u5C39\uF9D5\uF9D6\u6F64\u73A7\u80E4\u8D07\uF9D7\u9217\u958F\uF9D8\uF9D9\uF9DA\uF9DB\u807F\u620E\u701C\u7D68\u878D\uF9DC\u57A0\u6069\u6147\u6BB7\u8ABE\u9280\u96B1\u4E59\u541F\u6DEB\u852D\u9670\u97F3\u98EE\u63D6\u6CE3\u9091\u51DD\u61C9\u81BA\u9DF9\u4F9D\u501A\u5100\u5B9C\u610F\u61FF\u64EC\u6905\u6BC5\u7591\u77E3\u7FA9\u8264\u858F\u87FB\u8863\u8ABC"],
      ["eca1", "\u8B70\u91AB\u4E8C\u4EE5\u4F0A\uF9DD\uF9DE\u5937\u59E8\uF9DF\u5DF2\u5F1B\u5F5B\u6021\uF9E0\uF9E1\uF9E2\uF9E3\u723E\u73E5\uF9E4\u7570\u75CD\uF9E5\u79FB\uF9E6\u800C\u8033\u8084\u82E1\u8351\uF9E7\uF9E8\u8CBD\u8CB3\u9087\uF9E9\uF9EA\u98F4\u990C\uF9EB\uF9EC\u7037\u76CA\u7FCA\u7FCC\u7FFC\u8B1A\u4EBA\u4EC1\u5203\u5370\uF9ED\u54BD\u56E0\u59FB\u5BC5\u5F15\u5FCD\u6E6E\uF9EE\uF9EF\u7D6A\u8335\uF9F0\u8693\u8A8D\uF9F1\u976D\u9777\uF9F2\uF9F3\u4E00\u4F5A\u4F7E\u58F9\u65E5\u6EA2\u9038\u93B0\u99B9\u4EFB\u58EC\u598A\u59D9\u6041\uF9F4\uF9F5\u7A14\uF9F6\u834F\u8CC3\u5165\u5344"],
      ["eda1", "\uF9F7\uF9F8\uF9F9\u4ECD\u5269\u5B55\u82BF\u4ED4\u523A\u54A8\u59C9\u59FF\u5B50\u5B57\u5B5C\u6063\u6148\u6ECB\u7099\u716E\u7386\u74F7\u75B5\u78C1\u7D2B\u8005\u81EA\u8328\u8517\u85C9\u8AEE\u8CC7\u96CC\u4F5C\u52FA\u56BC\u65AB\u6628\u707C\u70B8\u7235\u7DBD\u828D\u914C\u96C0\u9D72\u5B71\u68E7\u6B98\u6F7A\u76DE\u5C91\u66AB\u6F5B\u7BB4\u7C2A\u8836\u96DC\u4E08\u4ED7\u5320\u5834\u58BB\u58EF\u596C\u5C07\u5E33\u5E84\u5F35\u638C\u66B2\u6756\u6A1F\u6AA3\u6B0C\u6F3F\u7246\uF9FA\u7350\u748B\u7AE0\u7CA7\u8178\u81DF\u81E7\u838A\u846C\u8523\u8594\u85CF\u88DD\u8D13\u91AC\u9577"],
      ["eea1", "\u969C\u518D\u54C9\u5728\u5BB0\u624D\u6750\u683D\u6893\u6E3D\u6ED3\u707D\u7E21\u88C1\u8CA1\u8F09\u9F4B\u9F4E\u722D\u7B8F\u8ACD\u931A\u4F47\u4F4E\u5132\u5480\u59D0\u5E95\u62B5\u6775\u696E\u6A17\u6CAE\u6E1A\u72D9\u732A\u75BD\u7BB8\u7D35\u82E7\u83F9\u8457\u85F7\u8A5B\u8CAF\u8E87\u9019\u90B8\u96CE\u9F5F\u52E3\u540A\u5AE1\u5BC2\u6458\u6575\u6EF4\u72C4\uF9FB\u7684\u7A4D\u7B1B\u7C4D\u7E3E\u7FDF\u837B\u8B2B\u8CCA\u8D64\u8DE1\u8E5F\u8FEA\u8FF9\u9069\u93D1\u4F43\u4F7A\u50B3\u5168\u5178\u524D\u526A\u5861\u587C\u5960\u5C08\u5C55\u5EDB\u609B\u6230\u6813\u6BBF\u6C08\u6FB1"],
      ["efa1", "\u714E\u7420\u7530\u7538\u7551\u7672\u7B4C\u7B8B\u7BAD\u7BC6\u7E8F\u8A6E\u8F3E\u8F49\u923F\u9293\u9322\u942B\u96FB\u985A\u986B\u991E\u5207\u622A\u6298\u6D59\u7664\u7ACA\u7BC0\u7D76\u5360\u5CBE\u5E97\u6F38\u70B9\u7C98\u9711\u9B8E\u9EDE\u63A5\u647A\u8776\u4E01\u4E95\u4EAD\u505C\u5075\u5448\u59C3\u5B9A\u5E40\u5EAD\u5EF7\u5F81\u60C5\u633A\u653F\u6574\u65CC\u6676\u6678\u67FE\u6968\u6A89\u6B63\u6C40\u6DC0\u6DE8\u6E1F\u6E5E\u701E\u70A1\u738E\u73FD\u753A\u775B\u7887\u798E\u7A0B\u7A7D\u7CBE\u7D8E\u8247\u8A02\u8AEA\u8C9E\u912D\u914A\u91D8\u9266\u92CC\u9320\u9706\u9756"],
      ["f0a1", "\u975C\u9802\u9F0E\u5236\u5291\u557C\u5824\u5E1D\u5F1F\u608C\u63D0\u68AF\u6FDF\u796D\u7B2C\u81CD\u85BA\u88FD\u8AF8\u8E44\u918D\u9664\u969B\u973D\u984C\u9F4A\u4FCE\u5146\u51CB\u52A9\u5632\u5F14\u5F6B\u63AA\u64CD\u65E9\u6641\u66FA\u66F9\u671D\u689D\u68D7\u69FD\u6F15\u6F6E\u7167\u71E5\u722A\u74AA\u773A\u7956\u795A\u79DF\u7A20\u7A95\u7C97\u7CDF\u7D44\u7E70\u8087\u85FB\u86A4\u8A54\u8ABF\u8D99\u8E81\u9020\u906D\u91E3\u963B\u96D5\u9CE5\u65CF\u7C07\u8DB3\u93C3\u5B58\u5C0A\u5352\u62D9\u731D\u5027\u5B97\u5F9E\u60B0\u616B\u68D5\u6DD9\u742E\u7A2E\u7D42\u7D9C\u7E31\u816B"],
      ["f1a1", "\u8E2A\u8E35\u937E\u9418\u4F50\u5750\u5DE6\u5EA7\u632B\u7F6A\u4E3B\u4F4F\u4F8F\u505A\u59DD\u80C4\u546A\u5468\u55FE\u594F\u5B99\u5DDE\u5EDA\u665D\u6731\u67F1\u682A\u6CE8\u6D32\u6E4A\u6F8D\u70B7\u73E0\u7587\u7C4C\u7D02\u7D2C\u7DA2\u821F\u86DB\u8A3B\u8A85\u8D70\u8E8A\u8F33\u9031\u914E\u9152\u9444\u99D0\u7AF9\u7CA5\u4FCA\u5101\u51C6\u57C8\u5BEF\u5CFB\u6659\u6A3D\u6D5A\u6E96\u6FEC\u710C\u756F\u7AE3\u8822\u9021\u9075\u96CB\u99FF\u8301\u4E2D\u4EF2\u8846\u91CD\u537D\u6ADB\u696B\u6C41\u847A\u589E\u618E\u66FE\u62EF\u70DD\u7511\u75C7\u7E52\u84B8\u8B49\u8D08\u4E4B\u53EA"],
      ["f2a1", "\u54AB\u5730\u5740\u5FD7\u6301\u6307\u646F\u652F\u65E8\u667A\u679D\u67B3\u6B62\u6C60\u6C9A\u6F2C\u77E5\u7825\u7949\u7957\u7D19\u80A2\u8102\u81F3\u829D\u82B7\u8718\u8A8C\uF9FC\u8D04\u8DBE\u9072\u76F4\u7A19\u7A37\u7E54\u8077\u5507\u55D4\u5875\u632F\u6422\u6649\u664B\u686D\u699B\u6B84\u6D25\u6EB1\u73CD\u7468\u74A1\u755B\u75B9\u76E1\u771E\u778B\u79E6\u7E09\u7E1D\u81FB\u852F\u8897\u8A3A\u8CD1\u8EEB\u8FB0\u9032\u93AD\u9663\u9673\u9707\u4F84\u53F1\u59EA\u5AC9\u5E19\u684E\u74C6\u75BE\u79E9\u7A92\u81A3\u86ED\u8CEA\u8DCC\u8FED\u659F\u6715\uF9FD\u57F7\u6F57\u7DDD\u8F2F"],
      ["f3a1", "\u93F6\u96C6\u5FB5\u61F2\u6F84\u4E14\u4F98\u501F\u53C9\u55DF\u5D6F\u5DEE\u6B21\u6B64\u78CB\u7B9A\uF9FE\u8E49\u8ECA\u906E\u6349\u643E\u7740\u7A84\u932F\u947F\u9F6A\u64B0\u6FAF\u71E6\u74A8\u74DA\u7AC4\u7C12\u7E82\u7CB2\u7E98\u8B9A\u8D0A\u947D\u9910\u994C\u5239\u5BDF\u64E6\u672D\u7D2E\u50ED\u53C3\u5879\u6158\u6159\u61FA\u65AC\u7AD9\u8B92\u8B96\u5009\u5021\u5275\u5531\u5A3C\u5EE0\u5F70\u6134\u655E\u660C\u6636\u66A2\u69CD\u6EC4\u6F32\u7316\u7621\u7A93\u8139\u8259\u83D6\u84BC\u50B5\u57F0\u5BC0\u5BE8\u5F69\u63A1\u7826\u7DB5\u83DC\u8521\u91C7\u91F5\u518A\u67F5\u7B56"],
      ["f4a1", "\u8CAC\u51C4\u59BB\u60BD\u8655\u501C\uF9FF\u5254\u5C3A\u617D\u621A\u62D3\u64F2\u65A5\u6ECC\u7620\u810A\u8E60\u965F\u96BB\u4EDF\u5343\u5598\u5929\u5DDD\u64C5\u6CC9\u6DFA\u7394\u7A7F\u821B\u85A6\u8CE4\u8E10\u9077\u91E7\u95E1\u9621\u97C6\u51F8\u54F2\u5586\u5FB9\u64A4\u6F88\u7DB4\u8F1F\u8F4D\u9435\u50C9\u5C16\u6CBE\u6DFB\u751B\u77BB\u7C3D\u7C64\u8A79\u8AC2\u581E\u59BE\u5E16\u6377\u7252\u758A\u776B\u8ADC\u8CBC\u8F12\u5EF3\u6674\u6DF8\u807D\u83C1\u8ACB\u9751\u9BD6\uFA00\u5243\u66FF\u6D95\u6EEF\u7DE0\u8AE6\u902E\u905E\u9AD4\u521D\u527F\u54E8\u6194\u6284\u62DB\u68A2"],
      ["f5a1", "\u6912\u695A\u6A35\u7092\u7126\u785D\u7901\u790E\u79D2\u7A0D\u8096\u8278\u82D5\u8349\u8549\u8C82\u8D85\u9162\u918B\u91AE\u4FC3\u56D1\u71ED\u77D7\u8700\u89F8\u5BF8\u5FD6\u6751\u90A8\u53E2\u585A\u5BF5\u60A4\u6181\u6460\u7E3D\u8070\u8525\u9283\u64AE\u50AC\u5D14\u6700\u589C\u62BD\u63A8\u690E\u6978\u6A1E\u6E6B\u76BA\u79CB\u82BB\u8429\u8ACF\u8DA8\u8FFD\u9112\u914B\u919C\u9310\u9318\u939A\u96DB\u9A36\u9C0D\u4E11\u755C\u795D\u7AFA\u7B51\u7BC9\u7E2E\u84C4\u8E59\u8E74\u8EF8\u9010\u6625\u693F\u7443\u51FA\u672E\u9EDC\u5145\u5FE0\u6C96\u87F2\u885D\u8877\u60B4\u81B5\u8403"],
      ["f6a1", "\u8D05\u53D6\u5439\u5634\u5A36\u5C31\u708A\u7FE0\u805A\u8106\u81ED\u8DA3\u9189\u9A5F\u9DF2\u5074\u4EC4\u53A0\u60FB\u6E2C\u5C64\u4F88\u5024\u55E4\u5CD9\u5E5F\u6065\u6894\u6CBB\u6DC4\u71BE\u75D4\u75F4\u7661\u7A1A\u7A49\u7DC7\u7DFB\u7F6E\u81F4\u86A9\u8F1C\u96C9\u99B3\u9F52\u5247\u52C5\u98ED\u89AA\u4E03\u67D2\u6F06\u4FB5\u5BE2\u6795\u6C88\u6D78\u741B\u7827\u91DD\u937C\u87C4\u79E4\u7A31\u5FEB\u4ED6\u54A4\u553E\u58AE\u59A5\u60F0\u6253\u62D6\u6736\u6955\u8235\u9640\u99B1\u99DD\u502C\u5353\u5544\u577C\uFA01\u6258\uFA02\u64E2\u666B\u67DD\u6FC1\u6FEF\u7422\u7438\u8A17"],
      ["f7a1", "\u9438\u5451\u5606\u5766\u5F48\u619A\u6B4E\u7058\u70AD\u7DBB\u8A95\u596A\u812B\u63A2\u7708\u803D\u8CAA\u5854\u642D\u69BB\u5B95\u5E11\u6E6F\uFA03\u8569\u514C\u53F0\u592A\u6020\u614B\u6B86\u6C70\u6CF0\u7B1E\u80CE\u82D4\u8DC6\u90B0\u98B1\uFA04\u64C7\u6FA4\u6491\u6504\u514E\u5410\u571F\u8A0E\u615F\u6876\uFA05\u75DB\u7B52\u7D71\u901A\u5806\u69CC\u817F\u892A\u9000\u9839\u5078\u5957\u59AC\u6295\u900F\u9B2A\u615D\u7279\u95D6\u5761\u5A46\u5DF4\u628A\u64AD\u64FA\u6777\u6CE2\u6D3E\u722C\u7436\u7834\u7F77\u82AD\u8DDB\u9817\u5224\u5742\u677F\u7248\u74E3\u8CA9\u8FA6\u9211"],
      ["f8a1", "\u962A\u516B\u53ED\u634C\u4F69\u5504\u6096\u6557\u6C9B\u6D7F\u724C\u72FD\u7A17\u8987\u8C9D\u5F6D\u6F8E\u70F9\u81A8\u610E\u4FBF\u504F\u6241\u7247\u7BC7\u7DE8\u7FE9\u904D\u97AD\u9A19\u8CB6\u576A\u5E73\u67B0\u840D\u8A55\u5420\u5B16\u5E63\u5EE2\u5F0A\u6583\u80BA\u853D\u9589\u965B\u4F48\u5305\u530D\u530F\u5486\u54FA\u5703\u5E03\u6016\u629B\u62B1\u6355\uFA06\u6CE1\u6D66\u75B1\u7832\u80DE\u812F\u82DE\u8461\u84B2\u888D\u8912\u900B\u92EA\u98FD\u9B91\u5E45\u66B4\u66DD\u7011\u7206\uFA07\u4FF5\u527D\u5F6A\u6153\u6753\u6A19\u6F02\u74E2\u7968\u8868\u8C79\u98C7\u98C4\u9A43"],
      ["f9a1", "\u54C1\u7A1F\u6953\u8AF7\u8C4A\u98A8\u99AE\u5F7C\u62AB\u75B2\u76AE\u88AB\u907F\u9642\u5339\u5F3C\u5FC5\u6CCC\u73CC\u7562\u758B\u7B46\u82FE\u999D\u4E4F\u903C\u4E0B\u4F55\u53A6\u590F\u5EC8\u6630\u6CB3\u7455\u8377\u8766\u8CC0\u9050\u971E\u9C15\u58D1\u5B78\u8650\u8B14\u9DB4\u5BD2\u6068\u608D\u65F1\u6C57\u6F22\u6FA3\u701A\u7F55\u7FF0\u9591\u9592\u9650\u97D3\u5272\u8F44\u51FD\u542B\u54B8\u5563\u558A\u6ABB\u6DB5\u7DD8\u8266\u929C\u9677\u9E79\u5408\u54C8\u76D2\u86E4\u95A4\u95D4\u965C\u4EA2\u4F09\u59EE\u5AE6\u5DF7\u6052\u6297\u676D\u6841\u6C86\u6E2F\u7F38\u809B\u822A"],
      ["faa1", "\uFA08\uFA09\u9805\u4EA5\u5055\u54B3\u5793\u595A\u5B69\u5BB3\u61C8\u6977\u6D77\u7023\u87F9\u89E3\u8A72\u8AE7\u9082\u99ED\u9AB8\u52BE\u6838\u5016\u5E78\u674F\u8347\u884C\u4EAB\u5411\u56AE\u73E6\u9115\u97FF\u9909\u9957\u9999\u5653\u589F\u865B\u8A31\u61B2\u6AF6\u737B\u8ED2\u6B47\u96AA\u9A57\u5955\u7200\u8D6B\u9769\u4FD4\u5CF4\u5F26\u61F8\u665B\u6CEB\u70AB\u7384\u73B9\u73FE\u7729\u774D\u7D43\u7D62\u7E23\u8237\u8852\uFA0A\u8CE2\u9249\u986F\u5B51\u7A74\u8840\u9801\u5ACC\u4FE0\u5354\u593E\u5CFD\u633E\u6D79\u72F9\u8105\u8107\u83A2\u92CF\u9830\u4EA8\u5144\u5211\u578B"],
      ["fba1", "\u5F62\u6CC2\u6ECE\u7005\u7050\u70AF\u7192\u73E9\u7469\u834A\u87A2\u8861\u9008\u90A2\u93A3\u99A8\u516E\u5F57\u60E0\u6167\u66B3\u8559\u8E4A\u91AF\u978B\u4E4E\u4E92\u547C\u58D5\u58FA\u597D\u5CB5\u5F27\u6236\u6248\u660A\u6667\u6BEB\u6D69\u6DCF\u6E56\u6EF8\u6F94\u6FE0\u6FE9\u705D\u72D0\u7425\u745A\u74E0\u7693\u795C\u7CCA\u7E1E\u80E1\u82A6\u846B\u84BF\u864E\u865F\u8774\u8B77\u8C6A\u93AC\u9800\u9865\u60D1\u6216\u9177\u5A5A\u660F\u6DF7\u6E3E\u743F\u9B42\u5FFD\u60DA\u7B0F\u54C4\u5F18\u6C5E\u6CD3\u6D2A\u70D8\u7D05\u8679\u8A0C\u9D3B\u5316\u548C\u5B05\u6A3A\u706B\u7575"],
      ["fca1", "\u798D\u79BE\u82B1\u83EF\u8A71\u8B41\u8CA8\u9774\uFA0B\u64F4\u652B\u78BA\u78BB\u7A6B\u4E38\u559A\u5950\u5BA6\u5E7B\u60A3\u63DB\u6B61\u6665\u6853\u6E19\u7165\u74B0\u7D08\u9084\u9A69\u9C25\u6D3B\u6ED1\u733E\u8C41\u95CA\u51F0\u5E4C\u5FA8\u604D\u60F6\u6130\u614C\u6643\u6644\u69A5\u6CC1\u6E5F\u6EC9\u6F62\u714C\u749C\u7687\u7BC1\u7C27\u8352\u8757\u9051\u968D\u9EC3\u532F\u56DE\u5EFB\u5F8A\u6062\u6094\u61F7\u6666\u6703\u6A9C\u6DEE\u6FAE\u7070\u736A\u7E6A\u81BE\u8334\u86D4\u8AA8\u8CC4\u5283\u7372\u5B96\u6A6B\u9404\u54EE\u5686\u5B5D\u6548\u6585\u66C9\u689F\u6D8D\u6DC6"],
      ["fda1", "\u723B\u80B4\u9175\u9A4D\u4FAF\u5019\u539A\u540E\u543C\u5589\u55C5\u5E3F\u5F8C\u673D\u7166\u73DD\u9005\u52DB\u52F3\u5864\u58CE\u7104\u718F\u71FB\u85B0\u8A13\u6688\u85A8\u55A7\u6684\u714A\u8431\u5349\u5599\u6BC1\u5F59\u5FBD\u63EE\u6689\u7147\u8AF1\u8F1D\u9EBE\u4F11\u643A\u70CB\u7566\u8667\u6064\u8B4E\u9DF8\u5147\u51F6\u5308\u6D36\u80F8\u9ED1\u6615\u6B23\u7098\u75D5\u5403\u5C79\u7D07\u8A16\u6B20\u6B3D\u6B46\u5438\u6070\u6D3D\u7FD5\u8208\u50D6\u51DE\u559C\u566B\u56CD\u59EC\u5B09\u5E0C\u6199\u6198\u6231\u665E\u66E6\u7199\u71B9\u71BA\u72A7\u79A7\u7A00\u7FB2\u8A70"]
    ];
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/cp950.json
var require_cp950 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/cp950.json"(exports2, module2) {
    module2.exports = [
      ["0", "\0", 127],
      ["a140", "\u3000\uFF0C\u3001\u3002\uFF0E\u2027\uFF1B\uFF1A\uFF1F\uFF01\uFE30\u2026\u2025\uFE50\uFE51\uFE52\xB7\uFE54\uFE55\uFE56\uFE57\uFF5C\u2013\uFE31\u2014\uFE33\u2574\uFE34\uFE4F\uFF08\uFF09\uFE35\uFE36\uFF5B\uFF5D\uFE37\uFE38\u3014\u3015\uFE39\uFE3A\u3010\u3011\uFE3B\uFE3C\u300A\u300B\uFE3D\uFE3E\u3008\u3009\uFE3F\uFE40\u300C\u300D\uFE41\uFE42\u300E\u300F\uFE43\uFE44\uFE59\uFE5A"],
      ["a1a1", "\uFE5B\uFE5C\uFE5D\uFE5E\u2018\u2019\u201C\u201D\u301D\u301E\u2035\u2032\uFF03\uFF06\uFF0A\u203B\xA7\u3003\u25CB\u25CF\u25B3\u25B2\u25CE\u2606\u2605\u25C7\u25C6\u25A1\u25A0\u25BD\u25BC\u32A3\u2105\xAF\uFFE3\uFF3F\u02CD\uFE49\uFE4A\uFE4D\uFE4E\uFE4B\uFE4C\uFE5F\uFE60\uFE61\uFF0B\uFF0D\xD7\xF7\xB1\u221A\uFF1C\uFF1E\uFF1D\u2266\u2267\u2260\u221E\u2252\u2261\uFE62", 4, "\uFF5E\u2229\u222A\u22A5\u2220\u221F\u22BF\u33D2\u33D1\u222B\u222E\u2235\u2234\u2640\u2642\u2295\u2299\u2191\u2193\u2190\u2192\u2196\u2197\u2199\u2198\u2225\u2223\uFF0F"],
      ["a240", "\uFF3C\u2215\uFE68\uFF04\uFFE5\u3012\uFFE0\uFFE1\uFF05\uFF20\u2103\u2109\uFE69\uFE6A\uFE6B\u33D5\u339C\u339D\u339E\u33CE\u33A1\u338E\u338F\u33C4\xB0\u5159\u515B\u515E\u515D\u5161\u5163\u55E7\u74E9\u7CCE\u2581", 7, "\u258F\u258E\u258D\u258C\u258B\u258A\u2589\u253C\u2534\u252C\u2524\u251C\u2594\u2500\u2502\u2595\u250C\u2510\u2514\u2518\u256D"],
      ["a2a1", "\u256E\u2570\u256F\u2550\u255E\u256A\u2561\u25E2\u25E3\u25E5\u25E4\u2571\u2572\u2573\uFF10", 9, "\u2160", 9, "\u3021", 8, "\u5341\u5344\u5345\uFF21", 25, "\uFF41", 21],
      ["a340", "\uFF57\uFF58\uFF59\uFF5A\u0391", 16, "\u03A3", 6, "\u03B1", 16, "\u03C3", 6, "\u3105", 10],
      ["a3a1", "\u3110", 25, "\u02D9\u02C9\u02CA\u02C7\u02CB"],
      ["a3e1", "\u20AC"],
      ["a440", "\u4E00\u4E59\u4E01\u4E03\u4E43\u4E5D\u4E86\u4E8C\u4EBA\u513F\u5165\u516B\u51E0\u5200\u5201\u529B\u5315\u5341\u535C\u53C8\u4E09\u4E0B\u4E08\u4E0A\u4E2B\u4E38\u51E1\u4E45\u4E48\u4E5F\u4E5E\u4E8E\u4EA1\u5140\u5203\u52FA\u5343\u53C9\u53E3\u571F\u58EB\u5915\u5927\u5973\u5B50\u5B51\u5B53\u5BF8\u5C0F\u5C22\u5C38\u5C71\u5DDD\u5DE5\u5DF1\u5DF2\u5DF3\u5DFE\u5E72\u5EFE\u5F0B\u5F13\u624D"],
      ["a4a1", "\u4E11\u4E10\u4E0D\u4E2D\u4E30\u4E39\u4E4B\u5C39\u4E88\u4E91\u4E95\u4E92\u4E94\u4EA2\u4EC1\u4EC0\u4EC3\u4EC6\u4EC7\u4ECD\u4ECA\u4ECB\u4EC4\u5143\u5141\u5167\u516D\u516E\u516C\u5197\u51F6\u5206\u5207\u5208\u52FB\u52FE\u52FF\u5316\u5339\u5348\u5347\u5345\u535E\u5384\u53CB\u53CA\u53CD\u58EC\u5929\u592B\u592A\u592D\u5B54\u5C11\u5C24\u5C3A\u5C6F\u5DF4\u5E7B\u5EFF\u5F14\u5F15\u5FC3\u6208\u6236\u624B\u624E\u652F\u6587\u6597\u65A4\u65B9\u65E5\u66F0\u6708\u6728\u6B20\u6B62\u6B79\u6BCB\u6BD4\u6BDB\u6C0F\u6C34\u706B\u722A\u7236\u723B\u7247\u7259\u725B\u72AC\u738B\u4E19"],
      ["a540", "\u4E16\u4E15\u4E14\u4E18\u4E3B\u4E4D\u4E4F\u4E4E\u4EE5\u4ED8\u4ED4\u4ED5\u4ED6\u4ED7\u4EE3\u4EE4\u4ED9\u4EDE\u5145\u5144\u5189\u518A\u51AC\u51F9\u51FA\u51F8\u520A\u52A0\u529F\u5305\u5306\u5317\u531D\u4EDF\u534A\u5349\u5361\u5360\u536F\u536E\u53BB\u53EF\u53E4\u53F3\u53EC\u53EE\u53E9\u53E8\u53FC\u53F8\u53F5\u53EB\u53E6\u53EA\u53F2\u53F1\u53F0\u53E5\u53ED\u53FB\u56DB\u56DA\u5916"],
      ["a5a1", "\u592E\u5931\u5974\u5976\u5B55\u5B83\u5C3C\u5DE8\u5DE7\u5DE6\u5E02\u5E03\u5E73\u5E7C\u5F01\u5F18\u5F17\u5FC5\u620A\u6253\u6254\u6252\u6251\u65A5\u65E6\u672E\u672C\u672A\u672B\u672D\u6B63\u6BCD\u6C11\u6C10\u6C38\u6C41\u6C40\u6C3E\u72AF\u7384\u7389\u74DC\u74E6\u7518\u751F\u7528\u7529\u7530\u7531\u7532\u7533\u758B\u767D\u76AE\u76BF\u76EE\u77DB\u77E2\u77F3\u793A\u79BE\u7A74\u7ACB\u4E1E\u4E1F\u4E52\u4E53\u4E69\u4E99\u4EA4\u4EA6\u4EA5\u4EFF\u4F09\u4F19\u4F0A\u4F15\u4F0D\u4F10\u4F11\u4F0F\u4EF2\u4EF6\u4EFB\u4EF0\u4EF3\u4EFD\u4F01\u4F0B\u5149\u5147\u5146\u5148\u5168"],
      ["a640", "\u5171\u518D\u51B0\u5217\u5211\u5212\u520E\u5216\u52A3\u5308\u5321\u5320\u5370\u5371\u5409\u540F\u540C\u540A\u5410\u5401\u540B\u5404\u5411\u540D\u5408\u5403\u540E\u5406\u5412\u56E0\u56DE\u56DD\u5733\u5730\u5728\u572D\u572C\u572F\u5729\u5919\u591A\u5937\u5938\u5984\u5978\u5983\u597D\u5979\u5982\u5981\u5B57\u5B58\u5B87\u5B88\u5B85\u5B89\u5BFA\u5C16\u5C79\u5DDE\u5E06\u5E76\u5E74"],
      ["a6a1", "\u5F0F\u5F1B\u5FD9\u5FD6\u620E\u620C\u620D\u6210\u6263\u625B\u6258\u6536\u65E9\u65E8\u65EC\u65ED\u66F2\u66F3\u6709\u673D\u6734\u6731\u6735\u6B21\u6B64\u6B7B\u6C16\u6C5D\u6C57\u6C59\u6C5F\u6C60\u6C50\u6C55\u6C61\u6C5B\u6C4D\u6C4E\u7070\u725F\u725D\u767E\u7AF9\u7C73\u7CF8\u7F36\u7F8A\u7FBD\u8001\u8003\u800C\u8012\u8033\u807F\u8089\u808B\u808C\u81E3\u81EA\u81F3\u81FC\u820C\u821B\u821F\u826E\u8272\u827E\u866B\u8840\u884C\u8863\u897F\u9621\u4E32\u4EA8\u4F4D\u4F4F\u4F47\u4F57\u4F5E\u4F34\u4F5B\u4F55\u4F30\u4F50\u4F51\u4F3D\u4F3A\u4F38\u4F43\u4F54\u4F3C\u4F46\u4F63"],
      ["a740", "\u4F5C\u4F60\u4F2F\u4F4E\u4F36\u4F59\u4F5D\u4F48\u4F5A\u514C\u514B\u514D\u5175\u51B6\u51B7\u5225\u5224\u5229\u522A\u5228\u52AB\u52A9\u52AA\u52AC\u5323\u5373\u5375\u541D\u542D\u541E\u543E\u5426\u544E\u5427\u5446\u5443\u5433\u5448\u5442\u541B\u5429\u544A\u5439\u543B\u5438\u542E\u5435\u5436\u5420\u543C\u5440\u5431\u542B\u541F\u542C\u56EA\u56F0\u56E4\u56EB\u574A\u5751\u5740\u574D"],
      ["a7a1", "\u5747\u574E\u573E\u5750\u574F\u573B\u58EF\u593E\u599D\u5992\u59A8\u599E\u59A3\u5999\u5996\u598D\u59A4\u5993\u598A\u59A5\u5B5D\u5B5C\u5B5A\u5B5B\u5B8C\u5B8B\u5B8F\u5C2C\u5C40\u5C41\u5C3F\u5C3E\u5C90\u5C91\u5C94\u5C8C\u5DEB\u5E0C\u5E8F\u5E87\u5E8A\u5EF7\u5F04\u5F1F\u5F64\u5F62\u5F77\u5F79\u5FD8\u5FCC\u5FD7\u5FCD\u5FF1\u5FEB\u5FF8\u5FEA\u6212\u6211\u6284\u6297\u6296\u6280\u6276\u6289\u626D\u628A\u627C\u627E\u6279\u6273\u6292\u626F\u6298\u626E\u6295\u6293\u6291\u6286\u6539\u653B\u6538\u65F1\u66F4\u675F\u674E\u674F\u6750\u6751\u675C\u6756\u675E\u6749\u6746\u6760"],
      ["a840", "\u6753\u6757\u6B65\u6BCF\u6C42\u6C5E\u6C99\u6C81\u6C88\u6C89\u6C85\u6C9B\u6C6A\u6C7A\u6C90\u6C70\u6C8C\u6C68\u6C96\u6C92\u6C7D\u6C83\u6C72\u6C7E\u6C74\u6C86\u6C76\u6C8D\u6C94\u6C98\u6C82\u7076\u707C\u707D\u7078\u7262\u7261\u7260\u72C4\u72C2\u7396\u752C\u752B\u7537\u7538\u7682\u76EF\u77E3\u79C1\u79C0\u79BF\u7A76\u7CFB\u7F55\u8096\u8093\u809D\u8098\u809B\u809A\u80B2\u826F\u8292"],
      ["a8a1", "\u828B\u828D\u898B\u89D2\u8A00\u8C37\u8C46\u8C55\u8C9D\u8D64\u8D70\u8DB3\u8EAB\u8ECA\u8F9B\u8FB0\u8FC2\u8FC6\u8FC5\u8FC4\u5DE1\u9091\u90A2\u90AA\u90A6\u90A3\u9149\u91C6\u91CC\u9632\u962E\u9631\u962A\u962C\u4E26\u4E56\u4E73\u4E8B\u4E9B\u4E9E\u4EAB\u4EAC\u4F6F\u4F9D\u4F8D\u4F73\u4F7F\u4F6C\u4F9B\u4F8B\u4F86\u4F83\u4F70\u4F75\u4F88\u4F69\u4F7B\u4F96\u4F7E\u4F8F\u4F91\u4F7A\u5154\u5152\u5155\u5169\u5177\u5176\u5178\u51BD\u51FD\u523B\u5238\u5237\u523A\u5230\u522E\u5236\u5241\u52BE\u52BB\u5352\u5354\u5353\u5351\u5366\u5377\u5378\u5379\u53D6\u53D4\u53D7\u5473\u5475"],
      ["a940", "\u5496\u5478\u5495\u5480\u547B\u5477\u5484\u5492\u5486\u547C\u5490\u5471\u5476\u548C\u549A\u5462\u5468\u548B\u547D\u548E\u56FA\u5783\u5777\u576A\u5769\u5761\u5766\u5764\u577C\u591C\u5949\u5947\u5948\u5944\u5954\u59BE\u59BB\u59D4\u59B9\u59AE\u59D1\u59C6\u59D0\u59CD\u59CB\u59D3\u59CA\u59AF\u59B3\u59D2\u59C5\u5B5F\u5B64\u5B63\u5B97\u5B9A\u5B98\u5B9C\u5B99\u5B9B\u5C1A\u5C48\u5C45"],
      ["a9a1", "\u5C46\u5CB7\u5CA1\u5CB8\u5CA9\u5CAB\u5CB1\u5CB3\u5E18\u5E1A\u5E16\u5E15\u5E1B\u5E11\u5E78\u5E9A\u5E97\u5E9C\u5E95\u5E96\u5EF6\u5F26\u5F27\u5F29\u5F80\u5F81\u5F7F\u5F7C\u5FDD\u5FE0\u5FFD\u5FF5\u5FFF\u600F\u6014\u602F\u6035\u6016\u602A\u6015\u6021\u6027\u6029\u602B\u601B\u6216\u6215\u623F\u623E\u6240\u627F\u62C9\u62CC\u62C4\u62BF\u62C2\u62B9\u62D2\u62DB\u62AB\u62D3\u62D4\u62CB\u62C8\u62A8\u62BD\u62BC\u62D0\u62D9\u62C7\u62CD\u62B5\u62DA\u62B1\u62D8\u62D6\u62D7\u62C6\u62AC\u62CE\u653E\u65A7\u65BC\u65FA\u6614\u6613\u660C\u6606\u6602\u660E\u6600\u660F\u6615\u660A"],
      ["aa40", "\u6607\u670D\u670B\u676D\u678B\u6795\u6771\u679C\u6773\u6777\u6787\u679D\u6797\u676F\u6770\u677F\u6789\u677E\u6790\u6775\u679A\u6793\u677C\u676A\u6772\u6B23\u6B66\u6B67\u6B7F\u6C13\u6C1B\u6CE3\u6CE8\u6CF3\u6CB1\u6CCC\u6CE5\u6CB3\u6CBD\u6CBE\u6CBC\u6CE2\u6CAB\u6CD5\u6CD3\u6CB8\u6CC4\u6CB9\u6CC1\u6CAE\u6CD7\u6CC5\u6CF1\u6CBF\u6CBB\u6CE1\u6CDB\u6CCA\u6CAC\u6CEF\u6CDC\u6CD6\u6CE0"],
      ["aaa1", "\u7095\u708E\u7092\u708A\u7099\u722C\u722D\u7238\u7248\u7267\u7269\u72C0\u72CE\u72D9\u72D7\u72D0\u73A9\u73A8\u739F\u73AB\u73A5\u753D\u759D\u7599\u759A\u7684\u76C2\u76F2\u76F4\u77E5\u77FD\u793E\u7940\u7941\u79C9\u79C8\u7A7A\u7A79\u7AFA\u7CFE\u7F54\u7F8C\u7F8B\u8005\u80BA\u80A5\u80A2\u80B1\u80A1\u80AB\u80A9\u80B4\u80AA\u80AF\u81E5\u81FE\u820D\u82B3\u829D\u8299\u82AD\u82BD\u829F\u82B9\u82B1\u82AC\u82A5\u82AF\u82B8\u82A3\u82B0\u82BE\u82B7\u864E\u8671\u521D\u8868\u8ECB\u8FCE\u8FD4\u8FD1\u90B5\u90B8\u90B1\u90B6\u91C7\u91D1\u9577\u9580\u961C\u9640\u963F\u963B\u9644"],
      ["ab40", "\u9642\u96B9\u96E8\u9752\u975E\u4E9F\u4EAD\u4EAE\u4FE1\u4FB5\u4FAF\u4FBF\u4FE0\u4FD1\u4FCF\u4FDD\u4FC3\u4FB6\u4FD8\u4FDF\u4FCA\u4FD7\u4FAE\u4FD0\u4FC4\u4FC2\u4FDA\u4FCE\u4FDE\u4FB7\u5157\u5192\u5191\u51A0\u524E\u5243\u524A\u524D\u524C\u524B\u5247\u52C7\u52C9\u52C3\u52C1\u530D\u5357\u537B\u539A\u53DB\u54AC\u54C0\u54A8\u54CE\u54C9\u54B8\u54A6\u54B3\u54C7\u54C2\u54BD\u54AA\u54C1"],
      ["aba1", "\u54C4\u54C8\u54AF\u54AB\u54B1\u54BB\u54A9\u54A7\u54BF\u56FF\u5782\u578B\u57A0\u57A3\u57A2\u57CE\u57AE\u5793\u5955\u5951\u594F\u594E\u5950\u59DC\u59D8\u59FF\u59E3\u59E8\u5A03\u59E5\u59EA\u59DA\u59E6\u5A01\u59FB\u5B69\u5BA3\u5BA6\u5BA4\u5BA2\u5BA5\u5C01\u5C4E\u5C4F\u5C4D\u5C4B\u5CD9\u5CD2\u5DF7\u5E1D\u5E25\u5E1F\u5E7D\u5EA0\u5EA6\u5EFA\u5F08\u5F2D\u5F65\u5F88\u5F85\u5F8A\u5F8B\u5F87\u5F8C\u5F89\u6012\u601D\u6020\u6025\u600E\u6028\u604D\u6070\u6068\u6062\u6046\u6043\u606C\u606B\u606A\u6064\u6241\u62DC\u6316\u6309\u62FC\u62ED\u6301\u62EE\u62FD\u6307\u62F1\u62F7"],
      ["ac40", "\u62EF\u62EC\u62FE\u62F4\u6311\u6302\u653F\u6545\u65AB\u65BD\u65E2\u6625\u662D\u6620\u6627\u662F\u661F\u6628\u6631\u6624\u66F7\u67FF\u67D3\u67F1\u67D4\u67D0\u67EC\u67B6\u67AF\u67F5\u67E9\u67EF\u67C4\u67D1\u67B4\u67DA\u67E5\u67B8\u67CF\u67DE\u67F3\u67B0\u67D9\u67E2\u67DD\u67D2\u6B6A\u6B83\u6B86\u6BB5\u6BD2\u6BD7\u6C1F\u6CC9\u6D0B\u6D32\u6D2A\u6D41\u6D25\u6D0C\u6D31\u6D1E\u6D17"],
      ["aca1", "\u6D3B\u6D3D\u6D3E\u6D36\u6D1B\u6CF5\u6D39\u6D27\u6D38\u6D29\u6D2E\u6D35\u6D0E\u6D2B\u70AB\u70BA\u70B3\u70AC\u70AF\u70AD\u70B8\u70AE\u70A4\u7230\u7272\u726F\u7274\u72E9\u72E0\u72E1\u73B7\u73CA\u73BB\u73B2\u73CD\u73C0\u73B3\u751A\u752D\u754F\u754C\u754E\u754B\u75AB\u75A4\u75A5\u75A2\u75A3\u7678\u7686\u7687\u7688\u76C8\u76C6\u76C3\u76C5\u7701\u76F9\u76F8\u7709\u770B\u76FE\u76FC\u7707\u77DC\u7802\u7814\u780C\u780D\u7946\u7949\u7948\u7947\u79B9\u79BA\u79D1\u79D2\u79CB\u7A7F\u7A81\u7AFF\u7AFD\u7C7D\u7D02\u7D05\u7D00\u7D09\u7D07\u7D04\u7D06\u7F38\u7F8E\u7FBF\u8004"],
      ["ad40", "\u8010\u800D\u8011\u8036\u80D6\u80E5\u80DA\u80C3\u80C4\u80CC\u80E1\u80DB\u80CE\u80DE\u80E4\u80DD\u81F4\u8222\u82E7\u8303\u8305\u82E3\u82DB\u82E6\u8304\u82E5\u8302\u8309\u82D2\u82D7\u82F1\u8301\u82DC\u82D4\u82D1\u82DE\u82D3\u82DF\u82EF\u8306\u8650\u8679\u867B\u867A\u884D\u886B\u8981\u89D4\u8A08\u8A02\u8A03\u8C9E\u8CA0\u8D74\u8D73\u8DB4\u8ECD\u8ECC\u8FF0\u8FE6\u8FE2\u8FEA\u8FE5"],
      ["ada1", "\u8FED\u8FEB\u8FE4\u8FE8\u90CA\u90CE\u90C1\u90C3\u914B\u914A\u91CD\u9582\u9650\u964B\u964C\u964D\u9762\u9769\u97CB\u97ED\u97F3\u9801\u98A8\u98DB\u98DF\u9996\u9999\u4E58\u4EB3\u500C\u500D\u5023\u4FEF\u5026\u5025\u4FF8\u5029\u5016\u5006\u503C\u501F\u501A\u5012\u5011\u4FFA\u5000\u5014\u5028\u4FF1\u5021\u500B\u5019\u5018\u4FF3\u4FEE\u502D\u502A\u4FFE\u502B\u5009\u517C\u51A4\u51A5\u51A2\u51CD\u51CC\u51C6\u51CB\u5256\u525C\u5254\u525B\u525D\u532A\u537F\u539F\u539D\u53DF\u54E8\u5510\u5501\u5537\u54FC\u54E5\u54F2\u5506\u54FA\u5514\u54E9\u54ED\u54E1\u5509\u54EE\u54EA"],
      ["ae40", "\u54E6\u5527\u5507\u54FD\u550F\u5703\u5704\u57C2\u57D4\u57CB\u57C3\u5809\u590F\u5957\u5958\u595A\u5A11\u5A18\u5A1C\u5A1F\u5A1B\u5A13\u59EC\u5A20\u5A23\u5A29\u5A25\u5A0C\u5A09\u5B6B\u5C58\u5BB0\u5BB3\u5BB6\u5BB4\u5BAE\u5BB5\u5BB9\u5BB8\u5C04\u5C51\u5C55\u5C50\u5CED\u5CFD\u5CFB\u5CEA\u5CE8\u5CF0\u5CF6\u5D01\u5CF4\u5DEE\u5E2D\u5E2B\u5EAB\u5EAD\u5EA7\u5F31\u5F92\u5F91\u5F90\u6059"],
      ["aea1", "\u6063\u6065\u6050\u6055\u606D\u6069\u606F\u6084\u609F\u609A\u608D\u6094\u608C\u6085\u6096\u6247\u62F3\u6308\u62FF\u634E\u633E\u632F\u6355\u6342\u6346\u634F\u6349\u633A\u6350\u633D\u632A\u632B\u6328\u634D\u634C\u6548\u6549\u6599\u65C1\u65C5\u6642\u6649\u664F\u6643\u6652\u664C\u6645\u6641\u66F8\u6714\u6715\u6717\u6821\u6838\u6848\u6846\u6853\u6839\u6842\u6854\u6829\u68B3\u6817\u684C\u6851\u683D\u67F4\u6850\u6840\u683C\u6843\u682A\u6845\u6813\u6818\u6841\u6B8A\u6B89\u6BB7\u6C23\u6C27\u6C28\u6C26\u6C24\u6CF0\u6D6A\u6D95\u6D88\u6D87\u6D66\u6D78\u6D77\u6D59\u6D93"],
      ["af40", "\u6D6C\u6D89\u6D6E\u6D5A\u6D74\u6D69\u6D8C\u6D8A\u6D79\u6D85\u6D65\u6D94\u70CA\u70D8\u70E4\u70D9\u70C8\u70CF\u7239\u7279\u72FC\u72F9\u72FD\u72F8\u72F7\u7386\u73ED\u7409\u73EE\u73E0\u73EA\u73DE\u7554\u755D\u755C\u755A\u7559\u75BE\u75C5\u75C7\u75B2\u75B3\u75BD\u75BC\u75B9\u75C2\u75B8\u768B\u76B0\u76CA\u76CD\u76CE\u7729\u771F\u7720\u7728\u77E9\u7830\u7827\u7838\u781D\u7834\u7837"],
      ["afa1", "\u7825\u782D\u7820\u781F\u7832\u7955\u7950\u7960\u795F\u7956\u795E\u795D\u7957\u795A\u79E4\u79E3\u79E7\u79DF\u79E6\u79E9\u79D8\u7A84\u7A88\u7AD9\u7B06\u7B11\u7C89\u7D21\u7D17\u7D0B\u7D0A\u7D20\u7D22\u7D14\u7D10\u7D15\u7D1A\u7D1C\u7D0D\u7D19\u7D1B\u7F3A\u7F5F\u7F94\u7FC5\u7FC1\u8006\u8018\u8015\u8019\u8017\u803D\u803F\u80F1\u8102\u80F0\u8105\u80ED\u80F4\u8106\u80F8\u80F3\u8108\u80FD\u810A\u80FC\u80EF\u81ED\u81EC\u8200\u8210\u822A\u822B\u8228\u822C\u82BB\u832B\u8352\u8354\u834A\u8338\u8350\u8349\u8335\u8334\u834F\u8332\u8339\u8336\u8317\u8340\u8331\u8328\u8343"],
      ["b040", "\u8654\u868A\u86AA\u8693\u86A4\u86A9\u868C\u86A3\u869C\u8870\u8877\u8881\u8882\u887D\u8879\u8A18\u8A10\u8A0E\u8A0C\u8A15\u8A0A\u8A17\u8A13\u8A16\u8A0F\u8A11\u8C48\u8C7A\u8C79\u8CA1\u8CA2\u8D77\u8EAC\u8ED2\u8ED4\u8ECF\u8FB1\u9001\u9006\u8FF7\u9000\u8FFA\u8FF4\u9003\u8FFD\u9005\u8FF8\u9095\u90E1\u90DD\u90E2\u9152\u914D\u914C\u91D8\u91DD\u91D7\u91DC\u91D9\u9583\u9662\u9663\u9661"],
      ["b0a1", "\u965B\u965D\u9664\u9658\u965E\u96BB\u98E2\u99AC\u9AA8\u9AD8\u9B25\u9B32\u9B3C\u4E7E\u507A\u507D\u505C\u5047\u5043\u504C\u505A\u5049\u5065\u5076\u504E\u5055\u5075\u5074\u5077\u504F\u500F\u506F\u506D\u515C\u5195\u51F0\u526A\u526F\u52D2\u52D9\u52D8\u52D5\u5310\u530F\u5319\u533F\u5340\u533E\u53C3\u66FC\u5546\u556A\u5566\u5544\u555E\u5561\u5543\u554A\u5531\u5556\u554F\u5555\u552F\u5564\u5538\u552E\u555C\u552C\u5563\u5533\u5541\u5557\u5708\u570B\u5709\u57DF\u5805\u580A\u5806\u57E0\u57E4\u57FA\u5802\u5835\u57F7\u57F9\u5920\u5962\u5A36\u5A41\u5A49\u5A66\u5A6A\u5A40"],
      ["b140", "\u5A3C\u5A62\u5A5A\u5A46\u5A4A\u5B70\u5BC7\u5BC5\u5BC4\u5BC2\u5BBF\u5BC6\u5C09\u5C08\u5C07\u5C60\u5C5C\u5C5D\u5D07\u5D06\u5D0E\u5D1B\u5D16\u5D22\u5D11\u5D29\u5D14\u5D19\u5D24\u5D27\u5D17\u5DE2\u5E38\u5E36\u5E33\u5E37\u5EB7\u5EB8\u5EB6\u5EB5\u5EBE\u5F35\u5F37\u5F57\u5F6C\u5F69\u5F6B\u5F97\u5F99\u5F9E\u5F98\u5FA1\u5FA0\u5F9C\u607F\u60A3\u6089\u60A0\u60A8\u60CB\u60B4\u60E6\u60BD"],
      ["b1a1", "\u60C5\u60BB\u60B5\u60DC\u60BC\u60D8\u60D5\u60C6\u60DF\u60B8\u60DA\u60C7\u621A\u621B\u6248\u63A0\u63A7\u6372\u6396\u63A2\u63A5\u6377\u6367\u6398\u63AA\u6371\u63A9\u6389\u6383\u639B\u636B\u63A8\u6384\u6388\u6399\u63A1\u63AC\u6392\u638F\u6380\u637B\u6369\u6368\u637A\u655D\u6556\u6551\u6559\u6557\u555F\u654F\u6558\u6555\u6554\u659C\u659B\u65AC\u65CF\u65CB\u65CC\u65CE\u665D\u665A\u6664\u6668\u6666\u665E\u66F9\u52D7\u671B\u6881\u68AF\u68A2\u6893\u68B5\u687F\u6876\u68B1\u68A7\u6897\u68B0\u6883\u68C4\u68AD\u6886\u6885\u6894\u689D\u68A8\u689F\u68A1\u6882\u6B32\u6BBA"],
      ["b240", "\u6BEB\u6BEC\u6C2B\u6D8E\u6DBC\u6DF3\u6DD9\u6DB2\u6DE1\u6DCC\u6DE4\u6DFB\u6DFA\u6E05\u6DC7\u6DCB\u6DAF\u6DD1\u6DAE\u6DDE\u6DF9\u6DB8\u6DF7\u6DF5\u6DC5\u6DD2\u6E1A\u6DB5\u6DDA\u6DEB\u6DD8\u6DEA\u6DF1\u6DEE\u6DE8\u6DC6\u6DC4\u6DAA\u6DEC\u6DBF\u6DE6\u70F9\u7109\u710A\u70FD\u70EF\u723D\u727D\u7281\u731C\u731B\u7316\u7313\u7319\u7387\u7405\u740A\u7403\u7406\u73FE\u740D\u74E0\u74F6"],
      ["b2a1", "\u74F7\u751C\u7522\u7565\u7566\u7562\u7570\u758F\u75D4\u75D5\u75B5\u75CA\u75CD\u768E\u76D4\u76D2\u76DB\u7737\u773E\u773C\u7736\u7738\u773A\u786B\u7843\u784E\u7965\u7968\u796D\u79FB\u7A92\u7A95\u7B20\u7B28\u7B1B\u7B2C\u7B26\u7B19\u7B1E\u7B2E\u7C92\u7C97\u7C95\u7D46\u7D43\u7D71\u7D2E\u7D39\u7D3C\u7D40\u7D30\u7D33\u7D44\u7D2F\u7D42\u7D32\u7D31\u7F3D\u7F9E\u7F9A\u7FCC\u7FCE\u7FD2\u801C\u804A\u8046\u812F\u8116\u8123\u812B\u8129\u8130\u8124\u8202\u8235\u8237\u8236\u8239\u838E\u839E\u8398\u8378\u83A2\u8396\u83BD\u83AB\u8392\u838A\u8393\u8389\u83A0\u8377\u837B\u837C"],
      ["b340", "\u8386\u83A7\u8655\u5F6A\u86C7\u86C0\u86B6\u86C4\u86B5\u86C6\u86CB\u86B1\u86AF\u86C9\u8853\u889E\u8888\u88AB\u8892\u8896\u888D\u888B\u8993\u898F\u8A2A\u8A1D\u8A23\u8A25\u8A31\u8A2D\u8A1F\u8A1B\u8A22\u8C49\u8C5A\u8CA9\u8CAC\u8CAB\u8CA8\u8CAA\u8CA7\u8D67\u8D66\u8DBE\u8DBA\u8EDB\u8EDF\u9019\u900D\u901A\u9017\u9023\u901F\u901D\u9010\u9015\u901E\u9020\u900F\u9022\u9016\u901B\u9014"],
      ["b3a1", "\u90E8\u90ED\u90FD\u9157\u91CE\u91F5\u91E6\u91E3\u91E7\u91ED\u91E9\u9589\u966A\u9675\u9673\u9678\u9670\u9674\u9676\u9677\u966C\u96C0\u96EA\u96E9\u7AE0\u7ADF\u9802\u9803\u9B5A\u9CE5\u9E75\u9E7F\u9EA5\u9EBB\u50A2\u508D\u5085\u5099\u5091\u5080\u5096\u5098\u509A\u6700\u51F1\u5272\u5274\u5275\u5269\u52DE\u52DD\u52DB\u535A\u53A5\u557B\u5580\u55A7\u557C\u558A\u559D\u5598\u5582\u559C\u55AA\u5594\u5587\u558B\u5583\u55B3\u55AE\u559F\u553E\u55B2\u559A\u55BB\u55AC\u55B1\u557E\u5589\u55AB\u5599\u570D\u582F\u582A\u5834\u5824\u5830\u5831\u5821\u581D\u5820\u58F9\u58FA\u5960"],
      ["b440", "\u5A77\u5A9A\u5A7F\u5A92\u5A9B\u5AA7\u5B73\u5B71\u5BD2\u5BCC\u5BD3\u5BD0\u5C0A\u5C0B\u5C31\u5D4C\u5D50\u5D34\u5D47\u5DFD\u5E45\u5E3D\u5E40\u5E43\u5E7E\u5ECA\u5EC1\u5EC2\u5EC4\u5F3C\u5F6D\u5FA9\u5FAA\u5FA8\u60D1\u60E1\u60B2\u60B6\u60E0\u611C\u6123\u60FA\u6115\u60F0\u60FB\u60F4\u6168\u60F1\u610E\u60F6\u6109\u6100\u6112\u621F\u6249\u63A3\u638C\u63CF\u63C0\u63E9\u63C9\u63C6\u63CD"],
      ["b4a1", "\u63D2\u63E3\u63D0\u63E1\u63D6\u63ED\u63EE\u6376\u63F4\u63EA\u63DB\u6452\u63DA\u63F9\u655E\u6566\u6562\u6563\u6591\u6590\u65AF\u666E\u6670\u6674\u6676\u666F\u6691\u667A\u667E\u6677\u66FE\u66FF\u671F\u671D\u68FA\u68D5\u68E0\u68D8\u68D7\u6905\u68DF\u68F5\u68EE\u68E7\u68F9\u68D2\u68F2\u68E3\u68CB\u68CD\u690D\u6912\u690E\u68C9\u68DA\u696E\u68FB\u6B3E\u6B3A\u6B3D\u6B98\u6B96\u6BBC\u6BEF\u6C2E\u6C2F\u6C2C\u6E2F\u6E38\u6E54\u6E21\u6E32\u6E67\u6E4A\u6E20\u6E25\u6E23\u6E1B\u6E5B\u6E58\u6E24\u6E56\u6E6E\u6E2D\u6E26\u6E6F\u6E34\u6E4D\u6E3A\u6E2C\u6E43\u6E1D\u6E3E\u6ECB"],
      ["b540", "\u6E89\u6E19\u6E4E\u6E63\u6E44\u6E72\u6E69\u6E5F\u7119\u711A\u7126\u7130\u7121\u7136\u716E\u711C\u724C\u7284\u7280\u7336\u7325\u7334\u7329\u743A\u742A\u7433\u7422\u7425\u7435\u7436\u7434\u742F\u741B\u7426\u7428\u7525\u7526\u756B\u756A\u75E2\u75DB\u75E3\u75D9\u75D8\u75DE\u75E0\u767B\u767C\u7696\u7693\u76B4\u76DC\u774F\u77ED\u785D\u786C\u786F\u7A0D\u7A08\u7A0B\u7A05\u7A00\u7A98"],
      ["b5a1", "\u7A97\u7A96\u7AE5\u7AE3\u7B49\u7B56\u7B46\u7B50\u7B52\u7B54\u7B4D\u7B4B\u7B4F\u7B51\u7C9F\u7CA5\u7D5E\u7D50\u7D68\u7D55\u7D2B\u7D6E\u7D72\u7D61\u7D66\u7D62\u7D70\u7D73\u5584\u7FD4\u7FD5\u800B\u8052\u8085\u8155\u8154\u814B\u8151\u814E\u8139\u8146\u813E\u814C\u8153\u8174\u8212\u821C\u83E9\u8403\u83F8\u840D\u83E0\u83C5\u840B\u83C1\u83EF\u83F1\u83F4\u8457\u840A\u83F0\u840C\u83CC\u83FD\u83F2\u83CA\u8438\u840E\u8404\u83DC\u8407\u83D4\u83DF\u865B\u86DF\u86D9\u86ED\u86D4\u86DB\u86E4\u86D0\u86DE\u8857\u88C1\u88C2\u88B1\u8983\u8996\u8A3B\u8A60\u8A55\u8A5E\u8A3C\u8A41"],
      ["b640", "\u8A54\u8A5B\u8A50\u8A46\u8A34\u8A3A\u8A36\u8A56\u8C61\u8C82\u8CAF\u8CBC\u8CB3\u8CBD\u8CC1\u8CBB\u8CC0\u8CB4\u8CB7\u8CB6\u8CBF\u8CB8\u8D8A\u8D85\u8D81\u8DCE\u8DDD\u8DCB\u8DDA\u8DD1\u8DCC\u8DDB\u8DC6\u8EFB\u8EF8\u8EFC\u8F9C\u902E\u9035\u9031\u9038\u9032\u9036\u9102\u90F5\u9109\u90FE\u9163\u9165\u91CF\u9214\u9215\u9223\u9209\u921E\u920D\u9210\u9207\u9211\u9594\u958F\u958B\u9591"],
      ["b6a1", "\u9593\u9592\u958E\u968A\u968E\u968B\u967D\u9685\u9686\u968D\u9672\u9684\u96C1\u96C5\u96C4\u96C6\u96C7\u96EF\u96F2\u97CC\u9805\u9806\u9808\u98E7\u98EA\u98EF\u98E9\u98F2\u98ED\u99AE\u99AD\u9EC3\u9ECD\u9ED1\u4E82\u50AD\u50B5\u50B2\u50B3\u50C5\u50BE\u50AC\u50B7\u50BB\u50AF\u50C7\u527F\u5277\u527D\u52DF\u52E6\u52E4\u52E2\u52E3\u532F\u55DF\u55E8\u55D3\u55E6\u55CE\u55DC\u55C7\u55D1\u55E3\u55E4\u55EF\u55DA\u55E1\u55C5\u55C6\u55E5\u55C9\u5712\u5713\u585E\u5851\u5858\u5857\u585A\u5854\u586B\u584C\u586D\u584A\u5862\u5852\u584B\u5967\u5AC1\u5AC9\u5ACC\u5ABE\u5ABD\u5ABC"],
      ["b740", "\u5AB3\u5AC2\u5AB2\u5D69\u5D6F\u5E4C\u5E79\u5EC9\u5EC8\u5F12\u5F59\u5FAC\u5FAE\u611A\u610F\u6148\u611F\u60F3\u611B\u60F9\u6101\u6108\u614E\u614C\u6144\u614D\u613E\u6134\u6127\u610D\u6106\u6137\u6221\u6222\u6413\u643E\u641E\u642A\u642D\u643D\u642C\u640F\u641C\u6414\u640D\u6436\u6416\u6417\u6406\u656C\u659F\u65B0\u6697\u6689\u6687\u6688\u6696\u6684\u6698\u668D\u6703\u6994\u696D"],
      ["b7a1", "\u695A\u6977\u6960\u6954\u6975\u6930\u6982\u694A\u6968\u696B\u695E\u6953\u6979\u6986\u695D\u6963\u695B\u6B47\u6B72\u6BC0\u6BBF\u6BD3\u6BFD\u6EA2\u6EAF\u6ED3\u6EB6\u6EC2\u6E90\u6E9D\u6EC7\u6EC5\u6EA5\u6E98\u6EBC\u6EBA\u6EAB\u6ED1\u6E96\u6E9C\u6EC4\u6ED4\u6EAA\u6EA7\u6EB4\u714E\u7159\u7169\u7164\u7149\u7167\u715C\u716C\u7166\u714C\u7165\u715E\u7146\u7168\u7156\u723A\u7252\u7337\u7345\u733F\u733E\u746F\u745A\u7455\u745F\u745E\u7441\u743F\u7459\u745B\u745C\u7576\u7578\u7600\u75F0\u7601\u75F2\u75F1\u75FA\u75FF\u75F4\u75F3\u76DE\u76DF\u775B\u776B\u7766\u775E\u7763"],
      ["b840", "\u7779\u776A\u776C\u775C\u7765\u7768\u7762\u77EE\u788E\u78B0\u7897\u7898\u788C\u7889\u787C\u7891\u7893\u787F\u797A\u797F\u7981\u842C\u79BD\u7A1C\u7A1A\u7A20\u7A14\u7A1F\u7A1E\u7A9F\u7AA0\u7B77\u7BC0\u7B60\u7B6E\u7B67\u7CB1\u7CB3\u7CB5\u7D93\u7D79\u7D91\u7D81\u7D8F\u7D5B\u7F6E\u7F69\u7F6A\u7F72\u7FA9\u7FA8\u7FA4\u8056\u8058\u8086\u8084\u8171\u8170\u8178\u8165\u816E\u8173\u816B"],
      ["b8a1", "\u8179\u817A\u8166\u8205\u8247\u8482\u8477\u843D\u8431\u8475\u8466\u846B\u8449\u846C\u845B\u843C\u8435\u8461\u8463\u8469\u846D\u8446\u865E\u865C\u865F\u86F9\u8713\u8708\u8707\u8700\u86FE\u86FB\u8702\u8703\u8706\u870A\u8859\u88DF\u88D4\u88D9\u88DC\u88D8\u88DD\u88E1\u88CA\u88D5\u88D2\u899C\u89E3\u8A6B\u8A72\u8A73\u8A66\u8A69\u8A70\u8A87\u8A7C\u8A63\u8AA0\u8A71\u8A85\u8A6D\u8A62\u8A6E\u8A6C\u8A79\u8A7B\u8A3E\u8A68\u8C62\u8C8A\u8C89\u8CCA\u8CC7\u8CC8\u8CC4\u8CB2\u8CC3\u8CC2\u8CC5\u8DE1\u8DDF\u8DE8\u8DEF\u8DF3\u8DFA\u8DEA\u8DE4\u8DE6\u8EB2\u8F03\u8F09\u8EFE\u8F0A"],
      ["b940", "\u8F9F\u8FB2\u904B\u904A\u9053\u9042\u9054\u903C\u9055\u9050\u9047\u904F\u904E\u904D\u9051\u903E\u9041\u9112\u9117\u916C\u916A\u9169\u91C9\u9237\u9257\u9238\u923D\u9240\u923E\u925B\u924B\u9264\u9251\u9234\u9249\u924D\u9245\u9239\u923F\u925A\u9598\u9698\u9694\u9695\u96CD\u96CB\u96C9\u96CA\u96F7\u96FB\u96F9\u96F6\u9756\u9774\u9776\u9810\u9811\u9813\u980A\u9812\u980C\u98FC\u98F4"],
      ["b9a1", "\u98FD\u98FE\u99B3\u99B1\u99B4\u9AE1\u9CE9\u9E82\u9F0E\u9F13\u9F20\u50E7\u50EE\u50E5\u50D6\u50ED\u50DA\u50D5\u50CF\u50D1\u50F1\u50CE\u50E9\u5162\u51F3\u5283\u5282\u5331\u53AD\u55FE\u5600\u561B\u5617\u55FD\u5614\u5606\u5609\u560D\u560E\u55F7\u5616\u561F\u5608\u5610\u55F6\u5718\u5716\u5875\u587E\u5883\u5893\u588A\u5879\u5885\u587D\u58FD\u5925\u5922\u5924\u596A\u5969\u5AE1\u5AE6\u5AE9\u5AD7\u5AD6\u5AD8\u5AE3\u5B75\u5BDE\u5BE7\u5BE1\u5BE5\u5BE6\u5BE8\u5BE2\u5BE4\u5BDF\u5C0D\u5C62\u5D84\u5D87\u5E5B\u5E63\u5E55\u5E57\u5E54\u5ED3\u5ED6\u5F0A\u5F46\u5F70\u5FB9\u6147"],
      ["ba40", "\u613F\u614B\u6177\u6162\u6163\u615F\u615A\u6158\u6175\u622A\u6487\u6458\u6454\u64A4\u6478\u645F\u647A\u6451\u6467\u6434\u646D\u647B\u6572\u65A1\u65D7\u65D6\u66A2\u66A8\u669D\u699C\u69A8\u6995\u69C1\u69AE\u69D3\u69CB\u699B\u69B7\u69BB\u69AB\u69B4\u69D0\u69CD\u69AD\u69CC\u69A6\u69C3\u69A3\u6B49\u6B4C\u6C33\u6F33\u6F14\u6EFE\u6F13\u6EF4\u6F29\u6F3E\u6F20\u6F2C\u6F0F\u6F02\u6F22"],
      ["baa1", "\u6EFF\u6EEF\u6F06\u6F31\u6F38\u6F32\u6F23\u6F15\u6F2B\u6F2F\u6F88\u6F2A\u6EEC\u6F01\u6EF2\u6ECC\u6EF7\u7194\u7199\u717D\u718A\u7184\u7192\u723E\u7292\u7296\u7344\u7350\u7464\u7463\u746A\u7470\u746D\u7504\u7591\u7627\u760D\u760B\u7609\u7613\u76E1\u76E3\u7784\u777D\u777F\u7761\u78C1\u789F\u78A7\u78B3\u78A9\u78A3\u798E\u798F\u798D\u7A2E\u7A31\u7AAA\u7AA9\u7AED\u7AEF\u7BA1\u7B95\u7B8B\u7B75\u7B97\u7B9D\u7B94\u7B8F\u7BB8\u7B87\u7B84\u7CB9\u7CBD\u7CBE\u7DBB\u7DB0\u7D9C\u7DBD\u7DBE\u7DA0\u7DCA\u7DB4\u7DB2\u7DB1\u7DBA\u7DA2\u7DBF\u7DB5\u7DB8\u7DAD\u7DD2\u7DC7\u7DAC"],
      ["bb40", "\u7F70\u7FE0\u7FE1\u7FDF\u805E\u805A\u8087\u8150\u8180\u818F\u8188\u818A\u817F\u8182\u81E7\u81FA\u8207\u8214\u821E\u824B\u84C9\u84BF\u84C6\u84C4\u8499\u849E\u84B2\u849C\u84CB\u84B8\u84C0\u84D3\u8490\u84BC\u84D1\u84CA\u873F\u871C\u873B\u8722\u8725\u8734\u8718\u8755\u8737\u8729\u88F3\u8902\u88F4\u88F9\u88F8\u88FD\u88E8\u891A\u88EF\u8AA6\u8A8C\u8A9E\u8AA3\u8A8D\u8AA1\u8A93\u8AA4"],
      ["bba1", "\u8AAA\u8AA5\u8AA8\u8A98\u8A91\u8A9A\u8AA7\u8C6A\u8C8D\u8C8C\u8CD3\u8CD1\u8CD2\u8D6B\u8D99\u8D95\u8DFC\u8F14\u8F12\u8F15\u8F13\u8FA3\u9060\u9058\u905C\u9063\u9059\u905E\u9062\u905D\u905B\u9119\u9118\u911E\u9175\u9178\u9177\u9174\u9278\u9280\u9285\u9298\u9296\u927B\u9293\u929C\u92A8\u927C\u9291\u95A1\u95A8\u95A9\u95A3\u95A5\u95A4\u9699\u969C\u969B\u96CC\u96D2\u9700\u977C\u9785\u97F6\u9817\u9818\u98AF\u98B1\u9903\u9905\u990C\u9909\u99C1\u9AAF\u9AB0\u9AE6\u9B41\u9B42\u9CF4\u9CF6\u9CF3\u9EBC\u9F3B\u9F4A\u5104\u5100\u50FB\u50F5\u50F9\u5102\u5108\u5109\u5105\u51DC"],
      ["bc40", "\u5287\u5288\u5289\u528D\u528A\u52F0\u53B2\u562E\u563B\u5639\u5632\u563F\u5634\u5629\u5653\u564E\u5657\u5674\u5636\u562F\u5630\u5880\u589F\u589E\u58B3\u589C\u58AE\u58A9\u58A6\u596D\u5B09\u5AFB\u5B0B\u5AF5\u5B0C\u5B08\u5BEE\u5BEC\u5BE9\u5BEB\u5C64\u5C65\u5D9D\u5D94\u5E62\u5E5F\u5E61\u5EE2\u5EDA\u5EDF\u5EDD\u5EE3\u5EE0\u5F48\u5F71\u5FB7\u5FB5\u6176\u6167\u616E\u615D\u6155\u6182"],
      ["bca1", "\u617C\u6170\u616B\u617E\u61A7\u6190\u61AB\u618E\u61AC\u619A\u61A4\u6194\u61AE\u622E\u6469\u646F\u6479\u649E\u64B2\u6488\u6490\u64B0\u64A5\u6493\u6495\u64A9\u6492\u64AE\u64AD\u64AB\u649A\u64AC\u6499\u64A2\u64B3\u6575\u6577\u6578\u66AE\u66AB\u66B4\u66B1\u6A23\u6A1F\u69E8\u6A01\u6A1E\u6A19\u69FD\u6A21\u6A13\u6A0A\u69F3\u6A02\u6A05\u69ED\u6A11\u6B50\u6B4E\u6BA4\u6BC5\u6BC6\u6F3F\u6F7C\u6F84\u6F51\u6F66\u6F54\u6F86\u6F6D\u6F5B\u6F78\u6F6E\u6F8E\u6F7A\u6F70\u6F64\u6F97\u6F58\u6ED5\u6F6F\u6F60\u6F5F\u719F\u71AC\u71B1\u71A8\u7256\u729B\u734E\u7357\u7469\u748B\u7483"],
      ["bd40", "\u747E\u7480\u757F\u7620\u7629\u761F\u7624\u7626\u7621\u7622\u769A\u76BA\u76E4\u778E\u7787\u778C\u7791\u778B\u78CB\u78C5\u78BA\u78CA\u78BE\u78D5\u78BC\u78D0\u7A3F\u7A3C\u7A40\u7A3D\u7A37\u7A3B\u7AAF\u7AAE\u7BAD\u7BB1\u7BC4\u7BB4\u7BC6\u7BC7\u7BC1\u7BA0\u7BCC\u7CCA\u7DE0\u7DF4\u7DEF\u7DFB\u7DD8\u7DEC\u7DDD\u7DE8\u7DE3\u7DDA\u7DDE\u7DE9\u7D9E\u7DD9\u7DF2\u7DF9\u7F75\u7F77\u7FAF"],
      ["bda1", "\u7FE9\u8026\u819B\u819C\u819D\u81A0\u819A\u8198\u8517\u853D\u851A\u84EE\u852C\u852D\u8513\u8511\u8523\u8521\u8514\u84EC\u8525\u84FF\u8506\u8782\u8774\u8776\u8760\u8766\u8778\u8768\u8759\u8757\u874C\u8753\u885B\u885D\u8910\u8907\u8912\u8913\u8915\u890A\u8ABC\u8AD2\u8AC7\u8AC4\u8A95\u8ACB\u8AF8\u8AB2\u8AC9\u8AC2\u8ABF\u8AB0\u8AD6\u8ACD\u8AB6\u8AB9\u8ADB\u8C4C\u8C4E\u8C6C\u8CE0\u8CDE\u8CE6\u8CE4\u8CEC\u8CED\u8CE2\u8CE3\u8CDC\u8CEA\u8CE1\u8D6D\u8D9F\u8DA3\u8E2B\u8E10\u8E1D\u8E22\u8E0F\u8E29\u8E1F\u8E21\u8E1E\u8EBA\u8F1D\u8F1B\u8F1F\u8F29\u8F26\u8F2A\u8F1C\u8F1E"],
      ["be40", "\u8F25\u9069\u906E\u9068\u906D\u9077\u9130\u912D\u9127\u9131\u9187\u9189\u918B\u9183\u92C5\u92BB\u92B7\u92EA\u92AC\u92E4\u92C1\u92B3\u92BC\u92D2\u92C7\u92F0\u92B2\u95AD\u95B1\u9704\u9706\u9707\u9709\u9760\u978D\u978B\u978F\u9821\u982B\u981C\u98B3\u990A\u9913\u9912\u9918\u99DD\u99D0\u99DF\u99DB\u99D1\u99D5\u99D2\u99D9\u9AB7\u9AEE\u9AEF\u9B27\u9B45\u9B44\u9B77\u9B6F\u9D06\u9D09"],
      ["bea1", "\u9D03\u9EA9\u9EBE\u9ECE\u58A8\u9F52\u5112\u5118\u5114\u5110\u5115\u5180\u51AA\u51DD\u5291\u5293\u52F3\u5659\u566B\u5679\u5669\u5664\u5678\u566A\u5668\u5665\u5671\u566F\u566C\u5662\u5676\u58C1\u58BE\u58C7\u58C5\u596E\u5B1D\u5B34\u5B78\u5BF0\u5C0E\u5F4A\u61B2\u6191\u61A9\u618A\u61CD\u61B6\u61BE\u61CA\u61C8\u6230\u64C5\u64C1\u64CB\u64BB\u64BC\u64DA\u64C4\u64C7\u64C2\u64CD\u64BF\u64D2\u64D4\u64BE\u6574\u66C6\u66C9\u66B9\u66C4\u66C7\u66B8\u6A3D\u6A38\u6A3A\u6A59\u6A6B\u6A58\u6A39\u6A44\u6A62\u6A61\u6A4B\u6A47\u6A35\u6A5F\u6A48\u6B59\u6B77\u6C05\u6FC2\u6FB1\u6FA1"],
      ["bf40", "\u6FC3\u6FA4\u6FC1\u6FA7\u6FB3\u6FC0\u6FB9\u6FB6\u6FA6\u6FA0\u6FB4\u71BE\u71C9\u71D0\u71D2\u71C8\u71D5\u71B9\u71CE\u71D9\u71DC\u71C3\u71C4\u7368\u749C\u74A3\u7498\u749F\u749E\u74E2\u750C\u750D\u7634\u7638\u763A\u76E7\u76E5\u77A0\u779E\u779F\u77A5\u78E8\u78DA\u78EC\u78E7\u79A6\u7A4D\u7A4E\u7A46\u7A4C\u7A4B\u7ABA\u7BD9\u7C11\u7BC9\u7BE4\u7BDB\u7BE1\u7BE9\u7BE6\u7CD5\u7CD6\u7E0A"],
      ["bfa1", "\u7E11\u7E08\u7E1B\u7E23\u7E1E\u7E1D\u7E09\u7E10\u7F79\u7FB2\u7FF0\u7FF1\u7FEE\u8028\u81B3\u81A9\u81A8\u81FB\u8208\u8258\u8259\u854A\u8559\u8548\u8568\u8569\u8543\u8549\u856D\u856A\u855E\u8783\u879F\u879E\u87A2\u878D\u8861\u892A\u8932\u8925\u892B\u8921\u89AA\u89A6\u8AE6\u8AFA\u8AEB\u8AF1\u8B00\u8ADC\u8AE7\u8AEE\u8AFE\u8B01\u8B02\u8AF7\u8AED\u8AF3\u8AF6\u8AFC\u8C6B\u8C6D\u8C93\u8CF4\u8E44\u8E31\u8E34\u8E42\u8E39\u8E35\u8F3B\u8F2F\u8F38\u8F33\u8FA8\u8FA6\u9075\u9074\u9078\u9072\u907C\u907A\u9134\u9192\u9320\u9336\u92F8\u9333\u932F\u9322\u92FC\u932B\u9304\u931A"],
      ["c040", "\u9310\u9326\u9321\u9315\u932E\u9319\u95BB\u96A7\u96A8\u96AA\u96D5\u970E\u9711\u9716\u970D\u9713\u970F\u975B\u975C\u9766\u9798\u9830\u9838\u983B\u9837\u982D\u9839\u9824\u9910\u9928\u991E\u991B\u9921\u991A\u99ED\u99E2\u99F1\u9AB8\u9ABC\u9AFB\u9AED\u9B28\u9B91\u9D15\u9D23\u9D26\u9D28\u9D12\u9D1B\u9ED8\u9ED4\u9F8D\u9F9C\u512A\u511F\u5121\u5132\u52F5\u568E\u5680\u5690\u5685\u5687"],
      ["c0a1", "\u568F\u58D5\u58D3\u58D1\u58CE\u5B30\u5B2A\u5B24\u5B7A\u5C37\u5C68\u5DBC\u5DBA\u5DBD\u5DB8\u5E6B\u5F4C\u5FBD\u61C9\u61C2\u61C7\u61E6\u61CB\u6232\u6234\u64CE\u64CA\u64D8\u64E0\u64F0\u64E6\u64EC\u64F1\u64E2\u64ED\u6582\u6583\u66D9\u66D6\u6A80\u6A94\u6A84\u6AA2\u6A9C\u6ADB\u6AA3\u6A7E\u6A97\u6A90\u6AA0\u6B5C\u6BAE\u6BDA\u6C08\u6FD8\u6FF1\u6FDF\u6FE0\u6FDB\u6FE4\u6FEB\u6FEF\u6F80\u6FEC\u6FE1\u6FE9\u6FD5\u6FEE\u6FF0\u71E7\u71DF\u71EE\u71E6\u71E5\u71ED\u71EC\u71F4\u71E0\u7235\u7246\u7370\u7372\u74A9\u74B0\u74A6\u74A8\u7646\u7642\u764C\u76EA\u77B3\u77AA\u77B0\u77AC"],
      ["c140", "\u77A7\u77AD\u77EF\u78F7\u78FA\u78F4\u78EF\u7901\u79A7\u79AA\u7A57\u7ABF\u7C07\u7C0D\u7BFE\u7BF7\u7C0C\u7BE0\u7CE0\u7CDC\u7CDE\u7CE2\u7CDF\u7CD9\u7CDD\u7E2E\u7E3E\u7E46\u7E37\u7E32\u7E43\u7E2B\u7E3D\u7E31\u7E45\u7E41\u7E34\u7E39\u7E48\u7E35\u7E3F\u7E2F\u7F44\u7FF3\u7FFC\u8071\u8072\u8070\u806F\u8073\u81C6\u81C3\u81BA\u81C2\u81C0\u81BF\u81BD\u81C9\u81BE\u81E8\u8209\u8271\u85AA"],
      ["c1a1", "\u8584\u857E\u859C\u8591\u8594\u85AF\u859B\u8587\u85A8\u858A\u8667\u87C0\u87D1\u87B3\u87D2\u87C6\u87AB\u87BB\u87BA\u87C8\u87CB\u893B\u8936\u8944\u8938\u893D\u89AC\u8B0E\u8B17\u8B19\u8B1B\u8B0A\u8B20\u8B1D\u8B04\u8B10\u8C41\u8C3F\u8C73\u8CFA\u8CFD\u8CFC\u8CF8\u8CFB\u8DA8\u8E49\u8E4B\u8E48\u8E4A\u8F44\u8F3E\u8F42\u8F45\u8F3F\u907F\u907D\u9084\u9081\u9082\u9080\u9139\u91A3\u919E\u919C\u934D\u9382\u9328\u9375\u934A\u9365\u934B\u9318\u937E\u936C\u935B\u9370\u935A\u9354\u95CA\u95CB\u95CC\u95C8\u95C6\u96B1\u96B8\u96D6\u971C\u971E\u97A0\u97D3\u9846\u98B6\u9935\u9A01"],
      ["c240", "\u99FF\u9BAE\u9BAB\u9BAA\u9BAD\u9D3B\u9D3F\u9E8B\u9ECF\u9EDE\u9EDC\u9EDD\u9EDB\u9F3E\u9F4B\u53E2\u5695\u56AE\u58D9\u58D8\u5B38\u5F5D\u61E3\u6233\u64F4\u64F2\u64FE\u6506\u64FA\u64FB\u64F7\u65B7\u66DC\u6726\u6AB3\u6AAC\u6AC3\u6ABB\u6AB8\u6AC2\u6AAE\u6AAF\u6B5F\u6B78\u6BAF\u7009\u700B\u6FFE\u7006\u6FFA\u7011\u700F\u71FB\u71FC\u71FE\u71F8\u7377\u7375\u74A7\u74BF\u7515\u7656\u7658"],
      ["c2a1", "\u7652\u77BD\u77BF\u77BB\u77BC\u790E\u79AE\u7A61\u7A62\u7A60\u7AC4\u7AC5\u7C2B\u7C27\u7C2A\u7C1E\u7C23\u7C21\u7CE7\u7E54\u7E55\u7E5E\u7E5A\u7E61\u7E52\u7E59\u7F48\u7FF9\u7FFB\u8077\u8076\u81CD\u81CF\u820A\u85CF\u85A9\u85CD\u85D0\u85C9\u85B0\u85BA\u85B9\u85A6\u87EF\u87EC\u87F2\u87E0\u8986\u89B2\u89F4\u8B28\u8B39\u8B2C\u8B2B\u8C50\u8D05\u8E59\u8E63\u8E66\u8E64\u8E5F\u8E55\u8EC0\u8F49\u8F4D\u9087\u9083\u9088\u91AB\u91AC\u91D0\u9394\u938A\u9396\u93A2\u93B3\u93AE\u93AC\u93B0\u9398\u939A\u9397\u95D4\u95D6\u95D0\u95D5\u96E2\u96DC\u96D9\u96DB\u96DE\u9724\u97A3\u97A6"],
      ["c340", "\u97AD\u97F9\u984D\u984F\u984C\u984E\u9853\u98BA\u993E\u993F\u993D\u992E\u99A5\u9A0E\u9AC1\u9B03\u9B06\u9B4F\u9B4E\u9B4D\u9BCA\u9BC9\u9BFD\u9BC8\u9BC0\u9D51\u9D5D\u9D60\u9EE0\u9F15\u9F2C\u5133\u56A5\u58DE\u58DF\u58E2\u5BF5\u9F90\u5EEC\u61F2\u61F7\u61F6\u61F5\u6500\u650F\u66E0\u66DD\u6AE5\u6ADD\u6ADA\u6AD3\u701B\u701F\u7028\u701A\u701D\u7015\u7018\u7206\u720D\u7258\u72A2\u7378"],
      ["c3a1", "\u737A\u74BD\u74CA\u74E3\u7587\u7586\u765F\u7661\u77C7\u7919\u79B1\u7A6B\u7A69\u7C3E\u7C3F\u7C38\u7C3D\u7C37\u7C40\u7E6B\u7E6D\u7E79\u7E69\u7E6A\u7F85\u7E73\u7FB6\u7FB9\u7FB8\u81D8\u85E9\u85DD\u85EA\u85D5\u85E4\u85E5\u85F7\u87FB\u8805\u880D\u87F9\u87FE\u8960\u895F\u8956\u895E\u8B41\u8B5C\u8B58\u8B49\u8B5A\u8B4E\u8B4F\u8B46\u8B59\u8D08\u8D0A\u8E7C\u8E72\u8E87\u8E76\u8E6C\u8E7A\u8E74\u8F54\u8F4E\u8FAD\u908A\u908B\u91B1\u91AE\u93E1\u93D1\u93DF\u93C3\u93C8\u93DC\u93DD\u93D6\u93E2\u93CD\u93D8\u93E4\u93D7\u93E8\u95DC\u96B4\u96E3\u972A\u9727\u9761\u97DC\u97FB\u985E"],
      ["c440", "\u9858\u985B\u98BC\u9945\u9949\u9A16\u9A19\u9B0D\u9BE8\u9BE7\u9BD6\u9BDB\u9D89\u9D61\u9D72\u9D6A\u9D6C\u9E92\u9E97\u9E93\u9EB4\u52F8\u56A8\u56B7\u56B6\u56B4\u56BC\u58E4\u5B40\u5B43\u5B7D\u5BF6\u5DC9\u61F8\u61FA\u6518\u6514\u6519\u66E6\u6727\u6AEC\u703E\u7030\u7032\u7210\u737B\u74CF\u7662\u7665\u7926\u792A\u792C\u792B\u7AC7\u7AF6\u7C4C\u7C43\u7C4D\u7CEF\u7CF0\u8FAE\u7E7D\u7E7C"],
      ["c4a1", "\u7E82\u7F4C\u8000\u81DA\u8266\u85FB\u85F9\u8611\u85FA\u8606\u860B\u8607\u860A\u8814\u8815\u8964\u89BA\u89F8\u8B70\u8B6C\u8B66\u8B6F\u8B5F\u8B6B\u8D0F\u8D0D\u8E89\u8E81\u8E85\u8E82\u91B4\u91CB\u9418\u9403\u93FD\u95E1\u9730\u98C4\u9952\u9951\u99A8\u9A2B\u9A30\u9A37\u9A35\u9C13\u9C0D\u9E79\u9EB5\u9EE8\u9F2F\u9F5F\u9F63\u9F61\u5137\u5138\u56C1\u56C0\u56C2\u5914\u5C6C\u5DCD\u61FC\u61FE\u651D\u651C\u6595\u66E9\u6AFB\u6B04\u6AFA\u6BB2\u704C\u721B\u72A7\u74D6\u74D4\u7669\u77D3\u7C50\u7E8F\u7E8C\u7FBC\u8617\u862D\u861A\u8823\u8822\u8821\u881F\u896A\u896C\u89BD\u8B74"],
      ["c540", "\u8B77\u8B7D\u8D13\u8E8A\u8E8D\u8E8B\u8F5F\u8FAF\u91BA\u942E\u9433\u9435\u943A\u9438\u9432\u942B\u95E2\u9738\u9739\u9732\u97FF\u9867\u9865\u9957\u9A45\u9A43\u9A40\u9A3E\u9ACF\u9B54\u9B51\u9C2D\u9C25\u9DAF\u9DB4\u9DC2\u9DB8\u9E9D\u9EEF\u9F19\u9F5C\u9F66\u9F67\u513C\u513B\u56C8\u56CA\u56C9\u5B7F\u5DD4\u5DD2\u5F4E\u61FF\u6524\u6B0A\u6B61\u7051\u7058\u7380\u74E4\u758A\u766E\u766C"],
      ["c5a1", "\u79B3\u7C60\u7C5F\u807E\u807D\u81DF\u8972\u896F\u89FC\u8B80\u8D16\u8D17\u8E91\u8E93\u8F61\u9148\u9444\u9451\u9452\u973D\u973E\u97C3\u97C1\u986B\u9955\u9A55\u9A4D\u9AD2\u9B1A\u9C49\u9C31\u9C3E\u9C3B\u9DD3\u9DD7\u9F34\u9F6C\u9F6A\u9F94\u56CC\u5DD6\u6200\u6523\u652B\u652A\u66EC\u6B10\u74DA\u7ACA\u7C64\u7C63\u7C65\u7E93\u7E96\u7E94\u81E2\u8638\u863F\u8831\u8B8A\u9090\u908F\u9463\u9460\u9464\u9768\u986F\u995C\u9A5A\u9A5B\u9A57\u9AD3\u9AD4\u9AD1\u9C54\u9C57\u9C56\u9DE5\u9E9F\u9EF4\u56D1\u58E9\u652C\u705E\u7671\u7672\u77D7\u7F50\u7F88\u8836\u8839\u8862\u8B93\u8B92"],
      ["c640", "\u8B96\u8277\u8D1B\u91C0\u946A\u9742\u9748\u9744\u97C6\u9870\u9A5F\u9B22\u9B58\u9C5F\u9DF9\u9DFA\u9E7C\u9E7D\u9F07\u9F77\u9F72\u5EF3\u6B16\u7063\u7C6C\u7C6E\u883B\u89C0\u8EA1\u91C1\u9472\u9470\u9871\u995E\u9AD6\u9B23\u9ECC\u7064\u77DA\u8B9A\u9477\u97C9\u9A62\u9A65\u7E9C\u8B9C\u8EAA\u91C5\u947D\u947E\u947C\u9C77\u9C78\u9EF7\u8C54\u947F\u9E1A\u7228\u9A6A\u9B31\u9E1B\u9E1E\u7C72"],
      ["c940", "\u4E42\u4E5C\u51F5\u531A\u5382\u4E07\u4E0C\u4E47\u4E8D\u56D7\uFA0C\u5C6E\u5F73\u4E0F\u5187\u4E0E\u4E2E\u4E93\u4EC2\u4EC9\u4EC8\u5198\u52FC\u536C\u53B9\u5720\u5903\u592C\u5C10\u5DFF\u65E1\u6BB3\u6BCC\u6C14\u723F\u4E31\u4E3C\u4EE8\u4EDC\u4EE9\u4EE1\u4EDD\u4EDA\u520C\u531C\u534C\u5722\u5723\u5917\u592F\u5B81\u5B84\u5C12\u5C3B\u5C74\u5C73\u5E04\u5E80\u5E82\u5FC9\u6209\u6250\u6C15"],
      ["c9a1", "\u6C36\u6C43\u6C3F\u6C3B\u72AE\u72B0\u738A\u79B8\u808A\u961E\u4F0E\u4F18\u4F2C\u4EF5\u4F14\u4EF1\u4F00\u4EF7\u4F08\u4F1D\u4F02\u4F05\u4F22\u4F13\u4F04\u4EF4\u4F12\u51B1\u5213\u5209\u5210\u52A6\u5322\u531F\u534D\u538A\u5407\u56E1\u56DF\u572E\u572A\u5734\u593C\u5980\u597C\u5985\u597B\u597E\u5977\u597F\u5B56\u5C15\u5C25\u5C7C\u5C7A\u5C7B\u5C7E\u5DDF\u5E75\u5E84\u5F02\u5F1A\u5F74\u5FD5\u5FD4\u5FCF\u625C\u625E\u6264\u6261\u6266\u6262\u6259\u6260\u625A\u6265\u65EF\u65EE\u673E\u6739\u6738\u673B\u673A\u673F\u673C\u6733\u6C18\u6C46\u6C52\u6C5C\u6C4F\u6C4A\u6C54\u6C4B"],
      ["ca40", "\u6C4C\u7071\u725E\u72B4\u72B5\u738E\u752A\u767F\u7A75\u7F51\u8278\u827C\u8280\u827D\u827F\u864D\u897E\u9099\u9097\u9098\u909B\u9094\u9622\u9624\u9620\u9623\u4F56\u4F3B\u4F62\u4F49\u4F53\u4F64\u4F3E\u4F67\u4F52\u4F5F\u4F41\u4F58\u4F2D\u4F33\u4F3F\u4F61\u518F\u51B9\u521C\u521E\u5221\u52AD\u52AE\u5309\u5363\u5372\u538E\u538F\u5430\u5437\u542A\u5454\u5445\u5419\u541C\u5425\u5418"],
      ["caa1", "\u543D\u544F\u5441\u5428\u5424\u5447\u56EE\u56E7\u56E5\u5741\u5745\u574C\u5749\u574B\u5752\u5906\u5940\u59A6\u5998\u59A0\u5997\u598E\u59A2\u5990\u598F\u59A7\u59A1\u5B8E\u5B92\u5C28\u5C2A\u5C8D\u5C8F\u5C88\u5C8B\u5C89\u5C92\u5C8A\u5C86\u5C93\u5C95\u5DE0\u5E0A\u5E0E\u5E8B\u5E89\u5E8C\u5E88\u5E8D\u5F05\u5F1D\u5F78\u5F76\u5FD2\u5FD1\u5FD0\u5FED\u5FE8\u5FEE\u5FF3\u5FE1\u5FE4\u5FE3\u5FFA\u5FEF\u5FF7\u5FFB\u6000\u5FF4\u623A\u6283\u628C\u628E\u628F\u6294\u6287\u6271\u627B\u627A\u6270\u6281\u6288\u6277\u627D\u6272\u6274\u6537\u65F0\u65F4\u65F3\u65F2\u65F5\u6745\u6747"],
      ["cb40", "\u6759\u6755\u674C\u6748\u675D\u674D\u675A\u674B\u6BD0\u6C19\u6C1A\u6C78\u6C67\u6C6B\u6C84\u6C8B\u6C8F\u6C71\u6C6F\u6C69\u6C9A\u6C6D\u6C87\u6C95\u6C9C\u6C66\u6C73\u6C65\u6C7B\u6C8E\u7074\u707A\u7263\u72BF\u72BD\u72C3\u72C6\u72C1\u72BA\u72C5\u7395\u7397\u7393\u7394\u7392\u753A\u7539\u7594\u7595\u7681\u793D\u8034\u8095\u8099\u8090\u8092\u809C\u8290\u828F\u8285\u828E\u8291\u8293"],
      ["cba1", "\u828A\u8283\u8284\u8C78\u8FC9\u8FBF\u909F\u90A1\u90A5\u909E\u90A7\u90A0\u9630\u9628\u962F\u962D\u4E33\u4F98\u4F7C\u4F85\u4F7D\u4F80\u4F87\u4F76\u4F74\u4F89\u4F84\u4F77\u4F4C\u4F97\u4F6A\u4F9A\u4F79\u4F81\u4F78\u4F90\u4F9C\u4F94\u4F9E\u4F92\u4F82\u4F95\u4F6B\u4F6E\u519E\u51BC\u51BE\u5235\u5232\u5233\u5246\u5231\u52BC\u530A\u530B\u533C\u5392\u5394\u5487\u547F\u5481\u5491\u5482\u5488\u546B\u547A\u547E\u5465\u546C\u5474\u5466\u548D\u546F\u5461\u5460\u5498\u5463\u5467\u5464\u56F7\u56F9\u576F\u5772\u576D\u576B\u5771\u5770\u5776\u5780\u5775\u577B\u5773\u5774\u5762"],
      ["cc40", "\u5768\u577D\u590C\u5945\u59B5\u59BA\u59CF\u59CE\u59B2\u59CC\u59C1\u59B6\u59BC\u59C3\u59D6\u59B1\u59BD\u59C0\u59C8\u59B4\u59C7\u5B62\u5B65\u5B93\u5B95\u5C44\u5C47\u5CAE\u5CA4\u5CA0\u5CB5\u5CAF\u5CA8\u5CAC\u5C9F\u5CA3\u5CAD\u5CA2\u5CAA\u5CA7\u5C9D\u5CA5\u5CB6\u5CB0\u5CA6\u5E17\u5E14\u5E19\u5F28\u5F22\u5F23\u5F24\u5F54\u5F82\u5F7E\u5F7D\u5FDE\u5FE5\u602D\u6026\u6019\u6032\u600B"],
      ["cca1", "\u6034\u600A\u6017\u6033\u601A\u601E\u602C\u6022\u600D\u6010\u602E\u6013\u6011\u600C\u6009\u601C\u6214\u623D\u62AD\u62B4\u62D1\u62BE\u62AA\u62B6\u62CA\u62AE\u62B3\u62AF\u62BB\u62A9\u62B0\u62B8\u653D\u65A8\u65BB\u6609\u65FC\u6604\u6612\u6608\u65FB\u6603\u660B\u660D\u6605\u65FD\u6611\u6610\u66F6\u670A\u6785\u676C\u678E\u6792\u6776\u677B\u6798\u6786\u6784\u6774\u678D\u678C\u677A\u679F\u6791\u6799\u6783\u677D\u6781\u6778\u6779\u6794\u6B25\u6B80\u6B7E\u6BDE\u6C1D\u6C93\u6CEC\u6CEB\u6CEE\u6CD9\u6CB6\u6CD4\u6CAD\u6CE7\u6CB7\u6CD0\u6CC2\u6CBA\u6CC3\u6CC6\u6CED\u6CF2"],
      ["cd40", "\u6CD2\u6CDD\u6CB4\u6C8A\u6C9D\u6C80\u6CDE\u6CC0\u6D30\u6CCD\u6CC7\u6CB0\u6CF9\u6CCF\u6CE9\u6CD1\u7094\u7098\u7085\u7093\u7086\u7084\u7091\u7096\u7082\u709A\u7083\u726A\u72D6\u72CB\u72D8\u72C9\u72DC\u72D2\u72D4\u72DA\u72CC\u72D1\u73A4\u73A1\u73AD\u73A6\u73A2\u73A0\u73AC\u739D\u74DD\u74E8\u753F\u7540\u753E\u758C\u7598\u76AF\u76F3\u76F1\u76F0\u76F5\u77F8\u77FC\u77F9\u77FB\u77FA"],
      ["cda1", "\u77F7\u7942\u793F\u79C5\u7A78\u7A7B\u7AFB\u7C75\u7CFD\u8035\u808F\u80AE\u80A3\u80B8\u80B5\u80AD\u8220\u82A0\u82C0\u82AB\u829A\u8298\u829B\u82B5\u82A7\u82AE\u82BC\u829E\u82BA\u82B4\u82A8\u82A1\u82A9\u82C2\u82A4\u82C3\u82B6\u82A2\u8670\u866F\u866D\u866E\u8C56\u8FD2\u8FCB\u8FD3\u8FCD\u8FD6\u8FD5\u8FD7\u90B2\u90B4\u90AF\u90B3\u90B0\u9639\u963D\u963C\u963A\u9643\u4FCD\u4FC5\u4FD3\u4FB2\u4FC9\u4FCB\u4FC1\u4FD4\u4FDC\u4FD9\u4FBB\u4FB3\u4FDB\u4FC7\u4FD6\u4FBA\u4FC0\u4FB9\u4FEC\u5244\u5249\u52C0\u52C2\u533D\u537C\u5397\u5396\u5399\u5398\u54BA\u54A1\u54AD\u54A5\u54CF"],
      ["ce40", "\u54C3\u830D\u54B7\u54AE\u54D6\u54B6\u54C5\u54C6\u54A0\u5470\u54BC\u54A2\u54BE\u5472\u54DE\u54B0\u57B5\u579E\u579F\u57A4\u578C\u5797\u579D\u579B\u5794\u5798\u578F\u5799\u57A5\u579A\u5795\u58F4\u590D\u5953\u59E1\u59DE\u59EE\u5A00\u59F1\u59DD\u59FA\u59FD\u59FC\u59F6\u59E4\u59F2\u59F7\u59DB\u59E9\u59F3\u59F5\u59E0\u59FE\u59F4\u59ED\u5BA8\u5C4C\u5CD0\u5CD8\u5CCC\u5CD7\u5CCB\u5CDB"],
      ["cea1", "\u5CDE\u5CDA\u5CC9\u5CC7\u5CCA\u5CD6\u5CD3\u5CD4\u5CCF\u5CC8\u5CC6\u5CCE\u5CDF\u5CF8\u5DF9\u5E21\u5E22\u5E23\u5E20\u5E24\u5EB0\u5EA4\u5EA2\u5E9B\u5EA3\u5EA5\u5F07\u5F2E\u5F56\u5F86\u6037\u6039\u6054\u6072\u605E\u6045\u6053\u6047\u6049\u605B\u604C\u6040\u6042\u605F\u6024\u6044\u6058\u6066\u606E\u6242\u6243\u62CF\u630D\u630B\u62F5\u630E\u6303\u62EB\u62F9\u630F\u630C\u62F8\u62F6\u6300\u6313\u6314\u62FA\u6315\u62FB\u62F0\u6541\u6543\u65AA\u65BF\u6636\u6621\u6632\u6635\u661C\u6626\u6622\u6633\u662B\u663A\u661D\u6634\u6639\u662E\u670F\u6710\u67C1\u67F2\u67C8\u67BA"],
      ["cf40", "\u67DC\u67BB\u67F8\u67D8\u67C0\u67B7\u67C5\u67EB\u67E4\u67DF\u67B5\u67CD\u67B3\u67F7\u67F6\u67EE\u67E3\u67C2\u67B9\u67CE\u67E7\u67F0\u67B2\u67FC\u67C6\u67ED\u67CC\u67AE\u67E6\u67DB\u67FA\u67C9\u67CA\u67C3\u67EA\u67CB\u6B28\u6B82\u6B84\u6BB6\u6BD6\u6BD8\u6BE0\u6C20\u6C21\u6D28\u6D34\u6D2D\u6D1F\u6D3C\u6D3F\u6D12\u6D0A\u6CDA\u6D33\u6D04\u6D19\u6D3A\u6D1A\u6D11\u6D00\u6D1D\u6D42"],
      ["cfa1", "\u6D01\u6D18\u6D37\u6D03\u6D0F\u6D40\u6D07\u6D20\u6D2C\u6D08\u6D22\u6D09\u6D10\u70B7\u709F\u70BE\u70B1\u70B0\u70A1\u70B4\u70B5\u70A9\u7241\u7249\u724A\u726C\u7270\u7273\u726E\u72CA\u72E4\u72E8\u72EB\u72DF\u72EA\u72E6\u72E3\u7385\u73CC\u73C2\u73C8\u73C5\u73B9\u73B6\u73B5\u73B4\u73EB\u73BF\u73C7\u73BE\u73C3\u73C6\u73B8\u73CB\u74EC\u74EE\u752E\u7547\u7548\u75A7\u75AA\u7679\u76C4\u7708\u7703\u7704\u7705\u770A\u76F7\u76FB\u76FA\u77E7\u77E8\u7806\u7811\u7812\u7805\u7810\u780F\u780E\u7809\u7803\u7813\u794A\u794C\u794B\u7945\u7944\u79D5\u79CD\u79CF\u79D6\u79CE\u7A80"],
      ["d040", "\u7A7E\u7AD1\u7B00\u7B01\u7C7A\u7C78\u7C79\u7C7F\u7C80\u7C81\u7D03\u7D08\u7D01\u7F58\u7F91\u7F8D\u7FBE\u8007\u800E\u800F\u8014\u8037\u80D8\u80C7\u80E0\u80D1\u80C8\u80C2\u80D0\u80C5\u80E3\u80D9\u80DC\u80CA\u80D5\u80C9\u80CF\u80D7\u80E6\u80CD\u81FF\u8221\u8294\u82D9\u82FE\u82F9\u8307\u82E8\u8300\u82D5\u833A\u82EB\u82D6\u82F4\u82EC\u82E1\u82F2\u82F5\u830C\u82FB\u82F6\u82F0\u82EA"],
      ["d0a1", "\u82E4\u82E0\u82FA\u82F3\u82ED\u8677\u8674\u867C\u8673\u8841\u884E\u8867\u886A\u8869\u89D3\u8A04\u8A07\u8D72\u8FE3\u8FE1\u8FEE\u8FE0\u90F1\u90BD\u90BF\u90D5\u90C5\u90BE\u90C7\u90CB\u90C8\u91D4\u91D3\u9654\u964F\u9651\u9653\u964A\u964E\u501E\u5005\u5007\u5013\u5022\u5030\u501B\u4FF5\u4FF4\u5033\u5037\u502C\u4FF6\u4FF7\u5017\u501C\u5020\u5027\u5035\u502F\u5031\u500E\u515A\u5194\u5193\u51CA\u51C4\u51C5\u51C8\u51CE\u5261\u525A\u5252\u525E\u525F\u5255\u5262\u52CD\u530E\u539E\u5526\u54E2\u5517\u5512\u54E7\u54F3\u54E4\u551A\u54FF\u5504\u5508\u54EB\u5511\u5505\u54F1"],
      ["d140", "\u550A\u54FB\u54F7\u54F8\u54E0\u550E\u5503\u550B\u5701\u5702\u57CC\u5832\u57D5\u57D2\u57BA\u57C6\u57BD\u57BC\u57B8\u57B6\u57BF\u57C7\u57D0\u57B9\u57C1\u590E\u594A\u5A19\u5A16\u5A2D\u5A2E\u5A15\u5A0F\u5A17\u5A0A\u5A1E\u5A33\u5B6C\u5BA7\u5BAD\u5BAC\u5C03\u5C56\u5C54\u5CEC\u5CFF\u5CEE\u5CF1\u5CF7\u5D00\u5CF9\u5E29\u5E28\u5EA8\u5EAE\u5EAA\u5EAC\u5F33\u5F30\u5F67\u605D\u605A\u6067"],
      ["d1a1", "\u6041\u60A2\u6088\u6080\u6092\u6081\u609D\u6083\u6095\u609B\u6097\u6087\u609C\u608E\u6219\u6246\u62F2\u6310\u6356\u632C\u6344\u6345\u6336\u6343\u63E4\u6339\u634B\u634A\u633C\u6329\u6341\u6334\u6358\u6354\u6359\u632D\u6347\u6333\u635A\u6351\u6338\u6357\u6340\u6348\u654A\u6546\u65C6\u65C3\u65C4\u65C2\u664A\u665F\u6647\u6651\u6712\u6713\u681F\u681A\u6849\u6832\u6833\u683B\u684B\u684F\u6816\u6831\u681C\u6835\u682B\u682D\u682F\u684E\u6844\u6834\u681D\u6812\u6814\u6826\u6828\u682E\u684D\u683A\u6825\u6820\u6B2C\u6B2F\u6B2D\u6B31\u6B34\u6B6D\u8082\u6B88\u6BE6\u6BE4"],
      ["d240", "\u6BE8\u6BE3\u6BE2\u6BE7\u6C25\u6D7A\u6D63\u6D64\u6D76\u6D0D\u6D61\u6D92\u6D58\u6D62\u6D6D\u6D6F\u6D91\u6D8D\u6DEF\u6D7F\u6D86\u6D5E\u6D67\u6D60\u6D97\u6D70\u6D7C\u6D5F\u6D82\u6D98\u6D2F\u6D68\u6D8B\u6D7E\u6D80\u6D84\u6D16\u6D83\u6D7B\u6D7D\u6D75\u6D90\u70DC\u70D3\u70D1\u70DD\u70CB\u7F39\u70E2\u70D7\u70D2\u70DE\u70E0\u70D4\u70CD\u70C5\u70C6\u70C7\u70DA\u70CE\u70E1\u7242\u7278"],
      ["d2a1", "\u7277\u7276\u7300\u72FA\u72F4\u72FE\u72F6\u72F3\u72FB\u7301\u73D3\u73D9\u73E5\u73D6\u73BC\u73E7\u73E3\u73E9\u73DC\u73D2\u73DB\u73D4\u73DD\u73DA\u73D7\u73D8\u73E8\u74DE\u74DF\u74F4\u74F5\u7521\u755B\u755F\u75B0\u75C1\u75BB\u75C4\u75C0\u75BF\u75B6\u75BA\u768A\u76C9\u771D\u771B\u7710\u7713\u7712\u7723\u7711\u7715\u7719\u771A\u7722\u7727\u7823\u782C\u7822\u7835\u782F\u7828\u782E\u782B\u7821\u7829\u7833\u782A\u7831\u7954\u795B\u794F\u795C\u7953\u7952\u7951\u79EB\u79EC\u79E0\u79EE\u79ED\u79EA\u79DC\u79DE\u79DD\u7A86\u7A89\u7A85\u7A8B\u7A8C\u7A8A\u7A87\u7AD8\u7B10"],
      ["d340", "\u7B04\u7B13\u7B05\u7B0F\u7B08\u7B0A\u7B0E\u7B09\u7B12\u7C84\u7C91\u7C8A\u7C8C\u7C88\u7C8D\u7C85\u7D1E\u7D1D\u7D11\u7D0E\u7D18\u7D16\u7D13\u7D1F\u7D12\u7D0F\u7D0C\u7F5C\u7F61\u7F5E\u7F60\u7F5D\u7F5B\u7F96\u7F92\u7FC3\u7FC2\u7FC0\u8016\u803E\u8039\u80FA\u80F2\u80F9\u80F5\u8101\u80FB\u8100\u8201\u822F\u8225\u8333\u832D\u8344\u8319\u8351\u8325\u8356\u833F\u8341\u8326\u831C\u8322"],
      ["d3a1", "\u8342\u834E\u831B\u832A\u8308\u833C\u834D\u8316\u8324\u8320\u8337\u832F\u8329\u8347\u8345\u834C\u8353\u831E\u832C\u834B\u8327\u8348\u8653\u8652\u86A2\u86A8\u8696\u868D\u8691\u869E\u8687\u8697\u8686\u868B\u869A\u8685\u86A5\u8699\u86A1\u86A7\u8695\u8698\u868E\u869D\u8690\u8694\u8843\u8844\u886D\u8875\u8876\u8872\u8880\u8871\u887F\u886F\u8883\u887E\u8874\u887C\u8A12\u8C47\u8C57\u8C7B\u8CA4\u8CA3\u8D76\u8D78\u8DB5\u8DB7\u8DB6\u8ED1\u8ED3\u8FFE\u8FF5\u9002\u8FFF\u8FFB\u9004\u8FFC\u8FF6\u90D6\u90E0\u90D9\u90DA\u90E3\u90DF\u90E5\u90D8\u90DB\u90D7\u90DC\u90E4\u9150"],
      ["d440", "\u914E\u914F\u91D5\u91E2\u91DA\u965C\u965F\u96BC\u98E3\u9ADF\u9B2F\u4E7F\u5070\u506A\u5061\u505E\u5060\u5053\u504B\u505D\u5072\u5048\u504D\u5041\u505B\u504A\u5062\u5015\u5045\u505F\u5069\u506B\u5063\u5064\u5046\u5040\u506E\u5073\u5057\u5051\u51D0\u526B\u526D\u526C\u526E\u52D6\u52D3\u532D\u539C\u5575\u5576\u553C\u554D\u5550\u5534\u552A\u5551\u5562\u5536\u5535\u5530\u5552\u5545"],
      ["d4a1", "\u550C\u5532\u5565\u554E\u5539\u5548\u552D\u553B\u5540\u554B\u570A\u5707\u57FB\u5814\u57E2\u57F6\u57DC\u57F4\u5800\u57ED\u57FD\u5808\u57F8\u580B\u57F3\u57CF\u5807\u57EE\u57E3\u57F2\u57E5\u57EC\u57E1\u580E\u57FC\u5810\u57E7\u5801\u580C\u57F1\u57E9\u57F0\u580D\u5804\u595C\u5A60\u5A58\u5A55\u5A67\u5A5E\u5A38\u5A35\u5A6D\u5A50\u5A5F\u5A65\u5A6C\u5A53\u5A64\u5A57\u5A43\u5A5D\u5A52\u5A44\u5A5B\u5A48\u5A8E\u5A3E\u5A4D\u5A39\u5A4C\u5A70\u5A69\u5A47\u5A51\u5A56\u5A42\u5A5C\u5B72\u5B6E\u5BC1\u5BC0\u5C59\u5D1E\u5D0B\u5D1D\u5D1A\u5D20\u5D0C\u5D28\u5D0D\u5D26\u5D25\u5D0F"],
      ["d540", "\u5D30\u5D12\u5D23\u5D1F\u5D2E\u5E3E\u5E34\u5EB1\u5EB4\u5EB9\u5EB2\u5EB3\u5F36\u5F38\u5F9B\u5F96\u5F9F\u608A\u6090\u6086\u60BE\u60B0\u60BA\u60D3\u60D4\u60CF\u60E4\u60D9\u60DD\u60C8\u60B1\u60DB\u60B7\u60CA\u60BF\u60C3\u60CD\u60C0\u6332\u6365\u638A\u6382\u637D\u63BD\u639E\u63AD\u639D\u6397\u63AB\u638E\u636F\u6387\u6390\u636E\u63AF\u6375\u639C\u636D\u63AE\u637C\u63A4\u633B\u639F"],
      ["d5a1", "\u6378\u6385\u6381\u6391\u638D\u6370\u6553\u65CD\u6665\u6661\u665B\u6659\u665C\u6662\u6718\u6879\u6887\u6890\u689C\u686D\u686E\u68AE\u68AB\u6956\u686F\u68A3\u68AC\u68A9\u6875\u6874\u68B2\u688F\u6877\u6892\u687C\u686B\u6872\u68AA\u6880\u6871\u687E\u689B\u6896\u688B\u68A0\u6889\u68A4\u6878\u687B\u6891\u688C\u688A\u687D\u6B36\u6B33\u6B37\u6B38\u6B91\u6B8F\u6B8D\u6B8E\u6B8C\u6C2A\u6DC0\u6DAB\u6DB4\u6DB3\u6E74\u6DAC\u6DE9\u6DE2\u6DB7\u6DF6\u6DD4\u6E00\u6DC8\u6DE0\u6DDF\u6DD6\u6DBE\u6DE5\u6DDC\u6DDD\u6DDB\u6DF4\u6DCA\u6DBD\u6DED\u6DF0\u6DBA\u6DD5\u6DC2\u6DCF\u6DC9"],
      ["d640", "\u6DD0\u6DF2\u6DD3\u6DFD\u6DD7\u6DCD\u6DE3\u6DBB\u70FA\u710D\u70F7\u7117\u70F4\u710C\u70F0\u7104\u70F3\u7110\u70FC\u70FF\u7106\u7113\u7100\u70F8\u70F6\u710B\u7102\u710E\u727E\u727B\u727C\u727F\u731D\u7317\u7307\u7311\u7318\u730A\u7308\u72FF\u730F\u731E\u7388\u73F6\u73F8\u73F5\u7404\u7401\u73FD\u7407\u7400\u73FA\u73FC\u73FF\u740C\u740B\u73F4\u7408\u7564\u7563\u75CE\u75D2\u75CF"],
      ["d6a1", "\u75CB\u75CC\u75D1\u75D0\u768F\u7689\u76D3\u7739\u772F\u772D\u7731\u7732\u7734\u7733\u773D\u7725\u773B\u7735\u7848\u7852\u7849\u784D\u784A\u784C\u7826\u7845\u7850\u7964\u7967\u7969\u796A\u7963\u796B\u7961\u79BB\u79FA\u79F8\u79F6\u79F7\u7A8F\u7A94\u7A90\u7B35\u7B47\u7B34\u7B25\u7B30\u7B22\u7B24\u7B33\u7B18\u7B2A\u7B1D\u7B31\u7B2B\u7B2D\u7B2F\u7B32\u7B38\u7B1A\u7B23\u7C94\u7C98\u7C96\u7CA3\u7D35\u7D3D\u7D38\u7D36\u7D3A\u7D45\u7D2C\u7D29\u7D41\u7D47\u7D3E\u7D3F\u7D4A\u7D3B\u7D28\u7F63\u7F95\u7F9C\u7F9D\u7F9B\u7FCA\u7FCB\u7FCD\u7FD0\u7FD1\u7FC7\u7FCF\u7FC9\u801F"],
      ["d740", "\u801E\u801B\u8047\u8043\u8048\u8118\u8125\u8119\u811B\u812D\u811F\u812C\u811E\u8121\u8115\u8127\u811D\u8122\u8211\u8238\u8233\u823A\u8234\u8232\u8274\u8390\u83A3\u83A8\u838D\u837A\u8373\u83A4\u8374\u838F\u8381\u8395\u8399\u8375\u8394\u83A9\u837D\u8383\u838C\u839D\u839B\u83AA\u838B\u837E\u83A5\u83AF\u8388\u8397\u83B0\u837F\u83A6\u8387\u83AE\u8376\u839A\u8659\u8656\u86BF\u86B7"],
      ["d7a1", "\u86C2\u86C1\u86C5\u86BA\u86B0\u86C8\u86B9\u86B3\u86B8\u86CC\u86B4\u86BB\u86BC\u86C3\u86BD\u86BE\u8852\u8889\u8895\u88A8\u88A2\u88AA\u889A\u8891\u88A1\u889F\u8898\u88A7\u8899\u889B\u8897\u88A4\u88AC\u888C\u8893\u888E\u8982\u89D6\u89D9\u89D5\u8A30\u8A27\u8A2C\u8A1E\u8C39\u8C3B\u8C5C\u8C5D\u8C7D\u8CA5\u8D7D\u8D7B\u8D79\u8DBC\u8DC2\u8DB9\u8DBF\u8DC1\u8ED8\u8EDE\u8EDD\u8EDC\u8ED7\u8EE0\u8EE1\u9024\u900B\u9011\u901C\u900C\u9021\u90EF\u90EA\u90F0\u90F4\u90F2\u90F3\u90D4\u90EB\u90EC\u90E9\u9156\u9158\u915A\u9153\u9155\u91EC\u91F4\u91F1\u91F3\u91F8\u91E4\u91F9\u91EA"],
      ["d840", "\u91EB\u91F7\u91E8\u91EE\u957A\u9586\u9588\u967C\u966D\u966B\u9671\u966F\u96BF\u976A\u9804\u98E5\u9997\u509B\u5095\u5094\u509E\u508B\u50A3\u5083\u508C\u508E\u509D\u5068\u509C\u5092\u5082\u5087\u515F\u51D4\u5312\u5311\u53A4\u53A7\u5591\u55A8\u55A5\u55AD\u5577\u5645\u55A2\u5593\u5588\u558F\u55B5\u5581\u55A3\u5592\u55A4\u557D\u558C\u55A6\u557F\u5595\u55A1\u558E\u570C\u5829\u5837"],
      ["d8a1", "\u5819\u581E\u5827\u5823\u5828\u57F5\u5848\u5825\u581C\u581B\u5833\u583F\u5836\u582E\u5839\u5838\u582D\u582C\u583B\u5961\u5AAF\u5A94\u5A9F\u5A7A\u5AA2\u5A9E\u5A78\u5AA6\u5A7C\u5AA5\u5AAC\u5A95\u5AAE\u5A37\u5A84\u5A8A\u5A97\u5A83\u5A8B\u5AA9\u5A7B\u5A7D\u5A8C\u5A9C\u5A8F\u5A93\u5A9D\u5BEA\u5BCD\u5BCB\u5BD4\u5BD1\u5BCA\u5BCE\u5C0C\u5C30\u5D37\u5D43\u5D6B\u5D41\u5D4B\u5D3F\u5D35\u5D51\u5D4E\u5D55\u5D33\u5D3A\u5D52\u5D3D\u5D31\u5D59\u5D42\u5D39\u5D49\u5D38\u5D3C\u5D32\u5D36\u5D40\u5D45\u5E44\u5E41\u5F58\u5FA6\u5FA5\u5FAB\u60C9\u60B9\u60CC\u60E2\u60CE\u60C4\u6114"],
      ["d940", "\u60F2\u610A\u6116\u6105\u60F5\u6113\u60F8\u60FC\u60FE\u60C1\u6103\u6118\u611D\u6110\u60FF\u6104\u610B\u624A\u6394\u63B1\u63B0\u63CE\u63E5\u63E8\u63EF\u63C3\u649D\u63F3\u63CA\u63E0\u63F6\u63D5\u63F2\u63F5\u6461\u63DF\u63BE\u63DD\u63DC\u63C4\u63D8\u63D3\u63C2\u63C7\u63CC\u63CB\u63C8\u63F0\u63D7\u63D9\u6532\u6567\u656A\u6564\u655C\u6568\u6565\u658C\u659D\u659E\u65AE\u65D0\u65D2"],
      ["d9a1", "\u667C\u666C\u667B\u6680\u6671\u6679\u666A\u6672\u6701\u690C\u68D3\u6904\u68DC\u692A\u68EC\u68EA\u68F1\u690F\u68D6\u68F7\u68EB\u68E4\u68F6\u6913\u6910\u68F3\u68E1\u6907\u68CC\u6908\u6970\u68B4\u6911\u68EF\u68C6\u6914\u68F8\u68D0\u68FD\u68FC\u68E8\u690B\u690A\u6917\u68CE\u68C8\u68DD\u68DE\u68E6\u68F4\u68D1\u6906\u68D4\u68E9\u6915\u6925\u68C7\u6B39\u6B3B\u6B3F\u6B3C\u6B94\u6B97\u6B99\u6B95\u6BBD\u6BF0\u6BF2\u6BF3\u6C30\u6DFC\u6E46\u6E47\u6E1F\u6E49\u6E88\u6E3C\u6E3D\u6E45\u6E62\u6E2B\u6E3F\u6E41\u6E5D\u6E73\u6E1C\u6E33\u6E4B\u6E40\u6E51\u6E3B\u6E03\u6E2E\u6E5E"],
      ["da40", "\u6E68\u6E5C\u6E61\u6E31\u6E28\u6E60\u6E71\u6E6B\u6E39\u6E22\u6E30\u6E53\u6E65\u6E27\u6E78\u6E64\u6E77\u6E55\u6E79\u6E52\u6E66\u6E35\u6E36\u6E5A\u7120\u711E\u712F\u70FB\u712E\u7131\u7123\u7125\u7122\u7132\u711F\u7128\u713A\u711B\u724B\u725A\u7288\u7289\u7286\u7285\u728B\u7312\u730B\u7330\u7322\u7331\u7333\u7327\u7332\u732D\u7326\u7323\u7335\u730C\u742E\u742C\u7430\u742B\u7416"],
      ["daa1", "\u741A\u7421\u742D\u7431\u7424\u7423\u741D\u7429\u7420\u7432\u74FB\u752F\u756F\u756C\u75E7\u75DA\u75E1\u75E6\u75DD\u75DF\u75E4\u75D7\u7695\u7692\u76DA\u7746\u7747\u7744\u774D\u7745\u774A\u774E\u774B\u774C\u77DE\u77EC\u7860\u7864\u7865\u785C\u786D\u7871\u786A\u786E\u7870\u7869\u7868\u785E\u7862\u7974\u7973\u7972\u7970\u7A02\u7A0A\u7A03\u7A0C\u7A04\u7A99\u7AE6\u7AE4\u7B4A\u7B3B\u7B44\u7B48\u7B4C\u7B4E\u7B40\u7B58\u7B45\u7CA2\u7C9E\u7CA8\u7CA1\u7D58\u7D6F\u7D63\u7D53\u7D56\u7D67\u7D6A\u7D4F\u7D6D\u7D5C\u7D6B\u7D52\u7D54\u7D69\u7D51\u7D5F\u7D4E\u7F3E\u7F3F\u7F65"],
      ["db40", "\u7F66\u7FA2\u7FA0\u7FA1\u7FD7\u8051\u804F\u8050\u80FE\u80D4\u8143\u814A\u8152\u814F\u8147\u813D\u814D\u813A\u81E6\u81EE\u81F7\u81F8\u81F9\u8204\u823C\u823D\u823F\u8275\u833B\u83CF\u83F9\u8423\u83C0\u83E8\u8412\u83E7\u83E4\u83FC\u83F6\u8410\u83C6\u83C8\u83EB\u83E3\u83BF\u8401\u83DD\u83E5\u83D8\u83FF\u83E1\u83CB\u83CE\u83D6\u83F5\u83C9\u8409\u840F\u83DE\u8411\u8406\u83C2\u83F3"],
      ["dba1", "\u83D5\u83FA\u83C7\u83D1\u83EA\u8413\u83C3\u83EC\u83EE\u83C4\u83FB\u83D7\u83E2\u841B\u83DB\u83FE\u86D8\u86E2\u86E6\u86D3\u86E3\u86DA\u86EA\u86DD\u86EB\u86DC\u86EC\u86E9\u86D7\u86E8\u86D1\u8848\u8856\u8855\u88BA\u88D7\u88B9\u88B8\u88C0\u88BE\u88B6\u88BC\u88B7\u88BD\u88B2\u8901\u88C9\u8995\u8998\u8997\u89DD\u89DA\u89DB\u8A4E\u8A4D\u8A39\u8A59\u8A40\u8A57\u8A58\u8A44\u8A45\u8A52\u8A48\u8A51\u8A4A\u8A4C\u8A4F\u8C5F\u8C81\u8C80\u8CBA\u8CBE\u8CB0\u8CB9\u8CB5\u8D84\u8D80\u8D89\u8DD8\u8DD3\u8DCD\u8DC7\u8DD6\u8DDC\u8DCF\u8DD5\u8DD9\u8DC8\u8DD7\u8DC5\u8EEF\u8EF7\u8EFA"],
      ["dc40", "\u8EF9\u8EE6\u8EEE\u8EE5\u8EF5\u8EE7\u8EE8\u8EF6\u8EEB\u8EF1\u8EEC\u8EF4\u8EE9\u902D\u9034\u902F\u9106\u912C\u9104\u90FF\u90FC\u9108\u90F9\u90FB\u9101\u9100\u9107\u9105\u9103\u9161\u9164\u915F\u9162\u9160\u9201\u920A\u9225\u9203\u921A\u9226\u920F\u920C\u9200\u9212\u91FF\u91FD\u9206\u9204\u9227\u9202\u921C\u9224\u9219\u9217\u9205\u9216\u957B\u958D\u958C\u9590\u9687\u967E\u9688"],
      ["dca1", "\u9689\u9683\u9680\u96C2\u96C8\u96C3\u96F1\u96F0\u976C\u9770\u976E\u9807\u98A9\u98EB\u9CE6\u9EF9\u4E83\u4E84\u4EB6\u50BD\u50BF\u50C6\u50AE\u50C4\u50CA\u50B4\u50C8\u50C2\u50B0\u50C1\u50BA\u50B1\u50CB\u50C9\u50B6\u50B8\u51D7\u527A\u5278\u527B\u527C\u55C3\u55DB\u55CC\u55D0\u55CB\u55CA\u55DD\u55C0\u55D4\u55C4\u55E9\u55BF\u55D2\u558D\u55CF\u55D5\u55E2\u55D6\u55C8\u55F2\u55CD\u55D9\u55C2\u5714\u5853\u5868\u5864\u584F\u584D\u5849\u586F\u5855\u584E\u585D\u5859\u5865\u585B\u583D\u5863\u5871\u58FC\u5AC7\u5AC4\u5ACB\u5ABA\u5AB8\u5AB1\u5AB5\u5AB0\u5ABF\u5AC8\u5ABB\u5AC6"],
      ["dd40", "\u5AB7\u5AC0\u5ACA\u5AB4\u5AB6\u5ACD\u5AB9\u5A90\u5BD6\u5BD8\u5BD9\u5C1F\u5C33\u5D71\u5D63\u5D4A\u5D65\u5D72\u5D6C\u5D5E\u5D68\u5D67\u5D62\u5DF0\u5E4F\u5E4E\u5E4A\u5E4D\u5E4B\u5EC5\u5ECC\u5EC6\u5ECB\u5EC7\u5F40\u5FAF\u5FAD\u60F7\u6149\u614A\u612B\u6145\u6136\u6132\u612E\u6146\u612F\u614F\u6129\u6140\u6220\u9168\u6223\u6225\u6224\u63C5\u63F1\u63EB\u6410\u6412\u6409\u6420\u6424"],
      ["dda1", "\u6433\u6443\u641F\u6415\u6418\u6439\u6437\u6422\u6423\u640C\u6426\u6430\u6428\u6441\u6435\u642F\u640A\u641A\u6440\u6425\u6427\u640B\u63E7\u641B\u642E\u6421\u640E\u656F\u6592\u65D3\u6686\u668C\u6695\u6690\u668B\u668A\u6699\u6694\u6678\u6720\u6966\u695F\u6938\u694E\u6962\u6971\u693F\u6945\u696A\u6939\u6942\u6957\u6959\u697A\u6948\u6949\u6935\u696C\u6933\u693D\u6965\u68F0\u6978\u6934\u6969\u6940\u696F\u6944\u6976\u6958\u6941\u6974\u694C\u693B\u694B\u6937\u695C\u694F\u6951\u6932\u6952\u692F\u697B\u693C\u6B46\u6B45\u6B43\u6B42\u6B48\u6B41\u6B9B\uFA0D\u6BFB\u6BFC"],
      ["de40", "\u6BF9\u6BF7\u6BF8\u6E9B\u6ED6\u6EC8\u6E8F\u6EC0\u6E9F\u6E93\u6E94\u6EA0\u6EB1\u6EB9\u6EC6\u6ED2\u6EBD\u6EC1\u6E9E\u6EC9\u6EB7\u6EB0\u6ECD\u6EA6\u6ECF\u6EB2\u6EBE\u6EC3\u6EDC\u6ED8\u6E99\u6E92\u6E8E\u6E8D\u6EA4\u6EA1\u6EBF\u6EB3\u6ED0\u6ECA\u6E97\u6EAE\u6EA3\u7147\u7154\u7152\u7163\u7160\u7141\u715D\u7162\u7172\u7178\u716A\u7161\u7142\u7158\u7143\u714B\u7170\u715F\u7150\u7153"],
      ["dea1", "\u7144\u714D\u715A\u724F\u728D\u728C\u7291\u7290\u728E\u733C\u7342\u733B\u733A\u7340\u734A\u7349\u7444\u744A\u744B\u7452\u7451\u7457\u7440\u744F\u7450\u744E\u7442\u7446\u744D\u7454\u74E1\u74FF\u74FE\u74FD\u751D\u7579\u7577\u6983\u75EF\u760F\u7603\u75F7\u75FE\u75FC\u75F9\u75F8\u7610\u75FB\u75F6\u75ED\u75F5\u75FD\u7699\u76B5\u76DD\u7755\u775F\u7760\u7752\u7756\u775A\u7769\u7767\u7754\u7759\u776D\u77E0\u7887\u789A\u7894\u788F\u7884\u7895\u7885\u7886\u78A1\u7883\u7879\u7899\u7880\u7896\u787B\u797C\u7982\u797D\u7979\u7A11\u7A18\u7A19\u7A12\u7A17\u7A15\u7A22\u7A13"],
      ["df40", "\u7A1B\u7A10\u7AA3\u7AA2\u7A9E\u7AEB\u7B66\u7B64\u7B6D\u7B74\u7B69\u7B72\u7B65\u7B73\u7B71\u7B70\u7B61\u7B78\u7B76\u7B63\u7CB2\u7CB4\u7CAF\u7D88\u7D86\u7D80\u7D8D\u7D7F\u7D85\u7D7A\u7D8E\u7D7B\u7D83\u7D7C\u7D8C\u7D94\u7D84\u7D7D\u7D92\u7F6D\u7F6B\u7F67\u7F68\u7F6C\u7FA6\u7FA5\u7FA7\u7FDB\u7FDC\u8021\u8164\u8160\u8177\u815C\u8169\u815B\u8162\u8172\u6721\u815E\u8176\u8167\u816F"],
      ["dfa1", "\u8144\u8161\u821D\u8249\u8244\u8240\u8242\u8245\u84F1\u843F\u8456\u8476\u8479\u848F\u848D\u8465\u8451\u8440\u8486\u8467\u8430\u844D\u847D\u845A\u8459\u8474\u8473\u845D\u8507\u845E\u8437\u843A\u8434\u847A\u8443\u8478\u8432\u8445\u8429\u83D9\u844B\u842F\u8442\u842D\u845F\u8470\u8439\u844E\u844C\u8452\u846F\u84C5\u848E\u843B\u8447\u8436\u8433\u8468\u847E\u8444\u842B\u8460\u8454\u846E\u8450\u870B\u8704\u86F7\u870C\u86FA\u86D6\u86F5\u874D\u86F8\u870E\u8709\u8701\u86F6\u870D\u8705\u88D6\u88CB\u88CD\u88CE\u88DE\u88DB\u88DA\u88CC\u88D0\u8985\u899B\u89DF\u89E5\u89E4"],
      ["e040", "\u89E1\u89E0\u89E2\u89DC\u89E6\u8A76\u8A86\u8A7F\u8A61\u8A3F\u8A77\u8A82\u8A84\u8A75\u8A83\u8A81\u8A74\u8A7A\u8C3C\u8C4B\u8C4A\u8C65\u8C64\u8C66\u8C86\u8C84\u8C85\u8CCC\u8D68\u8D69\u8D91\u8D8C\u8D8E\u8D8F\u8D8D\u8D93\u8D94\u8D90\u8D92\u8DF0\u8DE0\u8DEC\u8DF1\u8DEE\u8DD0\u8DE9\u8DE3\u8DE2\u8DE7\u8DF2\u8DEB\u8DF4\u8F06\u8EFF\u8F01\u8F00\u8F05\u8F07\u8F08\u8F02\u8F0B\u9052\u903F"],
      ["e0a1", "\u9044\u9049\u903D\u9110\u910D\u910F\u9111\u9116\u9114\u910B\u910E\u916E\u916F\u9248\u9252\u9230\u923A\u9266\u9233\u9265\u925E\u9283\u922E\u924A\u9246\u926D\u926C\u924F\u9260\u9267\u926F\u9236\u9261\u9270\u9231\u9254\u9263\u9250\u9272\u924E\u9253\u924C\u9256\u9232\u959F\u959C\u959E\u959B\u9692\u9693\u9691\u9697\u96CE\u96FA\u96FD\u96F8\u96F5\u9773\u9777\u9778\u9772\u980F\u980D\u980E\u98AC\u98F6\u98F9\u99AF\u99B2\u99B0\u99B5\u9AAD\u9AAB\u9B5B\u9CEA\u9CED\u9CE7\u9E80\u9EFD\u50E6\u50D4\u50D7\u50E8\u50F3\u50DB\u50EA\u50DD\u50E4\u50D3\u50EC\u50F0\u50EF\u50E3\u50E0"],
      ["e140", "\u51D8\u5280\u5281\u52E9\u52EB\u5330\u53AC\u5627\u5615\u560C\u5612\u55FC\u560F\u561C\u5601\u5613\u5602\u55FA\u561D\u5604\u55FF\u55F9\u5889\u587C\u5890\u5898\u5886\u5881\u587F\u5874\u588B\u587A\u5887\u5891\u588E\u5876\u5882\u5888\u587B\u5894\u588F\u58FE\u596B\u5ADC\u5AEE\u5AE5\u5AD5\u5AEA\u5ADA\u5AED\u5AEB\u5AF3\u5AE2\u5AE0\u5ADB\u5AEC\u5ADE\u5ADD\u5AD9\u5AE8\u5ADF\u5B77\u5BE0"],
      ["e1a1", "\u5BE3\u5C63\u5D82\u5D80\u5D7D\u5D86\u5D7A\u5D81\u5D77\u5D8A\u5D89\u5D88\u5D7E\u5D7C\u5D8D\u5D79\u5D7F\u5E58\u5E59\u5E53\u5ED8\u5ED1\u5ED7\u5ECE\u5EDC\u5ED5\u5ED9\u5ED2\u5ED4\u5F44\u5F43\u5F6F\u5FB6\u612C\u6128\u6141\u615E\u6171\u6173\u6152\u6153\u6172\u616C\u6180\u6174\u6154\u617A\u615B\u6165\u613B\u616A\u6161\u6156\u6229\u6227\u622B\u642B\u644D\u645B\u645D\u6474\u6476\u6472\u6473\u647D\u6475\u6466\u64A6\u644E\u6482\u645E\u645C\u644B\u6453\u6460\u6450\u647F\u643F\u646C\u646B\u6459\u6465\u6477\u6573\u65A0\u66A1\u66A0\u669F\u6705\u6704\u6722\u69B1\u69B6\u69C9"],
      ["e240", "\u69A0\u69CE\u6996\u69B0\u69AC\u69BC\u6991\u6999\u698E\u69A7\u698D\u69A9\u69BE\u69AF\u69BF\u69C4\u69BD\u69A4\u69D4\u69B9\u69CA\u699A\u69CF\u69B3\u6993\u69AA\u69A1\u699E\u69D9\u6997\u6990\u69C2\u69B5\u69A5\u69C6\u6B4A\u6B4D\u6B4B\u6B9E\u6B9F\u6BA0\u6BC3\u6BC4\u6BFE\u6ECE\u6EF5\u6EF1\u6F03\u6F25\u6EF8\u6F37\u6EFB\u6F2E\u6F09\u6F4E\u6F19\u6F1A\u6F27\u6F18\u6F3B\u6F12\u6EED\u6F0A"],
      ["e2a1", "\u6F36\u6F73\u6EF9\u6EEE\u6F2D\u6F40\u6F30\u6F3C\u6F35\u6EEB\u6F07\u6F0E\u6F43\u6F05\u6EFD\u6EF6\u6F39\u6F1C\u6EFC\u6F3A\u6F1F\u6F0D\u6F1E\u6F08\u6F21\u7187\u7190\u7189\u7180\u7185\u7182\u718F\u717B\u7186\u7181\u7197\u7244\u7253\u7297\u7295\u7293\u7343\u734D\u7351\u734C\u7462\u7473\u7471\u7475\u7472\u7467\u746E\u7500\u7502\u7503\u757D\u7590\u7616\u7608\u760C\u7615\u7611\u760A\u7614\u76B8\u7781\u777C\u7785\u7782\u776E\u7780\u776F\u777E\u7783\u78B2\u78AA\u78B4\u78AD\u78A8\u787E\u78AB\u789E\u78A5\u78A0\u78AC\u78A2\u78A4\u7998\u798A\u798B\u7996\u7995\u7994\u7993"],
      ["e340", "\u7997\u7988\u7992\u7990\u7A2B\u7A4A\u7A30\u7A2F\u7A28\u7A26\u7AA8\u7AAB\u7AAC\u7AEE\u7B88\u7B9C\u7B8A\u7B91\u7B90\u7B96\u7B8D\u7B8C\u7B9B\u7B8E\u7B85\u7B98\u5284\u7B99\u7BA4\u7B82\u7CBB\u7CBF\u7CBC\u7CBA\u7DA7\u7DB7\u7DC2\u7DA3\u7DAA\u7DC1\u7DC0\u7DC5\u7D9D\u7DCE\u7DC4\u7DC6\u7DCB\u7DCC\u7DAF\u7DB9\u7D96\u7DBC\u7D9F\u7DA6\u7DAE\u7DA9\u7DA1\u7DC9\u7F73\u7FE2\u7FE3\u7FE5\u7FDE"],
      ["e3a1", "\u8024\u805D\u805C\u8189\u8186\u8183\u8187\u818D\u818C\u818B\u8215\u8497\u84A4\u84A1\u849F\u84BA\u84CE\u84C2\u84AC\u84AE\u84AB\u84B9\u84B4\u84C1\u84CD\u84AA\u849A\u84B1\u84D0\u849D\u84A7\u84BB\u84A2\u8494\u84C7\u84CC\u849B\u84A9\u84AF\u84A8\u84D6\u8498\u84B6\u84CF\u84A0\u84D7\u84D4\u84D2\u84DB\u84B0\u8491\u8661\u8733\u8723\u8728\u876B\u8740\u872E\u871E\u8721\u8719\u871B\u8743\u872C\u8741\u873E\u8746\u8720\u8732\u872A\u872D\u873C\u8712\u873A\u8731\u8735\u8742\u8726\u8727\u8738\u8724\u871A\u8730\u8711\u88F7\u88E7\u88F1\u88F2\u88FA\u88FE\u88EE\u88FC\u88F6\u88FB"],
      ["e440", "\u88F0\u88EC\u88EB\u899D\u89A1\u899F\u899E\u89E9\u89EB\u89E8\u8AAB\u8A99\u8A8B\u8A92\u8A8F\u8A96\u8C3D\u8C68\u8C69\u8CD5\u8CCF\u8CD7\u8D96\u8E09\u8E02\u8DFF\u8E0D\u8DFD\u8E0A\u8E03\u8E07\u8E06\u8E05\u8DFE\u8E00\u8E04\u8F10\u8F11\u8F0E\u8F0D\u9123\u911C\u9120\u9122\u911F\u911D\u911A\u9124\u9121\u911B\u917A\u9172\u9179\u9173\u92A5\u92A4\u9276\u929B\u927A\u92A0\u9294\u92AA\u928D"],
      ["e4a1", "\u92A6\u929A\u92AB\u9279\u9297\u927F\u92A3\u92EE\u928E\u9282\u9295\u92A2\u927D\u9288\u92A1\u928A\u9286\u928C\u9299\u92A7\u927E\u9287\u92A9\u929D\u928B\u922D\u969E\u96A1\u96FF\u9758\u977D\u977A\u977E\u9783\u9780\u9782\u977B\u9784\u9781\u977F\u97CE\u97CD\u9816\u98AD\u98AE\u9902\u9900\u9907\u999D\u999C\u99C3\u99B9\u99BB\u99BA\u99C2\u99BD\u99C7\u9AB1\u9AE3\u9AE7\u9B3E\u9B3F\u9B60\u9B61\u9B5F\u9CF1\u9CF2\u9CF5\u9EA7\u50FF\u5103\u5130\u50F8\u5106\u5107\u50F6\u50FE\u510B\u510C\u50FD\u510A\u528B\u528C\u52F1\u52EF\u5648\u5642\u564C\u5635\u5641\u564A\u5649\u5646\u5658"],
      ["e540", "\u565A\u5640\u5633\u563D\u562C\u563E\u5638\u562A\u563A\u571A\u58AB\u589D\u58B1\u58A0\u58A3\u58AF\u58AC\u58A5\u58A1\u58FF\u5AFF\u5AF4\u5AFD\u5AF7\u5AF6\u5B03\u5AF8\u5B02\u5AF9\u5B01\u5B07\u5B05\u5B0F\u5C67\u5D99\u5D97\u5D9F\u5D92\u5DA2\u5D93\u5D95\u5DA0\u5D9C\u5DA1\u5D9A\u5D9E\u5E69\u5E5D\u5E60\u5E5C\u7DF3\u5EDB\u5EDE\u5EE1\u5F49\u5FB2\u618B\u6183\u6179\u61B1\u61B0\u61A2\u6189"],
      ["e5a1", "\u619B\u6193\u61AF\u61AD\u619F\u6192\u61AA\u61A1\u618D\u6166\u61B3\u622D\u646E\u6470\u6496\u64A0\u6485\u6497\u649C\u648F\u648B\u648A\u648C\u64A3\u649F\u6468\u64B1\u6498\u6576\u657A\u6579\u657B\u65B2\u65B3\u66B5\u66B0\u66A9\u66B2\u66B7\u66AA\u66AF\u6A00\u6A06\u6A17\u69E5\u69F8\u6A15\u69F1\u69E4\u6A20\u69FF\u69EC\u69E2\u6A1B\u6A1D\u69FE\u6A27\u69F2\u69EE\u6A14\u69F7\u69E7\u6A40\u6A08\u69E6\u69FB\u6A0D\u69FC\u69EB\u6A09\u6A04\u6A18\u6A25\u6A0F\u69F6\u6A26\u6A07\u69F4\u6A16\u6B51\u6BA5\u6BA3\u6BA2\u6BA6\u6C01\u6C00\u6BFF\u6C02\u6F41\u6F26\u6F7E\u6F87\u6FC6\u6F92"],
      ["e640", "\u6F8D\u6F89\u6F8C\u6F62\u6F4F\u6F85\u6F5A\u6F96\u6F76\u6F6C\u6F82\u6F55\u6F72\u6F52\u6F50\u6F57\u6F94\u6F93\u6F5D\u6F00\u6F61\u6F6B\u6F7D\u6F67\u6F90\u6F53\u6F8B\u6F69\u6F7F\u6F95\u6F63\u6F77\u6F6A\u6F7B\u71B2\u71AF\u719B\u71B0\u71A0\u719A\u71A9\u71B5\u719D\u71A5\u719E\u71A4\u71A1\u71AA\u719C\u71A7\u71B3\u7298\u729A\u7358\u7352\u735E\u735F\u7360\u735D\u735B\u7361\u735A\u7359"],
      ["e6a1", "\u7362\u7487\u7489\u748A\u7486\u7481\u747D\u7485\u7488\u747C\u7479\u7508\u7507\u757E\u7625\u761E\u7619\u761D\u761C\u7623\u761A\u7628\u761B\u769C\u769D\u769E\u769B\u778D\u778F\u7789\u7788\u78CD\u78BB\u78CF\u78CC\u78D1\u78CE\u78D4\u78C8\u78C3\u78C4\u78C9\u799A\u79A1\u79A0\u799C\u79A2\u799B\u6B76\u7A39\u7AB2\u7AB4\u7AB3\u7BB7\u7BCB\u7BBE\u7BAC\u7BCE\u7BAF\u7BB9\u7BCA\u7BB5\u7CC5\u7CC8\u7CCC\u7CCB\u7DF7\u7DDB\u7DEA\u7DE7\u7DD7\u7DE1\u7E03\u7DFA\u7DE6\u7DF6\u7DF1\u7DF0\u7DEE\u7DDF\u7F76\u7FAC\u7FB0\u7FAD\u7FED\u7FEB\u7FEA\u7FEC\u7FE6\u7FE8\u8064\u8067\u81A3\u819F"],
      ["e740", "\u819E\u8195\u81A2\u8199\u8197\u8216\u824F\u8253\u8252\u8250\u824E\u8251\u8524\u853B\u850F\u8500\u8529\u850E\u8509\u850D\u851F\u850A\u8527\u851C\u84FB\u852B\u84FA\u8508\u850C\u84F4\u852A\u84F2\u8515\u84F7\u84EB\u84F3\u84FC\u8512\u84EA\u84E9\u8516\u84FE\u8528\u851D\u852E\u8502\u84FD\u851E\u84F6\u8531\u8526\u84E7\u84E8\u84F0\u84EF\u84F9\u8518\u8520\u8530\u850B\u8519\u852F\u8662"],
      ["e7a1", "\u8756\u8763\u8764\u8777\u87E1\u8773\u8758\u8754\u875B\u8752\u8761\u875A\u8751\u875E\u876D\u876A\u8750\u874E\u875F\u875D\u876F\u876C\u877A\u876E\u875C\u8765\u874F\u877B\u8775\u8762\u8767\u8769\u885A\u8905\u890C\u8914\u890B\u8917\u8918\u8919\u8906\u8916\u8911\u890E\u8909\u89A2\u89A4\u89A3\u89ED\u89F0\u89EC\u8ACF\u8AC6\u8AB8\u8AD3\u8AD1\u8AD4\u8AD5\u8ABB\u8AD7\u8ABE\u8AC0\u8AC5\u8AD8\u8AC3\u8ABA\u8ABD\u8AD9\u8C3E\u8C4D\u8C8F\u8CE5\u8CDF\u8CD9\u8CE8\u8CDA\u8CDD\u8CE7\u8DA0\u8D9C\u8DA1\u8D9B\u8E20\u8E23\u8E25\u8E24\u8E2E\u8E15\u8E1B\u8E16\u8E11\u8E19\u8E26\u8E27"],
      ["e840", "\u8E14\u8E12\u8E18\u8E13\u8E1C\u8E17\u8E1A\u8F2C\u8F24\u8F18\u8F1A\u8F20\u8F23\u8F16\u8F17\u9073\u9070\u906F\u9067\u906B\u912F\u912B\u9129\u912A\u9132\u9126\u912E\u9185\u9186\u918A\u9181\u9182\u9184\u9180\u92D0\u92C3\u92C4\u92C0\u92D9\u92B6\u92CF\u92F1\u92DF\u92D8\u92E9\u92D7\u92DD\u92CC\u92EF\u92C2\u92E8\u92CA\u92C8\u92CE\u92E6\u92CD\u92D5\u92C9\u92E0\u92DE\u92E7\u92D1\u92D3"],
      ["e8a1", "\u92B5\u92E1\u92C6\u92B4\u957C\u95AC\u95AB\u95AE\u95B0\u96A4\u96A2\u96D3\u9705\u9708\u9702\u975A\u978A\u978E\u9788\u97D0\u97CF\u981E\u981D\u9826\u9829\u9828\u9820\u981B\u9827\u98B2\u9908\u98FA\u9911\u9914\u9916\u9917\u9915\u99DC\u99CD\u99CF\u99D3\u99D4\u99CE\u99C9\u99D6\u99D8\u99CB\u99D7\u99CC\u9AB3\u9AEC\u9AEB\u9AF3\u9AF2\u9AF1\u9B46\u9B43\u9B67\u9B74\u9B71\u9B66\u9B76\u9B75\u9B70\u9B68\u9B64\u9B6C\u9CFC\u9CFA\u9CFD\u9CFF\u9CF7\u9D07\u9D00\u9CF9\u9CFB\u9D08\u9D05\u9D04\u9E83\u9ED3\u9F0F\u9F10\u511C\u5113\u5117\u511A\u5111\u51DE\u5334\u53E1\u5670\u5660\u566E"],
      ["e940", "\u5673\u5666\u5663\u566D\u5672\u565E\u5677\u571C\u571B\u58C8\u58BD\u58C9\u58BF\u58BA\u58C2\u58BC\u58C6\u5B17\u5B19\u5B1B\u5B21\u5B14\u5B13\u5B10\u5B16\u5B28\u5B1A\u5B20\u5B1E\u5BEF\u5DAC\u5DB1\u5DA9\u5DA7\u5DB5\u5DB0\u5DAE\u5DAA\u5DA8\u5DB2\u5DAD\u5DAF\u5DB4\u5E67\u5E68\u5E66\u5E6F\u5EE9\u5EE7\u5EE6\u5EE8\u5EE5\u5F4B\u5FBC\u619D\u61A8\u6196\u61C5\u61B4\u61C6\u61C1\u61CC\u61BA"],
      ["e9a1", "\u61BF\u61B8\u618C\u64D7\u64D6\u64D0\u64CF\u64C9\u64BD\u6489\u64C3\u64DB\u64F3\u64D9\u6533\u657F\u657C\u65A2\u66C8\u66BE\u66C0\u66CA\u66CB\u66CF\u66BD\u66BB\u66BA\u66CC\u6723\u6A34\u6A66\u6A49\u6A67\u6A32\u6A68\u6A3E\u6A5D\u6A6D\u6A76\u6A5B\u6A51\u6A28\u6A5A\u6A3B\u6A3F\u6A41\u6A6A\u6A64\u6A50\u6A4F\u6A54\u6A6F\u6A69\u6A60\u6A3C\u6A5E\u6A56\u6A55\u6A4D\u6A4E\u6A46\u6B55\u6B54\u6B56\u6BA7\u6BAA\u6BAB\u6BC8\u6BC7\u6C04\u6C03\u6C06\u6FAD\u6FCB\u6FA3\u6FC7\u6FBC\u6FCE\u6FC8\u6F5E\u6FC4\u6FBD\u6F9E\u6FCA\u6FA8\u7004\u6FA5\u6FAE\u6FBA\u6FAC\u6FAA\u6FCF\u6FBF\u6FB8"],
      ["ea40", "\u6FA2\u6FC9\u6FAB\u6FCD\u6FAF\u6FB2\u6FB0\u71C5\u71C2\u71BF\u71B8\u71D6\u71C0\u71C1\u71CB\u71D4\u71CA\u71C7\u71CF\u71BD\u71D8\u71BC\u71C6\u71DA\u71DB\u729D\u729E\u7369\u7366\u7367\u736C\u7365\u736B\u736A\u747F\u749A\u74A0\u7494\u7492\u7495\u74A1\u750B\u7580\u762F\u762D\u7631\u763D\u7633\u763C\u7635\u7632\u7630\u76BB\u76E6\u779A\u779D\u77A1\u779C\u779B\u77A2\u77A3\u7795\u7799"],
      ["eaa1", "\u7797\u78DD\u78E9\u78E5\u78EA\u78DE\u78E3\u78DB\u78E1\u78E2\u78ED\u78DF\u78E0\u79A4\u7A44\u7A48\u7A47\u7AB6\u7AB8\u7AB5\u7AB1\u7AB7\u7BDE\u7BE3\u7BE7\u7BDD\u7BD5\u7BE5\u7BDA\u7BE8\u7BF9\u7BD4\u7BEA\u7BE2\u7BDC\u7BEB\u7BD8\u7BDF\u7CD2\u7CD4\u7CD7\u7CD0\u7CD1\u7E12\u7E21\u7E17\u7E0C\u7E1F\u7E20\u7E13\u7E0E\u7E1C\u7E15\u7E1A\u7E22\u7E0B\u7E0F\u7E16\u7E0D\u7E14\u7E25\u7E24\u7F43\u7F7B\u7F7C\u7F7A\u7FB1\u7FEF\u802A\u8029\u806C\u81B1\u81A6\u81AE\u81B9\u81B5\u81AB\u81B0\u81AC\u81B4\u81B2\u81B7\u81A7\u81F2\u8255\u8256\u8257\u8556\u8545\u856B\u854D\u8553\u8561\u8558"],
      ["eb40", "\u8540\u8546\u8564\u8541\u8562\u8544\u8551\u8547\u8563\u853E\u855B\u8571\u854E\u856E\u8575\u8555\u8567\u8560\u858C\u8566\u855D\u8554\u8565\u856C\u8663\u8665\u8664\u879B\u878F\u8797\u8793\u8792\u8788\u8781\u8796\u8798\u8779\u8787\u87A3\u8785\u8790\u8791\u879D\u8784\u8794\u879C\u879A\u8789\u891E\u8926\u8930\u892D\u892E\u8927\u8931\u8922\u8929\u8923\u892F\u892C\u891F\u89F1\u8AE0"],
      ["eba1", "\u8AE2\u8AF2\u8AF4\u8AF5\u8ADD\u8B14\u8AE4\u8ADF\u8AF0\u8AC8\u8ADE\u8AE1\u8AE8\u8AFF\u8AEF\u8AFB\u8C91\u8C92\u8C90\u8CF5\u8CEE\u8CF1\u8CF0\u8CF3\u8D6C\u8D6E\u8DA5\u8DA7\u8E33\u8E3E\u8E38\u8E40\u8E45\u8E36\u8E3C\u8E3D\u8E41\u8E30\u8E3F\u8EBD\u8F36\u8F2E\u8F35\u8F32\u8F39\u8F37\u8F34\u9076\u9079\u907B\u9086\u90FA\u9133\u9135\u9136\u9193\u9190\u9191\u918D\u918F\u9327\u931E\u9308\u931F\u9306\u930F\u937A\u9338\u933C\u931B\u9323\u9312\u9301\u9346\u932D\u930E\u930D\u92CB\u931D\u92FA\u9325\u9313\u92F9\u92F7\u9334\u9302\u9324\u92FF\u9329\u9339\u9335\u932A\u9314\u930C"],
      ["ec40", "\u930B\u92FE\u9309\u9300\u92FB\u9316\u95BC\u95CD\u95BE\u95B9\u95BA\u95B6\u95BF\u95B5\u95BD\u96A9\u96D4\u970B\u9712\u9710\u9799\u9797\u9794\u97F0\u97F8\u9835\u982F\u9832\u9924\u991F\u9927\u9929\u999E\u99EE\u99EC\u99E5\u99E4\u99F0\u99E3\u99EA\u99E9\u99E7\u9AB9\u9ABF\u9AB4\u9ABB\u9AF6\u9AFA\u9AF9\u9AF7\u9B33\u9B80\u9B85\u9B87\u9B7C\u9B7E\u9B7B\u9B82\u9B93\u9B92\u9B90\u9B7A\u9B95"],
      ["eca1", "\u9B7D\u9B88\u9D25\u9D17\u9D20\u9D1E\u9D14\u9D29\u9D1D\u9D18\u9D22\u9D10\u9D19\u9D1F\u9E88\u9E86\u9E87\u9EAE\u9EAD\u9ED5\u9ED6\u9EFA\u9F12\u9F3D\u5126\u5125\u5122\u5124\u5120\u5129\u52F4\u5693\u568C\u568D\u5686\u5684\u5683\u567E\u5682\u567F\u5681\u58D6\u58D4\u58CF\u58D2\u5B2D\u5B25\u5B32\u5B23\u5B2C\u5B27\u5B26\u5B2F\u5B2E\u5B7B\u5BF1\u5BF2\u5DB7\u5E6C\u5E6A\u5FBE\u5FBB\u61C3\u61B5\u61BC\u61E7\u61E0\u61E5\u61E4\u61E8\u61DE\u64EF\u64E9\u64E3\u64EB\u64E4\u64E8\u6581\u6580\u65B6\u65DA\u66D2\u6A8D\u6A96\u6A81\u6AA5\u6A89\u6A9F\u6A9B\u6AA1\u6A9E\u6A87\u6A93\u6A8E"],
      ["ed40", "\u6A95\u6A83\u6AA8\u6AA4\u6A91\u6A7F\u6AA6\u6A9A\u6A85\u6A8C\u6A92\u6B5B\u6BAD\u6C09\u6FCC\u6FA9\u6FF4\u6FD4\u6FE3\u6FDC\u6FED\u6FE7\u6FE6\u6FDE\u6FF2\u6FDD\u6FE2\u6FE8\u71E1\u71F1\u71E8\u71F2\u71E4\u71F0\u71E2\u7373\u736E\u736F\u7497\u74B2\u74AB\u7490\u74AA\u74AD\u74B1\u74A5\u74AF\u7510\u7511\u7512\u750F\u7584\u7643\u7648\u7649\u7647\u76A4\u76E9\u77B5\u77AB\u77B2\u77B7\u77B6"],
      ["eda1", "\u77B4\u77B1\u77A8\u77F0\u78F3\u78FD\u7902\u78FB\u78FC\u78F2\u7905\u78F9\u78FE\u7904\u79AB\u79A8\u7A5C\u7A5B\u7A56\u7A58\u7A54\u7A5A\u7ABE\u7AC0\u7AC1\u7C05\u7C0F\u7BF2\u7C00\u7BFF\u7BFB\u7C0E\u7BF4\u7C0B\u7BF3\u7C02\u7C09\u7C03\u7C01\u7BF8\u7BFD\u7C06\u7BF0\u7BF1\u7C10\u7C0A\u7CE8\u7E2D\u7E3C\u7E42\u7E33\u9848\u7E38\u7E2A\u7E49\u7E40\u7E47\u7E29\u7E4C\u7E30\u7E3B\u7E36\u7E44\u7E3A\u7F45\u7F7F\u7F7E\u7F7D\u7FF4\u7FF2\u802C\u81BB\u81C4\u81CC\u81CA\u81C5\u81C7\u81BC\u81E9\u825B\u825A\u825C\u8583\u8580\u858F\u85A7\u8595\u85A0\u858B\u85A3\u857B\u85A4\u859A\u859E"],
      ["ee40", "\u8577\u857C\u8589\u85A1\u857A\u8578\u8557\u858E\u8596\u8586\u858D\u8599\u859D\u8581\u85A2\u8582\u8588\u8585\u8579\u8576\u8598\u8590\u859F\u8668\u87BE\u87AA\u87AD\u87C5\u87B0\u87AC\u87B9\u87B5\u87BC\u87AE\u87C9\u87C3\u87C2\u87CC\u87B7\u87AF\u87C4\u87CA\u87B4\u87B6\u87BF\u87B8\u87BD\u87DE\u87B2\u8935\u8933\u893C\u893E\u8941\u8952\u8937\u8942\u89AD\u89AF\u89AE\u89F2\u89F3\u8B1E"],
      ["eea1", "\u8B18\u8B16\u8B11\u8B05\u8B0B\u8B22\u8B0F\u8B12\u8B15\u8B07\u8B0D\u8B08\u8B06\u8B1C\u8B13\u8B1A\u8C4F\u8C70\u8C72\u8C71\u8C6F\u8C95\u8C94\u8CF9\u8D6F\u8E4E\u8E4D\u8E53\u8E50\u8E4C\u8E47\u8F43\u8F40\u9085\u907E\u9138\u919A\u91A2\u919B\u9199\u919F\u91A1\u919D\u91A0\u93A1\u9383\u93AF\u9364\u9356\u9347\u937C\u9358\u935C\u9376\u9349\u9350\u9351\u9360\u936D\u938F\u934C\u936A\u9379\u9357\u9355\u9352\u934F\u9371\u9377\u937B\u9361\u935E\u9363\u9367\u9380\u934E\u9359\u95C7\u95C0\u95C9\u95C3\u95C5\u95B7\u96AE\u96B0\u96AC\u9720\u971F\u9718\u971D\u9719\u979A\u97A1\u979C"],
      ["ef40", "\u979E\u979D\u97D5\u97D4\u97F1\u9841\u9844\u984A\u9849\u9845\u9843\u9925\u992B\u992C\u992A\u9933\u9932\u992F\u992D\u9931\u9930\u9998\u99A3\u99A1\u9A02\u99FA\u99F4\u99F7\u99F9\u99F8\u99F6\u99FB\u99FD\u99FE\u99FC\u9A03\u9ABE\u9AFE\u9AFD\u9B01\u9AFC\u9B48\u9B9A\u9BA8\u9B9E\u9B9B\u9BA6\u9BA1\u9BA5\u9BA4\u9B86\u9BA2\u9BA0\u9BAF\u9D33\u9D41\u9D67\u9D36\u9D2E\u9D2F\u9D31\u9D38\u9D30"],
      ["efa1", "\u9D45\u9D42\u9D43\u9D3E\u9D37\u9D40\u9D3D\u7FF5\u9D2D\u9E8A\u9E89\u9E8D\u9EB0\u9EC8\u9EDA\u9EFB\u9EFF\u9F24\u9F23\u9F22\u9F54\u9FA0\u5131\u512D\u512E\u5698\u569C\u5697\u569A\u569D\u5699\u5970\u5B3C\u5C69\u5C6A\u5DC0\u5E6D\u5E6E\u61D8\u61DF\u61ED\u61EE\u61F1\u61EA\u61F0\u61EB\u61D6\u61E9\u64FF\u6504\u64FD\u64F8\u6501\u6503\u64FC\u6594\u65DB\u66DA\u66DB\u66D8\u6AC5\u6AB9\u6ABD\u6AE1\u6AC6\u6ABA\u6AB6\u6AB7\u6AC7\u6AB4\u6AAD\u6B5E\u6BC9\u6C0B\u7007\u700C\u700D\u7001\u7005\u7014\u700E\u6FFF\u7000\u6FFB\u7026\u6FFC\u6FF7\u700A\u7201\u71FF\u71F9\u7203\u71FD\u7376"],
      ["f040", "\u74B8\u74C0\u74B5\u74C1\u74BE\u74B6\u74BB\u74C2\u7514\u7513\u765C\u7664\u7659\u7650\u7653\u7657\u765A\u76A6\u76BD\u76EC\u77C2\u77BA\u78FF\u790C\u7913\u7914\u7909\u7910\u7912\u7911\u79AD\u79AC\u7A5F\u7C1C\u7C29\u7C19\u7C20\u7C1F\u7C2D\u7C1D\u7C26\u7C28\u7C22\u7C25\u7C30\u7E5C\u7E50\u7E56\u7E63\u7E58\u7E62\u7E5F\u7E51\u7E60\u7E57\u7E53\u7FB5\u7FB3\u7FF7\u7FF8\u8075\u81D1\u81D2"],
      ["f0a1", "\u81D0\u825F\u825E\u85B4\u85C6\u85C0\u85C3\u85C2\u85B3\u85B5\u85BD\u85C7\u85C4\u85BF\u85CB\u85CE\u85C8\u85C5\u85B1\u85B6\u85D2\u8624\u85B8\u85B7\u85BE\u8669\u87E7\u87E6\u87E2\u87DB\u87EB\u87EA\u87E5\u87DF\u87F3\u87E4\u87D4\u87DC\u87D3\u87ED\u87D8\u87E3\u87A4\u87D7\u87D9\u8801\u87F4\u87E8\u87DD\u8953\u894B\u894F\u894C\u8946\u8950\u8951\u8949\u8B2A\u8B27\u8B23\u8B33\u8B30\u8B35\u8B47\u8B2F\u8B3C\u8B3E\u8B31\u8B25\u8B37\u8B26\u8B36\u8B2E\u8B24\u8B3B\u8B3D\u8B3A\u8C42\u8C75\u8C99\u8C98\u8C97\u8CFE\u8D04\u8D02\u8D00\u8E5C\u8E62\u8E60\u8E57\u8E56\u8E5E\u8E65\u8E67"],
      ["f140", "\u8E5B\u8E5A\u8E61\u8E5D\u8E69\u8E54\u8F46\u8F47\u8F48\u8F4B\u9128\u913A\u913B\u913E\u91A8\u91A5\u91A7\u91AF\u91AA\u93B5\u938C\u9392\u93B7\u939B\u939D\u9389\u93A7\u938E\u93AA\u939E\u93A6\u9395\u9388\u9399\u939F\u938D\u93B1\u9391\u93B2\u93A4\u93A8\u93B4\u93A3\u93A5\u95D2\u95D3\u95D1\u96B3\u96D7\u96DA\u5DC2\u96DF\u96D8\u96DD\u9723\u9722\u9725\u97AC\u97AE\u97A8\u97AB\u97A4\u97AA"],
      ["f1a1", "\u97A2\u97A5\u97D7\u97D9\u97D6\u97D8\u97FA\u9850\u9851\u9852\u98B8\u9941\u993C\u993A\u9A0F\u9A0B\u9A09\u9A0D\u9A04\u9A11\u9A0A\u9A05\u9A07\u9A06\u9AC0\u9ADC\u9B08\u9B04\u9B05\u9B29\u9B35\u9B4A\u9B4C\u9B4B\u9BC7\u9BC6\u9BC3\u9BBF\u9BC1\u9BB5\u9BB8\u9BD3\u9BB6\u9BC4\u9BB9\u9BBD\u9D5C\u9D53\u9D4F\u9D4A\u9D5B\u9D4B\u9D59\u9D56\u9D4C\u9D57\u9D52\u9D54\u9D5F\u9D58\u9D5A\u9E8E\u9E8C\u9EDF\u9F01\u9F00\u9F16\u9F25\u9F2B\u9F2A\u9F29\u9F28\u9F4C\u9F55\u5134\u5135\u5296\u52F7\u53B4\u56AB\u56AD\u56A6\u56A7\u56AA\u56AC\u58DA\u58DD\u58DB\u5912\u5B3D\u5B3E\u5B3F\u5DC3\u5E70"],
      ["f240", "\u5FBF\u61FB\u6507\u6510\u650D\u6509\u650C\u650E\u6584\u65DE\u65DD\u66DE\u6AE7\u6AE0\u6ACC\u6AD1\u6AD9\u6ACB\u6ADF\u6ADC\u6AD0\u6AEB\u6ACF\u6ACD\u6ADE\u6B60\u6BB0\u6C0C\u7019\u7027\u7020\u7016\u702B\u7021\u7022\u7023\u7029\u7017\u7024\u701C\u702A\u720C\u720A\u7207\u7202\u7205\u72A5\u72A6\u72A4\u72A3\u72A1\u74CB\u74C5\u74B7\u74C3\u7516\u7660\u77C9\u77CA\u77C4\u77F1\u791D\u791B"],
      ["f2a1", "\u7921\u791C\u7917\u791E\u79B0\u7A67\u7A68\u7C33\u7C3C\u7C39\u7C2C\u7C3B\u7CEC\u7CEA\u7E76\u7E75\u7E78\u7E70\u7E77\u7E6F\u7E7A\u7E72\u7E74\u7E68\u7F4B\u7F4A\u7F83\u7F86\u7FB7\u7FFD\u7FFE\u8078\u81D7\u81D5\u8264\u8261\u8263\u85EB\u85F1\u85ED\u85D9\u85E1\u85E8\u85DA\u85D7\u85EC\u85F2\u85F8\u85D8\u85DF\u85E3\u85DC\u85D1\u85F0\u85E6\u85EF\u85DE\u85E2\u8800\u87FA\u8803\u87F6\u87F7\u8809\u880C\u880B\u8806\u87FC\u8808\u87FF\u880A\u8802\u8962\u895A\u895B\u8957\u8961\u895C\u8958\u895D\u8959\u8988\u89B7\u89B6\u89F6\u8B50\u8B48\u8B4A\u8B40\u8B53\u8B56\u8B54\u8B4B\u8B55"],
      ["f340", "\u8B51\u8B42\u8B52\u8B57\u8C43\u8C77\u8C76\u8C9A\u8D06\u8D07\u8D09\u8DAC\u8DAA\u8DAD\u8DAB\u8E6D\u8E78\u8E73\u8E6A\u8E6F\u8E7B\u8EC2\u8F52\u8F51\u8F4F\u8F50\u8F53\u8FB4\u9140\u913F\u91B0\u91AD\u93DE\u93C7\u93CF\u93C2\u93DA\u93D0\u93F9\u93EC\u93CC\u93D9\u93A9\u93E6\u93CA\u93D4\u93EE\u93E3\u93D5\u93C4\u93CE\u93C0\u93D2\u93E7\u957D\u95DA\u95DB\u96E1\u9729\u972B\u972C\u9728\u9726"],
      ["f3a1", "\u97B3\u97B7\u97B6\u97DD\u97DE\u97DF\u985C\u9859\u985D\u9857\u98BF\u98BD\u98BB\u98BE\u9948\u9947\u9943\u99A6\u99A7\u9A1A\u9A15\u9A25\u9A1D\u9A24\u9A1B\u9A22\u9A20\u9A27\u9A23\u9A1E\u9A1C\u9A14\u9AC2\u9B0B\u9B0A\u9B0E\u9B0C\u9B37\u9BEA\u9BEB\u9BE0\u9BDE\u9BE4\u9BE6\u9BE2\u9BF0\u9BD4\u9BD7\u9BEC\u9BDC\u9BD9\u9BE5\u9BD5\u9BE1\u9BDA\u9D77\u9D81\u9D8A\u9D84\u9D88\u9D71\u9D80\u9D78\u9D86\u9D8B\u9D8C\u9D7D\u9D6B\u9D74\u9D75\u9D70\u9D69\u9D85\u9D73\u9D7B\u9D82\u9D6F\u9D79\u9D7F\u9D87\u9D68\u9E94\u9E91\u9EC0\u9EFC\u9F2D\u9F40\u9F41\u9F4D\u9F56\u9F57\u9F58\u5337\u56B2"],
      ["f440", "\u56B5\u56B3\u58E3\u5B45\u5DC6\u5DC7\u5EEE\u5EEF\u5FC0\u5FC1\u61F9\u6517\u6516\u6515\u6513\u65DF\u66E8\u66E3\u66E4\u6AF3\u6AF0\u6AEA\u6AE8\u6AF9\u6AF1\u6AEE\u6AEF\u703C\u7035\u702F\u7037\u7034\u7031\u7042\u7038\u703F\u703A\u7039\u7040\u703B\u7033\u7041\u7213\u7214\u72A8\u737D\u737C\u74BA\u76AB\u76AA\u76BE\u76ED\u77CC\u77CE\u77CF\u77CD\u77F2\u7925\u7923\u7927\u7928\u7924\u7929"],
      ["f4a1", "\u79B2\u7A6E\u7A6C\u7A6D\u7AF7\u7C49\u7C48\u7C4A\u7C47\u7C45\u7CEE\u7E7B\u7E7E\u7E81\u7E80\u7FBA\u7FFF\u8079\u81DB\u81D9\u820B\u8268\u8269\u8622\u85FF\u8601\u85FE\u861B\u8600\u85F6\u8604\u8609\u8605\u860C\u85FD\u8819\u8810\u8811\u8817\u8813\u8816\u8963\u8966\u89B9\u89F7\u8B60\u8B6A\u8B5D\u8B68\u8B63\u8B65\u8B67\u8B6D\u8DAE\u8E86\u8E88\u8E84\u8F59\u8F56\u8F57\u8F55\u8F58\u8F5A\u908D\u9143\u9141\u91B7\u91B5\u91B2\u91B3\u940B\u9413\u93FB\u9420\u940F\u9414\u93FE\u9415\u9410\u9428\u9419\u940D\u93F5\u9400\u93F7\u9407\u940E\u9416\u9412\u93FA\u9409\u93F8\u940A\u93FF"],
      ["f540", "\u93FC\u940C\u93F6\u9411\u9406\u95DE\u95E0\u95DF\u972E\u972F\u97B9\u97BB\u97FD\u97FE\u9860\u9862\u9863\u985F\u98C1\u98C2\u9950\u994E\u9959\u994C\u994B\u9953\u9A32\u9A34\u9A31\u9A2C\u9A2A\u9A36\u9A29\u9A2E\u9A38\u9A2D\u9AC7\u9ACA\u9AC6\u9B10\u9B12\u9B11\u9C0B\u9C08\u9BF7\u9C05\u9C12\u9BF8\u9C40\u9C07\u9C0E\u9C06\u9C17\u9C14\u9C09\u9D9F\u9D99\u9DA4\u9D9D\u9D92\u9D98\u9D90\u9D9B"],
      ["f5a1", "\u9DA0\u9D94\u9D9C\u9DAA\u9D97\u9DA1\u9D9A\u9DA2\u9DA8\u9D9E\u9DA3\u9DBF\u9DA9\u9D96\u9DA6\u9DA7\u9E99\u9E9B\u9E9A\u9EE5\u9EE4\u9EE7\u9EE6\u9F30\u9F2E\u9F5B\u9F60\u9F5E\u9F5D\u9F59\u9F91\u513A\u5139\u5298\u5297\u56C3\u56BD\u56BE\u5B48\u5B47\u5DCB\u5DCF\u5EF1\u61FD\u651B\u6B02\u6AFC\u6B03\u6AF8\u6B00\u7043\u7044\u704A\u7048\u7049\u7045\u7046\u721D\u721A\u7219\u737E\u7517\u766A\u77D0\u792D\u7931\u792F\u7C54\u7C53\u7CF2\u7E8A\u7E87\u7E88\u7E8B\u7E86\u7E8D\u7F4D\u7FBB\u8030\u81DD\u8618\u862A\u8626\u861F\u8623\u861C\u8619\u8627\u862E\u8621\u8620\u8629\u861E\u8625"],
      ["f640", "\u8829\u881D\u881B\u8820\u8824\u881C\u882B\u884A\u896D\u8969\u896E\u896B\u89FA\u8B79\u8B78\u8B45\u8B7A\u8B7B\u8D10\u8D14\u8DAF\u8E8E\u8E8C\u8F5E\u8F5B\u8F5D\u9146\u9144\u9145\u91B9\u943F\u943B\u9436\u9429\u943D\u943C\u9430\u9439\u942A\u9437\u942C\u9440\u9431\u95E5\u95E4\u95E3\u9735\u973A\u97BF\u97E1\u9864\u98C9\u98C6\u98C0\u9958\u9956\u9A39\u9A3D\u9A46\u9A44\u9A42\u9A41\u9A3A"],
      ["f6a1", "\u9A3F\u9ACD\u9B15\u9B17\u9B18\u9B16\u9B3A\u9B52\u9C2B\u9C1D\u9C1C\u9C2C\u9C23\u9C28\u9C29\u9C24\u9C21\u9DB7\u9DB6\u9DBC\u9DC1\u9DC7\u9DCA\u9DCF\u9DBE\u9DC5\u9DC3\u9DBB\u9DB5\u9DCE\u9DB9\u9DBA\u9DAC\u9DC8\u9DB1\u9DAD\u9DCC\u9DB3\u9DCD\u9DB2\u9E7A\u9E9C\u9EEB\u9EEE\u9EED\u9F1B\u9F18\u9F1A\u9F31\u9F4E\u9F65\u9F64\u9F92\u4EB9\u56C6\u56C5\u56CB\u5971\u5B4B\u5B4C\u5DD5\u5DD1\u5EF2\u6521\u6520\u6526\u6522\u6B0B\u6B08\u6B09\u6C0D\u7055\u7056\u7057\u7052\u721E\u721F\u72A9\u737F\u74D8\u74D5\u74D9\u74D7\u766D\u76AD\u7935\u79B4\u7A70\u7A71\u7C57\u7C5C\u7C59\u7C5B\u7C5A"],
      ["f740", "\u7CF4\u7CF1\u7E91\u7F4F\u7F87\u81DE\u826B\u8634\u8635\u8633\u862C\u8632\u8636\u882C\u8828\u8826\u882A\u8825\u8971\u89BF\u89BE\u89FB\u8B7E\u8B84\u8B82\u8B86\u8B85\u8B7F\u8D15\u8E95\u8E94\u8E9A\u8E92\u8E90\u8E96\u8E97\u8F60\u8F62\u9147\u944C\u9450\u944A\u944B\u944F\u9447\u9445\u9448\u9449\u9446\u973F\u97E3\u986A\u9869\u98CB\u9954\u995B\u9A4E\u9A53\u9A54\u9A4C\u9A4F\u9A48\u9A4A"],
      ["f7a1", "\u9A49\u9A52\u9A50\u9AD0\u9B19\u9B2B\u9B3B\u9B56\u9B55\u9C46\u9C48\u9C3F\u9C44\u9C39\u9C33\u9C41\u9C3C\u9C37\u9C34\u9C32\u9C3D\u9C36\u9DDB\u9DD2\u9DDE\u9DDA\u9DCB\u9DD0\u9DDC\u9DD1\u9DDF\u9DE9\u9DD9\u9DD8\u9DD6\u9DF5\u9DD5\u9DDD\u9EB6\u9EF0\u9F35\u9F33\u9F32\u9F42\u9F6B\u9F95\u9FA2\u513D\u5299\u58E8\u58E7\u5972\u5B4D\u5DD8\u882F\u5F4F\u6201\u6203\u6204\u6529\u6525\u6596\u66EB\u6B11\u6B12\u6B0F\u6BCA\u705B\u705A\u7222\u7382\u7381\u7383\u7670\u77D4\u7C67\u7C66\u7E95\u826C\u863A\u8640\u8639\u863C\u8631\u863B\u863E\u8830\u8832\u882E\u8833\u8976\u8974\u8973\u89FE"],
      ["f840", "\u8B8C\u8B8E\u8B8B\u8B88\u8C45\u8D19\u8E98\u8F64\u8F63\u91BC\u9462\u9455\u945D\u9457\u945E\u97C4\u97C5\u9800\u9A56\u9A59\u9B1E\u9B1F\u9B20\u9C52\u9C58\u9C50\u9C4A\u9C4D\u9C4B\u9C55\u9C59\u9C4C\u9C4E\u9DFB\u9DF7\u9DEF\u9DE3\u9DEB\u9DF8\u9DE4\u9DF6\u9DE1\u9DEE\u9DE6\u9DF2\u9DF0\u9DE2\u9DEC\u9DF4\u9DF3\u9DE8\u9DED\u9EC2\u9ED0\u9EF2\u9EF3\u9F06\u9F1C\u9F38\u9F37\u9F36\u9F43\u9F4F"],
      ["f8a1", "\u9F71\u9F70\u9F6E\u9F6F\u56D3\u56CD\u5B4E\u5C6D\u652D\u66ED\u66EE\u6B13\u705F\u7061\u705D\u7060\u7223\u74DB\u74E5\u77D5\u7938\u79B7\u79B6\u7C6A\u7E97\u7F89\u826D\u8643\u8838\u8837\u8835\u884B\u8B94\u8B95\u8E9E\u8E9F\u8EA0\u8E9D\u91BE\u91BD\u91C2\u946B\u9468\u9469\u96E5\u9746\u9743\u9747\u97C7\u97E5\u9A5E\u9AD5\u9B59\u9C63\u9C67\u9C66\u9C62\u9C5E\u9C60\u9E02\u9DFE\u9E07\u9E03\u9E06\u9E05\u9E00\u9E01\u9E09\u9DFF\u9DFD\u9E04\u9EA0\u9F1E\u9F46\u9F74\u9F75\u9F76\u56D4\u652E\u65B8\u6B18\u6B19\u6B17\u6B1A\u7062\u7226\u72AA\u77D8\u77D9\u7939\u7C69\u7C6B\u7CF6\u7E9A"],
      ["f940", "\u7E98\u7E9B\u7E99\u81E0\u81E1\u8646\u8647\u8648\u8979\u897A\u897C\u897B\u89FF\u8B98\u8B99\u8EA5\u8EA4\u8EA3\u946E\u946D\u946F\u9471\u9473\u9749\u9872\u995F\u9C68\u9C6E\u9C6D\u9E0B\u9E0D\u9E10\u9E0F\u9E12\u9E11\u9EA1\u9EF5\u9F09\u9F47\u9F78\u9F7B\u9F7A\u9F79\u571E\u7066\u7C6F\u883C\u8DB2\u8EA6\u91C3\u9474\u9478\u9476\u9475\u9A60\u9C74\u9C73\u9C71\u9C75\u9E14\u9E13\u9EF6\u9F0A"],
      ["f9a1", "\u9FA4\u7068\u7065\u7CF7\u866A\u883E\u883D\u883F\u8B9E\u8C9C\u8EA9\u8EC9\u974B\u9873\u9874\u98CC\u9961\u99AB\u9A64\u9A66\u9A67\u9B24\u9E15\u9E17\u9F48\u6207\u6B1E\u7227\u864C\u8EA8\u9482\u9480\u9481\u9A69\u9A68\u9B2E\u9E19\u7229\u864B\u8B9F\u9483\u9C79\u9EB7\u7675\u9A6B\u9C7A\u9E1D\u7069\u706A\u9EA4\u9F7E\u9F49\u9F98\u7881\u92B9\u88CF\u58BB\u6052\u7CA7\u5AFA\u2554\u2566\u2557\u2560\u256C\u2563\u255A\u2569\u255D\u2552\u2564\u2555\u255E\u256A\u2561\u2558\u2567\u255B\u2553\u2565\u2556\u255F\u256B\u2562\u2559\u2568\u255C\u2551\u2550\u256D\u256E\u2570\u256F\u2593"]
    ];
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/big5-added.json
var require_big5_added = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/tables/big5-added.json"(exports2, module2) {
    module2.exports = [
      ["8740", "\u43F0\u4C32\u4603\u45A6\u4578\u{27267}\u4D77\u45B3\u{27CB1}\u4CE2\u{27CC5}\u3B95\u4736\u4744\u4C47\u4C40\u{242BF}\u{23617}\u{27352}\u{26E8B}\u{270D2}\u4C57\u{2A351}\u474F\u45DA\u4C85\u{27C6C}\u4D07\u4AA4\u46A1\u{26B23}\u7225\u{25A54}\u{21A63}\u{23E06}\u{23F61}\u664D\u56FB"],
      ["8767", "\u7D95\u591D\u{28BB9}\u3DF4\u9734\u{27BEF}\u5BDB\u{21D5E}\u5AA4\u3625\u{29EB0}\u5AD1\u5BB7\u5CFC\u676E\u8593\u{29945}\u7461\u749D\u3875\u{21D53}\u{2369E}\u{26021}\u3EEC"],
      ["87a1", "\u{258DE}\u3AF5\u7AFC\u9F97\u{24161}\u{2890D}\u{231EA}\u{20A8A}\u{2325E}\u430A\u8484\u9F96\u942F\u4930\u8613\u5896\u974A\u9218\u79D0\u7A32\u6660\u6A29\u889D\u744C\u7BC5\u6782\u7A2C\u524F\u9046\u34E6\u73C4\u{25DB9}\u74C6\u9FC7\u57B3\u492F\u544C\u4131\u{2368E}\u5818\u7A72\u{27B65}\u8B8F\u46AE\u{26E88}\u4181\u{25D99}\u7BAE\u{224BC}\u9FC8\u{224C1}\u{224C9}\u{224CC}\u9FC9\u8504\u{235BB}\u40B4\u9FCA\u44E1\u{2ADFF}\u62C1\u706E\u9FCB"],
      ["8840", "\u31C0", 4, "\u{2010C}\u31C5\u{200D1}\u{200CD}\u31C6\u31C7\u{200CB}\u{21FE8}\u31C8\u{200CA}\u31C9\u31CA\u31CB\u31CC\u{2010E}\u31CD\u31CE\u0100\xC1\u01CD\xC0\u0112\xC9\u011A\xC8\u014C\xD3\u01D1\xD2\u0FFF\xCA\u0304\u1EBE\u0FFF\xCA\u030C\u1EC0\xCA\u0101\xE1\u01CE\xE0\u0251\u0113\xE9\u011B\xE8\u012B\xED\u01D0\xEC\u014D\xF3\u01D2\xF2\u016B\xFA\u01D4\xF9\u01D6\u01D8\u01DA"],
      ["88a1", "\u01DC\xFC\u0FFF\xEA\u0304\u1EBF\u0FFF\xEA\u030C\u1EC1\xEA\u0261\u23DA\u23DB"],
      ["8940", "\u{2A3A9}\u{21145}"],
      ["8943", "\u650A"],
      ["8946", "\u4E3D\u6EDD\u9D4E\u91DF"],
      ["894c", "\u{27735}\u6491\u4F1A\u4F28\u4FA8\u5156\u5174\u519C\u51E4\u52A1\u52A8\u533B\u534E\u53D1\u53D8\u56E2\u58F0\u5904\u5907\u5932\u5934\u5B66\u5B9E\u5B9F\u5C9A\u5E86\u603B\u6589\u67FE\u6804\u6865\u6D4E\u70BC\u7535\u7EA4\u7EAC\u7EBA\u7EC7\u7ECF\u7EDF\u7F06\u7F37\u827A\u82CF\u836F\u89C6\u8BBE\u8BE2\u8F66\u8F67\u8F6E"],
      ["89a1", "\u7411\u7CFC\u7DCD\u6946\u7AC9\u5227"],
      ["89ab", "\u918C\u78B8\u915E\u80BC"],
      ["89b0", "\u8D0B\u80F6\u{209E7}"],
      ["89b5", "\u809F\u9EC7\u4CCD\u9DC9\u9E0C\u4C3E\u{29DF6}\u{2700E}\u9E0A\u{2A133}\u35C1"],
      ["89c1", "\u6E9A\u823E\u7519"],
      ["89c5", "\u4911\u9A6C\u9A8F\u9F99\u7987\u{2846C}\u{21DCA}\u{205D0}\u{22AE6}\u4E24\u4E81\u4E80\u4E87\u4EBF\u4EEB\u4F37\u344C\u4FBD\u3E48\u5003\u5088\u347D\u3493\u34A5\u5186\u5905\u51DB\u51FC\u5205\u4E89\u5279\u5290\u5327\u35C7\u53A9\u3551\u53B0\u3553\u53C2\u5423\u356D\u3572\u3681\u5493\u54A3\u54B4\u54B9\u54D0\u54EF\u5518\u5523\u5528\u3598\u553F\u35A5\u35BF\u55D7\u35C5"],
      ["8a40", "\u{27D84}\u5525"],
      ["8a43", "\u{20C42}\u{20D15}\u{2512B}\u5590\u{22CC6}\u39EC\u{20341}\u8E46\u{24DB8}\u{294E5}\u4053\u{280BE}\u777A\u{22C38}\u3A34\u47D5\u{2815D}\u{269F2}\u{24DEA}\u64DD\u{20D7C}\u{20FB4}\u{20CD5}\u{210F4}\u648D\u8E7E\u{20E96}\u{20C0B}\u{20F64}\u{22CA9}\u{28256}\u{244D3}"],
      ["8a64", "\u{20D46}\u{29A4D}\u{280E9}\u47F4\u{24EA7}\u{22CC2}\u9AB2\u3A67\u{295F4}\u3FED\u3506\u{252C7}\u{297D4}\u{278C8}\u{22D44}\u9D6E\u9815"],
      ["8a76", "\u43D9\u{260A5}\u64B4\u54E3\u{22D4C}\u{22BCA}\u{21077}\u39FB\u{2106F}"],
      ["8aa1", "\u{266DA}\u{26716}\u{279A0}\u64EA\u{25052}\u{20C43}\u8E68\u{221A1}\u{28B4C}\u{20731}"],
      ["8aac", "\u480B\u{201A9}\u3FFA\u5873\u{22D8D}"],
      ["8ab2", "\u{245C8}\u{204FC}\u{26097}\u{20F4C}\u{20D96}\u5579\u40BB\u43BA"],
      ["8abb", "\u4AB4\u{22A66}\u{2109D}\u81AA\u98F5\u{20D9C}\u6379\u39FE\u{22775}\u8DC0\u56A1\u647C\u3E43"],
      ["8ac9", "\u{2A601}\u{20E09}\u{22ACF}\u{22CC9}"],
      ["8ace", "\u{210C8}\u{239C2}\u3992\u3A06\u{2829B}\u3578\u{25E49}\u{220C7}\u5652\u{20F31}\u{22CB2}\u{29720}\u34BC\u6C3D\u{24E3B}"],
      ["8adf", "\u{27574}\u{22E8B}\u{22208}\u{2A65B}\u{28CCD}\u{20E7A}\u{20C34}\u{2681C}\u7F93\u{210CF}\u{22803}\u{22939}\u35FB\u{251E3}\u{20E8C}\u{20F8D}\u{20EAA}\u3F93\u{20F30}\u{20D47}\u{2114F}\u{20E4C}"],
      ["8af6", "\u{20EAB}\u{20BA9}\u{20D48}\u{210C0}\u{2113D}\u3FF9\u{22696}\u6432\u{20FAD}"],
      ["8b40", "\u{233F4}\u{27639}\u{22BCE}\u{20D7E}\u{20D7F}\u{22C51}\u{22C55}\u3A18\u{20E98}\u{210C7}\u{20F2E}\u{2A632}\u{26B50}\u{28CD2}\u{28D99}\u{28CCA}\u95AA\u54CC\u82C4\u55B9"],
      ["8b55", "\u{29EC3}\u9C26\u9AB6\u{2775E}\u{22DEE}\u7140\u816D\u80EC\u5C1C\u{26572}\u8134\u3797\u535F\u{280BD}\u91B6\u{20EFA}\u{20E0F}\u{20E77}\u{20EFB}\u35DD\u{24DEB}\u3609\u{20CD6}\u56AF\u{227B5}\u{210C9}\u{20E10}\u{20E78}\u{21078}\u{21148}\u{28207}\u{21455}\u{20E79}\u{24E50}\u{22DA4}\u5A54\u{2101D}\u{2101E}\u{210F5}\u{210F6}\u579C\u{20E11}"],
      ["8ba1", "\u{27694}\u{282CD}\u{20FB5}\u{20E7B}\u{2517E}\u3703\u{20FB6}\u{21180}\u{252D8}\u{2A2BD}\u{249DA}\u{2183A}\u{24177}\u{2827C}\u5899\u5268\u361A\u{2573D}\u7BB2\u5B68\u4800\u4B2C\u9F27\u49E7\u9C1F\u9B8D\u{25B74}\u{2313D}\u55FB\u35F2\u5689\u4E28\u5902\u{21BC1}\u{2F878}\u9751\u{20086}\u4E5B\u4EBB\u353E\u5C23\u5F51\u5FC4\u38FA\u624C\u6535\u6B7A\u6C35\u6C3A\u706C\u722B\u4E2C\u72AD\u{248E9}\u7F52\u793B\u7CF9\u7F53\u{2626A}\u34C1"],
      ["8bde", "\u{2634B}\u8002\u8080\u{26612}\u{26951}\u535D\u8864\u89C1\u{278B2}\u8BA0\u8D1D\u9485\u9578\u957F\u95E8\u{28E0F}\u97E6\u9875\u98CE\u98DE\u9963\u{29810}\u9C7C\u9E1F\u9EC4\u6B6F\uF907\u4E37\u{20087}\u961D\u6237\u94A2"],
      ["8c40", "\u503B\u6DFE\u{29C73}\u9FA6\u3DC9\u888F\u{2414E}\u7077\u5CF5\u4B20\u{251CD}\u3559\u{25D30}\u6122\u{28A32}\u8FA7\u91F6\u7191\u6719\u73BA\u{23281}\u{2A107}\u3C8B\u{21980}\u4B10\u78E4\u7402\u51AE\u{2870F}\u4009\u6A63\u{2A2BA}\u4223\u860F\u{20A6F}\u7A2A\u{29947}\u{28AEA}\u9755\u704D\u5324\u{2207E}\u93F4\u76D9\u{289E3}\u9FA7\u77DD\u4EA3\u4FF0\u50BC\u4E2F\u4F17\u9FA8\u5434\u7D8B\u5892\u58D0\u{21DB6}\u5E92\u5E99\u5FC2\u{22712}\u658B"],
      ["8ca1", "\u{233F9}\u6919\u6A43\u{23C63}\u6CFF"],
      ["8ca7", "\u7200\u{24505}\u738C\u3EDB\u{24A13}\u5B15\u74B9\u8B83\u{25CA4}\u{25695}\u7A93\u7BEC\u7CC3\u7E6C\u82F8\u8597\u9FA9\u8890\u9FAA\u8EB9\u9FAB\u8FCF\u855F\u99E0\u9221\u9FAC\u{28DB9}\u{2143F}\u4071\u42A2\u5A1A"],
      ["8cc9", "\u9868\u676B\u4276\u573D"],
      ["8cce", "\u85D6\u{2497B}\u82BF\u{2710D}\u4C81\u{26D74}\u5D7B\u{26B15}\u{26FBE}\u9FAD\u9FAE\u5B96\u9FAF\u66E7\u7E5B\u6E57\u79CA\u3D88\u44C3\u{23256}\u{22796}\u439A\u4536"],
      ["8ce6", "\u5CD5\u{23B1A}\u8AF9\u5C78\u3D12\u{23551}\u5D78\u9FB2\u7157\u4558\u{240EC}\u{21E23}\u4C77\u3978\u344A\u{201A4}\u{26C41}\u8ACC\u4FB4\u{20239}\u59BF\u816C\u9856\u{298FA}\u5F3B"],
      ["8d40", "\u{20B9F}"],
      ["8d42", "\u{221C1}\u{2896D}\u4102\u46BB\u{29079}\u3F07\u9FB3\u{2A1B5}\u40F8\u37D6\u46F7\u{26C46}\u417C\u{286B2}\u{273FF}\u456D\u38D4\u{2549A}\u4561\u451B\u4D89\u4C7B\u4D76\u45EA\u3FC8\u{24B0F}\u3661\u44DE\u44BD\u41ED\u5D3E\u5D48\u5D56\u3DFC\u380F\u5DA4\u5DB9\u3820\u3838\u5E42\u5EBD\u5F25\u5F83\u3908\u3914\u393F\u394D\u60D7\u613D\u5CE5\u3989\u61B7\u61B9\u61CF\u39B8\u622C\u6290\u62E5\u6318\u39F8\u56B1"],
      ["8da1", "\u3A03\u63E2\u63FB\u6407\u645A\u3A4B\u64C0\u5D15\u5621\u9F9F\u3A97\u6586\u3ABD\u65FF\u6653\u3AF2\u6692\u3B22\u6716\u3B42\u67A4\u6800\u3B58\u684A\u6884\u3B72\u3B71\u3B7B\u6909\u6943\u725C\u6964\u699F\u6985\u3BBC\u69D6\u3BDD\u6A65\u6A74\u6A71\u6A82\u3BEC\u6A99\u3BF2\u6AAB\u6AB5\u6AD4\u6AF6\u6B81\u6BC1\u6BEA\u6C75\u6CAA\u3CCB\u6D02\u6D06\u6D26\u6D81\u3CEF\u6DA4\u6DB1\u6E15\u6E18\u6E29\u6E86\u{289C0}\u6EBB\u6EE2\u6EDA\u9F7F\u6EE8\u6EE9\u6F24\u6F34\u3D46\u{23F41}\u6F81\u6FBE\u3D6A\u3D75\u71B7\u5C99\u3D8A\u702C\u3D91\u7050\u7054\u706F\u707F\u7089\u{20325}\u43C1\u35F1\u{20ED8}"],
      ["8e40", "\u{23ED7}\u57BE\u{26ED3}\u713E\u{257E0}\u364E\u69A2\u{28BE9}\u5B74\u7A49\u{258E1}\u{294D9}\u7A65\u7A7D\u{259AC}\u7ABB\u7AB0\u7AC2\u7AC3\u71D1\u{2648D}\u41CA\u7ADA\u7ADD\u7AEA\u41EF\u54B2\u{25C01}\u7B0B\u7B55\u7B29\u{2530E}\u{25CFE}\u7BA2\u7B6F\u839C\u{25BB4}\u{26C7F}\u7BD0\u8421\u7B92\u7BB8\u{25D20}\u3DAD\u{25C65}\u8492\u7BFA\u7C06\u7C35\u{25CC1}\u7C44\u7C83\u{24882}\u7CA6\u667D\u{24578}\u7CC9\u7CC7\u7CE6\u7C74\u7CF3\u7CF5\u7CCE"],
      ["8ea1", "\u7E67\u451D\u{26E44}\u7D5D\u{26ED6}\u748D\u7D89\u7DAB\u7135\u7DB3\u7DD2\u{24057}\u{26029}\u7DE4\u3D13\u7DF5\u{217F9}\u7DE5\u{2836D}\u7E1D\u{26121}\u{2615A}\u7E6E\u7E92\u432B\u946C\u7E27\u7F40\u7F41\u7F47\u7936\u{262D0}\u99E1\u7F97\u{26351}\u7FA3\u{21661}\u{20068}\u455C\u{23766}\u4503\u{2833A}\u7FFA\u{26489}\u8005\u8008\u801D\u8028\u802F\u{2A087}\u{26CC3}\u803B\u803C\u8061\u{22714}\u4989\u{26626}\u{23DE3}\u{266E8}\u6725\u80A7\u{28A48}\u8107\u811A\u58B0\u{226F6}\u6C7F\u{26498}\u{24FB8}\u64E7\u{2148A}\u8218\u{2185E}\u6A53\u{24A65}\u{24A95}\u447A\u8229\u{20B0D}\u{26A52}\u{23D7E}\u4FF9\u{214FD}\u84E2\u8362\u{26B0A}\u{249A7}\u{23530}\u{21773}\u{23DF8}\u82AA\u691B\u{2F994}\u41DB"],
      ["8f40", "\u854B\u82D0\u831A\u{20E16}\u{217B4}\u36C1\u{2317D}\u{2355A}\u827B\u82E2\u8318\u{23E8B}\u{26DA3}\u{26B05}\u{26B97}\u{235CE}\u3DBF\u831D\u55EC\u8385\u450B\u{26DA5}\u83AC\u83C1\u83D3\u347E\u{26ED4}\u6A57\u855A\u3496\u{26E42}\u{22EEF}\u8458\u{25BE4}\u8471\u3DD3\u44E4\u6AA7\u844A\u{23CB5}\u7958\u84A8\u{26B96}\u{26E77}\u{26E43}\u84DE\u840F\u8391\u44A0\u8493\u84E4\u{25C91}\u4240\u{25CC0}\u4543\u8534\u5AF2\u{26E99}\u4527\u8573\u4516\u67BF\u8616"],
      ["8fa1", "\u{28625}\u{2863B}\u85C1\u{27088}\u8602\u{21582}\u{270CD}\u{2F9B2}\u456A\u8628\u3648\u{218A2}\u53F7\u{2739A}\u867E\u8771\u{2A0F8}\u87EE\u{22C27}\u87B1\u87DA\u880F\u5661\u866C\u6856\u460F\u8845\u8846\u{275E0}\u{23DB9}\u{275E4}\u885E\u889C\u465B\u88B4\u88B5\u63C1\u88C5\u7777\u{2770F}\u8987\u898A\u89A6\u89A9\u89A7\u89BC\u{28A25}\u89E7\u{27924}\u{27ABD}\u8A9C\u7793\u91FE\u8A90\u{27A59}\u7AE9\u{27B3A}\u{23F8F}\u4713\u{27B38}\u717C\u8B0C\u8B1F\u{25430}\u{25565}\u8B3F\u8B4C\u8B4D\u8AA9\u{24A7A}\u8B90\u8B9B\u8AAF\u{216DF}\u4615\u884F\u8C9B\u{27D54}\u{27D8F}\u{2F9D4}\u3725\u{27D53}\u8CD6\u{27D98}\u{27DBD}\u8D12\u8D03\u{21910}\u8CDB\u705C\u8D11\u{24CC9}\u3ED0\u8D77"],
      ["9040", "\u8DA9\u{28002}\u{21014}\u{2498A}\u3B7C\u{281BC}\u{2710C}\u7AE7\u8EAD\u8EB6\u8EC3\u92D4\u8F19\u8F2D\u{28365}\u{28412}\u8FA5\u9303\u{2A29F}\u{20A50}\u8FB3\u492A\u{289DE}\u{2853D}\u{23DBB}\u5EF8\u{23262}\u8FF9\u{2A014}\u{286BC}\u{28501}\u{22325}\u3980\u{26ED7}\u9037\u{2853C}\u{27ABE}\u9061\u{2856C}\u{2860B}\u90A8\u{28713}\u90C4\u{286E6}\u90AE\u90FD\u9167\u3AF0\u91A9\u91C4\u7CAC\u{28933}\u{21E89}\u920E\u6C9F\u9241\u9262\u{255B9}\u92B9\u{28AC6}\u{23C9B}\u{28B0C}\u{255DB}"],
      ["90a1", "\u{20D31}\u932C\u936B\u{28AE1}\u{28BEB}\u708F\u5AC3\u{28AE2}\u{28AE5}\u4965\u9244\u{28BEC}\u{28C39}\u{28BFF}\u9373\u945B\u8EBC\u9585\u95A6\u9426\u95A0\u6FF6\u42B9\u{2267A}\u{286D8}\u{2127C}\u{23E2E}\u49DF\u6C1C\u967B\u9696\u416C\u96A3\u{26ED5}\u61DA\u96B6\u78F5\u{28AE0}\u96BD\u53CC\u49A1\u{26CB8}\u{20274}\u{26410}\u{290AF}\u{290E5}\u{24AD1}\u{21915}\u{2330A}\u9731\u8642\u9736\u4A0F\u453D\u4585\u{24AE9}\u7075\u5B41\u971B\u975C\u{291D5}\u9757\u5B4A\u{291EB}\u975F\u9425\u50D0\u{230B7}\u{230BC}\u9789\u979F\u97B1\u97BE\u97C0\u97D2\u97E0\u{2546C}\u97EE\u741C\u{29433}\u97FF\u97F5\u{2941D}\u{2797A}\u4AD1\u9834\u9833\u984B\u9866\u3B0E\u{27175}\u3D51\u{20630}\u{2415C}"],
      ["9140", "\u{25706}\u98CA\u98B7\u98C8\u98C7\u4AFF\u{26D27}\u{216D3}\u55B0\u98E1\u98E6\u98EC\u9378\u9939\u{24A29}\u4B72\u{29857}\u{29905}\u99F5\u9A0C\u9A3B\u9A10\u9A58\u{25725}\u36C4\u{290B1}\u{29BD5}\u9AE0\u9AE2\u{29B05}\u9AF4\u4C0E\u9B14\u9B2D\u{28600}\u5034\u9B34\u{269A8}\u38C3\u{2307D}\u9B50\u9B40\u{29D3E}\u5A45\u{21863}\u9B8E\u{2424B}\u9C02\u9BFF\u9C0C\u{29E68}\u9DD4\u{29FB7}\u{2A192}\u{2A1AB}\u{2A0E1}\u{2A123}\u{2A1DF}\u9D7E\u9D83\u{2A134}\u9E0E\u6888"],
      ["91a1", "\u9DC4\u{2215B}\u{2A193}\u{2A220}\u{2193B}\u{2A233}\u9D39\u{2A0B9}\u{2A2B4}\u9E90\u9E95\u9E9E\u9EA2\u4D34\u9EAA\u9EAF\u{24364}\u9EC1\u3B60\u39E5\u3D1D\u4F32\u37BE\u{28C2B}\u9F02\u9F08\u4B96\u9424\u{26DA2}\u9F17\u9F16\u9F39\u569F\u568A\u9F45\u99B8\u{2908B}\u97F2\u847F\u9F62\u9F69\u7ADC\u9F8E\u7216\u4BBE\u{24975}\u{249BB}\u7177\u{249F8}\u{24348}\u{24A51}\u739E\u{28BDA}\u{218FA}\u799F\u{2897E}\u{28E36}\u9369\u93F3\u{28A44}\u92EC\u9381\u93CB\u{2896C}\u{244B9}\u7217\u3EEB\u7772\u7A43\u70D0\u{24473}\u{243F8}\u717E\u{217EF}\u70A3\u{218BE}\u{23599}\u3EC7\u{21885}\u{2542F}\u{217F8}\u3722\u{216FB}\u{21839}\u36E1\u{21774}\u{218D1}\u{25F4B}\u3723\u{216C0}\u575B\u{24A25}\u{213FE}\u{212A8}"],
      ["9240", "\u{213C6}\u{214B6}\u8503\u{236A6}\u8503\u8455\u{24994}\u{27165}\u{23E31}\u{2555C}\u{23EFB}\u{27052}\u44F4\u{236EE}\u{2999D}\u{26F26}\u67F9\u3733\u3C15\u3DE7\u586C\u{21922}\u6810\u4057\u{2373F}\u{240E1}\u{2408B}\u{2410F}\u{26C21}\u54CB\u569E\u{266B1}\u5692\u{20FDF}\u{20BA8}\u{20E0D}\u93C6\u{28B13}\u939C\u4EF8\u512B\u3819\u{24436}\u4EBC\u{20465}\u{2037F}\u4F4B\u4F8A\u{25651}\u5A68\u{201AB}\u{203CB}\u3999\u{2030A}\u{20414}\u3435\u4F29\u{202C0}\u{28EB3}\u{20275}\u8ADA\u{2020C}\u4E98"],
      ["92a1", "\u50CD\u510D\u4FA2\u4F03\u{24A0E}\u{23E8A}\u4F42\u502E\u506C\u5081\u4FCC\u4FE5\u5058\u50FC\u5159\u515B\u515D\u515E\u6E76\u{23595}\u{23E39}\u{23EBF}\u6D72\u{21884}\u{23E89}\u51A8\u51C3\u{205E0}\u44DD\u{204A3}\u{20492}\u{20491}\u8D7A\u{28A9C}\u{2070E}\u5259\u52A4\u{20873}\u52E1\u936E\u467A\u718C\u{2438C}\u{20C20}\u{249AC}\u{210E4}\u69D1\u{20E1D}\u7479\u3EDE\u7499\u7414\u7456\u7398\u4B8E\u{24ABC}\u{2408D}\u53D0\u3584\u720F\u{240C9}\u55B4\u{20345}\u54CD\u{20BC6}\u571D\u925D\u96F4\u9366\u57DD\u578D\u577F\u363E\u58CB\u5A99\u{28A46}\u{216FA}\u{2176F}\u{21710}\u5A2C\u59B8\u928F\u5A7E\u5ACF\u5A12\u{25946}\u{219F3}\u{21861}\u{24295}\u36F5\u6D05\u7443\u5A21\u{25E83}"],
      ["9340", "\u5A81\u{28BD7}\u{20413}\u93E0\u748C\u{21303}\u7105\u4972\u9408\u{289FB}\u93BD\u37A0\u5C1E\u5C9E\u5E5E\u5E48\u{21996}\u{2197C}\u{23AEE}\u5ECD\u5B4F\u{21903}\u{21904}\u3701\u{218A0}\u36DD\u{216FE}\u36D3\u812A\u{28A47}\u{21DBA}\u{23472}\u{289A8}\u5F0C\u5F0E\u{21927}\u{217AB}\u5A6B\u{2173B}\u5B44\u8614\u{275FD}\u8860\u607E\u{22860}\u{2262B}\u5FDB\u3EB8\u{225AF}\u{225BE}\u{29088}\u{26F73}\u61C0\u{2003E}\u{20046}\u{2261B}\u6199\u6198\u6075\u{22C9B}\u{22D07}\u{246D4}\u{2914D}"],
      ["93a1", "\u6471\u{24665}\u{22B6A}\u3A29\u{22B22}\u{23450}\u{298EA}\u{22E78}\u6337\u{2A45B}\u64B6\u6331\u63D1\u{249E3}\u{22D67}\u62A4\u{22CA1}\u643B\u656B\u6972\u3BF4\u{2308E}\u{232AD}\u{24989}\u{232AB}\u550D\u{232E0}\u{218D9}\u{2943F}\u66CE\u{23289}\u{231B3}\u3AE0\u4190\u{25584}\u{28B22}\u{2558F}\u{216FC}\u{2555B}\u{25425}\u78EE\u{23103}\u{2182A}\u{23234}\u3464\u{2320F}\u{23182}\u{242C9}\u668E\u{26D24}\u666B\u4B93\u6630\u{27870}\u{21DEB}\u6663\u{232D2}\u{232E1}\u661E\u{25872}\u38D1\u{2383A}\u{237BC}\u3B99\u{237A2}\u{233FE}\u74D0\u3B96\u678F\u{2462A}\u68B6\u681E\u3BC4\u6ABE\u3863\u{237D5}\u{24487}\u6A33\u6A52\u6AC9\u6B05\u{21912}\u6511\u6898\u6A4C\u3BD7\u6A7A\u6B57\u{23FC0}\u{23C9A}\u93A0\u92F2\u{28BEA}\u{28ACB}"],
      ["9440", "\u9289\u{2801E}\u{289DC}\u9467\u6DA5\u6F0B\u{249EC}\u6D67\u{23F7F}\u3D8F\u6E04\u{2403C}\u5A3D\u6E0A\u5847\u6D24\u7842\u713B\u{2431A}\u{24276}\u70F1\u7250\u7287\u7294\u{2478F}\u{24725}\u5179\u{24AA4}\u{205EB}\u747A\u{23EF8}\u{2365F}\u{24A4A}\u{24917}\u{25FE1}\u3F06\u3EB1\u{24ADF}\u{28C23}\u{23F35}\u60A7\u3EF3\u74CC\u743C\u9387\u7437\u449F\u{26DEA}\u4551\u7583\u3F63\u{24CD9}\u{24D06}\u3F58\u7555\u7673\u{2A5C6}\u3B19\u7468\u{28ACC}\u{249AB}\u{2498E}\u3AFB"],
      ["94a1", "\u3DCD\u{24A4E}\u3EFF\u{249C5}\u{248F3}\u91FA\u5732\u9342\u{28AE3}\u{21864}\u50DF\u{25221}\u{251E7}\u7778\u{23232}\u770E\u770F\u777B\u{24697}\u{23781}\u3A5E\u{248F0}\u7438\u749B\u3EBF\u{24ABA}\u{24AC7}\u40C8\u{24A96}\u{261AE}\u9307\u{25581}\u781E\u788D\u7888\u78D2\u73D0\u7959\u{27741}\u{256E3}\u410E\u799B\u8496\u79A5\u6A2D\u{23EFA}\u7A3A\u79F4\u416E\u{216E6}\u4132\u9235\u79F1\u{20D4C}\u{2498C}\u{20299}\u{23DBA}\u{2176E}\u3597\u556B\u3570\u36AA\u{201D4}\u{20C0D}\u7AE2\u5A59\u{226F5}\u{25AAF}\u{25A9C}\u5A0D\u{2025B}\u78F0\u5A2A\u{25BC6}\u7AFE\u41F9\u7C5D\u7C6D\u4211\u{25BB3}\u{25EBC}\u{25EA6}\u7CCD\u{249F9}\u{217B0}\u7C8E\u7C7C\u7CAE\u6AB2\u7DDC\u7E07\u7DD3\u7F4E\u{26261}"],
      ["9540", "\u{2615C}\u{27B48}\u7D97\u{25E82}\u426A\u{26B75}\u{20916}\u67D6\u{2004E}\u{235CF}\u57C4\u{26412}\u{263F8}\u{24962}\u7FDD\u7B27\u{2082C}\u{25AE9}\u{25D43}\u7B0C\u{25E0E}\u99E6\u8645\u9A63\u6A1C\u{2343F}\u39E2\u{249F7}\u{265AD}\u9A1F\u{265A0}\u8480\u{27127}\u{26CD1}\u44EA\u8137\u4402\u80C6\u8109\u8142\u{267B4}\u98C3\u{26A42}\u8262\u8265\u{26A51}\u8453\u{26DA7}\u8610\u{2721B}\u5A86\u417F\u{21840}\u5B2B\u{218A1}\u5AE4\u{218D8}\u86A0\u{2F9BC}\u{23D8F}\u882D\u{27422}\u5A02"],
      ["95a1", "\u886E\u4F45\u8887\u88BF\u88E6\u8965\u894D\u{25683}\u8954\u{27785}\u{27784}\u{28BF5}\u{28BD9}\u{28B9C}\u{289F9}\u3EAD\u84A3\u46F5\u46CF\u37F2\u8A3D\u8A1C\u{29448}\u5F4D\u922B\u{24284}\u65D4\u7129\u70C4\u{21845}\u9D6D\u8C9F\u8CE9\u{27DDC}\u599A\u77C3\u59F0\u436E\u36D4\u8E2A\u8EA7\u{24C09}\u8F30\u8F4A\u42F4\u6C58\u6FBB\u{22321}\u489B\u6F79\u6E8B\u{217DA}\u9BE9\u36B5\u{2492F}\u90BB\u9097\u5571\u4906\u91BB\u9404\u{28A4B}\u4062\u{28AFC}\u9427\u{28C1D}\u{28C3B}\u84E5\u8A2B\u9599\u95A7\u9597\u9596\u{28D34}\u7445\u3EC2\u{248FF}\u{24A42}\u{243EA}\u3EE7\u{23225}\u968F\u{28EE7}\u{28E66}\u{28E65}\u3ECC\u{249ED}\u{24A78}\u{23FEE}\u7412\u746B\u3EFC\u9741\u{290B0}"],
      ["9640", "\u6847\u4A1D\u{29093}\u{257DF}\u975D\u9368\u{28989}\u{28C26}\u{28B2F}\u{263BE}\u92BA\u5B11\u8B69\u493C\u73F9\u{2421B}\u979B\u9771\u9938\u{20F26}\u5DC1\u{28BC5}\u{24AB2}\u981F\u{294DA}\u92F6\u{295D7}\u91E5\u44C0\u{28B50}\u{24A67}\u{28B64}\u98DC\u{28A45}\u3F00\u922A\u4925\u8414\u993B\u994D\u{27B06}\u3DFD\u999B\u4B6F\u99AA\u9A5C\u{28B65}\u{258C8}\u6A8F\u9A21\u5AFE\u9A2F\u{298F1}\u4B90\u{29948}\u99BC\u4BBD\u4B97\u937D\u5872\u{21302}\u5822\u{249B8}"],
      ["96a1", "\u{214E8}\u7844\u{2271F}\u{23DB8}\u68C5\u3D7D\u9458\u3927\u6150\u{22781}\u{2296B}\u6107\u9C4F\u9C53\u9C7B\u9C35\u9C10\u9B7F\u9BCF\u{29E2D}\u9B9F\u{2A1F5}\u{2A0FE}\u9D21\u4CAE\u{24104}\u9E18\u4CB0\u9D0C\u{2A1B4}\u{2A0ED}\u{2A0F3}\u{2992F}\u9DA5\u84BD\u{26E12}\u{26FDF}\u{26B82}\u85FC\u4533\u{26DA4}\u{26E84}\u{26DF0}\u8420\u85EE\u{26E00}\u{237D7}\u{26064}\u79E2\u{2359C}\u{23640}\u492D\u{249DE}\u3D62\u93DB\u92BE\u9348\u{202BF}\u78B9\u9277\u944D\u4FE4\u3440\u9064\u{2555D}\u783D\u7854\u78B6\u784B\u{21757}\u{231C9}\u{24941}\u369A\u4F72\u6FDA\u6FD9\u701E\u701E\u5414\u{241B5}\u57BB\u58F3\u578A\u9D16\u57D7\u7134\u34AF\u{241AC}\u71EB\u{26C40}\u{24F97}\u5B28\u{217B5}\u{28A49}"],
      ["9740", "\u610C\u5ACE\u5A0B\u42BC\u{24488}\u372C\u4B7B\u{289FC}\u93BB\u93B8\u{218D6}\u{20F1D}\u8472\u{26CC0}\u{21413}\u{242FA}\u{22C26}\u{243C1}\u5994\u{23DB7}\u{26741}\u7DA8\u{2615B}\u{260A4}\u{249B9}\u{2498B}\u{289FA}\u92E5\u73E2\u3EE9\u74B4\u{28B63}\u{2189F}\u3EE1\u{24AB3}\u6AD8\u73F3\u73FB\u3ED6\u{24A3E}\u{24A94}\u{217D9}\u{24A66}\u{203A7}\u{21424}\u{249E5}\u7448\u{24916}\u70A5\u{24976}\u9284\u73E6\u935F\u{204FE}\u9331\u{28ACE}\u{28A16}\u9386\u{28BE7}\u{255D5}\u4935\u{28A82}\u716B"],
      ["97a1", "\u{24943}\u{20CFF}\u56A4\u{2061A}\u{20BEB}\u{20CB8}\u5502\u79C4\u{217FA}\u7DFE\u{216C2}\u{24A50}\u{21852}\u452E\u9401\u370A\u{28AC0}\u{249AD}\u59B0\u{218BF}\u{21883}\u{27484}\u5AA1\u36E2\u{23D5B}\u36B0\u925F\u5A79\u{28A81}\u{21862}\u9374\u3CCD\u{20AB4}\u4A96\u398A\u50F4\u3D69\u3D4C\u{2139C}\u7175\u42FB\u{28218}\u6E0F\u{290E4}\u44EB\u6D57\u{27E4F}\u7067\u6CAF\u3CD6\u{23FED}\u{23E2D}\u6E02\u6F0C\u3D6F\u{203F5}\u7551\u36BC\u34C8\u4680\u3EDA\u4871\u59C4\u926E\u493E\u8F41\u{28C1C}\u{26BC0}\u5812\u57C8\u36D6\u{21452}\u70FE\u{24362}\u{24A71}\u{22FE3}\u{212B0}\u{223BD}\u68B9\u6967\u{21398}\u{234E5}\u{27BF4}\u{236DF}\u{28A83}\u{237D6}\u{233FA}\u{24C9F}\u6A1A\u{236AD}\u{26CB7}\u843E\u44DF\u44CE"],
      ["9840", "\u{26D26}\u{26D51}\u{26C82}\u{26FDE}\u6F17\u{27109}\u833D\u{2173A}\u83ED\u{26C80}\u{27053}\u{217DB}\u5989\u5A82\u{217B3}\u5A61\u5A71\u{21905}\u{241FC}\u372D\u59EF\u{2173C}\u36C7\u718E\u9390\u669A\u{242A5}\u5A6E\u5A2B\u{24293}\u6A2B\u{23EF9}\u{27736}\u{2445B}\u{242CA}\u711D\u{24259}\u{289E1}\u4FB0\u{26D28}\u5CC2\u{244CE}\u{27E4D}\u{243BD}\u6A0C\u{24256}\u{21304}\u70A6\u7133\u{243E9}\u3DA5\u6CDF\u{2F825}\u{24A4F}\u7E65\u59EB\u5D2F\u3DF3\u5F5C\u{24A5D}\u{217DF}\u7DA4\u8426"],
      ["98a1", "\u5485\u{23AFA}\u{23300}\u{20214}\u577E\u{208D5}\u{20619}\u3FE5\u{21F9E}\u{2A2B6}\u7003\u{2915B}\u5D70\u738F\u7CD3\u{28A59}\u{29420}\u4FC8\u7FE7\u72CD\u7310\u{27AF4}\u7338\u7339\u{256F6}\u7341\u7348\u3EA9\u{27B18}\u906C\u71F5\u{248F2}\u73E1\u81F6\u3ECA\u770C\u3ED1\u6CA2\u56FD\u7419\u741E\u741F\u3EE2\u3EF0\u3EF4\u3EFA\u74D3\u3F0E\u3F53\u7542\u756D\u7572\u758D\u3F7C\u75C8\u75DC\u3FC0\u764D\u3FD7\u7674\u3FDC\u767A\u{24F5C}\u7188\u5623\u8980\u5869\u401D\u7743\u4039\u6761\u4045\u35DB\u7798\u406A\u406F\u5C5E\u77BE\u77CB\u58F2\u7818\u70B9\u781C\u40A8\u7839\u7847\u7851\u7866\u8448\u{25535}\u7933\u6803\u7932\u4103"],
      ["9940", "\u4109\u7991\u7999\u8FBB\u7A06\u8FBC\u4167\u7A91\u41B2\u7ABC\u8279\u41C4\u7ACF\u7ADB\u41CF\u4E21\u7B62\u7B6C\u7B7B\u7C12\u7C1B\u4260\u427A\u7C7B\u7C9C\u428C\u7CB8\u4294\u7CED\u8F93\u70C0\u{20CCF}\u7DCF\u7DD4\u7DD0\u7DFD\u7FAE\u7FB4\u729F\u4397\u8020\u8025\u7B39\u802E\u8031\u8054\u3DCC\u57B4\u70A0\u80B7\u80E9\u43ED\u810C\u732A\u810E\u8112\u7560\u8114\u4401\u3B39\u8156\u8159\u815A"],
      ["99a1", "\u4413\u583A\u817C\u8184\u4425\u8193\u442D\u81A5\u57EF\u81C1\u81E4\u8254\u448F\u82A6\u8276\u82CA\u82D8\u82FF\u44B0\u8357\u9669\u698A\u8405\u70F5\u8464\u60E3\u8488\u4504\u84BE\u84E1\u84F8\u8510\u8538\u8552\u453B\u856F\u8570\u85E0\u4577\u8672\u8692\u86B2\u86EF\u9645\u878B\u4606\u4617\u88AE\u88FF\u8924\u8947\u8991\u{27967}\u8A29\u8A38\u8A94\u8AB4\u8C51\u8CD4\u8CF2\u8D1C\u4798\u585F\u8DC3\u47ED\u4EEE\u8E3A\u55D8\u5754\u8E71\u55F5\u8EB0\u4837\u8ECE\u8EE2\u8EE4\u8EED\u8EF2\u8FB7\u8FC1\u8FCA\u8FCC\u9033\u99C4\u48AD\u98E0\u9213\u491E\u9228\u9258\u926B\u92B1\u92AE\u92BF"],
      ["9a40", "\u92E3\u92EB\u92F3\u92F4\u92FD\u9343\u9384\u93AD\u4945\u4951\u9EBF\u9417\u5301\u941D\u942D\u943E\u496A\u9454\u9479\u952D\u95A2\u49A7\u95F4\u9633\u49E5\u67A0\u4A24\u9740\u4A35\u97B2\u97C2\u5654\u4AE4\u60E8\u98B9\u4B19\u98F1\u5844\u990E\u9919\u51B4\u991C\u9937\u9942\u995D\u9962\u4B70\u99C5\u4B9D\u9A3C\u9B0F\u7A83\u9B69\u9B81\u9BDD\u9BF1\u9BF4\u4C6D\u9C20\u376F\u{21BC2}\u9D49\u9C3A"],
      ["9aa1", "\u9EFE\u5650\u9D93\u9DBD\u9DC0\u9DFC\u94F6\u8FB6\u9E7B\u9EAC\u9EB1\u9EBD\u9EC6\u94DC\u9EE2\u9EF1\u9EF8\u7AC8\u9F44\u{20094}\u{202B7}\u{203A0}\u691A\u94C3\u59AC\u{204D7}\u5840\u94C1\u37B9\u{205D5}\u{20615}\u{20676}\u{216BA}\u5757\u7173\u{20AC2}\u{20ACD}\u{20BBF}\u546A\u{2F83B}\u{20BCB}\u549E\u{20BFB}\u{20C3B}\u{20C53}\u{20C65}\u{20C7C}\u60E7\u{20C8D}\u567A\u{20CB5}\u{20CDD}\u{20CED}\u{20D6F}\u{20DB2}\u{20DC8}\u6955\u9C2F\u87A5\u{20E04}\u{20E0E}\u{20ED7}\u{20F90}\u{20F2D}\u{20E73}\u5C20\u{20FBC}\u5E0B\u{2105C}\u{2104F}\u{21076}\u671E\u{2107B}\u{21088}\u{21096}\u3647\u{210BF}\u{210D3}\u{2112F}\u{2113B}\u5364\u84AD\u{212E3}\u{21375}\u{21336}\u8B81\u{21577}\u{21619}\u{217C3}\u{217C7}\u4E78\u70BB\u{2182D}\u{2196A}"],
      ["9b40", "\u{21A2D}\u{21A45}\u{21C2A}\u{21C70}\u{21CAC}\u{21EC8}\u62C3\u{21ED5}\u{21F15}\u7198\u6855\u{22045}\u69E9\u36C8\u{2227C}\u{223D7}\u{223FA}\u{2272A}\u{22871}\u{2294F}\u82FD\u{22967}\u{22993}\u{22AD5}\u89A5\u{22AE8}\u8FA0\u{22B0E}\u97B8\u{22B3F}\u9847\u9ABD\u{22C4C}"],
      ["9b62", "\u{22C88}\u{22CB7}\u{25BE8}\u{22D08}\u{22D12}\u{22DB7}\u{22D95}\u{22E42}\u{22F74}\u{22FCC}\u{23033}\u{23066}\u{2331F}\u{233DE}\u5FB1\u6648\u66BF\u{27A79}\u{23567}\u{235F3}\u7201\u{249BA}\u77D7\u{2361A}\u{23716}\u7E87\u{20346}\u58B5\u670E"],
      ["9ba1", "\u6918\u{23AA7}\u{27657}\u{25FE2}\u{23E11}\u{23EB9}\u{275FE}\u{2209A}\u48D0\u4AB8\u{24119}\u{28A9A}\u{242EE}\u{2430D}\u{2403B}\u{24334}\u{24396}\u{24A45}\u{205CA}\u51D2\u{20611}\u599F\u{21EA8}\u3BBE\u{23CFF}\u{24404}\u{244D6}\u5788\u{24674}\u399B\u{2472F}\u{285E8}\u{299C9}\u3762\u{221C3}\u8B5E\u{28B4E}\u99D6\u{24812}\u{248FB}\u{24A15}\u7209\u{24AC0}\u{20C78}\u5965\u{24EA5}\u{24F86}\u{20779}\u8EDA\u{2502C}\u528F\u573F\u7171\u{25299}\u{25419}\u{23F4A}\u{24AA7}\u55BC\u{25446}\u{2546E}\u{26B52}\u91D4\u3473\u{2553F}\u{27632}\u{2555E}\u4718\u{25562}\u{25566}\u{257C7}\u{2493F}\u{2585D}\u5066\u34FB\u{233CC}\u60DE\u{25903}\u477C\u{28948}\u{25AAE}\u{25B89}\u{25C06}\u{21D90}\u57A1\u7151\u6FB6\u{26102}\u{27C12}\u9056\u{261B2}\u{24F9A}\u8B62\u{26402}\u{2644A}"],
      ["9c40", "\u5D5B\u{26BF7}\u8F36\u{26484}\u{2191C}\u8AEA\u{249F6}\u{26488}\u{23FEF}\u{26512}\u4BC0\u{265BF}\u{266B5}\u{2271B}\u9465\u{257E1}\u6195\u5A27\u{2F8CD}\u4FBB\u56B9\u{24521}\u{266FC}\u4E6A\u{24934}\u9656\u6D8F\u{26CBD}\u3618\u8977\u{26799}\u{2686E}\u{26411}\u{2685E}\u71DF\u{268C7}\u7B42\u{290C0}\u{20A11}\u{26926}\u9104\u{26939}\u7A45\u9DF0\u{269FA}\u9A26\u{26A2D}\u365F\u{26469}\u{20021}\u7983\u{26A34}\u{26B5B}\u5D2C\u{23519}\u83CF\u{26B9D}\u46D0\u{26CA4}\u753B\u8865\u{26DAE}\u58B6"],
      ["9ca1", "\u371C\u{2258D}\u{2704B}\u{271CD}\u3C54\u{27280}\u{27285}\u9281\u{2217A}\u{2728B}\u9330\u{272E6}\u{249D0}\u6C39\u949F\u{27450}\u{20EF8}\u8827\u88F5\u{22926}\u{28473}\u{217B1}\u6EB8\u{24A2A}\u{21820}\u39A4\u36B9\u5C10\u79E3\u453F\u66B6\u{29CAD}\u{298A4}\u8943\u{277CC}\u{27858}\u56D6\u40DF\u{2160A}\u39A1\u{2372F}\u{280E8}\u{213C5}\u71AD\u8366\u{279DD}\u{291A8}\u5A67\u4CB7\u{270AF}\u{289AB}\u{279FD}\u{27A0A}\u{27B0B}\u{27D66}\u{2417A}\u7B43\u797E\u{28009}\u6FB5\u{2A2DF}\u6A03\u{28318}\u53A2\u{26E07}\u93BF\u6836\u975D\u{2816F}\u{28023}\u{269B5}\u{213ED}\u{2322F}\u{28048}\u5D85\u{28C30}\u{28083}\u5715\u9823\u{28949}\u5DAB\u{24988}\u65BE\u69D5\u53D2\u{24AA5}\u{23F81}\u3C11\u6736\u{28090}\u{280F4}\u{2812E}\u{21FA1}\u{2814F}"],
      ["9d40", "\u{28189}\u{281AF}\u{2821A}\u{28306}\u{2832F}\u{2838A}\u35CA\u{28468}\u{286AA}\u48FA\u63E6\u{28956}\u7808\u9255\u{289B8}\u43F2\u{289E7}\u43DF\u{289E8}\u{28B46}\u{28BD4}\u59F8\u{28C09}\u8F0B\u{28FC5}\u{290EC}\u7B51\u{29110}\u{2913C}\u3DF7\u{2915E}\u{24ACA}\u8FD0\u728F\u568B\u{294E7}\u{295E9}\u{295B0}\u{295B8}\u{29732}\u{298D1}\u{29949}\u{2996A}\u{299C3}\u{29A28}\u{29B0E}\u{29D5A}\u{29D9B}\u7E9F\u{29EF8}\u{29F23}\u4CA4\u9547\u{2A293}\u71A2\u{2A2FF}\u4D91\u9012\u{2A5CB}\u4D9C\u{20C9C}\u8FBE\u55C1"],
      ["9da1", "\u8FBA\u{224B0}\u8FB9\u{24A93}\u4509\u7E7F\u6F56\u6AB1\u4EEA\u34E4\u{28B2C}\u{2789D}\u373A\u8E80\u{217F5}\u{28024}\u{28B6C}\u{28B99}\u{27A3E}\u{266AF}\u3DEB\u{27655}\u{23CB7}\u{25635}\u{25956}\u4E9A\u{25E81}\u{26258}\u56BF\u{20E6D}\u8E0E\u5B6D\u{23E88}\u{24C9E}\u63DE\u62D0\u{217F6}\u{2187B}\u6530\u562D\u{25C4A}\u541A\u{25311}\u3DC6\u{29D98}\u4C7D\u5622\u561E\u7F49\u{25ED8}\u5975\u{23D40}\u8770\u4E1C\u{20FEA}\u{20D49}\u{236BA}\u8117\u9D5E\u8D18\u763B\u9C45\u764E\u77B9\u9345\u5432\u8148\u82F7\u5625\u8132\u8418\u80BD\u55EA\u7962\u5643\u5416\u{20E9D}\u35CE\u5605\u55F1\u66F1\u{282E2}\u362D\u7534\u55F0\u55BA\u5497\u5572\u{20C41}\u{20C96}\u5ED0\u{25148}\u{20E76}\u{22C62}"],
      ["9e40", "\u{20EA2}\u9EAB\u7D5A\u55DE\u{21075}\u629D\u976D\u5494\u8CCD\u71F6\u9176\u63FC\u63B9\u63FE\u5569\u{22B43}\u9C72\u{22EB3}\u519A\u34DF\u{20DA7}\u51A7\u544D\u551E\u5513\u7666\u8E2D\u{2688A}\u75B1\u80B6\u8804\u8786\u88C7\u81B6\u841C\u{210C1}\u44EC\u7304\u{24706}\u5B90\u830B\u{26893}\u567B\u{226F4}\u{27D2F}\u{241A3}\u{27D73}\u{26ED0}\u{272B6}\u9170\u{211D9}\u9208\u{23CFC}\u{2A6A9}\u{20EAC}\u{20EF9}\u7266\u{21CA2}\u474E\u{24FC2}\u{27FF9}\u{20FEB}\u40FA"],
      ["9ea1", "\u9C5D\u651F\u{22DA0}\u48F3\u{247E0}\u{29D7C}\u{20FEC}\u{20E0A}\u6062\u{275A3}\u{20FED}"],
      ["9ead", "\u{26048}\u{21187}\u71A3\u7E8E\u9D50\u4E1A\u4E04\u3577\u5B0D\u6CB2\u5367\u36AC\u39DC\u537D\u36A5\u{24618}\u589A\u{24B6E}\u822D\u544B\u57AA\u{25A95}\u{20979}"],
      ["9ec5", "\u3A52\u{22465}\u7374\u{29EAC}\u4D09\u9BED\u{23CFE}\u{29F30}\u4C5B\u{24FA9}\u{2959E}\u{29FDE}\u845C\u{23DB6}\u{272B2}\u{267B3}\u{23720}\u632E\u7D25\u{23EF7}\u{23E2C}\u3A2A\u9008\u52CC\u3E74\u367A\u45E9\u{2048E}\u7640\u5AF0\u{20EB6}\u787A\u{27F2E}\u58A7\u40BF\u567C\u9B8B\u5D74\u7654\u{2A434}\u9E85\u4CE1\u75F9\u37FB\u6119\u{230DA}\u{243F2}"],
      ["9ef5", "\u565D\u{212A9}\u57A7\u{24963}\u{29E06}\u5234\u{270AE}\u35AD\u6C4A\u9D7C"],
      ["9f40", "\u7C56\u9B39\u57DE\u{2176C}\u5C53\u64D3\u{294D0}\u{26335}\u{27164}\u86AD\u{20D28}\u{26D22}\u{24AE2}\u{20D71}"],
      ["9f4f", "\u51FE\u{21F0F}\u5D8E\u9703\u{21DD1}\u9E81\u904C\u7B1F\u9B02\u5CD1\u7BA3\u6268\u6335\u9AFF\u7BCF\u9B2A\u7C7E\u9B2E\u7C42\u7C86\u9C15\u7BFC\u9B09\u9F17\u9C1B\u{2493E}\u9F5A\u5573\u5BC3\u4FFD\u9E98\u4FF2\u5260\u3E06\u52D1\u5767\u5056\u59B7\u5E12\u97C8\u9DAB\u8F5C\u5469\u97B4\u9940\u97BA\u532C\u6130"],
      ["9fa1", "\u692C\u53DA\u9C0A\u9D02\u4C3B\u9641\u6980\u50A6\u7546\u{2176D}\u99DA\u5273"],
      ["9fae", "\u9159\u9681\u915C"],
      ["9fb2", "\u9151\u{28E97}\u637F\u{26D23}\u6ACA\u5611\u918E\u757A\u6285\u{203FC}\u734F\u7C70\u{25C21}\u{23CFD}"],
      ["9fc1", "\u{24919}\u76D6\u9B9D\u4E2A\u{20CD4}\u83BE\u8842"],
      ["9fc9", "\u5C4A\u69C0\u50ED\u577A\u521F\u5DF5\u4ECE\u6C31\u{201F2}\u4F39\u549C\u54DA\u529A\u8D82\u35FE\u5F0C\u35F3"],
      ["9fdb", "\u6B52\u917C\u9FA5\u9B97\u982E\u98B4\u9ABA\u9EA8\u9E84\u717A\u7B14"],
      ["9fe7", "\u6BFA\u8818\u7F78"],
      ["9feb", "\u5620\u{2A64A}\u8E77\u9F53"],
      ["9ff0", "\u8DD4\u8E4F\u9E1C\u8E01\u6282\u{2837D}\u8E28\u8E75\u7AD3\u{24A77}\u7A3E\u78D8\u6CEA\u8A67\u7607"],
      ["a040", "\u{28A5A}\u9F26\u6CCE\u87D6\u75C3\u{2A2B2}\u7853\u{2F840}\u8D0C\u72E2\u7371\u8B2D\u7302\u74F1\u8CEB\u{24ABB}\u862F\u5FBA\u88A0\u44B7"],
      ["a055", "\u{2183B}\u{26E05}"],
      ["a058", "\u8A7E\u{2251B}"],
      ["a05b", "\u60FD\u7667\u9AD7\u9D44\u936E\u9B8F\u87F5"],
      ["a063", "\u880F\u8CF7\u732C\u9721\u9BB0\u35D6\u72B2\u4C07\u7C51\u994A\u{26159}\u6159\u4C04\u9E96\u617D"],
      ["a073", "\u575F\u616F\u62A6\u6239\u62CE\u3A5C\u61E2\u53AA\u{233F5}\u6364\u6802\u35D2"],
      ["a0a1", "\u5D57\u{28BC2}\u8FDA\u{28E39}"],
      ["a0a6", "\u50D9\u{21D46}\u7906\u5332\u9638\u{20F3B}\u4065"],
      ["a0ae", "\u77FE"],
      ["a0b0", "\u7CC2\u{25F1A}\u7CDA\u7A2D\u8066\u8063\u7D4D\u7505\u74F2\u8994\u821A\u670C\u8062\u{27486}\u805B\u74F0\u8103\u7724\u8989\u{267CC}\u7553\u{26ED1}\u87A9\u87CE\u81C8\u878C\u8A49\u8CAD\u8B43\u772B\u74F8\u84DA\u3635\u69B2\u8DA6"],
      ["a0d4", "\u89A9\u7468\u6DB9\u87C1\u{24011}\u74E7\u3DDB\u7176\u60A4\u619C\u3CD1\u7162\u6077"],
      ["a0e2", "\u7F71\u{28B2D}\u7250\u60E9\u4B7E\u5220\u3C18\u{23CC7}\u{25ED7}\u{27656}\u{25531}\u{21944}\u{212FE}\u{29903}\u{26DDC}\u{270AD}\u5CC1\u{261AD}\u{28A0F}\u{23677}\u{200EE}\u{26846}\u{24F0E}\u4562\u5B1F\u{2634C}\u9F50\u9EA6\u{2626B}"],
      ["a3c0", "\u2400", 31, "\u2421"],
      ["c6a1", "\u2460", 9, "\u2474", 9, "\u2170", 9, "\u4E36\u4E3F\u4E85\u4EA0\u5182\u5196\u51AB\u52F9\u5338\u5369\u53B6\u590A\u5B80\u5DDB\u2F33\u5E7F\u5EF4\u5F50\u5F61\u6534\u65E0\u7592\u7676\u8FB5\u96B6\xA8\u02C6\u30FD\u30FE\u309D\u309E\u3003\u4EDD\u3005\u3006\u3007\u30FC\uFF3B\uFF3D\u273D\u3041", 23],
      ["c740", "\u3059", 58, "\u30A1\u30A2\u30A3\u30A4"],
      ["c7a1", "\u30A5", 81, "\u0410", 5, "\u0401\u0416", 4],
      ["c840", "\u041B", 26, "\u0451\u0436", 25, "\u21E7\u21B8\u21B9\u31CF\u{200CC}\u4E5A\u{2008A}\u5202\u4491"],
      ["c8a1", "\u9FB0\u5188\u9FB1\u{27607}"],
      ["c8cd", "\uFFE2\uFFE4\uFF07\uFF02\u3231\u2116\u2121\u309B\u309C\u2E80\u2E84\u2E86\u2E87\u2E88\u2E8A\u2E8C\u2E8D\u2E95\u2E9C\u2E9D\u2EA5\u2EA7\u2EAA\u2EAC\u2EAE\u2EB6\u2EBC\u2EBE\u2EC6\u2ECA\u2ECC\u2ECD\u2ECF\u2ED6\u2ED7\u2EDE\u2EE3"],
      ["c8f5", "\u0283\u0250\u025B\u0254\u0275\u0153\xF8\u014B\u028A\u026A"],
      ["f9fe", "\uFFED"],
      ["fa40", "\u{20547}\u92DB\u{205DF}\u{23FC5}\u854C\u42B5\u73EF\u51B5\u3649\u{24942}\u{289E4}\u9344\u{219DB}\u82EE\u{23CC8}\u783C\u6744\u62DF\u{24933}\u{289AA}\u{202A0}\u{26BB3}\u{21305}\u4FAB\u{224ED}\u5008\u{26D29}\u{27A84}\u{23600}\u{24AB1}\u{22513}\u5029\u{2037E}\u5FA4\u{20380}\u{20347}\u6EDB\u{2041F}\u507D\u5101\u347A\u510E\u986C\u3743\u8416\u{249A4}\u{20487}\u5160\u{233B4}\u516A\u{20BFF}\u{220FC}\u{202E5}\u{22530}\u{2058E}\u{23233}\u{21983}\u5B82\u877D\u{205B3}\u{23C99}\u51B2\u51B8"],
      ["faa1", "\u9D34\u51C9\u51CF\u51D1\u3CDC\u51D3\u{24AA6}\u51B3\u51E2\u5342\u51ED\u83CD\u693E\u{2372D}\u5F7B\u520B\u5226\u523C\u52B5\u5257\u5294\u52B9\u52C5\u7C15\u8542\u52E0\u860D\u{26B13}\u5305\u{28ADE}\u5549\u6ED9\u{23F80}\u{20954}\u{23FEC}\u5333\u5344\u{20BE2}\u6CCB\u{21726}\u681B\u73D5\u604A\u3EAA\u38CC\u{216E8}\u71DD\u44A2\u536D\u5374\u{286AB}\u537E\u537F\u{21596}\u{21613}\u77E6\u5393\u{28A9B}\u53A0\u53AB\u53AE\u73A7\u{25772}\u3F59\u739C\u53C1\u53C5\u6C49\u4E49\u57FE\u53D9\u3AAB\u{20B8F}\u53E0\u{23FEB}\u{22DA3}\u53F6\u{20C77}\u5413\u7079\u552B\u6657\u6D5B\u546D\u{26B53}\u{20D74}\u555D\u548F\u54A4\u47A6\u{2170D}\u{20EDD}\u3DB4\u{20D4D}"],
      ["fb40", "\u{289BC}\u{22698}\u5547\u4CED\u542F\u7417\u5586\u55A9\u5605\u{218D7}\u{2403A}\u4552\u{24435}\u66B3\u{210B4}\u5637\u66CD\u{2328A}\u66A4\u66AD\u564D\u564F\u78F1\u56F1\u9787\u53FE\u5700\u56EF\u56ED\u{28B66}\u3623\u{2124F}\u5746\u{241A5}\u6C6E\u708B\u5742\u36B1\u{26C7E}\u57E6\u{21416}\u5803\u{21454}\u{24363}\u5826\u{24BF5}\u585C\u58AA\u3561\u58E0\u58DC\u{2123C}\u58FB\u5BFF\u5743\u{2A150}\u{24278}\u93D3\u35A1\u591F\u68A6\u36C3\u6E59"],
      ["fba1", "\u{2163E}\u5A24\u5553\u{21692}\u8505\u59C9\u{20D4E}\u{26C81}\u{26D2A}\u{217DC}\u59D9\u{217FB}\u{217B2}\u{26DA6}\u6D71\u{21828}\u{216D5}\u59F9\u{26E45}\u5AAB\u5A63\u36E6\u{249A9}\u5A77\u3708\u5A96\u7465\u5AD3\u{26FA1}\u{22554}\u3D85\u{21911}\u3732\u{216B8}\u5E83\u52D0\u5B76\u6588\u5B7C\u{27A0E}\u4004\u485D\u{20204}\u5BD5\u6160\u{21A34}\u{259CC}\u{205A5}\u5BF3\u5B9D\u4D10\u5C05\u{21B44}\u5C13\u73CE\u5C14\u{21CA5}\u{26B28}\u5C49\u48DD\u5C85\u5CE9\u5CEF\u5D8B\u{21DF9}\u{21E37}\u5D10\u5D18\u5D46\u{21EA4}\u5CBA\u5DD7\u82FC\u382D\u{24901}\u{22049}\u{22173}\u8287\u3836\u3BC2\u5E2E\u6A8A\u5E75\u5E7A\u{244BC}\u{20CD3}\u53A6\u4EB7\u5ED0\u53A8\u{21771}\u5E09\u5EF4\u{28482}"],
      ["fc40", "\u5EF9\u5EFB\u38A0\u5EFC\u683E\u941B\u5F0D\u{201C1}\u{2F894}\u3ADE\u48AE\u{2133A}\u5F3A\u{26888}\u{223D0}\u5F58\u{22471}\u5F63\u97BD\u{26E6E}\u5F72\u9340\u{28A36}\u5FA7\u5DB6\u3D5F\u{25250}\u{21F6A}\u{270F8}\u{22668}\u91D6\u{2029E}\u{28A29}\u6031\u6685\u{21877}\u3963\u3DC7\u3639\u5790\u{227B4}\u7971\u3E40\u609E\u60A4\u60B3\u{24982}\u{2498F}\u{27A53}\u74A4\u50E1\u5AA0\u6164\u8424\u6142\u{2F8A6}\u{26ED2}\u6181\u51F4\u{20656}\u6187\u5BAA\u{23FB7}"],
      ["fca1", "\u{2285F}\u61D3\u{28B9D}\u{2995D}\u61D0\u3932\u{22980}\u{228C1}\u6023\u615C\u651E\u638B\u{20118}\u62C5\u{21770}\u62D5\u{22E0D}\u636C\u{249DF}\u3A17\u6438\u63F8\u{2138E}\u{217FC}\u6490\u6F8A\u{22E36}\u9814\u{2408C}\u{2571D}\u64E1\u64E5\u947B\u3A66\u643A\u3A57\u654D\u6F16\u{24A28}\u{24A23}\u6585\u656D\u655F\u{2307E}\u65B5\u{24940}\u4B37\u65D1\u40D8\u{21829}\u65E0\u65E3\u5FDF\u{23400}\u6618\u{231F7}\u{231F8}\u6644\u{231A4}\u{231A5}\u664B\u{20E75}\u6667\u{251E6}\u6673\u6674\u{21E3D}\u{23231}\u{285F4}\u{231C8}\u{25313}\u77C5\u{228F7}\u99A4\u6702\u{2439C}\u{24A21}\u3B2B\u69FA\u{237C2}\u675E\u6767\u6762\u{241CD}\u{290ED}\u67D7\u44E9\u6822\u6E50\u923C\u6801\u{233E6}\u{26DA0}\u685D"],
      ["fd40", "\u{2346F}\u69E1\u6A0B\u{28ADF}\u6973\u68C3\u{235CD}\u6901\u6900\u3D32\u3A01\u{2363C}\u3B80\u67AC\u6961\u{28A4A}\u42FC\u6936\u6998\u3BA1\u{203C9}\u8363\u5090\u69F9\u{23659}\u{2212A}\u6A45\u{23703}\u6A9D\u3BF3\u67B1\u6AC8\u{2919C}\u3C0D\u6B1D\u{20923}\u60DE\u6B35\u6B74\u{227CD}\u6EB5\u{23ADB}\u{203B5}\u{21958}\u3740\u5421\u{23B5A}\u6BE1\u{23EFC}\u6BDC\u6C37\u{2248B}\u{248F1}\u{26B51}\u6C5A\u8226\u6C79\u{23DBC}\u44C5\u{23DBD}\u{241A4}\u{2490C}\u{24900}"],
      ["fda1", "\u{23CC9}\u36E5\u3CEB\u{20D32}\u9B83\u{231F9}\u{22491}\u7F8F\u6837\u{26D25}\u{26DA1}\u{26DEB}\u6D96\u6D5C\u6E7C\u6F04\u{2497F}\u{24085}\u{26E72}\u8533\u{26F74}\u51C7\u6C9C\u6E1D\u842E\u{28B21}\u6E2F\u{23E2F}\u7453\u{23F82}\u79CC\u6E4F\u5A91\u{2304B}\u6FF8\u370D\u6F9D\u{23E30}\u6EFA\u{21497}\u{2403D}\u4555\u93F0\u6F44\u6F5C\u3D4E\u6F74\u{29170}\u3D3B\u6F9F\u{24144}\u6FD3\u{24091}\u{24155}\u{24039}\u{23FF0}\u{23FB4}\u{2413F}\u51DF\u{24156}\u{24157}\u{24140}\u{261DD}\u704B\u707E\u70A7\u7081\u70CC\u70D5\u70D6\u70DF\u4104\u3DE8\u71B4\u7196\u{24277}\u712B\u7145\u5A88\u714A\u716E\u5C9C\u{24365}\u714F\u9362\u{242C1}\u712C\u{2445A}\u{24A27}\u{24A22}\u71BA\u{28BE8}\u70BD\u720E"],
      ["fe40", "\u9442\u7215\u5911\u9443\u7224\u9341\u{25605}\u722E\u7240\u{24974}\u68BD\u7255\u7257\u3E55\u{23044}\u680D\u6F3D\u7282\u732A\u732B\u{24823}\u{2882B}\u48ED\u{28804}\u7328\u732E\u73CF\u73AA\u{20C3A}\u{26A2E}\u73C9\u7449\u{241E2}\u{216E7}\u{24A24}\u6623\u36C5\u{249B7}\u{2498D}\u{249FB}\u73F7\u7415\u6903\u{24A26}\u7439\u{205C3}\u3ED7\u745C\u{228AD}\u7460\u{28EB2}\u7447\u73E4\u7476\u83B9\u746C\u3730\u7474\u93F1\u6A2C\u7482\u4953\u{24A8C}"],
      ["fea1", "\u{2415F}\u{24A79}\u{28B8F}\u5B46\u{28C03}\u{2189E}\u74C8\u{21988}\u750E\u74E9\u751E\u{28ED9}\u{21A4B}\u5BD7\u{28EAC}\u9385\u754D\u754A\u7567\u756E\u{24F82}\u3F04\u{24D13}\u758E\u745D\u759E\u75B4\u7602\u762C\u7651\u764F\u766F\u7676\u{263F5}\u7690\u81EF\u37F8\u{26911}\u{2690E}\u76A1\u76A5\u76B7\u76CC\u{26F9F}\u8462\u{2509D}\u{2517D}\u{21E1C}\u771E\u7726\u7740\u64AF\u{25220}\u7758\u{232AC}\u77AF\u{28964}\u{28968}\u{216C1}\u77F4\u7809\u{21376}\u{24A12}\u68CA\u78AF\u78C7\u78D3\u96A5\u792E\u{255E0}\u78D7\u7934\u78B1\u{2760C}\u8FB8\u8884\u{28B2B}\u{26083}\u{2261C}\u7986\u8900\u6902\u7980\u{25857}\u799D\u{27B39}\u793C\u79A9\u6E2A\u{27126}\u3EA8\u79C6\u{2910D}\u79D4"]
    ];
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/dbcs-data.js
var require_dbcs_data = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/dbcs-data.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      // == Japanese/ShiftJIS ====================================================
      // All japanese encodings are based on JIS X set of standards:
      // JIS X 0201 - Single-byte encoding of ASCII + ¥ + Kana chars at 0xA1-0xDF.
      // JIS X 0208 - Main set of 6879 characters, placed in 94x94 plane, to be encoded by 2 bytes. 
      //              Has several variations in 1978, 1983, 1990 and 1997.
      // JIS X 0212 - Supplementary plane of 6067 chars in 94x94 plane. 1990. Effectively dead.
      // JIS X 0213 - Extension and modern replacement of 0208 and 0212. Total chars: 11233.
      //              2 planes, first is superset of 0208, second - revised 0212.
      //              Introduced in 2000, revised 2004. Some characters are in Unicode Plane 2 (0x2xxxx)
      // Byte encodings are:
      //  * Shift_JIS: Compatible with 0201, uses not defined chars in top half as lead bytes for double-byte
      //               encoding of 0208. Lead byte ranges: 0x81-0x9F, 0xE0-0xEF; Trail byte ranges: 0x40-0x7E, 0x80-0x9E, 0x9F-0xFC.
      //               Windows CP932 is a superset of Shift_JIS. Some companies added more chars, notably KDDI.
      //  * EUC-JP:    Up to 3 bytes per character. Used mostly on *nixes.
      //               0x00-0x7F       - lower part of 0201
      //               0x8E, 0xA1-0xDF - upper part of 0201
      //               (0xA1-0xFE)x2   - 0208 plane (94x94).
      //               0x8F, (0xA1-0xFE)x2 - 0212 plane (94x94).
      //  * JIS X 208: 7-bit, direct encoding of 0208. Byte ranges: 0x21-0x7E (94 values). Uncommon.
      //               Used as-is in ISO2022 family.
      //  * ISO2022-JP: Stateful encoding, with escape sequences to switch between ASCII, 
      //                0201-1976 Roman, 0208-1978, 0208-1983.
      //  * ISO2022-JP-1: Adds esc seq for 0212-1990.
      //  * ISO2022-JP-2: Adds esc seq for GB2313-1980, KSX1001-1992, ISO8859-1, ISO8859-7.
      //  * ISO2022-JP-3: Adds esc seq for 0201-1976 Kana set, 0213-2000 Planes 1, 2.
      //  * ISO2022-JP-2004: Adds 0213-2004 Plane 1.
      //
      // After JIS X 0213 appeared, Shift_JIS-2004, EUC-JISX0213 and ISO2022-JP-2004 followed, with just changing the planes.
      //
      // Overall, it seems that it's a mess :( http://www8.plala.or.jp/tkubota1/unicode-symbols-map2.html
      "shiftjis": {
        type: "_dbcs",
        table: function() {
          return require_shiftjis();
        },
        encodeAdd: { "\xA5": 92, "\u203E": 126 },
        encodeSkipVals: [{ from: 60736, to: 63808 }]
      },
      "csshiftjis": "shiftjis",
      "mskanji": "shiftjis",
      "sjis": "shiftjis",
      "windows31j": "shiftjis",
      "ms31j": "shiftjis",
      "xsjis": "shiftjis",
      "windows932": "shiftjis",
      "ms932": "shiftjis",
      "932": "shiftjis",
      "cp932": "shiftjis",
      "eucjp": {
        type: "_dbcs",
        table: function() {
          return require_eucjp();
        },
        encodeAdd: { "\xA5": 92, "\u203E": 126 }
      },
      // TODO: KDDI extension to Shift_JIS
      // TODO: IBM CCSID 942 = CP932, but F0-F9 custom chars and other char changes.
      // TODO: IBM CCSID 943 = Shift_JIS = CP932 with original Shift_JIS lower 128 chars.
      // == Chinese/GBK ==========================================================
      // http://en.wikipedia.org/wiki/GBK
      // We mostly implement W3C recommendation: https://www.w3.org/TR/encoding/#gbk-encoder
      // Oldest GB2312 (1981, ~7600 chars) is a subset of CP936
      "gb2312": "cp936",
      "gb231280": "cp936",
      "gb23121980": "cp936",
      "csgb2312": "cp936",
      "csiso58gb231280": "cp936",
      "euccn": "cp936",
      // Microsoft's CP936 is a subset and approximation of GBK.
      "windows936": "cp936",
      "ms936": "cp936",
      "936": "cp936",
      "cp936": {
        type: "_dbcs",
        table: function() {
          return require_cp936();
        }
      },
      // GBK (~22000 chars) is an extension of CP936 that added user-mapped chars and some other.
      "gbk": {
        type: "_dbcs",
        table: function() {
          return require_cp936().concat(require_gbk_added());
        }
      },
      "xgbk": "gbk",
      "isoir58": "gbk",
      // GB18030 is an algorithmic extension of GBK.
      // Main source: https://www.w3.org/TR/encoding/#gbk-encoder
      // http://icu-project.org/docs/papers/gb18030.html
      // http://source.icu-project.org/repos/icu/data/trunk/charset/data/xml/gb-18030-2000.xml
      // http://www.khngai.com/chinese/charmap/tblgbk.php?page=0
      "gb18030": {
        type: "_dbcs",
        table: function() {
          return require_cp936().concat(require_gbk_added());
        },
        gb18030: function() {
          return require_gb18030_ranges();
        },
        encodeSkipVals: [128],
        encodeAdd: { "\u20AC": 41699 }
      },
      "chinese": "gb18030",
      // == Korean ===============================================================
      // EUC-KR, KS_C_5601 and KS X 1001 are exactly the same.
      "windows949": "cp949",
      "ms949": "cp949",
      "949": "cp949",
      "cp949": {
        type: "_dbcs",
        table: function() {
          return require_cp949();
        }
      },
      "cseuckr": "cp949",
      "csksc56011987": "cp949",
      "euckr": "cp949",
      "isoir149": "cp949",
      "korean": "cp949",
      "ksc56011987": "cp949",
      "ksc56011989": "cp949",
      "ksc5601": "cp949",
      // == Big5/Taiwan/Hong Kong ================================================
      // There are lots of tables for Big5 and cp950. Please see the following links for history:
      // http://moztw.org/docs/big5/  http://www.haible.de/bruno/charsets/conversion-tables/Big5.html
      // Variations, in roughly number of defined chars:
      //  * Windows CP 950: Microsoft variant of Big5. Canonical: http://www.unicode.org/Public/MAPPINGS/VENDORS/MICSFT/WINDOWS/CP950.TXT
      //  * Windows CP 951: Microsoft variant of Big5-HKSCS-2001. Seems to be never public. http://me.abelcheung.org/articles/research/what-is-cp951/
      //  * Big5-2003 (Taiwan standard) almost superset of cp950.
      //  * Unicode-at-on (UAO) / Mozilla 1.8. Falling out of use on the Web. Not supported by other browsers.
      //  * Big5-HKSCS (-2001, -2004, -2008). Hong Kong standard. 
      //    many unicode code points moved from PUA to Supplementary plane (U+2XXXX) over the years.
      //    Plus, it has 4 combining sequences.
      //    Seems that Mozilla refused to support it for 10 yrs. https://bugzilla.mozilla.org/show_bug.cgi?id=162431 https://bugzilla.mozilla.org/show_bug.cgi?id=310299
      //    because big5-hkscs is the only encoding to include astral characters in non-algorithmic way.
      //    Implementations are not consistent within browsers; sometimes labeled as just big5.
      //    MS Internet Explorer switches from big5 to big5-hkscs when a patch applied.
      //    Great discussion & recap of what's going on https://bugzilla.mozilla.org/show_bug.cgi?id=912470#c31
      //    In the encoder, it might make sense to support encoding old PUA mappings to Big5 bytes seq-s.
      //    Official spec: http://www.ogcio.gov.hk/en/business/tech_promotion/ccli/terms/doc/2003cmp_2008.txt
      //                   http://www.ogcio.gov.hk/tc/business/tech_promotion/ccli/terms/doc/hkscs-2008-big5-iso.txt
      // 
      // Current understanding of how to deal with Big5(-HKSCS) is in the Encoding Standard, http://encoding.spec.whatwg.org/#big5-encoder
      // Unicode mapping (http://www.unicode.org/Public/MAPPINGS/OBSOLETE/EASTASIA/OTHER/BIG5.TXT) is said to be wrong.
      "windows950": "cp950",
      "ms950": "cp950",
      "950": "cp950",
      "cp950": {
        type: "_dbcs",
        table: function() {
          return require_cp950();
        }
      },
      // Big5 has many variations and is an extension of cp950. We use Encoding Standard's as a consensus.
      "big5": "big5hkscs",
      "big5hkscs": {
        type: "_dbcs",
        table: function() {
          return require_cp950().concat(require_big5_added());
        },
        encodeSkipVals: [
          // Although Encoding Standard says we should avoid encoding to HKSCS area (See Step 1 of
          // https://encoding.spec.whatwg.org/#index-big5-pointer), we still do it to increase compatibility with ICU.
          // But if a single unicode point can be encoded both as HKSCS and regular Big5, we prefer the latter.
          36457,
          36463,
          36478,
          36523,
          36532,
          36557,
          36560,
          36695,
          36713,
          36718,
          36811,
          36862,
          36973,
          36986,
          37060,
          37084,
          37105,
          37311,
          37551,
          37552,
          37553,
          37554,
          37585,
          37959,
          38090,
          38361,
          38652,
          39285,
          39798,
          39800,
          39803,
          39878,
          39902,
          39916,
          39926,
          40002,
          40019,
          40034,
          40040,
          40043,
          40055,
          40124,
          40125,
          40144,
          40279,
          40282,
          40388,
          40431,
          40443,
          40617,
          40687,
          40701,
          40800,
          40907,
          41079,
          41180,
          41183,
          36812,
          37576,
          38468,
          38637,
          // Step 2 of https://encoding.spec.whatwg.org/#index-big5-pointer: Use last pointer for U+2550, U+255E, U+2561, U+256A, U+5341, or U+5345
          41636,
          41637,
          41639,
          41638,
          41676,
          41678
        ]
      },
      "cnbig5": "big5hkscs",
      "csbig5": "big5hkscs",
      "xxbig5": "big5hkscs"
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/index.js
var require_encodings = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/encodings/index.js"(exports2, module2) {
    "use strict";
    var modules = [
      require_internal(),
      require_utf32(),
      require_utf16(),
      require_utf7(),
      require_sbcs_codec(),
      require_sbcs_data(),
      require_sbcs_data_generated(),
      require_dbcs_codec(),
      require_dbcs_data()
    ];
    for (i8 = 0; i8 < modules.length; i8++) {
      module2 = modules[i8];
      for (enc in module2)
        if (Object.prototype.hasOwnProperty.call(module2, enc))
          exports2[enc] = module2[enc];
    }
    var module2;
    var enc;
    var i8;
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/streams.js
var require_streams2 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/streams.js"(exports2, module2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    module2.exports = function(stream_module) {
      var Transform = stream_module.Transform;
      function IconvLiteEncoderStream(conv, options) {
        this.conv = conv;
        options = options || {};
        options.decodeStrings = false;
        Transform.call(this, options);
      }
      IconvLiteEncoderStream.prototype = Object.create(Transform.prototype, {
        constructor: { value: IconvLiteEncoderStream }
      });
      IconvLiteEncoderStream.prototype._transform = function(chunk, encoding, done) {
        if (typeof chunk != "string")
          return done(new Error("Iconv encoding stream needs strings as its input."));
        try {
          var res = this.conv.write(chunk);
          if (res && res.length) this.push(res);
          done();
        } catch (e6) {
          done(e6);
        }
      };
      IconvLiteEncoderStream.prototype._flush = function(done) {
        try {
          var res = this.conv.end();
          if (res && res.length) this.push(res);
          done();
        } catch (e6) {
          done(e6);
        }
      };
      IconvLiteEncoderStream.prototype.collect = function(cb) {
        var chunks = [];
        this.on("error", cb);
        this.on("data", function(chunk) {
          chunks.push(chunk);
        });
        this.on("end", function() {
          cb(null, Buffer8.concat(chunks));
        });
        return this;
      };
      function IconvLiteDecoderStream(conv, options) {
        this.conv = conv;
        options = options || {};
        options.encoding = this.encoding = "utf8";
        Transform.call(this, options);
      }
      IconvLiteDecoderStream.prototype = Object.create(Transform.prototype, {
        constructor: { value: IconvLiteDecoderStream }
      });
      IconvLiteDecoderStream.prototype._transform = function(chunk, encoding, done) {
        if (!Buffer8.isBuffer(chunk) && !(chunk instanceof Uint8Array))
          return done(new Error("Iconv decoding stream needs buffers as its input."));
        try {
          var res = this.conv.write(chunk);
          if (res && res.length) this.push(res, this.encoding);
          done();
        } catch (e6) {
          done(e6);
        }
      };
      IconvLiteDecoderStream.prototype._flush = function(done) {
        try {
          var res = this.conv.end();
          if (res && res.length) this.push(res, this.encoding);
          done();
        } catch (e6) {
          done(e6);
        }
      };
      IconvLiteDecoderStream.prototype.collect = function(cb) {
        var res = "";
        this.on("error", cb);
        this.on("data", function(chunk) {
          res += chunk;
        });
        this.on("end", function() {
          cb(null, res);
        });
        return this;
      };
      return {
        IconvLiteEncoderStream,
        IconvLiteDecoderStream
      };
    };
  }
});

// ../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/index.js
var require_lib6 = __commonJS({
  "../node_modules/.pnpm/iconv-lite@0.6.3/node_modules/iconv-lite/lib/index.js"(exports2, module2) {
    "use strict";
    var Buffer8 = require_safer().Buffer;
    var bomHandling = require_bom_handling();
    var iconv = module2.exports;
    iconv.encodings = null;
    iconv.defaultCharUnicode = "\uFFFD";
    iconv.defaultCharSingleByte = "?";
    iconv.encode = function encode2(str, encoding, options) {
      str = "" + (str || "");
      var encoder = iconv.getEncoder(encoding, options);
      var res = encoder.write(str);
      var trail = encoder.end();
      return trail && trail.length > 0 ? Buffer8.concat([res, trail]) : res;
    };
    iconv.decode = function decode2(buf, encoding, options) {
      if (typeof buf === "string") {
        if (!iconv.skipDecodeWarning) {
          console.error("Iconv-lite warning: decode()-ing strings is deprecated. Refer to https://github.com/ashtuchkin/iconv-lite/wiki/Use-Buffers-when-decoding");
          iconv.skipDecodeWarning = true;
        }
        buf = Buffer8.from("" + (buf || ""), "binary");
      }
      var decoder2 = iconv.getDecoder(encoding, options);
      var res = decoder2.write(buf);
      var trail = decoder2.end();
      return trail ? res + trail : res;
    };
    iconv.encodingExists = function encodingExists(enc) {
      try {
        iconv.getCodec(enc);
        return true;
      } catch (e6) {
        return false;
      }
    };
    iconv.toEncoding = iconv.encode;
    iconv.fromEncoding = iconv.decode;
    iconv._codecDataCache = {};
    iconv.getCodec = function getCodec(encoding) {
      if (!iconv.encodings)
        iconv.encodings = require_encodings();
      var enc = iconv._canonicalizeEncoding(encoding);
      var codecOptions = {};
      while (true) {
        var codec = iconv._codecDataCache[enc];
        if (codec)
          return codec;
        var codecDef = iconv.encodings[enc];
        switch (typeof codecDef) {
          case "string":
            enc = codecDef;
            break;
          case "object":
            for (var key in codecDef)
              codecOptions[key] = codecDef[key];
            if (!codecOptions.encodingName)
              codecOptions.encodingName = enc;
            enc = codecDef.type;
            break;
          case "function":
            if (!codecOptions.encodingName)
              codecOptions.encodingName = enc;
            codec = new codecDef(codecOptions, iconv);
            iconv._codecDataCache[codecOptions.encodingName] = codec;
            return codec;
          default:
            throw new Error("Encoding not recognized: '" + encoding + "' (searched as: '" + enc + "')");
        }
      }
    };
    iconv._canonicalizeEncoding = function(encoding) {
      return ("" + encoding).toLowerCase().replace(/:\d{4}$|[^0-9a-z]/g, "");
    };
    iconv.getEncoder = function getEncoder(encoding, options) {
      var codec = iconv.getCodec(encoding), encoder = new codec.encoder(options, codec);
      if (codec.bomAware && options && options.addBOM)
        encoder = new bomHandling.PrependBOM(encoder, options);
      return encoder;
    };
    iconv.getDecoder = function getDecoder(encoding, options) {
      var codec = iconv.getCodec(encoding), decoder2 = new codec.decoder(options, codec);
      if (codec.bomAware && !(options && options.stripBOM === false))
        decoder2 = new bomHandling.StripBOM(decoder2, options);
      return decoder2;
    };
    iconv.enableStreamingAPI = function enableStreamingAPI(stream_module2) {
      if (iconv.supportsStreams)
        return;
      var streams = require_streams2()(stream_module2);
      iconv.IconvLiteEncoderStream = streams.IconvLiteEncoderStream;
      iconv.IconvLiteDecoderStream = streams.IconvLiteDecoderStream;
      iconv.encodeStream = function encodeStream(encoding, options) {
        return new iconv.IconvLiteEncoderStream(iconv.getEncoder(encoding, options), options);
      };
      iconv.decodeStream = function decodeStream(encoding, options) {
        return new iconv.IconvLiteDecoderStream(iconv.getDecoder(encoding, options), options);
      };
      iconv.supportsStreams = true;
    };
    var stream_module;
    try {
      stream_module = require("stream");
    } catch (e6) {
    }
    if (stream_module && stream_module.Transform) {
      iconv.enableStreamingAPI(stream_module);
    } else {
      iconv.encodeStream = iconv.decodeStream = function() {
        throw new Error("iconv-lite Streaming API is not enabled. Use iconv.enableStreamingAPI(require('stream')); to enable it.");
      };
    }
    if (false) {
      console.error("iconv-lite warning: js files use non-utf8 encoding. See https://github.com/ashtuchkin/iconv-lite/wiki/Javascript-source-file-encodings for more info.");
    }
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/string.js
var require_string = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/string.js"(exports2) {
    "use strict";
    var Iconv = require_lib6();
    var { createLRU } = require_lib5();
    var decoderCache = createLRU({
      max: 500
    });
    exports2.decode = function(buffer2, encoding, start2, end, options) {
      if (Buffer.isEncoding(encoding)) {
        return buffer2.toString(encoding, start2, end);
      }
      let decoder2;
      if (!options) {
        decoder2 = decoderCache.get(encoding);
        if (!decoder2) {
          decoder2 = Iconv.getDecoder(encoding);
          decoderCache.set(encoding, decoder2);
        }
      } else {
        const decoderArgs = { encoding, options };
        const decoderKey = JSON.stringify(decoderArgs);
        decoder2 = decoderCache.get(decoderKey);
        if (!decoder2) {
          decoder2 = Iconv.getDecoder(decoderArgs.encoding, decoderArgs.options);
          decoderCache.set(decoderKey, decoder2);
        }
      }
      const res = decoder2.write(buffer2.slice(start2, end));
      const trail = decoder2.end();
      return trail ? res + trail : res;
    };
    exports2.encode = function(string2, encoding, options) {
      if (Buffer.isEncoding(encoding)) {
        return Buffer.from(string2, encoding);
      }
      const encoder = Iconv.getEncoder(encoding, options || {});
      const res = encoder.write(string2);
      const trail = encoder.end();
      return trail && trail.length > 0 ? Buffer.concat([res, trail]) : res;
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/types.js
var require_types2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/types.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      0: "DECIMAL",
      // aka DECIMAL
      1: "TINY",
      // aka TINYINT, 1 byte
      2: "SHORT",
      // aka SMALLINT, 2 bytes
      3: "LONG",
      // aka INT, 4 bytes
      4: "FLOAT",
      // aka FLOAT, 4-8 bytes
      5: "DOUBLE",
      // aka DOUBLE, 8 bytes
      6: "NULL",
      // NULL (used for prepared statements, I think)
      7: "TIMESTAMP",
      // aka TIMESTAMP
      8: "LONGLONG",
      // aka BIGINT, 8 bytes
      9: "INT24",
      // aka MEDIUMINT, 3 bytes
      10: "DATE",
      // aka DATE
      11: "TIME",
      // aka TIME
      12: "DATETIME",
      // aka DATETIME
      13: "YEAR",
      // aka YEAR, 1 byte (don't ask)
      14: "NEWDATE",
      // aka ?
      15: "VARCHAR",
      // aka VARCHAR (?)
      16: "BIT",
      // aka BIT, 1-8 byte
      245: "JSON",
      246: "NEWDECIMAL",
      // aka DECIMAL
      247: "ENUM",
      // aka ENUM
      248: "SET",
      // aka SET
      249: "TINY_BLOB",
      // aka TINYBLOB, TINYTEXT
      250: "MEDIUM_BLOB",
      // aka MEDIUMBLOB, MEDIUMTEXT
      251: "LONG_BLOB",
      // aka LONGBLOG, LONGTEXT
      252: "BLOB",
      // aka BLOB, TEXT
      253: "VAR_STRING",
      // aka VARCHAR, VARBINARY
      254: "STRING",
      // aka CHAR, BINARY
      255: "GEOMETRY"
      // aka GEOMETRY
    };
    module2.exports.DECIMAL = 0;
    module2.exports.TINY = 1;
    module2.exports.SHORT = 2;
    module2.exports.LONG = 3;
    module2.exports.FLOAT = 4;
    module2.exports.DOUBLE = 5;
    module2.exports.NULL = 6;
    module2.exports.TIMESTAMP = 7;
    module2.exports.LONGLONG = 8;
    module2.exports.INT24 = 9;
    module2.exports.DATE = 10;
    module2.exports.TIME = 11;
    module2.exports.DATETIME = 12;
    module2.exports.YEAR = 13;
    module2.exports.NEWDATE = 14;
    module2.exports.VARCHAR = 15;
    module2.exports.BIT = 16;
    module2.exports.VECTOR = 242;
    module2.exports.JSON = 245;
    module2.exports.NEWDECIMAL = 246;
    module2.exports.ENUM = 247;
    module2.exports.SET = 248;
    module2.exports.TINY_BLOB = 249;
    module2.exports.MEDIUM_BLOB = 250;
    module2.exports.LONG_BLOB = 251;
    module2.exports.BLOB = 252;
    module2.exports.VAR_STRING = 253;
    module2.exports.STRING = 254;
    module2.exports.GEOMETRY = 255;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/packet.js
var require_packet = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/packet.js"(exports2, module2) {
    "use strict";
    var ErrorCodeToName = require_errors2();
    var NativeBuffer = require("buffer").Buffer;
    var Long = require_umd();
    var StringParser = require_string();
    var Types = require_types2();
    var INVALID_DATE = /* @__PURE__ */ new Date(NaN);
    var pad = "000000000000";
    function leftPad(num, value) {
      const s10 = value.toString();
      if (s10.length >= num) {
        return s10;
      }
      return (pad + s10).slice(-num);
    }
    var minus2 = "-".charCodeAt(0);
    var plus = "+".charCodeAt(0);
    var dot = ".".charCodeAt(0);
    var exponent = "e".charCodeAt(0);
    var exponentCapital = "E".charCodeAt(0);
    var Packet = class _Packet {
      constructor(id, buffer2, start2, end) {
        this.sequenceId = id;
        this.numPackets = 1;
        this.buffer = buffer2;
        this.start = start2;
        this.offset = start2 + 4;
        this.end = end;
      }
      // ==============================
      // readers
      // ==============================
      reset() {
        this.offset = this.start + 4;
      }
      length() {
        return this.end - this.start;
      }
      slice() {
        return this.buffer.slice(this.start, this.end);
      }
      dump() {
        console.log(
          [this.buffer.asciiSlice(this.start, this.end)],
          this.buffer.slice(this.start, this.end),
          this.length(),
          this.sequenceId
        );
      }
      haveMoreData() {
        return this.end > this.offset;
      }
      skip(num) {
        this.offset += num;
      }
      readInt8() {
        return this.buffer[this.offset++];
      }
      readInt16() {
        this.offset += 2;
        return this.buffer.readUInt16LE(this.offset - 2);
      }
      readInt24() {
        return this.readInt16() + (this.readInt8() << 16);
      }
      readInt32() {
        this.offset += 4;
        return this.buffer.readUInt32LE(this.offset - 4);
      }
      readSInt8() {
        return this.buffer.readInt8(this.offset++);
      }
      readSInt16() {
        this.offset += 2;
        return this.buffer.readInt16LE(this.offset - 2);
      }
      readSInt32() {
        this.offset += 4;
        return this.buffer.readInt32LE(this.offset - 4);
      }
      readInt64JSNumber() {
        const word0 = this.readInt32();
        const word1 = this.readInt32();
        const l7 = new Long(word0, word1, true);
        return l7.toNumber();
      }
      readSInt64JSNumber() {
        const word0 = this.readInt32();
        const word1 = this.readInt32();
        if (!(word1 & 2147483648)) {
          return word0 + 4294967296 * word1;
        }
        const l7 = new Long(word0, word1, false);
        return l7.toNumber();
      }
      readInt64String() {
        const word0 = this.readInt32();
        const word1 = this.readInt32();
        const res = new Long(word0, word1, true);
        return res.toString();
      }
      readSInt64String() {
        const word0 = this.readInt32();
        const word1 = this.readInt32();
        const res = new Long(word0, word1, false);
        return res.toString();
      }
      readInt64() {
        const word0 = this.readInt32();
        const word1 = this.readInt32();
        let res = new Long(word0, word1, true);
        const resNumber = res.toNumber();
        const resString = res.toString();
        res = resNumber.toString() === resString ? resNumber : resString;
        return res;
      }
      readSInt64() {
        const word0 = this.readInt32();
        const word1 = this.readInt32();
        let res = new Long(word0, word1, false);
        const resNumber = res.toNumber();
        const resString = res.toString();
        res = resNumber.toString() === resString ? resNumber : resString;
        return res;
      }
      isEOF() {
        return this.buffer[this.offset] === 254 && this.length() < 13;
      }
      eofStatusFlags() {
        return this.buffer.readInt16LE(this.offset + 3);
      }
      eofWarningCount() {
        return this.buffer.readInt16LE(this.offset + 1);
      }
      readLengthCodedNumber(bigNumberStrings, signed) {
        const byte1 = this.buffer[this.offset++];
        if (byte1 < 251) {
          return byte1;
        }
        return this.readLengthCodedNumberExt(byte1, bigNumberStrings, signed);
      }
      readLengthCodedNumberSigned(bigNumberStrings) {
        return this.readLengthCodedNumber(bigNumberStrings, true);
      }
      readLengthCodedNumberExt(tag, bigNumberStrings, signed) {
        let word0, word1;
        let res;
        if (tag === 251) {
          return null;
        }
        if (tag === 252) {
          return this.readInt8() + (this.readInt8() << 8);
        }
        if (tag === 253) {
          return this.readInt8() + (this.readInt8() << 8) + (this.readInt8() << 16);
        }
        if (tag === 254) {
          word0 = this.readInt32();
          word1 = this.readInt32();
          if (word1 === 0) {
            return word0;
          }
          if (word1 < 2097152) {
            return word1 * 4294967296 + word0;
          }
          res = new Long(word0, word1, !signed);
          const resNumber = res.toNumber();
          const resString = res.toString();
          res = resNumber.toString() === resString ? resNumber : resString;
          return bigNumberStrings ? resString : res;
        }
        console.trace();
        throw new Error(`Should not reach here: ${tag}`);
      }
      readFloat() {
        const res = this.buffer.readFloatLE(this.offset);
        this.offset += 4;
        return res;
      }
      readDouble() {
        const res = this.buffer.readDoubleLE(this.offset);
        this.offset += 8;
        return res;
      }
      readBuffer(len) {
        if (typeof len === "undefined") {
          len = this.end - this.offset;
        }
        this.offset += len;
        return this.buffer.slice(this.offset - len, this.offset);
      }
      // DATE, DATETIME and TIMESTAMP
      readDateTime(timezone) {
        if (!timezone || timezone === "Z" || timezone === "local") {
          const length = this.readInt8();
          if (length === 251) {
            return null;
          }
          let y7 = 0;
          let m12 = 0;
          let d7 = 0;
          let H5 = 0;
          let M3 = 0;
          let S7 = 0;
          let ms3 = 0;
          if (length > 3) {
            y7 = this.readInt16();
            m12 = this.readInt8();
            d7 = this.readInt8();
          }
          if (length > 6) {
            H5 = this.readInt8();
            M3 = this.readInt8();
            S7 = this.readInt8();
          }
          if (length > 10) {
            ms3 = this.readInt32() / 1e3;
          }
          if (y7 + m12 + d7 + H5 + M3 + S7 + ms3 === 0) {
            return INVALID_DATE;
          }
          if (timezone === "Z") {
            return new Date(Date.UTC(y7, m12 - 1, d7, H5, M3, S7, ms3));
          }
          return new Date(y7, m12 - 1, d7, H5, M3, S7, ms3);
        }
        let str = this.readDateTimeString(6, "T", null);
        if (str.length === 10) {
          str += "T00:00:00";
        }
        return new Date(str + timezone);
      }
      readDateTimeString(decimals, timeSep, columnType) {
        const length = this.readInt8();
        let y7 = 0;
        let m12 = 0;
        let d7 = 0;
        let H5 = 0;
        let M3 = 0;
        let S7 = 0;
        let ms3 = 0;
        let str;
        if (length > 3) {
          y7 = this.readInt16();
          m12 = this.readInt8();
          d7 = this.readInt8();
          str = [leftPad(4, y7), leftPad(2, m12), leftPad(2, d7)].join("-");
        }
        if (length > 6) {
          H5 = this.readInt8();
          M3 = this.readInt8();
          S7 = this.readInt8();
          str += `${timeSep || " "}${[
            leftPad(2, H5),
            leftPad(2, M3),
            leftPad(2, S7)
          ].join(":")}`;
        } else if (columnType === Types.DATETIME) {
          str += " 00:00:00";
        }
        if (length > 10) {
          ms3 = this.readInt32();
          str += ".";
          if (decimals) {
            ms3 = leftPad(6, ms3);
            if (ms3.length > decimals) {
              ms3 = ms3.substring(0, decimals);
            }
          }
          str += ms3;
        }
        return str;
      }
      // TIME - value as a string, Can be negative
      readTimeString(convertTtoMs) {
        const length = this.readInt8();
        if (length === 0) {
          return "00:00:00";
        }
        const sign = this.readInt8() ? -1 : 1;
        let d7 = 0;
        let H5 = 0;
        let M3 = 0;
        let S7 = 0;
        let ms3 = 0;
        if (length > 6) {
          d7 = this.readInt32();
          H5 = this.readInt8();
          M3 = this.readInt8();
          S7 = this.readInt8();
        }
        if (length > 10) {
          ms3 = this.readInt32();
        }
        if (convertTtoMs) {
          H5 += d7 * 24;
          M3 += H5 * 60;
          S7 += M3 * 60;
          ms3 += S7 * 1e3;
          ms3 *= sign;
          return ms3;
        }
        return (sign === -1 ? "-" : "") + [leftPad(2, d7 * 24 + H5), leftPad(2, M3), leftPad(2, S7)].join(":") + (ms3 ? `.${ms3}`.replace(/0+$/, "") : "");
      }
      readLengthCodedString(encoding) {
        const len = this.readLengthCodedNumber();
        if (len === null) {
          return null;
        }
        this.offset += len;
        return StringParser.decode(
          this.buffer,
          encoding,
          this.offset - len,
          this.offset
        );
      }
      readLengthCodedBuffer() {
        const len = this.readLengthCodedNumber();
        if (len === null) {
          return null;
        }
        return this.readBuffer(len);
      }
      readNullTerminatedString(encoding) {
        const start2 = this.offset;
        let end = this.offset;
        while (this.buffer[end]) {
          end = end + 1;
        }
        this.offset = end + 1;
        return StringParser.decode(this.buffer, encoding, start2, end);
      }
      // TODO reuse?
      readString(len, encoding) {
        if (typeof len === "string" && typeof encoding === "undefined") {
          encoding = len;
          len = void 0;
        }
        if (typeof len === "undefined") {
          len = this.end - this.offset;
        }
        this.offset += len;
        return StringParser.decode(
          this.buffer,
          encoding,
          this.offset - len,
          this.offset
        );
      }
      parseInt(len, supportBigNumbers) {
        if (len === null) {
          return null;
        }
        if (len >= 14 && !supportBigNumbers) {
          const s10 = this.buffer.toString("ascii", this.offset, this.offset + len);
          this.offset += len;
          return Number(s10);
        }
        let result = 0;
        const start2 = this.offset;
        const end = this.offset + len;
        let sign = 1;
        if (len === 0) {
          return 0;
        }
        if (this.buffer[this.offset] === minus2) {
          this.offset++;
          sign = -1;
        }
        let str;
        const numDigits = end - this.offset;
        if (supportBigNumbers) {
          if (numDigits >= 15) {
            str = this.readString(end - this.offset, "binary");
            result = parseInt(str, 10);
            if (result.toString() === str) {
              return sign * result;
            }
            return sign === -1 ? `-${str}` : str;
          }
          if (numDigits > 16) {
            str = this.readString(end - this.offset);
            return sign === -1 ? `-${str}` : str;
          }
        }
        if (this.buffer[this.offset] === plus) {
          this.offset++;
        }
        while (this.offset < end) {
          result *= 10;
          result += this.buffer[this.offset] - 48;
          this.offset++;
        }
        const num = result * sign;
        if (!supportBigNumbers) {
          return num;
        }
        str = this.buffer.toString("ascii", start2, end);
        if (num.toString() === str) {
          return num;
        }
        return str;
      }
      // note that if value of inputNumberAsString is bigger than MAX_SAFE_INTEGER
      // ( or smaller than MIN_SAFE_INTEGER ) the parseIntNoBigCheck result might be
      // different from what you would get from Number(inputNumberAsString)
      // String(parseIntNoBigCheck) <> String(Number(inputNumberAsString)) <> inputNumberAsString
      parseIntNoBigCheck(len) {
        if (len === null) {
          return null;
        }
        let result = 0;
        const end = this.offset + len;
        let sign = 1;
        if (len === 0) {
          return 0;
        }
        if (this.buffer[this.offset] === minus2) {
          this.offset++;
          sign = -1;
        }
        if (this.buffer[this.offset] === plus) {
          this.offset++;
        }
        while (this.offset < end) {
          result *= 10;
          result += this.buffer[this.offset] - 48;
          this.offset++;
        }
        return result * sign;
      }
      // copy-paste from https://github.com/mysqljs/mysql/blob/master/lib/protocol/Parser.js
      parseGeometryValue() {
        const buffer2 = this.readLengthCodedBuffer();
        let offset = 4;
        if (buffer2 === null || !buffer2.length) {
          return null;
        }
        function parseGeometry() {
          let x11, y7, i8, j7, numPoints, line2;
          let result = null;
          const byteOrder = buffer2.readUInt8(offset);
          offset += 1;
          const wkbType = byteOrder ? buffer2.readUInt32LE(offset) : buffer2.readUInt32BE(offset);
          offset += 4;
          switch (wkbType) {
            case 1:
              x11 = byteOrder ? buffer2.readDoubleLE(offset) : buffer2.readDoubleBE(offset);
              offset += 8;
              y7 = byteOrder ? buffer2.readDoubleLE(offset) : buffer2.readDoubleBE(offset);
              offset += 8;
              result = { x: x11, y: y7 };
              break;
            case 2:
              numPoints = byteOrder ? buffer2.readUInt32LE(offset) : buffer2.readUInt32BE(offset);
              offset += 4;
              result = [];
              for (i8 = numPoints; i8 > 0; i8--) {
                x11 = byteOrder ? buffer2.readDoubleLE(offset) : buffer2.readDoubleBE(offset);
                offset += 8;
                y7 = byteOrder ? buffer2.readDoubleLE(offset) : buffer2.readDoubleBE(offset);
                offset += 8;
                result.push({ x: x11, y: y7 });
              }
              break;
            case 3:
              const numRings = byteOrder ? buffer2.readUInt32LE(offset) : buffer2.readUInt32BE(offset);
              offset += 4;
              result = [];
              for (i8 = numRings; i8 > 0; i8--) {
                numPoints = byteOrder ? buffer2.readUInt32LE(offset) : buffer2.readUInt32BE(offset);
                offset += 4;
                line2 = [];
                for (j7 = numPoints; j7 > 0; j7--) {
                  x11 = byteOrder ? buffer2.readDoubleLE(offset) : buffer2.readDoubleBE(offset);
                  offset += 8;
                  y7 = byteOrder ? buffer2.readDoubleLE(offset) : buffer2.readDoubleBE(offset);
                  offset += 8;
                  line2.push({ x: x11, y: y7 });
                }
                result.push(line2);
              }
              break;
            case 4:
            // WKBMultiPoint
            case 5:
            // WKBMultiLineString
            case 6:
            // WKBMultiPolygon
            case 7:
              const num = byteOrder ? buffer2.readUInt32LE(offset) : buffer2.readUInt32BE(offset);
              offset += 4;
              result = [];
              for (i8 = num; i8 > 0; i8--) {
                result.push(parseGeometry());
              }
              break;
          }
          return result;
        }
        return parseGeometry();
      }
      parseVector() {
        const bufLen = this.readLengthCodedNumber();
        const vectorEnd = this.offset + bufLen;
        const result = [];
        while (this.offset < vectorEnd && this.offset < this.end) {
          result.push(this.readFloat());
        }
        return result;
      }
      parseDate(timezone) {
        const strLen = this.readLengthCodedNumber();
        if (strLen === null) {
          return null;
        }
        if (strLen !== 10) {
          return /* @__PURE__ */ new Date(NaN);
        }
        const y7 = this.parseInt(4);
        this.offset++;
        const m12 = this.parseInt(2);
        this.offset++;
        const d7 = this.parseInt(2);
        if (!timezone || timezone === "local") {
          return new Date(y7, m12 - 1, d7);
        }
        if (timezone === "Z") {
          return new Date(Date.UTC(y7, m12 - 1, d7));
        }
        return /* @__PURE__ */ new Date(
          `${leftPad(4, y7)}-${leftPad(2, m12)}-${leftPad(2, d7)}T00:00:00${timezone}`
        );
      }
      parseDateTime(timezone) {
        const str = this.readLengthCodedString("binary");
        if (str === null) {
          return null;
        }
        if (!timezone || timezone === "local") {
          return new Date(str);
        }
        return /* @__PURE__ */ new Date(`${str}${timezone}`);
      }
      parseFloat(len) {
        if (len === null) {
          return null;
        }
        let result = 0;
        const end = this.offset + len;
        let factor = 1;
        let pastDot = false;
        let charCode = 0;
        if (len === 0) {
          return 0;
        }
        if (this.buffer[this.offset] === minus2) {
          this.offset++;
          factor = -1;
        }
        if (this.buffer[this.offset] === plus) {
          this.offset++;
        }
        while (this.offset < end) {
          charCode = this.buffer[this.offset];
          if (charCode === dot) {
            pastDot = true;
            this.offset++;
          } else if (charCode === exponent || charCode === exponentCapital) {
            this.offset++;
            const exponentValue = this.parseInt(end - this.offset);
            return result / factor * Math.pow(10, exponentValue);
          } else {
            result *= 10;
            result += this.buffer[this.offset] - 48;
            this.offset++;
            if (pastDot) {
              factor = factor * 10;
            }
          }
        }
        return result / factor;
      }
      parseLengthCodedIntNoBigCheck() {
        return this.parseIntNoBigCheck(this.readLengthCodedNumber());
      }
      parseLengthCodedInt(supportBigNumbers) {
        return this.parseInt(this.readLengthCodedNumber(), supportBigNumbers);
      }
      parseLengthCodedIntString() {
        return this.readLengthCodedString("binary");
      }
      parseLengthCodedFloat() {
        return this.parseFloat(this.readLengthCodedNumber());
      }
      peekByte() {
        return this.buffer[this.offset];
      }
      // OxFE is often used as "Alt" flag - not ok, not error.
      // For example, it's first byte of AuthSwitchRequest
      isAlt() {
        return this.peekByte() === 254;
      }
      isError() {
        return this.peekByte() === 255;
      }
      asError(encoding) {
        this.reset();
        this.readInt8();
        const errorCode = this.readInt16();
        let sqlState = "";
        if (this.buffer[this.offset] === 35) {
          this.skip(1);
          sqlState = this.readBuffer(5).toString();
        }
        const message = this.readString(void 0, encoding);
        const err3 = new Error(message);
        err3.code = ErrorCodeToName[errorCode];
        err3.errno = errorCode;
        err3.sqlState = sqlState;
        err3.sqlMessage = message;
        return err3;
      }
      writeInt32(n7) {
        this.buffer.writeUInt32LE(n7, this.offset);
        this.offset += 4;
      }
      writeInt24(n7) {
        this.writeInt8(n7 & 255);
        this.writeInt16(n7 >> 8);
      }
      writeInt16(n7) {
        this.buffer.writeUInt16LE(n7, this.offset);
        this.offset += 2;
      }
      writeInt8(n7) {
        this.buffer.writeUInt8(n7, this.offset);
        this.offset++;
      }
      writeDouble(n7) {
        this.buffer.writeDoubleLE(n7, this.offset);
        this.offset += 8;
      }
      writeBuffer(b9) {
        b9.copy(this.buffer, this.offset);
        this.offset += b9.length;
      }
      writeNull() {
        this.buffer[this.offset] = 251;
        this.offset++;
      }
      // TODO: refactor following three?
      writeNullTerminatedString(s10, encoding) {
        const buf = StringParser.encode(s10, encoding);
        this.buffer.length && buf.copy(this.buffer, this.offset);
        this.offset += buf.length;
        this.writeInt8(0);
      }
      writeString(s10, encoding) {
        if (s10 === null) {
          this.writeInt8(251);
          return;
        }
        if (s10.length === 0) {
          return;
        }
        const buf = StringParser.encode(s10, encoding);
        this.buffer.length && buf.copy(this.buffer, this.offset);
        this.offset += buf.length;
      }
      writeLengthCodedString(s10, encoding) {
        const buf = StringParser.encode(s10, encoding);
        this.writeLengthCodedNumber(buf.length);
        this.buffer.length && buf.copy(this.buffer, this.offset);
        this.offset += buf.length;
      }
      writeLengthCodedBuffer(b9) {
        this.writeLengthCodedNumber(b9.length);
        b9.copy(this.buffer, this.offset);
        this.offset += b9.length;
      }
      writeLengthCodedNumber(n7) {
        if (n7 < 251) {
          return this.writeInt8(n7);
        }
        if (n7 < 65535) {
          this.writeInt8(252);
          return this.writeInt16(n7);
        }
        if (n7 < 16777215) {
          this.writeInt8(253);
          return this.writeInt24(n7);
        }
        if (n7 === null) {
          return this.writeInt8(251);
        }
        this.writeInt8(254);
        this.buffer.writeUInt32LE(n7, this.offset);
        this.offset += 4;
        this.buffer.writeUInt32LE(n7 >> 32, this.offset);
        this.offset += 4;
        return this.offset;
      }
      writeDate(d7, timezone) {
        this.buffer.writeUInt8(11, this.offset);
        if (!timezone || timezone === "local") {
          this.buffer.writeUInt16LE(d7.getFullYear(), this.offset + 1);
          this.buffer.writeUInt8(d7.getMonth() + 1, this.offset + 3);
          this.buffer.writeUInt8(d7.getDate(), this.offset + 4);
          this.buffer.writeUInt8(d7.getHours(), this.offset + 5);
          this.buffer.writeUInt8(d7.getMinutes(), this.offset + 6);
          this.buffer.writeUInt8(d7.getSeconds(), this.offset + 7);
          this.buffer.writeUInt32LE(d7.getMilliseconds() * 1e3, this.offset + 8);
        } else {
          if (timezone !== "Z") {
            const offset = (timezone[0] === "-" ? -1 : 1) * (parseInt(timezone.substring(1, 3), 10) * 60 + parseInt(timezone.substring(4), 10));
            if (offset !== 0) {
              d7 = new Date(d7.getTime() + 6e4 * offset);
            }
          }
          this.buffer.writeUInt16LE(d7.getUTCFullYear(), this.offset + 1);
          this.buffer.writeUInt8(d7.getUTCMonth() + 1, this.offset + 3);
          this.buffer.writeUInt8(d7.getUTCDate(), this.offset + 4);
          this.buffer.writeUInt8(d7.getUTCHours(), this.offset + 5);
          this.buffer.writeUInt8(d7.getUTCMinutes(), this.offset + 6);
          this.buffer.writeUInt8(d7.getUTCSeconds(), this.offset + 7);
          this.buffer.writeUInt32LE(d7.getUTCMilliseconds() * 1e3, this.offset + 8);
        }
        this.offset += 12;
      }
      writeHeader(sequenceId) {
        const offset = this.offset;
        this.offset = 0;
        this.writeInt24(this.buffer.length - 4);
        this.writeInt8(sequenceId);
        this.offset = offset;
      }
      clone() {
        return new _Packet(this.sequenceId, this.buffer, this.start, this.end);
      }
      type() {
        if (this.isEOF()) {
          return "EOF";
        }
        if (this.isError()) {
          return "Error";
        }
        if (this.buffer[this.offset] === 0) {
          return "maybeOK";
        }
        return "";
      }
      static lengthCodedNumberLength(n7) {
        if (n7 < 251) {
          return 1;
        }
        if (n7 < 65535) {
          return 3;
        }
        if (n7 < 16777215) {
          return 5;
        }
        return 9;
      }
      static lengthCodedStringLength(str, encoding) {
        const buf = StringParser.encode(str, encoding);
        const slen = buf.length;
        return _Packet.lengthCodedNumberLength(slen) + slen;
      }
      static MockBuffer() {
        const noop4 = function() {
        };
        const res = Buffer.alloc(0);
        for (const op in NativeBuffer.prototype) {
          if (typeof res[op] === "function") {
            res[op] = noop4;
          }
        }
        return res;
      }
    };
    module2.exports = Packet;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packet_parser.js
var require_packet_parser = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packet_parser.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var MAX_PACKET_LENGTH = 16777215;
    function readPacketLength(b9, off) {
      const b0 = b9[off];
      const b1 = b9[off + 1];
      const b22 = b9[off + 2];
      if (b1 + b22 === 0) {
        return b0;
      }
      return b0 + (b1 << 8) + (b22 << 16);
    }
    var PacketParser = class _PacketParser {
      constructor(onPacket, packetHeaderLength) {
        if (typeof packetHeaderLength === "undefined") {
          packetHeaderLength = 4;
        }
        this.buffer = [];
        this.bufferLength = 0;
        this.packetHeaderLength = packetHeaderLength;
        this.headerLen = 0;
        this.length = 0;
        this.largePacketParts = [];
        this.firstPacketSequenceId = 0;
        this.onPacket = onPacket;
        this.execute = _PacketParser.prototype.executeStart;
        this._flushLargePacket = packetHeaderLength === 7 ? this._flushLargePacket7 : this._flushLargePacket4;
      }
      _flushLargePacket4() {
        const numPackets = this.largePacketParts.length;
        this.largePacketParts.unshift(Buffer.from([0, 0, 0, 0]));
        const body2 = Buffer.concat(this.largePacketParts);
        const packet = new Packet(this.firstPacketSequenceId, body2, 0, body2.length);
        this.largePacketParts.length = 0;
        packet.numPackets = numPackets;
        this.onPacket(packet);
      }
      _flushLargePacket7() {
        const numPackets = this.largePacketParts.length;
        this.largePacketParts.unshift(Buffer.from([0, 0, 0, 0, 0, 0, 0]));
        const body2 = Buffer.concat(this.largePacketParts);
        this.largePacketParts.length = 0;
        const packet = new Packet(this.firstPacketSequenceId, body2, 0, body2.length);
        packet.numPackets = numPackets;
        this.onPacket(packet);
      }
      executeStart(chunk) {
        let start2 = 0;
        const end = chunk.length;
        while (end - start2 >= 3) {
          this.length = readPacketLength(chunk, start2);
          if (end - start2 >= this.length + this.packetHeaderLength) {
            const sequenceId = chunk[start2 + 3];
            if (this.length < MAX_PACKET_LENGTH && this.largePacketParts.length === 0) {
              this.onPacket(
                new Packet(
                  sequenceId,
                  chunk,
                  start2,
                  start2 + this.packetHeaderLength + this.length
                )
              );
            } else {
              if (this.largePacketParts.length === 0) {
                this.firstPacketSequenceId = sequenceId;
              }
              this.largePacketParts.push(
                chunk.slice(
                  start2 + this.packetHeaderLength,
                  start2 + this.packetHeaderLength + this.length
                )
              );
              if (this.length < MAX_PACKET_LENGTH) {
                this._flushLargePacket();
              }
            }
            start2 += this.packetHeaderLength + this.length;
          } else {
            this.buffer = [chunk.slice(start2 + 3, end)];
            this.bufferLength = end - start2 - 3;
            this.execute = _PacketParser.prototype.executePayload;
            return;
          }
        }
        if (end - start2 > 0) {
          this.headerLen = end - start2;
          this.length = chunk[start2];
          if (this.headerLen === 2) {
            this.length = chunk[start2] + (chunk[start2 + 1] << 8);
            this.execute = _PacketParser.prototype.executeHeader3;
          } else {
            this.execute = _PacketParser.prototype.executeHeader2;
          }
        }
      }
      executePayload(chunk) {
        let start2 = 0;
        const end = chunk.length;
        const remainingPayload = this.length - this.bufferLength + this.packetHeaderLength - 3;
        if (end - start2 >= remainingPayload) {
          const payload = Buffer.allocUnsafe(this.length + this.packetHeaderLength);
          let offset = 3;
          for (let i8 = 0; i8 < this.buffer.length; ++i8) {
            this.buffer[i8].copy(payload, offset);
            offset += this.buffer[i8].length;
          }
          chunk.copy(payload, offset, start2, start2 + remainingPayload);
          const sequenceId = payload[3];
          if (this.length < MAX_PACKET_LENGTH && this.largePacketParts.length === 0) {
            this.onPacket(
              new Packet(
                sequenceId,
                payload,
                0,
                this.length + this.packetHeaderLength
              )
            );
          } else {
            if (this.largePacketParts.length === 0) {
              this.firstPacketSequenceId = sequenceId;
            }
            this.largePacketParts.push(
              payload.slice(
                this.packetHeaderLength,
                this.packetHeaderLength + this.length
              )
            );
            if (this.length < MAX_PACKET_LENGTH) {
              this._flushLargePacket();
            }
          }
          this.buffer = [];
          this.bufferLength = 0;
          this.execute = _PacketParser.prototype.executeStart;
          start2 += remainingPayload;
          if (end - start2 > 0) {
            return this.execute(chunk.slice(start2, end));
          }
        } else {
          this.buffer.push(chunk);
          this.bufferLength += chunk.length;
        }
        return null;
      }
      executeHeader2(chunk) {
        this.length += chunk[0] << 8;
        if (chunk.length > 1) {
          this.length += chunk[1] << 16;
          this.execute = _PacketParser.prototype.executePayload;
          return this.executePayload(chunk.slice(2));
        }
        this.execute = _PacketParser.prototype.executeHeader3;
        return null;
      }
      executeHeader3(chunk) {
        this.length += chunk[0] << 16;
        this.execute = _PacketParser.prototype.executePayload;
        return this.executePayload(chunk.slice(1));
      }
    };
    module2.exports = PacketParser;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_next_factor.js
var require_auth_next_factor = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_next_factor.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var AuthNextFactor = class _AuthNextFactor {
      constructor(opts) {
        this.pluginName = opts.pluginName;
        this.pluginData = opts.pluginData;
      }
      toPacket(encoding) {
        const length = 6 + this.pluginName.length + this.pluginData.length;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(2);
        packet.writeNullTerminatedString(this.pluginName, encoding);
        packet.writeBuffer(this.pluginData);
        return packet;
      }
      static fromPacket(packet, encoding) {
        packet.readInt8();
        const name3 = packet.readNullTerminatedString(encoding);
        const data = packet.readBuffer();
        return new _AuthNextFactor({
          pluginName: name3,
          pluginData: data
        });
      }
    };
    module2.exports = AuthNextFactor;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_switch_request.js
var require_auth_switch_request = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_switch_request.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var AuthSwitchRequest = class _AuthSwitchRequest {
      constructor(opts) {
        this.pluginName = opts.pluginName;
        this.pluginData = opts.pluginData;
      }
      toPacket() {
        const length = 6 + this.pluginName.length + this.pluginData.length;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(254);
        packet.writeNullTerminatedString(this.pluginName, "cesu8");
        packet.writeBuffer(this.pluginData);
        return packet;
      }
      static fromPacket(packet) {
        packet.readInt8();
        const name3 = packet.readNullTerminatedString("cesu8");
        const data = packet.readBuffer();
        return new _AuthSwitchRequest({
          pluginName: name3,
          pluginData: data
        });
      }
    };
    module2.exports = AuthSwitchRequest;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_switch_request_more_data.js
var require_auth_switch_request_more_data = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_switch_request_more_data.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var AuthSwitchRequestMoreData = class _AuthSwitchRequestMoreData {
      constructor(data) {
        this.data = data;
      }
      toPacket() {
        const length = 5 + this.data.length;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(1);
        packet.writeBuffer(this.data);
        return packet;
      }
      static fromPacket(packet) {
        packet.readInt8();
        const data = packet.readBuffer();
        return new _AuthSwitchRequestMoreData(data);
      }
      static verifyMarker(packet) {
        return packet.peekByte() === 1;
      }
    };
    module2.exports = AuthSwitchRequestMoreData;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_switch_response.js
var require_auth_switch_response = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/auth_switch_response.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var AuthSwitchResponse = class _AuthSwitchResponse {
      constructor(data) {
        if (!Buffer.isBuffer(data)) {
          data = Buffer.from(data);
        }
        this.data = data;
      }
      toPacket() {
        const length = 4 + this.data.length;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeBuffer(this.data);
        return packet;
      }
      static fromPacket(packet) {
        const data = packet.readBuffer();
        return new _AuthSwitchResponse(data);
      }
    };
    module2.exports = AuthSwitchResponse;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/binary_row.js
var require_binary_row = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/binary_row.js"(exports2, module2) {
    "use strict";
    var Types = require_types2();
    var Packet = require_packet();
    var binaryReader = new Array(256);
    var BinaryRow = class _BinaryRow {
      constructor(columns) {
        this.columns = columns || [];
      }
      static toPacket(columns, encoding) {
        const sequenceId = 0;
        let length = 0;
        columns.forEach((val2) => {
          if (val2 === null || typeof val2 === "undefined") {
            ++length;
            return;
          }
          length += Packet.lengthCodedStringLength(val2.toString(10), encoding);
        });
        length = length + 2;
        const buffer2 = Buffer.allocUnsafe(length + 4);
        const packet = new Packet(sequenceId, buffer2, 0, length + 4);
        packet.offset = 4;
        packet.writeInt8(0);
        let bitmap = 0;
        let bitValue = 1;
        columns.forEach((parameter) => {
          if (parameter.type === Types.NULL) {
            bitmap += bitValue;
          }
          bitValue *= 2;
          if (bitValue === 256) {
            packet.writeInt8(bitmap);
            bitmap = 0;
            bitValue = 1;
          }
        });
        if (bitValue !== 1) {
          packet.writeInt8(bitmap);
        }
        columns.forEach((val2) => {
          if (val2 === null) {
            packet.writeNull();
            return;
          }
          if (typeof val2 === "undefined") {
            packet.writeInt8(0);
            return;
          }
          packet.writeLengthCodedString(val2.toString(10), encoding);
        });
        return packet;
      }
      // TODO: complete list of types...
      static fromPacket(fields, packet) {
        const columns = new Array(fields.length);
        packet.readInt8();
        const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
        packet.skip(nullBitmapLength);
        for (let i8 = 0; i8 < columns.length; ++i8) {
          columns[i8] = binaryReader[fields[i8].columnType].apply(packet);
        }
        return new _BinaryRow(columns);
      }
    };
    binaryReader[Types.DECIMAL] = Packet.prototype.readLengthCodedString;
    binaryReader[1] = Packet.prototype.readInt8;
    binaryReader[2] = Packet.prototype.readInt16;
    binaryReader[3] = Packet.prototype.readInt32;
    binaryReader[4] = Packet.prototype.readFloat;
    binaryReader[5] = Packet.prototype.readDouble;
    binaryReader[6] = Packet.prototype.assertInvalid;
    binaryReader[7] = Packet.prototype.readTimestamp;
    binaryReader[8] = Packet.prototype.readInt64;
    binaryReader[9] = Packet.prototype.readInt32;
    binaryReader[10] = Packet.prototype.readTimestamp;
    binaryReader[11] = Packet.prototype.readTime;
    binaryReader[12] = Packet.prototype.readDateTime;
    binaryReader[13] = Packet.prototype.readInt16;
    binaryReader[Types.VAR_STRING] = Packet.prototype.readLengthCodedString;
    module2.exports = BinaryRow;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/commands.js
var require_commands = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/commands.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      SLEEP: 0,
      // deprecated
      QUIT: 1,
      INIT_DB: 2,
      QUERY: 3,
      FIELD_LIST: 4,
      CREATE_DB: 5,
      DROP_DB: 6,
      REFRESH: 7,
      SHUTDOWN: 8,
      STATISTICS: 9,
      PROCESS_INFO: 10,
      // deprecated
      CONNECT: 11,
      // deprecated
      PROCESS_KILL: 12,
      DEBUG: 13,
      PING: 14,
      TIME: 15,
      // deprecated
      DELAYED_INSERT: 16,
      // deprecated
      CHANGE_USER: 17,
      BINLOG_DUMP: 18,
      TABLE_DUMP: 19,
      CONNECT_OUT: 20,
      REGISTER_SLAVE: 21,
      STMT_PREPARE: 22,
      STMT_EXECUTE: 23,
      STMT_SEND_LONG_DATA: 24,
      STMT_CLOSE: 25,
      STMT_RESET: 26,
      SET_OPTION: 27,
      STMT_FETCH: 28,
      DAEMON: 29,
      // deprecated
      BINLOG_DUMP_GTID: 30,
      UNKNOWN: 255
      // bad!
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/binlog_dump.js
var require_binlog_dump = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/binlog_dump.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var CommandCodes = require_commands();
    var BinlogDump = class {
      constructor(opts) {
        this.binlogPos = opts.binlogPos || 0;
        this.serverId = opts.serverId || 0;
        this.flags = opts.flags || 0;
        this.filename = opts.filename || "";
      }
      toPacket() {
        const length = 15 + Buffer.byteLength(this.filename, "utf8");
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(CommandCodes.BINLOG_DUMP);
        packet.writeInt32(this.binlogPos);
        packet.writeInt16(this.flags);
        packet.writeInt32(this.serverId);
        packet.writeString(this.filename);
        return packet;
      }
    };
    module2.exports = BinlogDump;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/client.js
var require_client3 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/client.js"(exports2) {
    "use strict";
    exports2.LONG_PASSWORD = 1;
    exports2.FOUND_ROWS = 2;
    exports2.LONG_FLAG = 4;
    exports2.CONNECT_WITH_DB = 8;
    exports2.NO_SCHEMA = 16;
    exports2.COMPRESS = 32;
    exports2.ODBC = 64;
    exports2.LOCAL_FILES = 128;
    exports2.IGNORE_SPACE = 256;
    exports2.PROTOCOL_41 = 512;
    exports2.INTERACTIVE = 1024;
    exports2.SSL = 2048;
    exports2.IGNORE_SIGPIPE = 4096;
    exports2.TRANSACTIONS = 8192;
    exports2.RESERVED = 16384;
    exports2.SECURE_CONNECTION = 32768;
    exports2.MULTI_STATEMENTS = 65536;
    exports2.MULTI_RESULTS = 131072;
    exports2.PS_MULTI_RESULTS = 262144;
    exports2.PLUGIN_AUTH = 524288;
    exports2.CONNECT_ATTRS = 1048576;
    exports2.PLUGIN_AUTH_LENENC_CLIENT_DATA = 2097152;
    exports2.CAN_HANDLE_EXPIRED_PASSWORDS = 4194304;
    exports2.SESSION_TRACK = 8388608;
    exports2.DEPRECATE_EOF = 16777216;
    exports2.SSL_VERIFY_SERVER_CERT = 1073741824;
    exports2.REMEMBER_OPTIONS = 2147483648;
    exports2.MULTI_FACTOR_AUTHENTICATION = 268435456;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_41.js
var require_auth_41 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_41.js"(exports2) {
    "use strict";
    var crypto7 = require("crypto");
    function sha1(msg, msg1, msg2) {
      const hash = crypto7.createHash("sha1");
      hash.update(msg);
      if (msg1) {
        hash.update(msg1);
      }
      if (msg2) {
        hash.update(msg2);
      }
      return hash.digest();
    }
    function xor2(a9, b9) {
      const result = Buffer.allocUnsafe(a9.length);
      for (let i8 = 0; i8 < a9.length; i8++) {
        result[i8] = a9[i8] ^ b9[i8];
      }
      return result;
    }
    exports2.xor = xor2;
    function token(password, scramble1, scramble2) {
      if (!password) {
        return Buffer.alloc(0);
      }
      const stage1 = sha1(password);
      return exports2.calculateTokenFromPasswordSha(stage1, scramble1, scramble2);
    }
    exports2.calculateTokenFromPasswordSha = function(passwordSha, scramble1, scramble2) {
      const authPluginData1 = scramble1.slice(0, 8);
      const authPluginData2 = scramble2.slice(0, 12);
      const stage2 = sha1(passwordSha);
      const stage3 = sha1(authPluginData1, authPluginData2, stage2);
      return xor2(stage3, passwordSha);
    };
    exports2.calculateToken = token;
    exports2.verifyToken = function(publicSeed1, publicSeed2, token2, doubleSha) {
      const hashStage1 = xor2(token2, sha1(publicSeed1, publicSeed2, doubleSha));
      const candidateHash2 = sha1(hashStage1);
      return candidateHash2.compare(doubleSha) === 0;
    };
    exports2.doubleSha1 = function(password) {
      return sha1(sha1(password));
    };
    function xorRotating(a9, seed) {
      const result = Buffer.allocUnsafe(a9.length);
      const seedLen = seed.length;
      for (let i8 = 0; i8 < a9.length; i8++) {
        result[i8] = a9[i8] ^ seed[i8 % seedLen];
      }
      return result;
    }
    exports2.xorRotating = xorRotating;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/charset_encodings.js
var require_charset_encodings = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/charset_encodings.js"(exports2, module2) {
    "use strict";
    module2.exports = [
      "utf8",
      "big5",
      "latin2",
      "dec8",
      "cp850",
      "latin1",
      "hp8",
      "koi8r",
      "latin1",
      "latin2",
      "swe7",
      "ascii",
      "eucjp",
      "sjis",
      "cp1251",
      "latin1",
      "hebrew",
      "utf8",
      "tis620",
      "euckr",
      "latin7",
      "latin2",
      "koi8u",
      "cp1251",
      "gb2312",
      "greek",
      "cp1250",
      "latin2",
      "gbk",
      "cp1257",
      "latin5",
      "latin1",
      "armscii8",
      "cesu8",
      "cp1250",
      "ucs2",
      "cp866",
      "keybcs2",
      "macintosh",
      "macroman",
      "cp852",
      "latin7",
      "latin7",
      "macintosh",
      "cp1250",
      "utf8",
      "utf8",
      "latin1",
      "latin1",
      "latin1",
      "cp1251",
      "cp1251",
      "cp1251",
      "macroman",
      "utf16",
      "utf16",
      "utf16-le",
      "cp1256",
      "cp1257",
      "cp1257",
      "utf32",
      "utf32",
      "utf16-le",
      "binary",
      "armscii8",
      "ascii",
      "cp1250",
      "cp1256",
      "cp866",
      "dec8",
      "greek",
      "hebrew",
      "hp8",
      "keybcs2",
      "koi8r",
      "koi8u",
      "cesu8",
      "latin2",
      "latin5",
      "latin7",
      "cp850",
      "cp852",
      "swe7",
      "cesu8",
      "big5",
      "euckr",
      "gb2312",
      "gbk",
      "sjis",
      "tis620",
      "ucs2",
      "eucjp",
      "geostd8",
      "geostd8",
      "latin1",
      "cp932",
      "cp932",
      "eucjpms",
      "eucjpms",
      "cp1250",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf16",
      "utf8",
      "utf8",
      "utf8",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "ucs2",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "ucs2",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf32",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "cesu8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "cesu8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "gb18030",
      "gb18030",
      "gb18030",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8",
      "utf8"
    ];
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/change_user.js
var require_change_user = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/change_user.js"(exports2, module2) {
    "use strict";
    var CommandCode = require_commands();
    var ClientConstants = require_client3();
    var Packet = require_packet();
    var auth41 = require_auth_41();
    var CharsetToEncoding = require_charset_encodings();
    var ChangeUser = class {
      constructor(opts) {
        this.flags = opts.flags;
        this.user = opts.user || "";
        this.database = opts.database || "";
        this.password = opts.password || "";
        this.passwordSha1 = opts.passwordSha1;
        this.authPluginData1 = opts.authPluginData1;
        this.authPluginData2 = opts.authPluginData2;
        this.connectAttributes = opts.connectAttrinutes || {};
        let authToken;
        if (this.passwordSha1) {
          authToken = auth41.calculateTokenFromPasswordSha(
            this.passwordSha1,
            this.authPluginData1,
            this.authPluginData2
          );
        } else {
          authToken = auth41.calculateToken(
            this.password,
            this.authPluginData1,
            this.authPluginData2
          );
        }
        this.authToken = authToken;
        this.charsetNumber = opts.charsetNumber;
      }
      // TODO
      // ChangeUser.fromPacket = function(packet)
      // };
      serializeToBuffer(buffer2) {
        const isSet2 = (flag) => this.flags & ClientConstants[flag];
        const packet = new Packet(0, buffer2, 0, buffer2.length);
        packet.offset = 4;
        const encoding = CharsetToEncoding[this.charsetNumber];
        packet.writeInt8(CommandCode.CHANGE_USER);
        packet.writeNullTerminatedString(this.user, encoding);
        if (isSet2("SECURE_CONNECTION")) {
          packet.writeInt8(this.authToken.length);
          packet.writeBuffer(this.authToken);
        } else {
          packet.writeBuffer(this.authToken);
          packet.writeInt8(0);
        }
        packet.writeNullTerminatedString(this.database, encoding);
        packet.writeInt16(this.charsetNumber);
        if (isSet2("PLUGIN_AUTH")) {
          packet.writeNullTerminatedString("mysql_native_password", "latin1");
        }
        if (isSet2("CONNECT_ATTRS")) {
          const connectAttributes = this.connectAttributes;
          const attrNames = Object.keys(connectAttributes);
          let keysLength = 0;
          for (let k9 = 0; k9 < attrNames.length; ++k9) {
            keysLength += Packet.lengthCodedStringLength(attrNames[k9], encoding);
            keysLength += Packet.lengthCodedStringLength(
              connectAttributes[attrNames[k9]],
              encoding
            );
          }
          packet.writeLengthCodedNumber(keysLength);
          for (let k9 = 0; k9 < attrNames.length; ++k9) {
            packet.writeLengthCodedString(attrNames[k9], encoding);
            packet.writeLengthCodedString(
              connectAttributes[attrNames[k9]],
              encoding
            );
          }
        }
        return packet;
      }
      toPacket() {
        if (typeof this.user !== "string") {
          throw new Error('"user" connection config property must be a string');
        }
        if (typeof this.database !== "string") {
          throw new Error('"database" connection config property must be a string');
        }
        const p11 = this.serializeToBuffer(Packet.MockBuffer());
        return this.serializeToBuffer(Buffer.allocUnsafe(p11.offset));
      }
    };
    module2.exports = ChangeUser;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/close_statement.js
var require_close_statement = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/close_statement.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var CommandCodes = require_commands();
    var CloseStatement = class {
      constructor(id) {
        this.id = id;
      }
      // note: no response sent back
      toPacket() {
        const packet = new Packet(0, Buffer.allocUnsafe(9), 0, 9);
        packet.offset = 4;
        packet.writeInt8(CommandCodes.STMT_CLOSE);
        packet.writeInt32(this.id);
        return packet;
      }
    };
    module2.exports = CloseStatement;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/field_flags.js
var require_field_flags = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/field_flags.js"(exports2) {
    "use strict";
    exports2.NOT_NULL = 1;
    exports2.PRI_KEY = 2;
    exports2.UNIQUE_KEY = 4;
    exports2.MULTIPLE_KEY = 8;
    exports2.BLOB = 16;
    exports2.UNSIGNED = 32;
    exports2.ZEROFILL = 64;
    exports2.BINARY = 128;
    exports2.ENUM = 256;
    exports2.AUTO_INCREMENT = 512;
    exports2.TIMESTAMP = 1024;
    exports2.SET = 2048;
    exports2.NO_DEFAULT_VALUE = 4096;
    exports2.ON_UPDATE_NOW = 8192;
    exports2.NUM = 32768;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/column_definition.js
var require_column_definition = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/column_definition.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var StringParser = require_string();
    var CharsetToEncoding = require_charset_encodings();
    var fields = ["catalog", "schema", "table", "orgTable", "name", "orgName"];
    var ColumnDefinition = class {
      constructor(packet, clientEncoding) {
        this._buf = packet.buffer;
        this._clientEncoding = clientEncoding;
        this._catalogLength = packet.readLengthCodedNumber();
        this._catalogStart = packet.offset;
        packet.offset += this._catalogLength;
        this._schemaLength = packet.readLengthCodedNumber();
        this._schemaStart = packet.offset;
        packet.offset += this._schemaLength;
        this._tableLength = packet.readLengthCodedNumber();
        this._tableStart = packet.offset;
        packet.offset += this._tableLength;
        this._orgTableLength = packet.readLengthCodedNumber();
        this._orgTableStart = packet.offset;
        packet.offset += this._orgTableLength;
        const _nameLength = packet.readLengthCodedNumber();
        const _nameStart = packet.offset;
        packet.offset += _nameLength;
        this._orgNameLength = packet.readLengthCodedNumber();
        this._orgNameStart = packet.offset;
        packet.offset += this._orgNameLength;
        packet.skip(1);
        this.characterSet = packet.readInt16();
        this.encoding = CharsetToEncoding[this.characterSet];
        this.name = StringParser.decode(
          this._buf,
          this.encoding === "binary" ? this._clientEncoding : this.encoding,
          _nameStart,
          _nameStart + _nameLength
        );
        this.columnLength = packet.readInt32();
        this.columnType = packet.readInt8();
        this.type = this.columnType;
        this.flags = packet.readInt16();
        this.decimals = packet.readInt8();
      }
      inspect() {
        return {
          catalog: this.catalog,
          schema: this.schema,
          name: this.name,
          orgName: this.orgName,
          table: this.table,
          orgTable: this.orgTable,
          characterSet: this.characterSet,
          encoding: this.encoding,
          columnLength: this.columnLength,
          type: this.columnType,
          flags: this.flags,
          decimals: this.decimals
        };
      }
      [Symbol.for("nodejs.util.inspect.custom")](depth, inspectOptions, inspect) {
        const Types = require_types2();
        const typeNames = [];
        for (const t6 in Types) {
          typeNames[Types[t6]] = t6;
        }
        const fiedFlags = require_field_flags();
        const flagNames = [];
        const inspectFlags = this.flags;
        for (const f9 in fiedFlags) {
          if (inspectFlags & fiedFlags[f9]) {
            if (f9 === "PRI_KEY") {
              flagNames.push("PRIMARY KEY");
            } else if (f9 === "NOT_NULL") {
              flagNames.push("NOT NULL");
            } else if (f9 === "BINARY") {
            } else if (f9 === "MULTIPLE_KEY") {
            } else if (f9 === "NO_DEFAULT_VALUE") {
            } else if (f9 === "BLOB") {
            } else if (f9 === "UNSIGNED") {
            } else if (f9 === "TIMESTAMP") {
            } else if (f9 === "ON_UPDATE_NOW") {
              flagNames.push("ON UPDATE CURRENT_TIMESTAMP");
            } else {
              flagNames.push(f9);
            }
          }
        }
        if (depth > 1) {
          return inspect({
            ...this.inspect(),
            typeName: typeNames[this.columnType],
            flags: flagNames
          });
        }
        const isUnsigned = this.flags & fiedFlags.UNSIGNED;
        let typeName = typeNames[this.columnType];
        if (typeName === "BLOB") {
          if (this.columnLength === 4294967295) {
            typeName = "LONGTEXT";
          } else if (this.columnLength === 67108860) {
            typeName = "MEDIUMTEXT";
          } else if (this.columnLength === 262140) {
            typeName = "TEXT";
          } else if (this.columnLength === 1020) {
            typeName = "TINYTEXT";
          } else {
            typeName = `BLOB(${this.columnLength})`;
          }
        } else if (typeName === "VAR_STRING") {
          typeName = `VARCHAR(${Math.ceil(this.columnLength / 4)})`;
        } else if (typeName === "TINY") {
          if (this.columnLength === 3 && isUnsigned || this.columnLength === 4 && !isUnsigned) {
            typeName = "TINYINT";
          } else {
            typeName = `TINYINT(${this.columnLength})`;
          }
        } else if (typeName === "LONGLONG") {
          if (this.columnLength === 20) {
            typeName = "BIGINT";
          } else {
            typeName = `BIGINT(${this.columnLength})`;
          }
        } else if (typeName === "SHORT") {
          if (isUnsigned && this.columnLength === 5) {
            typeName = "SMALLINT";
          } else if (!isUnsigned && this.columnLength === 6) {
            typeName = "SMALLINT";
          } else {
            typeName = `SMALLINT(${this.columnLength})`;
          }
        } else if (typeName === "LONG") {
          if (isUnsigned && this.columnLength === 10) {
            typeName = "INT";
          } else if (!isUnsigned && this.columnLength === 11) {
            typeName = "INT";
          } else {
            typeName = `INT(${this.columnLength})`;
          }
        } else if (typeName === "INT24") {
          if (isUnsigned && this.columnLength === 8) {
            typeName = "MEDIUMINT";
          } else if (!isUnsigned && this.columnLength === 9) {
            typeName = "MEDIUMINT";
          } else {
            typeName = `MEDIUMINT(${this.columnLength})`;
          }
        } else if (typeName === "DOUBLE") {
          if (this.columnLength === 22 && this.decimals === 31) {
            typeName = "DOUBLE";
          } else {
            typeName = `DOUBLE(${this.columnLength},${this.decimals})`;
          }
        } else if (typeName === "FLOAT") {
          if (this.columnLength === 12 && this.decimals === 31) {
            typeName = "FLOAT";
          } else {
            typeName = `FLOAT(${this.columnLength},${this.decimals})`;
          }
        } else if (typeName === "NEWDECIMAL") {
          if (this.columnLength === 11 && this.decimals === 0) {
            typeName = "DECIMAL";
          } else if (this.decimals === 0) {
            if (isUnsigned) {
              typeName = `DECIMAL(${this.columnLength})`;
            } else {
              typeName = `DECIMAL(${this.columnLength - 1})`;
            }
          } else {
            typeName = `DECIMAL(${this.columnLength - 2},${this.decimals})`;
          }
        } else {
          typeName = `${typeNames[this.columnType]}(${this.columnLength})`;
        }
        if (isUnsigned) {
          typeName += " UNSIGNED";
        }
        return `\`${this.name}\` ${[typeName, ...flagNames].join(" ")}`;
      }
      static toPacket(column6, sequenceId) {
        let length = 17;
        fields.forEach((field) => {
          length += Packet.lengthCodedStringLength(
            column6[field],
            CharsetToEncoding[column6.characterSet]
          );
        });
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(sequenceId, buffer2, 0, length);
        function writeField(name3) {
          packet.writeLengthCodedString(
            column6[name3],
            CharsetToEncoding[column6.characterSet]
          );
        }
        packet.offset = 4;
        fields.forEach(writeField);
        packet.writeInt8(12);
        packet.writeInt16(column6.characterSet);
        packet.writeInt32(column6.columnLength);
        packet.writeInt8(column6.columnType);
        packet.writeInt16(column6.flags);
        packet.writeInt8(column6.decimals);
        packet.writeInt16(0);
        return packet;
      }
      // node-mysql compatibility: alias "db" to "schema"
      get db() {
        return this.schema;
      }
    };
    var addString = function(name3) {
      Object.defineProperty(ColumnDefinition.prototype, name3, {
        get: function() {
          const start2 = this[`_${name3}Start`];
          const end = start2 + this[`_${name3}Length`];
          const val2 = StringParser.decode(
            this._buf,
            this.encoding === "binary" ? this._clientEncoding : this.encoding,
            start2,
            end
          );
          Object.defineProperty(this, name3, {
            value: val2,
            writable: false,
            configurable: false,
            enumerable: false
          });
          return val2;
        }
      });
    };
    addString("catalog");
    addString("schema");
    addString("table");
    addString("orgTable");
    addString("orgName");
    module2.exports = ColumnDefinition;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/cursor.js
var require_cursor = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/cursor.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      NO_CURSOR: 0,
      READ_ONLY: 1,
      FOR_UPDATE: 2,
      SCROLLABLE: 3
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/execute.js
var require_execute = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/execute.js"(exports2, module2) {
    "use strict";
    var CursorType = require_cursor();
    var CommandCodes = require_commands();
    var Types = require_types2();
    var Packet = require_packet();
    var CharsetToEncoding = require_charset_encodings();
    function isJSON(value) {
      return Array.isArray(value) || value.constructor === Object || typeof value.toJSON === "function" && !Buffer.isBuffer(value);
    }
    function toParameter(value, encoding, timezone) {
      let type = Types.VAR_STRING;
      let length;
      let writer = function(value2) {
        return Packet.prototype.writeLengthCodedString.call(this, value2, encoding);
      };
      if (value !== null) {
        switch (typeof value) {
          case "undefined":
            throw new TypeError("Bind parameters must not contain undefined");
          case "number":
            type = Types.DOUBLE;
            length = 8;
            writer = Packet.prototype.writeDouble;
            break;
          case "boolean":
            value = value | 0;
            type = Types.TINY;
            length = 1;
            writer = Packet.prototype.writeInt8;
            break;
          case "object":
            if (Object.prototype.toString.call(value) === "[object Date]") {
              type = Types.DATETIME;
              length = 12;
              writer = function(value2) {
                return Packet.prototype.writeDate.call(this, value2, timezone);
              };
            } else if (isJSON(value)) {
              value = JSON.stringify(value);
              type = Types.JSON;
            } else if (Buffer.isBuffer(value)) {
              length = Packet.lengthCodedNumberLength(value.length) + value.length;
              writer = Packet.prototype.writeLengthCodedBuffer;
            }
            break;
          default:
            value = value.toString();
        }
      } else {
        value = "";
        type = Types.NULL;
      }
      if (!length) {
        length = Packet.lengthCodedStringLength(value, encoding);
      }
      return { value, type, length, writer };
    }
    var Execute = class {
      constructor(id, parameters, charsetNumber, timezone) {
        this.id = id;
        this.parameters = parameters;
        this.encoding = CharsetToEncoding[charsetNumber];
        this.timezone = timezone;
      }
      static fromPacket(packet, encoding) {
        const stmtId = packet.readInt32();
        const flags2 = packet.readInt8();
        const iterationCount = packet.readInt32();
        let i8 = packet.offset;
        while (i8 < packet.end - 1) {
          if ((packet.buffer[i8 + 1] === Types.VAR_STRING || packet.buffer[i8 + 1] === Types.NULL || packet.buffer[i8 + 1] === Types.DOUBLE || packet.buffer[i8 + 1] === Types.TINY || packet.buffer[i8 + 1] === Types.DATETIME || packet.buffer[i8 + 1] === Types.JSON) && packet.buffer[i8] === 1 && packet.buffer[i8 + 2] === 0) {
            break;
          } else {
            packet.readInt8();
          }
          i8++;
        }
        const types6 = [];
        for (let i9 = packet.offset + 1; i9 < packet.end - 1; i9++) {
          if ((packet.buffer[i9] === Types.VAR_STRING || packet.buffer[i9] === Types.NULL || packet.buffer[i9] === Types.DOUBLE || packet.buffer[i9] === Types.TINY || packet.buffer[i9] === Types.DATETIME || packet.buffer[i9] === Types.JSON) && packet.buffer[i9 + 1] === 0) {
            types6.push(packet.buffer[i9]);
            packet.skip(2);
          }
        }
        packet.skip(1);
        const values2 = [];
        for (let i9 = 0; i9 < types6.length; i9++) {
          if (types6[i9] === Types.VAR_STRING) {
            values2.push(packet.readLengthCodedString(encoding));
          } else if (types6[i9] === Types.DOUBLE) {
            values2.push(packet.readDouble());
          } else if (types6[i9] === Types.TINY) {
            values2.push(packet.readInt8());
          } else if (types6[i9] === Types.DATETIME) {
            values2.push(packet.readDateTime());
          } else if (types6[i9] === Types.JSON) {
            values2.push(JSON.parse(packet.readLengthCodedString(encoding)));
          }
          if (types6[i9] === Types.NULL) {
            values2.push(null);
          }
        }
        return { stmtId, flags: flags2, iterationCount, values: values2 };
      }
      toPacket() {
        let length = 14;
        let parameters;
        if (this.parameters && this.parameters.length > 0) {
          length += Math.floor((this.parameters.length + 7) / 8);
          length += 1;
          length += 2 * this.parameters.length;
          parameters = this.parameters.map(
            (value) => toParameter(value, this.encoding, this.timezone)
          );
          length += parameters.reduce(
            (accumulator, parameter) => accumulator + parameter.length,
            0
          );
        }
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(CommandCodes.STMT_EXECUTE);
        packet.writeInt32(this.id);
        packet.writeInt8(CursorType.NO_CURSOR);
        packet.writeInt32(1);
        if (parameters) {
          let bitmap = 0;
          let bitValue = 1;
          parameters.forEach((parameter) => {
            if (parameter.type === Types.NULL) {
              bitmap += bitValue;
            }
            bitValue *= 2;
            if (bitValue === 256) {
              packet.writeInt8(bitmap);
              bitmap = 0;
              bitValue = 1;
            }
          });
          if (bitValue !== 1) {
            packet.writeInt8(bitmap);
          }
          packet.writeInt8(1);
          parameters.forEach((parameter) => {
            packet.writeInt8(parameter.type);
            packet.writeInt8(0);
          });
          parameters.forEach((parameter) => {
            if (parameter.type !== Types.NULL) {
              parameter.writer.call(packet, parameter.value);
            }
          });
        }
        return packet;
      }
    };
    module2.exports = Execute;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/handshake.js
var require_handshake = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/handshake.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var ClientConstants = require_client3();
    var Handshake = class _Handshake {
      constructor(args2) {
        this.protocolVersion = args2.protocolVersion;
        this.serverVersion = args2.serverVersion;
        this.capabilityFlags = args2.capabilityFlags;
        this.connectionId = args2.connectionId;
        this.authPluginData1 = args2.authPluginData1;
        this.authPluginData2 = args2.authPluginData2;
        this.characterSet = args2.characterSet;
        this.statusFlags = args2.statusFlags;
        this.authPluginName = args2.authPluginName;
      }
      setScrambleData(cb) {
        require("crypto").randomBytes(20, (err3, data) => {
          if (err3) {
            cb(err3);
            return;
          }
          this.authPluginData1 = data.slice(0, 8);
          this.authPluginData2 = data.slice(8, 20);
          cb();
        });
      }
      toPacket(sequenceId) {
        const length = 68 + Buffer.byteLength(this.serverVersion, "utf8");
        const buffer2 = Buffer.alloc(length + 4, 0);
        const packet = new Packet(sequenceId, buffer2, 0, length + 4);
        packet.offset = 4;
        packet.writeInt8(this.protocolVersion);
        packet.writeString(this.serverVersion, "cesu8");
        packet.writeInt8(0);
        packet.writeInt32(this.connectionId);
        packet.writeBuffer(this.authPluginData1);
        packet.writeInt8(0);
        const capabilityFlagsBuffer = Buffer.allocUnsafe(4);
        capabilityFlagsBuffer.writeUInt32LE(this.capabilityFlags, 0);
        packet.writeBuffer(capabilityFlagsBuffer.slice(0, 2));
        packet.writeInt8(this.characterSet);
        packet.writeInt16(this.statusFlags);
        packet.writeBuffer(capabilityFlagsBuffer.slice(2, 4));
        packet.writeInt8(21);
        packet.skip(10);
        packet.writeBuffer(this.authPluginData2);
        packet.writeInt8(0);
        packet.writeString("mysql_native_password", "latin1");
        packet.writeInt8(0);
        return packet;
      }
      static fromPacket(packet) {
        const args2 = {};
        args2.protocolVersion = packet.readInt8();
        args2.serverVersion = packet.readNullTerminatedString("cesu8");
        args2.connectionId = packet.readInt32();
        args2.authPluginData1 = packet.readBuffer(8);
        packet.skip(1);
        const capabilityFlagsBuffer = Buffer.allocUnsafe(4);
        capabilityFlagsBuffer[0] = packet.readInt8();
        capabilityFlagsBuffer[1] = packet.readInt8();
        if (packet.haveMoreData()) {
          args2.characterSet = packet.readInt8();
          args2.statusFlags = packet.readInt16();
          capabilityFlagsBuffer[2] = packet.readInt8();
          capabilityFlagsBuffer[3] = packet.readInt8();
          args2.capabilityFlags = capabilityFlagsBuffer.readUInt32LE(0);
          if (args2.capabilityFlags & ClientConstants.PLUGIN_AUTH) {
            args2.authPluginDataLength = packet.readInt8();
          } else {
            args2.authPluginDataLength = 0;
            packet.skip(1);
          }
          packet.skip(10);
        } else {
          args2.capabilityFlags = capabilityFlagsBuffer.readUInt16LE(0);
        }
        const isSecureConnection = args2.capabilityFlags & ClientConstants.SECURE_CONNECTION;
        if (isSecureConnection) {
          const authPluginDataLength = args2.authPluginDataLength;
          if (authPluginDataLength === 0) {
            args2.authPluginDataLength = 20;
            args2.authPluginData2 = packet.readBuffer(12);
            packet.skip(1);
          } else {
            const len = Math.max(13, authPluginDataLength - 8);
            args2.authPluginData2 = packet.readBuffer(len);
          }
        }
        if (args2.capabilityFlags & ClientConstants.PLUGIN_AUTH) {
          args2.authPluginName = packet.readNullTerminatedString("ascii");
        }
        return new _Handshake(args2);
      }
    };
    module2.exports = Handshake;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/handshake_response.js
var require_handshake_response = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/handshake_response.js"(exports2, module2) {
    "use strict";
    var ClientConstants = require_client3();
    var CharsetToEncoding = require_charset_encodings();
    var Packet = require_packet();
    var auth41 = require_auth_41();
    var HandshakeResponse = class {
      constructor(handshake) {
        this.user = handshake.user || "";
        this.database = handshake.database || "";
        this.password = handshake.password || "";
        this.passwordSha1 = handshake.passwordSha1;
        this.authPluginData1 = handshake.authPluginData1;
        this.authPluginData2 = handshake.authPluginData2;
        this.compress = handshake.compress;
        this.clientFlags = handshake.flags;
        let authToken;
        if (this.passwordSha1) {
          authToken = auth41.calculateTokenFromPasswordSha(
            this.passwordSha1,
            this.authPluginData1,
            this.authPluginData2
          );
        } else {
          authToken = auth41.calculateToken(
            this.password,
            this.authPluginData1,
            this.authPluginData2
          );
        }
        this.authToken = authToken;
        this.charsetNumber = handshake.charsetNumber;
        this.encoding = CharsetToEncoding[handshake.charsetNumber];
        this.connectAttributes = handshake.connectAttributes;
      }
      serializeResponse(buffer2) {
        const isSet2 = (flag) => this.clientFlags & ClientConstants[flag];
        const packet = new Packet(0, buffer2, 0, buffer2.length);
        packet.offset = 4;
        packet.writeInt32(this.clientFlags);
        packet.writeInt32(0);
        packet.writeInt8(this.charsetNumber);
        packet.skip(23);
        const encoding = this.encoding;
        packet.writeNullTerminatedString(this.user, encoding);
        let k9;
        if (isSet2("PLUGIN_AUTH_LENENC_CLIENT_DATA")) {
          packet.writeLengthCodedNumber(this.authToken.length);
          packet.writeBuffer(this.authToken);
        } else if (isSet2("SECURE_CONNECTION")) {
          packet.writeInt8(this.authToken.length);
          packet.writeBuffer(this.authToken);
        } else {
          packet.writeBuffer(this.authToken);
          packet.writeInt8(0);
        }
        if (isSet2("CONNECT_WITH_DB")) {
          packet.writeNullTerminatedString(this.database, encoding);
        }
        if (isSet2("PLUGIN_AUTH")) {
          packet.writeNullTerminatedString("mysql_native_password", "latin1");
        }
        if (isSet2("CONNECT_ATTRS")) {
          const connectAttributes = this.connectAttributes || {};
          const attrNames = Object.keys(connectAttributes);
          let keysLength = 0;
          for (k9 = 0; k9 < attrNames.length; ++k9) {
            keysLength += Packet.lengthCodedStringLength(attrNames[k9], encoding);
            keysLength += Packet.lengthCodedStringLength(
              connectAttributes[attrNames[k9]],
              encoding
            );
          }
          packet.writeLengthCodedNumber(keysLength);
          for (k9 = 0; k9 < attrNames.length; ++k9) {
            packet.writeLengthCodedString(attrNames[k9], encoding);
            packet.writeLengthCodedString(
              connectAttributes[attrNames[k9]],
              encoding
            );
          }
        }
        return packet;
      }
      toPacket() {
        if (typeof this.user !== "string") {
          throw new Error('"user" connection config property must be a string');
        }
        if (typeof this.database !== "string") {
          throw new Error('"database" connection config property must be a string');
        }
        const p11 = this.serializeResponse(Packet.MockBuffer());
        return this.serializeResponse(Buffer.alloc(p11.offset));
      }
      static fromPacket(packet) {
        const args2 = {};
        args2.clientFlags = packet.readInt32();
        function isSet2(flag) {
          return args2.clientFlags & ClientConstants[flag];
        }
        args2.maxPacketSize = packet.readInt32();
        args2.charsetNumber = packet.readInt8();
        const encoding = CharsetToEncoding[args2.charsetNumber];
        args2.encoding = encoding;
        packet.skip(23);
        args2.user = packet.readNullTerminatedString(encoding);
        let authTokenLength;
        if (isSet2("PLUGIN_AUTH_LENENC_CLIENT_DATA")) {
          authTokenLength = packet.readLengthCodedNumber(encoding);
          args2.authToken = packet.readBuffer(authTokenLength);
        } else if (isSet2("SECURE_CONNECTION")) {
          authTokenLength = packet.readInt8();
          args2.authToken = packet.readBuffer(authTokenLength);
        } else {
          args2.authToken = packet.readNullTerminatedString(encoding);
        }
        if (isSet2("CONNECT_WITH_DB")) {
          args2.database = packet.readNullTerminatedString(encoding);
        }
        if (isSet2("PLUGIN_AUTH")) {
          args2.authPluginName = packet.readNullTerminatedString(encoding);
        }
        if (isSet2("CONNECT_ATTRS")) {
          const keysLength = packet.readLengthCodedNumber(encoding);
          const keysEnd = packet.offset + keysLength;
          const attrs = {};
          while (packet.offset < keysEnd) {
            attrs[packet.readLengthCodedString(encoding)] = packet.readLengthCodedString(encoding);
          }
          args2.connectAttributes = attrs;
        }
        return args2;
      }
    };
    module2.exports = HandshakeResponse;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/prepare_statement.js
var require_prepare_statement = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/prepare_statement.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var CommandCodes = require_commands();
    var StringParser = require_string();
    var CharsetToEncoding = require_charset_encodings();
    var PrepareStatement = class {
      constructor(sql3, charsetNumber) {
        this.query = sql3;
        this.charsetNumber = charsetNumber;
        this.encoding = CharsetToEncoding[charsetNumber];
      }
      toPacket() {
        const buf = StringParser.encode(this.query, this.encoding);
        const length = 5 + buf.length;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(CommandCodes.STMT_PREPARE);
        packet.writeBuffer(buf);
        return packet;
      }
    };
    module2.exports = PrepareStatement;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/prepared_statement_header.js
var require_prepared_statement_header = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/prepared_statement_header.js"(exports2, module2) {
    "use strict";
    var PreparedStatementHeader = class {
      constructor(packet) {
        packet.skip(1);
        this.id = packet.readInt32();
        this.fieldCount = packet.readInt16();
        this.parameterCount = packet.readInt16();
        packet.skip(1);
        this.warningCount = packet.readInt16();
      }
    };
    module2.exports = PreparedStatementHeader;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/query.js
var require_query3 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/query.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var CommandCode = require_commands();
    var StringParser = require_string();
    var CharsetToEncoding = require_charset_encodings();
    var Query3 = class {
      constructor(sql3, charsetNumber) {
        this.query = sql3;
        this.charsetNumber = charsetNumber;
        this.encoding = CharsetToEncoding[charsetNumber];
      }
      toPacket() {
        const buf = StringParser.encode(this.query, this.encoding);
        const length = 5 + buf.length;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(CommandCode.QUERY);
        packet.writeBuffer(buf);
        return packet;
      }
    };
    module2.exports = Query3;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/register_slave.js
var require_register_slave = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/register_slave.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var CommandCodes = require_commands();
    var RegisterSlave = class {
      constructor(opts) {
        this.serverId = opts.serverId || 0;
        this.slaveHostname = opts.slaveHostname || "";
        this.slaveUser = opts.slaveUser || "";
        this.slavePassword = opts.slavePassword || "";
        this.slavePort = opts.slavePort || 0;
        this.replicationRank = opts.replicationRank || 0;
        this.masterId = opts.masterId || 0;
      }
      toPacket() {
        const length = 15 + // TODO: should be ascii?
        Buffer.byteLength(this.slaveHostname, "utf8") + Buffer.byteLength(this.slaveUser, "utf8") + Buffer.byteLength(this.slavePassword, "utf8") + 3 + 4;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(CommandCodes.REGISTER_SLAVE);
        packet.writeInt32(this.serverId);
        packet.writeInt8(Buffer.byteLength(this.slaveHostname, "utf8"));
        packet.writeString(this.slaveHostname);
        packet.writeInt8(Buffer.byteLength(this.slaveUser, "utf8"));
        packet.writeString(this.slaveUser);
        packet.writeInt8(Buffer.byteLength(this.slavePassword, "utf8"));
        packet.writeString(this.slavePassword);
        packet.writeInt16(this.slavePort);
        packet.writeInt32(this.replicationRank);
        packet.writeInt32(this.masterId);
        return packet;
      }
    };
    module2.exports = RegisterSlave;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/server_status.js
var require_server_status = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/server_status.js"(exports2) {
    "use strict";
    exports2.SERVER_STATUS_IN_TRANS = 1;
    exports2.SERVER_STATUS_AUTOCOMMIT = 2;
    exports2.SERVER_MORE_RESULTS_EXISTS = 8;
    exports2.SERVER_QUERY_NO_GOOD_INDEX_USED = 16;
    exports2.SERVER_QUERY_NO_INDEX_USED = 32;
    exports2.SERVER_STATUS_CURSOR_EXISTS = 64;
    exports2.SERVER_STATUS_LAST_ROW_SENT = 128;
    exports2.SERVER_STATUS_DB_DROPPED = 256;
    exports2.SERVER_STATUS_NO_BACKSLASH_ESCAPES = 512;
    exports2.SERVER_STATUS_METADATA_CHANGED = 1024;
    exports2.SERVER_QUERY_WAS_SLOW = 2048;
    exports2.SERVER_PS_OUT_PARAMS = 4096;
    exports2.SERVER_STATUS_IN_TRANS_READONLY = 8192;
    exports2.SERVER_SESSION_STATE_CHANGED = 16384;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/encoding_charset.js
var require_encoding_charset = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/encoding_charset.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      big5: 1,
      latin2: 2,
      dec8: 3,
      cp850: 4,
      latin1: 5,
      hp8: 6,
      koi8r: 7,
      swe7: 10,
      ascii: 11,
      eucjp: 12,
      sjis: 13,
      cp1251: 14,
      hebrew: 16,
      tis620: 18,
      euckr: 19,
      latin7: 20,
      koi8u: 22,
      gb2312: 24,
      greek: 25,
      cp1250: 26,
      gbk: 28,
      cp1257: 29,
      latin5: 30,
      armscii8: 32,
      cesu8: 33,
      ucs2: 35,
      cp866: 36,
      keybcs2: 37,
      macintosh: 38,
      macroman: 39,
      cp852: 40,
      utf8: 45,
      utf8mb4: 45,
      utf16: 54,
      utf16le: 56,
      cp1256: 57,
      utf32: 60,
      binary: 63,
      geostd8: 92,
      cp932: 95,
      eucjpms: 97,
      gb18030: 248,
      utf8mb3: 192
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/session_track.js
var require_session_track = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/session_track.js"(exports2) {
    "use strict";
    exports2.SYSTEM_VARIABLES = 0;
    exports2.SCHEMA = 1;
    exports2.STATE_CHANGE = 2;
    exports2.STATE_GTIDS = 3;
    exports2.TRANSACTION_CHARACTERISTICS = 4;
    exports2.TRANSACTION_STATE = 5;
    exports2.FIRST_KEY = exports2.SYSTEM_VARIABLES;
    exports2.LAST_KEY = exports2.TRANSACTION_STATE;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/resultset_header.js
var require_resultset_header = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/resultset_header.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var ClientConstants = require_client3();
    var ServerSatusFlags = require_server_status();
    var EncodingToCharset = require_encoding_charset();
    var sessionInfoTypes = require_session_track();
    var ResultSetHeader = class {
      constructor(packet, connection2) {
        const bigNumberStrings = connection2.config.bigNumberStrings;
        const encoding = connection2.serverEncoding;
        const flags2 = connection2._handshakePacket.capabilityFlags;
        const isSet2 = function(flag) {
          return flags2 & ClientConstants[flag];
        };
        if (packet.buffer[packet.offset] !== 0) {
          this.fieldCount = packet.readLengthCodedNumber();
          if (this.fieldCount === null) {
            this.infileName = packet.readString(void 0, encoding);
          }
          return;
        }
        this.fieldCount = packet.readInt8();
        this.affectedRows = packet.readLengthCodedNumber(bigNumberStrings);
        this.insertId = packet.readLengthCodedNumberSigned(bigNumberStrings);
        this.info = "";
        if (isSet2("PROTOCOL_41")) {
          this.serverStatus = packet.readInt16();
          this.warningStatus = packet.readInt16();
        } else if (isSet2("TRANSACTIONS")) {
          this.serverStatus = packet.readInt16();
        }
        let stateChanges = null;
        if (isSet2("SESSION_TRACK") && packet.offset < packet.end) {
          this.info = packet.readLengthCodedString(encoding);
          if (this.serverStatus && ServerSatusFlags.SERVER_SESSION_STATE_CHANGED) {
            let len = packet.offset < packet.end ? packet.readLengthCodedNumber() : 0;
            const end = packet.offset + len;
            let type, key, stateEnd;
            if (len > 0) {
              stateChanges = {
                systemVariables: {},
                schema: null,
                gtids: [],
                trackStateChange: null
              };
            }
            while (packet.offset < end) {
              type = packet.readInt8();
              len = packet.readLengthCodedNumber();
              stateEnd = packet.offset + len;
              if (type === sessionInfoTypes.SYSTEM_VARIABLES) {
                key = packet.readLengthCodedString(encoding);
                const val2 = packet.readLengthCodedString(encoding);
                stateChanges.systemVariables[key] = val2;
                if (key === "character_set_client") {
                  const charsetNumber = EncodingToCharset[val2];
                  if (typeof charsetNumber !== "undefined") {
                    connection2.config.charsetNumber = charsetNumber;
                  }
                }
              } else if (type === sessionInfoTypes.SCHEMA) {
                key = packet.readLengthCodedString(encoding);
                stateChanges.schema = key;
              } else if (type === sessionInfoTypes.STATE_CHANGE) {
                stateChanges.trackStateChange = packet.readLengthCodedString(encoding);
              } else if (type === sessionInfoTypes.STATE_GTIDS) {
                const _unknownString = packet.readLengthCodedString(encoding);
                const gtid = packet.readLengthCodedString(encoding);
                stateChanges.gtids = gtid.split(",");
              } else {
              }
              packet.offset = stateEnd;
            }
          }
        } else {
          this.info = packet.readString(void 0, encoding);
        }
        if (stateChanges) {
          this.stateChanges = stateChanges;
        }
        const m12 = this.info.match(/\schanged:\s*(\d+)/i);
        if (m12 !== null) {
          this.changedRows = parseInt(m12[1], 10);
        } else {
          this.changedRows = 0;
        }
      }
      // TODO: should be consistent instance member, but it's just easier here to have just function
      static toPacket(fieldCount, insertId) {
        let length = 4 + Packet.lengthCodedNumberLength(fieldCount);
        if (typeof insertId !== "undefined") {
          length += Packet.lengthCodedNumberLength(insertId);
        }
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeLengthCodedNumber(fieldCount);
        if (typeof insertId !== "undefined") {
          packet.writeLengthCodedNumber(insertId);
        }
        return packet;
      }
    };
    module2.exports = ResultSetHeader;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/ssl_request.js
var require_ssl_request = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/ssl_request.js"(exports2, module2) {
    "use strict";
    var ClientConstants = require_client3();
    var Packet = require_packet();
    var SSLRequest2 = class {
      constructor(flags2, charset) {
        this.clientFlags = flags2 | ClientConstants.SSL;
        this.charset = charset;
      }
      toPacket() {
        const length = 36;
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        buffer2.fill(0);
        packet.offset = 4;
        packet.writeInt32(this.clientFlags);
        packet.writeInt32(0);
        packet.writeInt8(this.charset);
        return packet;
      }
    };
    module2.exports = SSLRequest2;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/text_row.js
var require_text_row = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/text_row.js"(exports2, module2) {
    "use strict";
    var Packet = require_packet();
    var TextRow = class _TextRow {
      constructor(columns) {
        this.columns = columns || [];
      }
      static fromPacket(packet) {
        const columns = [];
        while (packet.haveMoreData()) {
          columns.push(packet.readLengthCodedString());
        }
        return new _TextRow(columns);
      }
      static toPacket(columns, encoding) {
        const sequenceId = 0;
        let length = 0;
        columns.forEach((val2) => {
          if (val2 === null || typeof val2 === "undefined") {
            ++length;
            return;
          }
          length += Packet.lengthCodedStringLength(val2.toString(10), encoding);
        });
        const buffer2 = Buffer.allocUnsafe(length + 4);
        const packet = new Packet(sequenceId, buffer2, 0, length + 4);
        packet.offset = 4;
        columns.forEach((val2) => {
          if (val2 === null) {
            packet.writeNull();
            return;
          }
          if (typeof val2 === "undefined") {
            packet.writeInt8(0);
            return;
          }
          packet.writeLengthCodedString(val2.toString(10), encoding);
        });
        return packet;
      }
    };
    module2.exports = TextRow;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/index.js
var require_packets = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/index.js"(exports2, module2) {
    "use strict";
    var process4 = require("process");
    var AuthNextFactor = require_auth_next_factor();
    var AuthSwitchRequest = require_auth_switch_request();
    var AuthSwitchRequestMoreData = require_auth_switch_request_more_data();
    var AuthSwitchResponse = require_auth_switch_response();
    var BinaryRow = require_binary_row();
    var BinlogDump = require_binlog_dump();
    var ChangeUser = require_change_user();
    var CloseStatement = require_close_statement();
    var ColumnDefinition = require_column_definition();
    var Execute = require_execute();
    var Handshake = require_handshake();
    var HandshakeResponse = require_handshake_response();
    var PrepareStatement = require_prepare_statement();
    var PreparedStatementHeader = require_prepared_statement_header();
    var Query3 = require_query3();
    var RegisterSlave = require_register_slave();
    var ResultSetHeader = require_resultset_header();
    var SSLRequest2 = require_ssl_request();
    var TextRow = require_text_row();
    var ctorMap = {
      AuthNextFactor,
      AuthSwitchRequest,
      AuthSwitchRequestMoreData,
      AuthSwitchResponse,
      BinaryRow,
      BinlogDump,
      ChangeUser,
      CloseStatement,
      ColumnDefinition,
      Execute,
      Handshake,
      HandshakeResponse,
      PrepareStatement,
      PreparedStatementHeader,
      Query: Query3,
      RegisterSlave,
      ResultSetHeader,
      SSLRequest: SSLRequest2,
      TextRow
    };
    Object.entries(ctorMap).forEach(([name3, ctor]) => {
      module2.exports[name3] = ctor;
      if (process4.env.NODE_DEBUG) {
        if (ctor.prototype.toPacket) {
          const old = ctor.prototype.toPacket;
          ctor.prototype.toPacket = function() {
            const p11 = old.call(this);
            p11._name = name3;
            return p11;
          };
        }
      }
    });
    var Packet = require_packet();
    exports2.Packet = Packet;
    var OK2 = class {
      static toPacket(args2, encoding) {
        args2 = args2 || {};
        const affectedRows = args2.affectedRows || 0;
        const insertId = args2.insertId || 0;
        const serverStatus = args2.serverStatus || 0;
        const warningCount = args2.warningCount || 0;
        const message = args2.message || "";
        let length = 9 + Packet.lengthCodedNumberLength(affectedRows);
        length += Packet.lengthCodedNumberLength(insertId);
        const buffer2 = Buffer.allocUnsafe(length);
        const packet = new Packet(0, buffer2, 0, length);
        packet.offset = 4;
        packet.writeInt8(0);
        packet.writeLengthCodedNumber(affectedRows);
        packet.writeLengthCodedNumber(insertId);
        packet.writeInt16(serverStatus);
        packet.writeInt16(warningCount);
        packet.writeString(message, encoding);
        packet._name = "OK";
        return packet;
      }
    };
    exports2.OK = OK2;
    var EOF = class {
      static toPacket(warnings, statusFlags) {
        if (typeof warnings === "undefined") {
          warnings = 0;
        }
        if (typeof statusFlags === "undefined") {
          statusFlags = 0;
        }
        const packet = new Packet(0, Buffer.allocUnsafe(9), 0, 9);
        packet.offset = 4;
        packet.writeInt8(254);
        packet.writeInt16(warnings);
        packet.writeInt16(statusFlags);
        packet._name = "EOF";
        return packet;
      }
    };
    exports2.EOF = EOF;
    var Error4 = class _Error {
      static toPacket(args2, encoding) {
        const length = 13 + Buffer.byteLength(args2.message, "utf8");
        const packet = new Packet(0, Buffer.allocUnsafe(length), 0, length);
        packet.offset = 4;
        packet.writeInt8(255);
        packet.writeInt16(args2.code);
        packet.writeString("#_____", encoding);
        packet.writeString(args2.message, encoding);
        packet._name = "Error";
        return packet;
      }
      static fromPacket(packet) {
        packet.readInt8();
        const code = packet.readInt16();
        packet.readString(1, "ascii");
        packet.readString(5, "ascii");
        const message = packet.readNullTerminatedString("utf8");
        const error2 = new _Error();
        error2.message = message;
        error2.code = code;
        return error2;
      }
    };
    exports2.Error = Error4;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/command.js
var require_command = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/command.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var Timers = require("timers");
    var Command2 = class extends EventEmitter {
      constructor() {
        super();
        this.next = null;
      }
      // slow. debug only
      stateName() {
        const state2 = this.next;
        for (const i8 in this) {
          if (this[i8] === state2 && i8 !== "next") {
            return i8;
          }
        }
        return "unknown name";
      }
      execute(packet, connection2) {
        if (!this.next) {
          this.next = this.start;
          connection2._resetSequenceId();
        }
        if (packet && packet.isError()) {
          const err3 = packet.asError(connection2.clientEncoding);
          err3.sql = this.sql || this.query;
          if (this.queryTimeout) {
            Timers.clearTimeout(this.queryTimeout);
            this.queryTimeout = null;
          }
          if (this.onResult) {
            this.onResult(err3);
            this.emit("end");
          } else {
            this.emit("error", err3);
            this.emit("end");
          }
          return true;
        }
        this.next = this.next(packet, connection2);
        if (this.next) {
          return false;
        }
        this.emit("end");
        return true;
      }
    };
    module2.exports = Command2;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/sha256_password.js
var require_sha256_password = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/sha256_password.js"(exports2, module2) {
    "use strict";
    var PLUGIN_NAME = "sha256_password";
    var crypto7 = require("crypto");
    var { xorRotating } = require_auth_41();
    var REQUEST_SERVER_KEY_PACKET = Buffer.from([1]);
    var STATE_INITIAL = 0;
    var STATE_WAIT_SERVER_KEY = 1;
    var STATE_FINAL = -1;
    function encrypt(password, scramble, key) {
      const stage1 = xorRotating(Buffer.from(`${password}\0`, "utf8"), scramble);
      return crypto7.publicEncrypt(key, stage1);
    }
    module2.exports = (pluginOptions = {}) => ({ connection: connection2 }) => {
      let state2 = 0;
      let scramble = null;
      const password = connection2.config.password;
      const authWithKey = (serverKey) => {
        const _password = encrypt(password, scramble, serverKey);
        state2 = STATE_FINAL;
        return _password;
      };
      return (data) => {
        switch (state2) {
          case STATE_INITIAL:
            scramble = data.slice(0, 20);
            if (pluginOptions.serverPublicKey) {
              return authWithKey(pluginOptions.serverPublicKey);
            }
            state2 = STATE_WAIT_SERVER_KEY;
            return REQUEST_SERVER_KEY_PACKET;
          case STATE_WAIT_SERVER_KEY:
            if (pluginOptions.onServerPublicKey) {
              pluginOptions.onServerPublicKey(data);
            }
            return authWithKey(data);
          case STATE_FINAL:
            throw new Error(
              `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_FINAL state.`
            );
        }
        throw new Error(
          `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in state ${state2}`
        );
      };
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/caching_sha2_password.js
var require_caching_sha2_password = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/caching_sha2_password.js"(exports2, module2) {
    "use strict";
    var PLUGIN_NAME = "caching_sha2_password";
    var crypto7 = require("crypto");
    var { xor: xor2, xorRotating } = require_auth_41();
    var REQUEST_SERVER_KEY_PACKET = Buffer.from([2]);
    var FAST_AUTH_SUCCESS_PACKET = Buffer.from([3]);
    var PERFORM_FULL_AUTHENTICATION_PACKET = Buffer.from([4]);
    var STATE_INITIAL = 0;
    var STATE_TOKEN_SENT = 1;
    var STATE_WAIT_SERVER_KEY = 2;
    var STATE_FINAL = -1;
    function sha2563(msg) {
      const hash = crypto7.createHash("sha256");
      hash.update(msg);
      return hash.digest();
    }
    function calculateToken(password, scramble) {
      if (!password) {
        return Buffer.alloc(0);
      }
      const stage1 = sha2563(Buffer.from(password));
      const stage2 = sha2563(stage1);
      const stage3 = sha2563(Buffer.concat([stage2, scramble]));
      return xor2(stage1, stage3);
    }
    function encrypt(password, scramble, key) {
      const stage1 = xorRotating(Buffer.from(`${password}\0`, "utf8"), scramble);
      return crypto7.publicEncrypt(
        {
          key,
          padding: crypto7.constants.RSA_PKCS1_OAEP_PADDING
        },
        stage1
      );
    }
    module2.exports = (pluginOptions = {}) => ({ connection: connection2 }) => {
      let state2 = 0;
      let scramble = null;
      const password = connection2.config.password;
      const authWithKey = (serverKey) => {
        const _password = encrypt(password, scramble, serverKey);
        state2 = STATE_FINAL;
        return _password;
      };
      return (data) => {
        switch (state2) {
          case STATE_INITIAL:
            scramble = data.slice(0, 20);
            state2 = STATE_TOKEN_SENT;
            return calculateToken(password, scramble);
          case STATE_TOKEN_SENT:
            if (FAST_AUTH_SUCCESS_PACKET.equals(data)) {
              state2 = STATE_FINAL;
              return null;
            }
            if (PERFORM_FULL_AUTHENTICATION_PACKET.equals(data)) {
              const isSecureConnection = typeof pluginOptions.overrideIsSecure === "undefined" ? connection2.config.ssl || connection2.config.socketPath : pluginOptions.overrideIsSecure;
              if (isSecureConnection) {
                state2 = STATE_FINAL;
                return Buffer.from(`${password}\0`, "utf8");
              }
              if (pluginOptions.serverPublicKey) {
                return authWithKey(pluginOptions.serverPublicKey);
              }
              state2 = STATE_WAIT_SERVER_KEY;
              return REQUEST_SERVER_KEY_PACKET;
            }
            throw new Error(
              `Invalid AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_TOKEN_SENT state.`
            );
          case STATE_WAIT_SERVER_KEY:
            if (pluginOptions.onServerPublicKey) {
              pluginOptions.onServerPublicKey(data);
            }
            return authWithKey(data);
          case STATE_FINAL:
            throw new Error(
              `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in STATE_FINAL state.`
            );
        }
        throw new Error(
          `Unexpected data in AuthMoreData packet received by ${PLUGIN_NAME} plugin in state ${state2}`
        );
      };
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/mysql_native_password.js
var require_mysql_native_password = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/mysql_native_password.js"(exports2, module2) {
    "use strict";
    var auth41 = require_auth_41();
    module2.exports = (pluginOptions) => ({ connection: connection2, command }) => {
      const password = command.password || pluginOptions.password || connection2.config.password;
      const passwordSha1 = command.passwordSha1 || pluginOptions.passwordSha1 || connection2.config.passwordSha1;
      return (data) => {
        const authPluginData1 = data.slice(0, 8);
        const authPluginData2 = data.slice(8, 20);
        let authToken;
        if (passwordSha1) {
          authToken = auth41.calculateTokenFromPasswordSha(
            passwordSha1,
            authPluginData1,
            authPluginData2
          );
        } else {
          authToken = auth41.calculateToken(
            password,
            authPluginData1,
            authPluginData2
          );
        }
        return authToken;
      };
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/mysql_clear_password.js
var require_mysql_clear_password = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/mysql_clear_password.js"(exports2, module2) {
    "use strict";
    function bufferFromStr(str) {
      return Buffer.from(`${str}\0`);
    }
    var create_mysql_clear_password_plugin = (pluginOptions) => function mysql_clear_password_plugin({ connection: connection2, command }) {
      const password = command.password || pluginOptions.password || connection2.config.password;
      return function() {
        return bufferFromStr(password);
      };
    };
    module2.exports = create_mysql_clear_password_plugin;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/auth_switch.js
var require_auth_switch = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/auth_switch.js"(exports2, module2) {
    "use strict";
    var Packets = require_packets();
    var sha256_password = require_sha256_password();
    var caching_sha2_password = require_caching_sha2_password();
    var mysql_native_password = require_mysql_native_password();
    var mysql_clear_password = require_mysql_clear_password();
    var standardAuthPlugins = {
      sha256_password: sha256_password({}),
      caching_sha2_password: caching_sha2_password({}),
      mysql_native_password: mysql_native_password({}),
      mysql_clear_password: mysql_clear_password({})
    };
    function warnLegacyAuthSwitch() {
      console.warn(
        "WARNING! authSwitchHandler api is deprecated, please use new authPlugins api"
      );
    }
    function authSwitchPluginError(error2, command) {
      error2.code = "AUTH_SWITCH_PLUGIN_ERROR";
      error2.fatal = true;
      command.emit("error", error2);
    }
    function authSwitchRequest(packet, connection2, command) {
      const { pluginName, pluginData } = Packets.AuthSwitchRequest.fromPacket(packet);
      let authPlugin = connection2.config.authPlugins && connection2.config.authPlugins[pluginName];
      if (connection2.config.authSwitchHandler && pluginName !== "mysql_native_password") {
        const legacySwitchHandler = connection2.config.authSwitchHandler;
        warnLegacyAuthSwitch();
        legacySwitchHandler({ pluginName, pluginData }, (err3, data) => {
          if (err3) {
            return authSwitchPluginError(err3, command);
          }
          connection2.writePacket(new Packets.AuthSwitchResponse(data).toPacket());
        });
        return;
      }
      if (!authPlugin) {
        authPlugin = standardAuthPlugins[pluginName];
      }
      if (!authPlugin) {
        throw new Error(
          `Server requests authentication using unknown plugin ${pluginName}. See ${"TODO: add plugins doco here"} on how to configure or author authentication plugins.`
        );
      }
      connection2._authPlugin = authPlugin({ connection: connection2, command });
      Promise.resolve(connection2._authPlugin(pluginData)).then((data) => {
        if (data) {
          connection2.writePacket(new Packets.AuthSwitchResponse(data).toPacket());
        }
      }).catch((err3) => {
        authSwitchPluginError(err3, command);
      });
    }
    function authSwitchRequestMoreData(packet, connection2, command) {
      const { data } = Packets.AuthSwitchRequestMoreData.fromPacket(packet);
      if (connection2.config.authSwitchHandler) {
        const legacySwitchHandler = connection2.config.authSwitchHandler;
        warnLegacyAuthSwitch();
        legacySwitchHandler({ pluginData: data }, (err3, data2) => {
          if (err3) {
            return authSwitchPluginError(err3, command);
          }
          connection2.writePacket(new Packets.AuthSwitchResponse(data2).toPacket());
        });
        return;
      }
      if (!connection2._authPlugin) {
        throw new Error(
          "AuthPluginMoreData received but no auth plugin instance found"
        );
      }
      Promise.resolve(connection2._authPlugin(data)).then((data2) => {
        if (data2) {
          connection2.writePacket(new Packets.AuthSwitchResponse(data2).toPacket());
        }
      }).catch((err3) => {
        authSwitchPluginError(err3, command);
      });
    }
    module2.exports = {
      authSwitchRequest,
      authSwitchRequestMoreData
    };
  }
});

// ../node_modules/.pnpm/seq-queue@0.0.5/node_modules/seq-queue/lib/seq-queue.js
var require_seq_queue = __commonJS({
  "../node_modules/.pnpm/seq-queue@0.0.5/node_modules/seq-queue/lib/seq-queue.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var util2 = require("util");
    var DEFAULT_TIMEOUT2 = 3e3;
    var INIT_ID = 0;
    var EVENT_CLOSED = "closed";
    var EVENT_DRAINED = "drained";
    var SeqQueue = function(timeout) {
      EventEmitter.call(this);
      if (timeout && timeout > 0) {
        this.timeout = timeout;
      } else {
        this.timeout = DEFAULT_TIMEOUT2;
      }
      this.status = SeqQueueManager.STATUS_IDLE;
      this.curId = INIT_ID;
      this.queue = [];
    };
    util2.inherits(SeqQueue, EventEmitter);
    SeqQueue.prototype.push = function(fn3, ontimeout, timeout) {
      if (this.status !== SeqQueueManager.STATUS_IDLE && this.status !== SeqQueueManager.STATUS_BUSY) {
        return false;
      }
      if (typeof fn3 !== "function") {
        throw new Error("fn should be a function.");
      }
      this.queue.push({ fn: fn3, ontimeout, timeout });
      if (this.status === SeqQueueManager.STATUS_IDLE) {
        this.status = SeqQueueManager.STATUS_BUSY;
        var self2 = this;
        process.nextTick(function() {
          self2._next(self2.curId);
        });
      }
      return true;
    };
    SeqQueue.prototype.close = function(force) {
      if (this.status !== SeqQueueManager.STATUS_IDLE && this.status !== SeqQueueManager.STATUS_BUSY) {
        return;
      }
      if (force) {
        this.status = SeqQueueManager.STATUS_DRAINED;
        if (this.timerId) {
          clearTimeout(this.timerId);
          this.timerId = void 0;
        }
        this.emit(EVENT_DRAINED);
      } else {
        this.status = SeqQueueManager.STATUS_CLOSED;
        this.emit(EVENT_CLOSED);
      }
    };
    SeqQueue.prototype._next = function(tid) {
      if (tid !== this.curId || this.status !== SeqQueueManager.STATUS_BUSY && this.status !== SeqQueueManager.STATUS_CLOSED) {
        return;
      }
      if (this.timerId) {
        clearTimeout(this.timerId);
        this.timerId = void 0;
      }
      var task = this.queue.shift();
      if (!task) {
        if (this.status === SeqQueueManager.STATUS_BUSY) {
          this.status = SeqQueueManager.STATUS_IDLE;
          this.curId++;
        } else {
          this.status = SeqQueueManager.STATUS_DRAINED;
          this.emit(EVENT_DRAINED);
        }
        return;
      }
      var self2 = this;
      task.id = ++this.curId;
      var timeout = task.timeout > 0 ? task.timeout : this.timeout;
      timeout = timeout > 0 ? timeout : DEFAULT_TIMEOUT2;
      this.timerId = setTimeout(function() {
        process.nextTick(function() {
          self2._next(task.id);
        });
        self2.emit("timeout", task);
        if (task.ontimeout) {
          task.ontimeout();
        }
      }, timeout);
      try {
        task.fn({
          done: function() {
            var res = task.id === self2.curId;
            process.nextTick(function() {
              self2._next(task.id);
            });
            return res;
          }
        });
      } catch (err3) {
        self2.emit("error", err3, task);
        process.nextTick(function() {
          self2._next(task.id);
        });
      }
    };
    var SeqQueueManager = module2.exports;
    SeqQueueManager.STATUS_IDLE = 0;
    SeqQueueManager.STATUS_BUSY = 1;
    SeqQueueManager.STATUS_CLOSED = 2;
    SeqQueueManager.STATUS_DRAINED = 3;
    SeqQueueManager.createQueue = function(timeout) {
      return new SeqQueue(timeout);
    };
  }
});

// ../node_modules/.pnpm/seq-queue@0.0.5/node_modules/seq-queue/index.js
var require_seq_queue2 = __commonJS({
  "../node_modules/.pnpm/seq-queue@0.0.5/node_modules/seq-queue/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_seq_queue();
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/compressed_protocol.js
var require_compressed_protocol = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/compressed_protocol.js"(exports2, module2) {
    "use strict";
    var zlib2 = require("zlib");
    var PacketParser = require_packet_parser();
    function handleCompressedPacket(packet) {
      const connection2 = this;
      const deflatedLength = packet.readInt24();
      const body2 = packet.readBuffer();
      if (deflatedLength !== 0) {
        connection2.inflateQueue.push((task) => {
          zlib2.inflate(body2, (err3, data) => {
            if (err3) {
              connection2._handleNetworkError(err3);
              return;
            }
            connection2._bumpCompressedSequenceId(packet.numPackets);
            connection2._inflatedPacketsParser.execute(data);
            task.done();
          });
        });
      } else {
        connection2.inflateQueue.push((task) => {
          connection2._bumpCompressedSequenceId(packet.numPackets);
          connection2._inflatedPacketsParser.execute(body2);
          task.done();
        });
      }
    }
    function writeCompressed(buffer2) {
      const MAX_COMPRESSED_LENGTH = 16777210;
      let start2;
      if (buffer2.length > MAX_COMPRESSED_LENGTH) {
        for (start2 = 0; start2 < buffer2.length; start2 += MAX_COMPRESSED_LENGTH) {
          writeCompressed.call(
            // eslint-disable-next-line no-invalid-this
            this,
            buffer2.slice(start2, start2 + MAX_COMPRESSED_LENGTH)
          );
        }
        return;
      }
      const connection2 = this;
      let packetLen = buffer2.length;
      const compressHeader = Buffer.allocUnsafe(7);
      (function(seqId) {
        connection2.deflateQueue.push((task) => {
          zlib2.deflate(buffer2, (err3, compressed) => {
            if (err3) {
              connection2._handleFatalError(err3);
              return;
            }
            let compressedLength = compressed.length;
            if (compressedLength < packetLen) {
              compressHeader.writeUInt8(compressedLength & 255, 0);
              compressHeader.writeUInt16LE(compressedLength >> 8, 1);
              compressHeader.writeUInt8(seqId, 3);
              compressHeader.writeUInt8(packetLen & 255, 4);
              compressHeader.writeUInt16LE(packetLen >> 8, 5);
              connection2.writeUncompressed(compressHeader);
              connection2.writeUncompressed(compressed);
            } else {
              compressedLength = packetLen;
              packetLen = 0;
              compressHeader.writeUInt8(compressedLength & 255, 0);
              compressHeader.writeUInt16LE(compressedLength >> 8, 1);
              compressHeader.writeUInt8(seqId, 3);
              compressHeader.writeUInt8(packetLen & 255, 4);
              compressHeader.writeUInt16LE(packetLen >> 8, 5);
              connection2.writeUncompressed(compressHeader);
              connection2.writeUncompressed(buffer2);
            }
            task.done();
          });
        });
      })(connection2.compressedSequenceId);
      connection2._bumpCompressedSequenceId(1);
    }
    function enableCompression(connection2) {
      connection2._lastWrittenPacketId = 0;
      connection2._lastReceivedPacketId = 0;
      connection2._handleCompressedPacket = handleCompressedPacket;
      connection2._inflatedPacketsParser = new PacketParser((p11) => {
        connection2.handlePacket(p11);
      }, 4);
      connection2._inflatedPacketsParser._lastPacket = 0;
      connection2.packetParser = new PacketParser((packet) => {
        connection2._handleCompressedPacket(packet);
      }, 7);
      connection2.writeUncompressed = connection2.write;
      connection2.write = writeCompressed;
      const seqqueue = require_seq_queue2();
      connection2.inflateQueue = seqqueue.createQueue();
      connection2.deflateQueue = seqqueue.createQueue();
    }
    module2.exports = {
      enableCompression
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/client_handshake.js
var require_client_handshake = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/client_handshake.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var Packets = require_packets();
    var ClientConstants = require_client3();
    var CharsetToEncoding = require_charset_encodings();
    var auth41 = require_auth_41();
    function flagNames(flags2) {
      const res = [];
      for (const c6 in ClientConstants) {
        if (flags2 & ClientConstants[c6]) {
          res.push(c6.replace(/_/g, " ").toLowerCase());
        }
      }
      return res;
    }
    var ClientHandshake = class _ClientHandshake extends Command2 {
      constructor(clientFlags) {
        super();
        this.handshake = null;
        this.clientFlags = clientFlags;
        this.authenticationFactor = 0;
      }
      start() {
        return _ClientHandshake.prototype.handshakeInit;
      }
      sendSSLRequest(connection2) {
        const sslRequest = new Packets.SSLRequest(
          this.clientFlags,
          connection2.config.charsetNumber
        );
        connection2.writePacket(sslRequest.toPacket());
      }
      sendCredentials(connection2) {
        if (connection2.config.debug) {
          console.log(
            "Sending handshake packet: flags:%d=(%s)",
            this.clientFlags,
            flagNames(this.clientFlags).join(", ")
          );
        }
        this.user = connection2.config.user;
        this.password = connection2.config.password;
        this.password1 = connection2.config.password;
        this.password2 = connection2.config.password2;
        this.password3 = connection2.config.password3;
        this.passwordSha1 = connection2.config.passwordSha1;
        this.database = connection2.config.database;
        this.authPluginName = this.handshake.authPluginName;
        const handshakeResponse = new Packets.HandshakeResponse({
          flags: this.clientFlags,
          user: this.user,
          database: this.database,
          password: this.password,
          passwordSha1: this.passwordSha1,
          charsetNumber: connection2.config.charsetNumber,
          authPluginData1: this.handshake.authPluginData1,
          authPluginData2: this.handshake.authPluginData2,
          compress: connection2.config.compress,
          connectAttributes: connection2.config.connectAttributes
        });
        connection2.writePacket(handshakeResponse.toPacket());
      }
      calculateNativePasswordAuthToken(authPluginData) {
        const authPluginData1 = authPluginData.slice(0, 8);
        const authPluginData2 = authPluginData.slice(8, 20);
        let authToken;
        if (this.passwordSha1) {
          authToken = auth41.calculateTokenFromPasswordSha(
            this.passwordSha1,
            authPluginData1,
            authPluginData2
          );
        } else {
          authToken = auth41.calculateToken(
            this.password,
            authPluginData1,
            authPluginData2
          );
        }
        return authToken;
      }
      handshakeInit(helloPacket, connection2) {
        this.on("error", (e6) => {
          connection2._fatalError = e6;
          connection2._protocolError = e6;
        });
        this.handshake = Packets.Handshake.fromPacket(helloPacket);
        if (connection2.config.debug) {
          console.log(
            "Server hello packet: capability flags:%d=(%s)",
            this.handshake.capabilityFlags,
            flagNames(this.handshake.capabilityFlags).join(", ")
          );
        }
        connection2.serverCapabilityFlags = this.handshake.capabilityFlags;
        connection2.serverEncoding = CharsetToEncoding[this.handshake.characterSet];
        connection2.connectionId = this.handshake.connectionId;
        const serverSSLSupport = this.handshake.capabilityFlags & ClientConstants.SSL;
        const multiFactorAuthentication = this.handshake.capabilityFlags & ClientConstants.MULTI_FACTOR_AUTHENTICATION;
        this.clientFlags = this.clientFlags | multiFactorAuthentication;
        connection2.config.compress = connection2.config.compress && this.handshake.capabilityFlags & ClientConstants.COMPRESS;
        this.clientFlags = this.clientFlags | connection2.config.compress;
        if (connection2.config.ssl) {
          if (!serverSSLSupport) {
            const err3 = new Error("Server does not support secure connection");
            err3.code = "HANDSHAKE_NO_SSL_SUPPORT";
            err3.fatal = true;
            this.emit("error", err3);
            return false;
          }
          this.clientFlags |= ClientConstants.SSL;
          this.sendSSLRequest(connection2);
          connection2.startTLS((err3) => {
            if (err3) {
              err3.code = "HANDSHAKE_SSL_ERROR";
              err3.fatal = true;
              this.emit("error", err3);
              return;
            }
            this.sendCredentials(connection2);
          });
        } else {
          this.sendCredentials(connection2);
        }
        if (multiFactorAuthentication) {
          this.authenticationFactor = 1;
        }
        return _ClientHandshake.prototype.handshakeResult;
      }
      handshakeResult(packet, connection2) {
        const marker = packet.peekByte();
        if (marker === 254 || marker === 1 || marker === 2) {
          const authSwitch = require_auth_switch();
          try {
            if (marker === 1) {
              authSwitch.authSwitchRequestMoreData(packet, connection2, this);
            } else {
              if (this.authenticationFactor !== 0) {
                connection2.config.password = this[`password${this.authenticationFactor}`];
                this.authenticationFactor += 1;
              }
              authSwitch.authSwitchRequest(packet, connection2, this);
            }
            return _ClientHandshake.prototype.handshakeResult;
          } catch (err3) {
            err3.code = "AUTH_SWITCH_PLUGIN_ERROR";
            err3.fatal = true;
            if (this.onResult) {
              this.onResult(err3);
            } else {
              this.emit("error", err3);
            }
            return null;
          }
        }
        if (marker !== 0) {
          const err3 = new Error("Unexpected packet during handshake phase");
          err3.code = "HANDSHAKE_UNKNOWN_ERROR";
          err3.fatal = true;
          if (this.onResult) {
            this.onResult(err3);
          } else {
            this.emit("error", err3);
          }
          return null;
        }
        if (!connection2.authorized) {
          connection2.authorized = true;
          if (connection2.config.compress) {
            const enableCompression = require_compressed_protocol().enableCompression;
            enableCompression(connection2);
          }
        }
        if (this.onResult) {
          this.onResult(null);
        }
        return null;
      }
    };
    module2.exports = ClientHandshake;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/server_handshake.js
var require_server_handshake = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/server_handshake.js"(exports2, module2) {
    "use strict";
    var CommandCode = require_commands();
    var Errors2 = require_errors2();
    var Command2 = require_command();
    var Packets = require_packets();
    var ServerHandshake = class _ServerHandshake extends Command2 {
      constructor(args2) {
        super();
        this.args = args2;
      }
      start(packet, connection2) {
        const serverHelloPacket = new Packets.Handshake(this.args);
        this.serverHello = serverHelloPacket;
        serverHelloPacket.setScrambleData((err3) => {
          if (err3) {
            connection2.emit("error", new Error("Error generating random bytes"));
            return;
          }
          connection2.writePacket(serverHelloPacket.toPacket(0));
        });
        return _ServerHandshake.prototype.readClientReply;
      }
      readClientReply(packet, connection2) {
        const clientHelloReply = Packets.HandshakeResponse.fromPacket(packet);
        connection2.clientHelloReply = clientHelloReply;
        if (this.args.authCallback) {
          this.args.authCallback(
            {
              user: clientHelloReply.user,
              database: clientHelloReply.database,
              address: connection2.stream.remoteAddress,
              authPluginData1: this.serverHello.authPluginData1,
              authPluginData2: this.serverHello.authPluginData2,
              authToken: clientHelloReply.authToken
            },
            (err3, mysqlError) => {
              if (!mysqlError) {
                connection2.writeOk();
              } else {
                connection2.writeError({
                  message: mysqlError.message || "",
                  code: mysqlError.code || 1045
                });
                connection2.close();
              }
            }
          );
        } else {
          connection2.writeOk();
        }
        return _ServerHandshake.prototype.dispatchCommands;
      }
      _isStatement(query, name3) {
        const firstWord = query.split(" ")[0].toUpperCase();
        return firstWord === name3;
      }
      dispatchCommands(packet, connection2) {
        let knownCommand = true;
        const encoding = connection2.clientHelloReply.encoding;
        const commandCode = packet.readInt8();
        switch (commandCode) {
          case CommandCode.STMT_PREPARE:
            if (connection2.listeners("stmt_prepare").length) {
              const query = packet.readString(void 0, encoding);
              connection2.emit("stmt_prepare", query);
            } else {
              connection2.writeError({
                code: Errors2.HA_ERR_INTERNAL_ERROR,
                message: "No query handler for prepared statements."
              });
            }
            break;
          case CommandCode.STMT_EXECUTE:
            if (connection2.listeners("stmt_execute").length) {
              const { stmtId, flags: flags2, iterationCount, values: values2 } = Packets.Execute.fromPacket(packet, encoding);
              connection2.emit(
                "stmt_execute",
                stmtId,
                flags2,
                iterationCount,
                values2
              );
            } else {
              connection2.writeError({
                code: Errors2.HA_ERR_INTERNAL_ERROR,
                message: "No query handler for execute statements."
              });
            }
            break;
          case CommandCode.QUIT:
            if (connection2.listeners("quit").length) {
              connection2.emit("quit");
            } else {
              connection2.stream.end();
            }
            break;
          case CommandCode.INIT_DB:
            if (connection2.listeners("init_db").length) {
              const schemaName = packet.readString(void 0, encoding);
              connection2.emit("init_db", schemaName);
            } else {
              connection2.writeOk();
            }
            break;
          case CommandCode.QUERY:
            if (connection2.listeners("query").length) {
              const query = packet.readString(void 0, encoding);
              if (this._isStatement(query, "PREPARE") || this._isStatement(query, "SET")) {
                connection2.emit("stmt_prepare", query);
              } else if (this._isStatement(query, "EXECUTE")) {
                connection2.emit("stmt_execute", null, null, null, null, query);
              } else connection2.emit("query", query);
            } else {
              connection2.writeError({
                code: Errors2.HA_ERR_INTERNAL_ERROR,
                message: "No query handler"
              });
            }
            break;
          case CommandCode.FIELD_LIST:
            if (connection2.listeners("field_list").length) {
              const table6 = packet.readNullTerminatedString(encoding);
              const fields = packet.readString(void 0, encoding);
              connection2.emit("field_list", table6, fields);
            } else {
              connection2.writeError({
                code: Errors2.ER_WARN_DEPRECATED_SYNTAX,
                message: "As of MySQL 5.7.11, COM_FIELD_LIST is deprecated and will be removed in a future version of MySQL."
              });
            }
            break;
          case CommandCode.PING:
            if (connection2.listeners("ping").length) {
              connection2.emit("ping");
            } else {
              connection2.writeOk();
            }
            break;
          default:
            knownCommand = false;
        }
        if (connection2.listeners("packet").length) {
          connection2.emit("packet", packet.clone(), knownCommand, commandCode);
        } else if (!knownCommand) {
          console.log("Unknown command:", commandCode);
        }
        return _ServerHandshake.prototype.dispatchCommands;
      }
    };
    module2.exports = ServerHandshake;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/charsets.js
var require_charsets = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/charsets.js"(exports2) {
    "use strict";
    exports2.BIG5_CHINESE_CI = 1;
    exports2.LATIN2_CZECH_CS = 2;
    exports2.DEC8_SWEDISH_CI = 3;
    exports2.CP850_GENERAL_CI = 4;
    exports2.LATIN1_GERMAN1_CI = 5;
    exports2.HP8_ENGLISH_CI = 6;
    exports2.KOI8R_GENERAL_CI = 7;
    exports2.LATIN1_SWEDISH_CI = 8;
    exports2.LATIN2_GENERAL_CI = 9;
    exports2.SWE7_SWEDISH_CI = 10;
    exports2.ASCII_GENERAL_CI = 11;
    exports2.UJIS_JAPANESE_CI = 12;
    exports2.SJIS_JAPANESE_CI = 13;
    exports2.CP1251_BULGARIAN_CI = 14;
    exports2.LATIN1_DANISH_CI = 15;
    exports2.HEBREW_GENERAL_CI = 16;
    exports2.TIS620_THAI_CI = 18;
    exports2.EUCKR_KOREAN_CI = 19;
    exports2.LATIN7_ESTONIAN_CS = 20;
    exports2.LATIN2_HUNGARIAN_CI = 21;
    exports2.KOI8U_GENERAL_CI = 22;
    exports2.CP1251_UKRAINIAN_CI = 23;
    exports2.GB2312_CHINESE_CI = 24;
    exports2.GREEK_GENERAL_CI = 25;
    exports2.CP1250_GENERAL_CI = 26;
    exports2.LATIN2_CROATIAN_CI = 27;
    exports2.GBK_CHINESE_CI = 28;
    exports2.CP1257_LITHUANIAN_CI = 29;
    exports2.LATIN5_TURKISH_CI = 30;
    exports2.LATIN1_GERMAN2_CI = 31;
    exports2.ARMSCII8_GENERAL_CI = 32;
    exports2.UTF8_GENERAL_CI = 33;
    exports2.CP1250_CZECH_CS = 34;
    exports2.UCS2_GENERAL_CI = 35;
    exports2.CP866_GENERAL_CI = 36;
    exports2.KEYBCS2_GENERAL_CI = 37;
    exports2.MACCE_GENERAL_CI = 38;
    exports2.MACROMAN_GENERAL_CI = 39;
    exports2.CP852_GENERAL_CI = 40;
    exports2.LATIN7_GENERAL_CI = 41;
    exports2.LATIN7_GENERAL_CS = 42;
    exports2.MACCE_BIN = 43;
    exports2.CP1250_CROATIAN_CI = 44;
    exports2.UTF8MB4_GENERAL_CI = 45;
    exports2.UTF8MB4_BIN = 46;
    exports2.LATIN1_BIN = 47;
    exports2.LATIN1_GENERAL_CI = 48;
    exports2.LATIN1_GENERAL_CS = 49;
    exports2.CP1251_BIN = 50;
    exports2.CP1251_GENERAL_CI = 51;
    exports2.CP1251_GENERAL_CS = 52;
    exports2.MACROMAN_BIN = 53;
    exports2.UTF16_GENERAL_CI = 54;
    exports2.UTF16_BIN = 55;
    exports2.UTF16LE_GENERAL_CI = 56;
    exports2.CP1256_GENERAL_CI = 57;
    exports2.CP1257_BIN = 58;
    exports2.CP1257_GENERAL_CI = 59;
    exports2.UTF32_GENERAL_CI = 60;
    exports2.UTF32_BIN = 61;
    exports2.UTF16LE_BIN = 62;
    exports2.BINARY = 63;
    exports2.ARMSCII8_BIN = 64;
    exports2.ASCII_BIN = 65;
    exports2.CP1250_BIN = 66;
    exports2.CP1256_BIN = 67;
    exports2.CP866_BIN = 68;
    exports2.DEC8_BIN = 69;
    exports2.GREEK_BIN = 70;
    exports2.HEBREW_BIN = 71;
    exports2.HP8_BIN = 72;
    exports2.KEYBCS2_BIN = 73;
    exports2.KOI8R_BIN = 74;
    exports2.KOI8U_BIN = 75;
    exports2.UTF8_TOLOWER_CI = 76;
    exports2.LATIN2_BIN = 77;
    exports2.LATIN5_BIN = 78;
    exports2.LATIN7_BIN = 79;
    exports2.CP850_BIN = 80;
    exports2.CP852_BIN = 81;
    exports2.SWE7_BIN = 82;
    exports2.UTF8_BIN = 83;
    exports2.BIG5_BIN = 84;
    exports2.EUCKR_BIN = 85;
    exports2.GB2312_BIN = 86;
    exports2.GBK_BIN = 87;
    exports2.SJIS_BIN = 88;
    exports2.TIS620_BIN = 89;
    exports2.UCS2_BIN = 90;
    exports2.UJIS_BIN = 91;
    exports2.GEOSTD8_GENERAL_CI = 92;
    exports2.GEOSTD8_BIN = 93;
    exports2.LATIN1_SPANISH_CI = 94;
    exports2.CP932_JAPANESE_CI = 95;
    exports2.CP932_BIN = 96;
    exports2.EUCJPMS_JAPANESE_CI = 97;
    exports2.EUCJPMS_BIN = 98;
    exports2.CP1250_POLISH_CI = 99;
    exports2.UTF16_UNICODE_CI = 101;
    exports2.UTF16_ICELANDIC_CI = 102;
    exports2.UTF16_LATVIAN_CI = 103;
    exports2.UTF16_ROMANIAN_CI = 104;
    exports2.UTF16_SLOVENIAN_CI = 105;
    exports2.UTF16_POLISH_CI = 106;
    exports2.UTF16_ESTONIAN_CI = 107;
    exports2.UTF16_SPANISH_CI = 108;
    exports2.UTF16_SWEDISH_CI = 109;
    exports2.UTF16_TURKISH_CI = 110;
    exports2.UTF16_CZECH_CI = 111;
    exports2.UTF16_DANISH_CI = 112;
    exports2.UTF16_LITHUANIAN_CI = 113;
    exports2.UTF16_SLOVAK_CI = 114;
    exports2.UTF16_SPANISH2_CI = 115;
    exports2.UTF16_ROMAN_CI = 116;
    exports2.UTF16_PERSIAN_CI = 117;
    exports2.UTF16_ESPERANTO_CI = 118;
    exports2.UTF16_HUNGARIAN_CI = 119;
    exports2.UTF16_SINHALA_CI = 120;
    exports2.UTF16_GERMAN2_CI = 121;
    exports2.UTF16_CROATIAN_CI = 122;
    exports2.UTF16_UNICODE_520_CI = 123;
    exports2.UTF16_VIETNAMESE_CI = 124;
    exports2.UCS2_UNICODE_CI = 128;
    exports2.UCS2_ICELANDIC_CI = 129;
    exports2.UCS2_LATVIAN_CI = 130;
    exports2.UCS2_ROMANIAN_CI = 131;
    exports2.UCS2_SLOVENIAN_CI = 132;
    exports2.UCS2_POLISH_CI = 133;
    exports2.UCS2_ESTONIAN_CI = 134;
    exports2.UCS2_SPANISH_CI = 135;
    exports2.UCS2_SWEDISH_CI = 136;
    exports2.UCS2_TURKISH_CI = 137;
    exports2.UCS2_CZECH_CI = 138;
    exports2.UCS2_DANISH_CI = 139;
    exports2.UCS2_LITHUANIAN_CI = 140;
    exports2.UCS2_SLOVAK_CI = 141;
    exports2.UCS2_SPANISH2_CI = 142;
    exports2.UCS2_ROMAN_CI = 143;
    exports2.UCS2_PERSIAN_CI = 144;
    exports2.UCS2_ESPERANTO_CI = 145;
    exports2.UCS2_HUNGARIAN_CI = 146;
    exports2.UCS2_SINHALA_CI = 147;
    exports2.UCS2_GERMAN2_CI = 148;
    exports2.UCS2_CROATIAN_CI = 149;
    exports2.UCS2_UNICODE_520_CI = 150;
    exports2.UCS2_VIETNAMESE_CI = 151;
    exports2.UCS2_GENERAL_MYSQL500_CI = 159;
    exports2.UTF32_UNICODE_CI = 160;
    exports2.UTF32_ICELANDIC_CI = 161;
    exports2.UTF32_LATVIAN_CI = 162;
    exports2.UTF32_ROMANIAN_CI = 163;
    exports2.UTF32_SLOVENIAN_CI = 164;
    exports2.UTF32_POLISH_CI = 165;
    exports2.UTF32_ESTONIAN_CI = 166;
    exports2.UTF32_SPANISH_CI = 167;
    exports2.UTF32_SWEDISH_CI = 168;
    exports2.UTF32_TURKISH_CI = 169;
    exports2.UTF32_CZECH_CI = 170;
    exports2.UTF32_DANISH_CI = 171;
    exports2.UTF32_LITHUANIAN_CI = 172;
    exports2.UTF32_SLOVAK_CI = 173;
    exports2.UTF32_SPANISH2_CI = 174;
    exports2.UTF32_ROMAN_CI = 175;
    exports2.UTF32_PERSIAN_CI = 176;
    exports2.UTF32_ESPERANTO_CI = 177;
    exports2.UTF32_HUNGARIAN_CI = 178;
    exports2.UTF32_SINHALA_CI = 179;
    exports2.UTF32_GERMAN2_CI = 180;
    exports2.UTF32_CROATIAN_CI = 181;
    exports2.UTF32_UNICODE_520_CI = 182;
    exports2.UTF32_VIETNAMESE_CI = 183;
    exports2.UTF8_UNICODE_CI = 192;
    exports2.UTF8_ICELANDIC_CI = 193;
    exports2.UTF8_LATVIAN_CI = 194;
    exports2.UTF8_ROMANIAN_CI = 195;
    exports2.UTF8_SLOVENIAN_CI = 196;
    exports2.UTF8_POLISH_CI = 197;
    exports2.UTF8_ESTONIAN_CI = 198;
    exports2.UTF8_SPANISH_CI = 199;
    exports2.UTF8_SWEDISH_CI = 200;
    exports2.UTF8_TURKISH_CI = 201;
    exports2.UTF8_CZECH_CI = 202;
    exports2.UTF8_DANISH_CI = 203;
    exports2.UTF8_LITHUANIAN_CI = 204;
    exports2.UTF8_SLOVAK_CI = 205;
    exports2.UTF8_SPANISH2_CI = 206;
    exports2.UTF8_ROMAN_CI = 207;
    exports2.UTF8_PERSIAN_CI = 208;
    exports2.UTF8_ESPERANTO_CI = 209;
    exports2.UTF8_HUNGARIAN_CI = 210;
    exports2.UTF8_SINHALA_CI = 211;
    exports2.UTF8_GERMAN2_CI = 212;
    exports2.UTF8_CROATIAN_CI = 213;
    exports2.UTF8_UNICODE_520_CI = 214;
    exports2.UTF8_VIETNAMESE_CI = 215;
    exports2.UTF8_GENERAL_MYSQL500_CI = 223;
    exports2.UTF8MB4_UNICODE_CI = 224;
    exports2.UTF8MB4_ICELANDIC_CI = 225;
    exports2.UTF8MB4_LATVIAN_CI = 226;
    exports2.UTF8MB4_ROMANIAN_CI = 227;
    exports2.UTF8MB4_SLOVENIAN_CI = 228;
    exports2.UTF8MB4_POLISH_CI = 229;
    exports2.UTF8MB4_ESTONIAN_CI = 230;
    exports2.UTF8MB4_SPANISH_CI = 231;
    exports2.UTF8MB4_SWEDISH_CI = 232;
    exports2.UTF8MB4_TURKISH_CI = 233;
    exports2.UTF8MB4_CZECH_CI = 234;
    exports2.UTF8MB4_DANISH_CI = 235;
    exports2.UTF8MB4_LITHUANIAN_CI = 236;
    exports2.UTF8MB4_SLOVAK_CI = 237;
    exports2.UTF8MB4_SPANISH2_CI = 238;
    exports2.UTF8MB4_ROMAN_CI = 239;
    exports2.UTF8MB4_PERSIAN_CI = 240;
    exports2.UTF8MB4_ESPERANTO_CI = 241;
    exports2.UTF8MB4_HUNGARIAN_CI = 242;
    exports2.UTF8MB4_SINHALA_CI = 243;
    exports2.UTF8MB4_GERMAN2_CI = 244;
    exports2.UTF8MB4_CROATIAN_CI = 245;
    exports2.UTF8MB4_UNICODE_520_CI = 246;
    exports2.UTF8MB4_VIETNAMESE_CI = 247;
    exports2.GB18030_CHINESE_CI = 248;
    exports2.GB18030_BIN = 249;
    exports2.GB18030_UNICODE_520_CI = 250;
    exports2.UTF8_GENERAL50_CI = 253;
    exports2.UTF8MB4_0900_AI_CI = 255;
    exports2.UTF8MB4_DE_PB_0900_AI_CI = 256;
    exports2.UTF8MB4_IS_0900_AI_CI = 257;
    exports2.UTF8MB4_LV_0900_AI_CI = 258;
    exports2.UTF8MB4_RO_0900_AI_CI = 259;
    exports2.UTF8MB4_SL_0900_AI_CI = 260;
    exports2.UTF8MB4_PL_0900_AI_CI = 261;
    exports2.UTF8MB4_ET_0900_AI_CI = 262;
    exports2.UTF8MB4_ES_0900_AI_CI = 263;
    exports2.UTF8MB4_SV_0900_AI_CI = 264;
    exports2.UTF8MB4_TR_0900_AI_CI = 265;
    exports2.UTF8MB4_CS_0900_AI_CI = 266;
    exports2.UTF8MB4_DA_0900_AI_CI = 267;
    exports2.UTF8MB4_LT_0900_AI_CI = 268;
    exports2.UTF8MB4_SK_0900_AI_CI = 269;
    exports2.UTF8MB4_ES_TRAD_0900_AI_CI = 270;
    exports2.UTF8MB4_LA_0900_AI_CI = 271;
    exports2.UTF8MB4_EO_0900_AI_CI = 273;
    exports2.UTF8MB4_HU_0900_AI_CI = 274;
    exports2.UTF8MB4_HR_0900_AI_CI = 275;
    exports2.UTF8MB4_VI_0900_AI_CI = 277;
    exports2.UTF8MB4_0900_AS_CS = 278;
    exports2.UTF8MB4_DE_PB_0900_AS_CS = 279;
    exports2.UTF8MB4_IS_0900_AS_CS = 280;
    exports2.UTF8MB4_LV_0900_AS_CS = 281;
    exports2.UTF8MB4_RO_0900_AS_CS = 282;
    exports2.UTF8MB4_SL_0900_AS_CS = 283;
    exports2.UTF8MB4_PL_0900_AS_CS = 284;
    exports2.UTF8MB4_ET_0900_AS_CS = 285;
    exports2.UTF8MB4_ES_0900_AS_CS = 286;
    exports2.UTF8MB4_SV_0900_AS_CS = 287;
    exports2.UTF8MB4_TR_0900_AS_CS = 288;
    exports2.UTF8MB4_CS_0900_AS_CS = 289;
    exports2.UTF8MB4_DA_0900_AS_CS = 290;
    exports2.UTF8MB4_LT_0900_AS_CS = 291;
    exports2.UTF8MB4_SK_0900_AS_CS = 292;
    exports2.UTF8MB4_ES_TRAD_0900_AS_CS = 293;
    exports2.UTF8MB4_LA_0900_AS_CS = 294;
    exports2.UTF8MB4_EO_0900_AS_CS = 296;
    exports2.UTF8MB4_HU_0900_AS_CS = 297;
    exports2.UTF8MB4_HR_0900_AS_CS = 298;
    exports2.UTF8MB4_VI_0900_AS_CS = 300;
    exports2.UTF8MB4_JA_0900_AS_CS = 303;
    exports2.UTF8MB4_JA_0900_AS_CS_KS = 304;
    exports2.UTF8MB4_0900_AS_CI = 305;
    exports2.UTF8MB4_RU_0900_AI_CI = 306;
    exports2.UTF8MB4_RU_0900_AS_CS = 307;
    exports2.UTF8MB4_ZH_0900_AS_CS = 308;
    exports2.UTF8MB4_0900_BIN = 309;
    exports2.BIG5 = exports2.BIG5_CHINESE_CI;
    exports2.DEC8 = exports2.DEC8_SWEDISH_CI;
    exports2.CP850 = exports2.CP850_GENERAL_CI;
    exports2.HP8 = exports2.HP8_ENGLISH_CI;
    exports2.KOI8R = exports2.KOI8R_GENERAL_CI;
    exports2.LATIN1 = exports2.LATIN1_SWEDISH_CI;
    exports2.LATIN2 = exports2.LATIN2_GENERAL_CI;
    exports2.SWE7 = exports2.SWE7_SWEDISH_CI;
    exports2.ASCII = exports2.ASCII_GENERAL_CI;
    exports2.UJIS = exports2.UJIS_JAPANESE_CI;
    exports2.SJIS = exports2.SJIS_JAPANESE_CI;
    exports2.HEBREW = exports2.HEBREW_GENERAL_CI;
    exports2.TIS620 = exports2.TIS620_THAI_CI;
    exports2.EUCKR = exports2.EUCKR_KOREAN_CI;
    exports2.KOI8U = exports2.KOI8U_GENERAL_CI;
    exports2.GB2312 = exports2.GB2312_CHINESE_CI;
    exports2.GREEK = exports2.GREEK_GENERAL_CI;
    exports2.CP1250 = exports2.CP1250_GENERAL_CI;
    exports2.GBK = exports2.GBK_CHINESE_CI;
    exports2.LATIN5 = exports2.LATIN5_TURKISH_CI;
    exports2.ARMSCII8 = exports2.ARMSCII8_GENERAL_CI;
    exports2.UTF8 = exports2.UTF8_GENERAL_CI;
    exports2.UCS2 = exports2.UCS2_GENERAL_CI;
    exports2.CP866 = exports2.CP866_GENERAL_CI;
    exports2.KEYBCS2 = exports2.KEYBCS2_GENERAL_CI;
    exports2.MACCE = exports2.MACCE_GENERAL_CI;
    exports2.MACROMAN = exports2.MACROMAN_GENERAL_CI;
    exports2.CP852 = exports2.CP852_GENERAL_CI;
    exports2.LATIN7 = exports2.LATIN7_GENERAL_CI;
    exports2.UTF8MB4 = exports2.UTF8MB4_GENERAL_CI;
    exports2.CP1251 = exports2.CP1251_GENERAL_CI;
    exports2.UTF16 = exports2.UTF16_GENERAL_CI;
    exports2.UTF16LE = exports2.UTF16LE_GENERAL_CI;
    exports2.CP1256 = exports2.CP1256_GENERAL_CI;
    exports2.CP1257 = exports2.CP1257_GENERAL_CI;
    exports2.UTF32 = exports2.UTF32_GENERAL_CI;
    exports2.CP932 = exports2.CP932_JAPANESE_CI;
    exports2.EUCJPMS = exports2.EUCJPMS_JAPANESE_CI;
    exports2.GB18030 = exports2.GB18030_CHINESE_CI;
    exports2.GEOSTD8 = exports2.GEOSTD8_GENERAL_CI;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/helpers.js
var require_helpers = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/helpers.js"(exports2) {
    "use strict";
    function srcEscape(str) {
      return JSON.stringify({
        [str]: 1
      }).slice(1, -3);
    }
    exports2.srcEscape = srcEscape;
    var highlightFn;
    var cardinalRecommended = false;
    try {
      const REQUIRE_TERMINATOR = "";
      highlightFn = require(`cardinal${REQUIRE_TERMINATOR}`).highlight;
    } catch (err3) {
      highlightFn = (text5) => {
        if (!cardinalRecommended) {
          console.log("For nicer debug output consider install cardinal@^2.0.0");
          cardinalRecommended = true;
        }
        return text5;
      };
    }
    function printDebugWithCode(msg, code) {
      console.log(`

${msg}:
`);
      console.log(`${highlightFn(code)}
`);
    }
    exports2.printDebugWithCode = printDebugWithCode;
    function typeMatch(type, list, Types) {
      if (Array.isArray(list)) {
        return list.some((t6) => type === Types[t6]);
      }
      return !!list;
    }
    exports2.typeMatch = typeMatch;
    var privateObjectProps = /* @__PURE__ */ new Set([
      "__defineGetter__",
      "__defineSetter__",
      "__lookupGetter__",
      "__lookupSetter__",
      "__proto__"
    ]);
    exports2.privateObjectProps = privateObjectProps;
    var fieldEscape = (field, isEval = true) => {
      if (privateObjectProps.has(field)) {
        throw new Error(
          `The field name (${field}) can't be the same as an object's private property.`
        );
      }
      return isEval ? srcEscape(field) : field;
    };
    exports2.fieldEscape = fieldEscape;
  }
});

// ../node_modules/.pnpm/is-property@1.0.2/node_modules/is-property/is-property.js
var require_is_property = __commonJS({
  "../node_modules/.pnpm/is-property@1.0.2/node_modules/is-property/is-property.js"(exports2, module2) {
    "use strict";
    function isProperty(str) {
      return /^[$A-Z\_a-z\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc][$A-Z\_a-z\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u0527\u0531-\u0556\u0559\u0561-\u0587\u05d0-\u05ea\u05f0-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u08a0\u08a2-\u08ac\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0977\u0979-\u097f\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c33\u0c35-\u0c39\u0c3d\u0c58\u0c59\u0c60\u0c61\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d05-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d60\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e87\u0e88\u0e8a\u0e8d\u0e94-\u0e97\u0e99-\u0e9f\u0ea1-\u0ea3\u0ea5\u0ea7\u0eaa\u0eab\u0ead-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f4\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f0\u1700-\u170c\u170e-\u1711\u1720-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1877\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191c\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19c1-\u19c7\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4b\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1ce9-\u1cec\u1cee-\u1cf1\u1cf5\u1cf6\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2119-\u211d\u2124\u2126\u2128\u212a-\u212d\u212f-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2c2e\u2c30-\u2c5e\u2c60-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u2e2f\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309d-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312d\u3131-\u318e\u31a0-\u31ba\u31f0-\u31ff\u3400-\u4db5\u4e00-\u9fcc\ua000-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua697\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua78e\ua790-\ua793\ua7a0-\ua7aa\ua7f8-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa80-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uabc0-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc0-9\u0300-\u036f\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u08e4-\u08fe\u0900-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b56\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c01-\u0c03\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c82\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d02\u0d03\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d82\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0eb9\u0ebb\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1712-\u1714\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u1810-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19b0-\u19c0\u19c8\u19c9\u19d0-\u19d9\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf2-\u1cf4\u1dc0-\u1de6\u1dfc-\u1dff\u200c\u200d\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua880\ua881\ua8b4-\ua8c4\ua8d0-\ua8d9\ua8e0-\ua8f1\ua900-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe26\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f]*$/.test(str);
    }
    module2.exports = isProperty;
  }
});

// ../node_modules/.pnpm/generate-function@2.3.1/node_modules/generate-function/index.js
var require_generate_function = __commonJS({
  "../node_modules/.pnpm/generate-function@2.3.1/node_modules/generate-function/index.js"(exports2, module2) {
    "use strict";
    var util2 = require("util");
    var isProperty = require_is_property();
    var INDENT_START = /[\{\[]/;
    var INDENT_END = /[\}\]]/;
    var RESERVED = [
      "do",
      "if",
      "in",
      "for",
      "let",
      "new",
      "try",
      "var",
      "case",
      "else",
      "enum",
      "eval",
      "null",
      "this",
      "true",
      "void",
      "with",
      "await",
      "break",
      "catch",
      "class",
      "const",
      "false",
      "super",
      "throw",
      "while",
      "yield",
      "delete",
      "export",
      "import",
      "public",
      "return",
      "static",
      "switch",
      "typeof",
      "default",
      "extends",
      "finally",
      "package",
      "private",
      "continue",
      "debugger",
      "function",
      "arguments",
      "interface",
      "protected",
      "implements",
      "instanceof",
      "NaN",
      "undefined"
    ];
    var RESERVED_MAP = {};
    for (i8 = 0; i8 < RESERVED.length; i8++) {
      RESERVED_MAP[RESERVED[i8]] = true;
    }
    var i8;
    var isVariable = function(name3) {
      return isProperty(name3) && !RESERVED_MAP.hasOwnProperty(name3);
    };
    var formats = {
      s: function(s10) {
        return "" + s10;
      },
      d: function(d7) {
        return "" + Number(d7);
      },
      o: function(o9) {
        return JSON.stringify(o9);
      }
    };
    var genfun = function() {
      var lines = [];
      var indent = 0;
      var vars = {};
      var push = function(str) {
        var spaces = "";
        while (spaces.length < indent * 2) spaces += "  ";
        lines.push(spaces + str);
      };
      var pushLine = function(line3) {
        if (INDENT_END.test(line3.trim()[0]) && INDENT_START.test(line3[line3.length - 1])) {
          indent--;
          push(line3);
          indent++;
          return;
        }
        if (INDENT_START.test(line3[line3.length - 1])) {
          push(line3);
          indent++;
          return;
        }
        if (INDENT_END.test(line3.trim()[0])) {
          indent--;
          push(line3);
          return;
        }
        push(line3);
      };
      var line2 = function(fmt) {
        if (!fmt) return line2;
        if (arguments.length === 1 && fmt.indexOf("\n") > -1) {
          var lines2 = fmt.trim().split("\n");
          for (var i9 = 0; i9 < lines2.length; i9++) {
            pushLine(lines2[i9].trim());
          }
        } else {
          pushLine(util2.format.apply(util2, arguments));
        }
        return line2;
      };
      line2.scope = {};
      line2.formats = formats;
      line2.sym = function(name3) {
        if (!name3 || !isVariable(name3)) name3 = "tmp";
        if (!vars[name3]) vars[name3] = 0;
        return name3 + (vars[name3]++ || "");
      };
      line2.property = function(obj, name3) {
        if (arguments.length === 1) {
          name3 = obj;
          obj = "";
        }
        name3 = name3 + "";
        if (isProperty(name3)) return obj ? obj + "." + name3 : name3;
        return obj ? obj + "[" + JSON.stringify(name3) + "]" : JSON.stringify(name3);
      };
      line2.toString = function() {
        return lines.join("\n");
      };
      line2.toFunction = function(scope) {
        if (!scope) scope = {};
        var src = "return (" + line2.toString() + ")";
        Object.keys(line2.scope).forEach(function(key) {
          if (!scope[key]) scope[key] = line2.scope[key];
        });
        var keys = Object.keys(scope).map(function(key) {
          return key;
        });
        var vals = keys.map(function(key) {
          return scope[key];
        });
        return Function.apply(null, keys.concat(src)).apply(null, vals);
      };
      if (arguments.length) line2.apply(null, arguments);
      return line2;
    };
    genfun.formats = formats;
    module2.exports = genfun;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/text_parser.js
var require_text_parser = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/text_parser.js"(exports2, module2) {
    "use strict";
    var Types = require_types2();
    var Charsets = require_charsets();
    var helpers = require_helpers();
    var genFunc = require_generate_function();
    var parserCache = require_parser_cache();
    var typeNames = [];
    for (const t6 in Types) {
      typeNames[Types[t6]] = t6;
    }
    function readCodeFor(type, charset, encodingExpr, config, options) {
      const supportBigNumbers = Boolean(
        options.supportBigNumbers || config.supportBigNumbers
      );
      const bigNumberStrings = Boolean(
        options.bigNumberStrings || config.bigNumberStrings
      );
      const timezone = options.timezone || config.timezone;
      const dateStrings = options.dateStrings || config.dateStrings;
      switch (type) {
        case Types.TINY:
        case Types.SHORT:
        case Types.LONG:
        case Types.INT24:
        case Types.YEAR:
          return "packet.parseLengthCodedIntNoBigCheck()";
        case Types.LONGLONG:
          if (supportBigNumbers && bigNumberStrings) {
            return "packet.parseLengthCodedIntString()";
          }
          return `packet.parseLengthCodedInt(${supportBigNumbers})`;
        case Types.FLOAT:
        case Types.DOUBLE:
          return "packet.parseLengthCodedFloat()";
        case Types.NULL:
          return "packet.readLengthCodedNumber()";
        case Types.DECIMAL:
        case Types.NEWDECIMAL:
          if (config.decimalNumbers) {
            return "packet.parseLengthCodedFloat()";
          }
          return 'packet.readLengthCodedString("ascii")';
        case Types.DATE:
          if (helpers.typeMatch(type, dateStrings, Types)) {
            return 'packet.readLengthCodedString("ascii")';
          }
          return `packet.parseDate(${helpers.srcEscape(timezone)})`;
        case Types.DATETIME:
        case Types.TIMESTAMP:
          if (helpers.typeMatch(type, dateStrings, Types)) {
            return 'packet.readLengthCodedString("ascii")';
          }
          return `packet.parseDateTime(${helpers.srcEscape(timezone)})`;
        case Types.TIME:
          return 'packet.readLengthCodedString("ascii")';
        case Types.GEOMETRY:
          return "packet.parseGeometryValue()";
        case Types.VECTOR:
          return "packet.parseVector()";
        case Types.JSON:
          return config.jsonStrings ? 'packet.readLengthCodedString("utf8")' : 'JSON.parse(packet.readLengthCodedString("utf8"))';
        default:
          if (charset === Charsets.BINARY) {
            return "packet.readLengthCodedBuffer()";
          }
          return `packet.readLengthCodedString(${encodingExpr})`;
      }
    }
    function compile(fields, options, config) {
      if (typeof config.typeCast === "function" && typeof options.typeCast !== "function") {
        options.typeCast = config.typeCast;
      }
      function wrap(field, _this) {
        return {
          type: typeNames[field.columnType],
          length: field.columnLength,
          db: field.schema,
          table: field.table,
          name: field.name,
          string: function(encoding = field.encoding) {
            if (field.columnType === Types.JSON && encoding === field.encoding) {
              console.warn(
                `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\``
              );
            }
            return _this.packet.readLengthCodedString(encoding);
          },
          buffer: function() {
            return _this.packet.readLengthCodedBuffer();
          },
          geometry: function() {
            return _this.packet.parseGeometryValue();
          }
        };
      }
      const parserFn = genFunc();
      parserFn("(function () {")("return class TextRow {");
      parserFn("constructor(fields) {");
      if (typeof options.typeCast === "function") {
        parserFn("const _this = this;");
        parserFn("for(let i=0; i<fields.length; ++i) {");
        parserFn("this[`wrap${i}`] = wrap(fields[i], _this);");
        parserFn("}");
      }
      parserFn("}");
      parserFn("next(packet, fields, options) {");
      parserFn("this.packet = packet;");
      if (options.rowsAsArray) {
        parserFn(`const result = new Array(${fields.length});`);
      } else {
        parserFn("const result = {};");
      }
      const resultTables = {};
      let resultTablesArray = [];
      if (options.nestTables === true) {
        for (let i8 = 0; i8 < fields.length; i8++) {
          resultTables[fields[i8].table] = 1;
        }
        resultTablesArray = Object.keys(resultTables);
        for (let i8 = 0; i8 < resultTablesArray.length; i8++) {
          parserFn(`result[${helpers.fieldEscape(resultTablesArray[i8])}] = {};`);
        }
      }
      let lvalue = "";
      let fieldName = "";
      let tableName = "";
      for (let i8 = 0; i8 < fields.length; i8++) {
        fieldName = helpers.fieldEscape(fields[i8].name);
        if (typeof options.nestTables === "string") {
          lvalue = `result[${helpers.fieldEscape(fields[i8].table + options.nestTables + fields[i8].name)}]`;
        } else if (options.nestTables === true) {
          tableName = helpers.fieldEscape(fields[i8].table);
          parserFn(`if (!result[${tableName}]) result[${tableName}] = {};`);
          lvalue = `result[${tableName}][${fieldName}]`;
        } else if (options.rowsAsArray) {
          lvalue = `result[${i8.toString(10)}]`;
        } else {
          lvalue = `result[${fieldName}]`;
        }
        if (options.typeCast === false) {
          parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
        } else {
          const encodingExpr = `fields[${i8}].encoding`;
          const readCode = readCodeFor(
            fields[i8].columnType,
            fields[i8].characterSet,
            encodingExpr,
            config,
            options
          );
          if (typeof options.typeCast === "function") {
            parserFn(
              `${lvalue} = options.typeCast(this.wrap${i8}, function() { return ${readCode} });`
            );
          } else {
            parserFn(`${lvalue} = ${readCode};`);
          }
        }
      }
      parserFn("return result;");
      parserFn("}");
      parserFn("};")("})()");
      if (config.debug) {
        helpers.printDebugWithCode(
          "Compiled text protocol row parser",
          parserFn.toString()
        );
      }
      if (typeof options.typeCast === "function") {
        return parserFn.toFunction({ wrap });
      }
      return parserFn.toFunction();
    }
    function getTextParser(fields, options, config) {
      return parserCache.getParser("text", fields, options, config, compile);
    }
    module2.exports = getTextParser;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/static_text_parser.js
var require_static_text_parser = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/static_text_parser.js"(exports2, module2) {
    "use strict";
    var Types = require_types2();
    var Charsets = require_charsets();
    var helpers = require_helpers();
    var typeNames = [];
    for (const t6 in Types) {
      typeNames[Types[t6]] = t6;
    }
    function readField({ packet, type, charset, encoding, config, options }) {
      const supportBigNumbers = Boolean(
        options.supportBigNumbers || config.supportBigNumbers
      );
      const bigNumberStrings = Boolean(
        options.bigNumberStrings || config.bigNumberStrings
      );
      const timezone = options.timezone || config.timezone;
      const dateStrings = options.dateStrings || config.dateStrings;
      switch (type) {
        case Types.TINY:
        case Types.SHORT:
        case Types.LONG:
        case Types.INT24:
        case Types.YEAR:
          return packet.parseLengthCodedIntNoBigCheck();
        case Types.LONGLONG:
          if (supportBigNumbers && bigNumberStrings) {
            return packet.parseLengthCodedIntString();
          }
          return packet.parseLengthCodedInt(supportBigNumbers);
        case Types.FLOAT:
        case Types.DOUBLE:
          return packet.parseLengthCodedFloat();
        case Types.NULL:
        case Types.DECIMAL:
        case Types.NEWDECIMAL:
          if (config.decimalNumbers) {
            return packet.parseLengthCodedFloat();
          }
          return packet.readLengthCodedString("ascii");
        case Types.DATE:
          if (helpers.typeMatch(type, dateStrings, Types)) {
            return packet.readLengthCodedString("ascii");
          }
          return packet.parseDate(timezone);
        case Types.DATETIME:
        case Types.TIMESTAMP:
          if (helpers.typeMatch(type, dateStrings, Types)) {
            return packet.readLengthCodedString("ascii");
          }
          return packet.parseDateTime(timezone);
        case Types.TIME:
          return packet.readLengthCodedString("ascii");
        case Types.GEOMETRY:
          return packet.parseGeometryValue();
        case Types.VECTOR:
          return packet.parseVector();
        case Types.JSON:
          return config.jsonStrings ? packet.readLengthCodedString("utf8") : JSON.parse(packet.readLengthCodedString("utf8"));
        default:
          if (charset === Charsets.BINARY) {
            return packet.readLengthCodedBuffer();
          }
          return packet.readLengthCodedString(encoding);
      }
    }
    function createTypecastField(field, packet) {
      return {
        type: typeNames[field.columnType],
        length: field.columnLength,
        db: field.schema,
        table: field.table,
        name: field.name,
        string: function(encoding = field.encoding) {
          if (field.columnType === Types.JSON && encoding === field.encoding) {
            console.warn(
              `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\``
            );
          }
          return packet.readLengthCodedString(encoding);
        },
        buffer: function() {
          return packet.readLengthCodedBuffer();
        },
        geometry: function() {
          return packet.parseGeometryValue();
        }
      };
    }
    function getTextParser(_fields, _options2, config) {
      return {
        next(packet, fields, options) {
          const result = options.rowsAsArray ? [] : {};
          for (let i8 = 0; i8 < fields.length; i8++) {
            const field = fields[i8];
            const typeCast = options.typeCast ? options.typeCast : config.typeCast;
            const next = () => readField({
              packet,
              type: field.columnType,
              encoding: field.encoding,
              charset: field.characterSet,
              config,
              options
            });
            let value;
            if (options.typeCast === false) {
              value = packet.readLengthCodedBuffer();
            } else if (typeof typeCast === "function") {
              value = typeCast(createTypecastField(field, packet), next);
            } else {
              value = next();
            }
            if (options.rowsAsArray) {
              result.push(value);
            } else if (typeof options.nestTables === "string") {
              result[`${helpers.fieldEscape(field.table, false)}${options.nestTables}${helpers.fieldEscape(field.name, false)}`] = value;
            } else if (options.nestTables) {
              const tableName = helpers.fieldEscape(field.table, false);
              if (!result[tableName]) {
                result[tableName] = {};
              }
              result[tableName][helpers.fieldEscape(field.name, false)] = value;
            } else {
              result[helpers.fieldEscape(field.name, false)] = value;
            }
          }
          return result;
        }
      };
    }
    module2.exports = getTextParser;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/query.js
var require_query4 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/query.js"(exports2, module2) {
    "use strict";
    var process4 = require("process");
    var Timers = require("timers");
    var Readable6 = require("stream").Readable;
    var Command2 = require_command();
    var Packets = require_packets();
    var getTextParser = require_text_parser();
    var staticParser = require_static_text_parser();
    var ServerStatus = require_server_status();
    var EmptyPacket = new Packets.Packet(0, Buffer.allocUnsafe(4), 0, 4);
    var Query3 = class _Query extends Command2 {
      constructor(options, callback) {
        super();
        this.sql = options.sql;
        this.values = options.values;
        this._queryOptions = options;
        this.namedPlaceholders = options.namedPlaceholders || false;
        this.onResult = callback;
        this.timeout = options.timeout;
        this.queryTimeout = null;
        this._fieldCount = 0;
        this._rowParser = null;
        this._fields = [];
        this._rows = [];
        this._receivedFieldsCount = 0;
        this._resultIndex = 0;
        this._localStream = null;
        this._unpipeStream = function() {
        };
        this._streamFactory = options.infileStreamFactory;
        this._connection = null;
      }
      then() {
        const err3 = "You have tried to call .then(), .catch(), or invoked await on the result of query that is not a promise, which is a programming error. Try calling con.promise().query(), or require('mysql2/promise') instead of 'mysql2' for a promise-compatible version of the query interface. To learn how to use async/await or Promises check out documentation at https://sidorares.github.io/node-mysql2/docs#using-promise-wrapper, or the mysql2 documentation at https://sidorares.github.io/node-mysql2/docs/documentation/promise-wrapper";
        console.log(err3);
        throw new Error(err3);
      }
      /* eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }] */
      start(_packet, connection2) {
        if (connection2.config.debug) {
          console.log("        Sending query command: %s", this.sql);
        }
        this._connection = connection2;
        this.options = Object.assign({}, connection2.config, this._queryOptions);
        this._setTimeout();
        const cmdPacket = new Packets.Query(
          this.sql,
          connection2.config.charsetNumber
        );
        connection2.writePacket(cmdPacket.toPacket(1));
        return _Query.prototype.resultsetHeader;
      }
      done() {
        this._unpipeStream();
        if (this.timeout && !this.queryTimeout) {
          return null;
        }
        if (this.queryTimeout) {
          Timers.clearTimeout(this.queryTimeout);
          this.queryTimeout = null;
        }
        if (this.onResult) {
          let rows, fields;
          if (this._resultIndex === 0) {
            rows = this._rows[0];
            fields = this._fields[0];
          } else {
            rows = this._rows;
            fields = this._fields;
          }
          if (fields) {
            process4.nextTick(() => {
              this.onResult(null, rows, fields);
            });
          } else {
            process4.nextTick(() => {
              this.onResult(null, rows);
            });
          }
        }
        return null;
      }
      doneInsert(rs3) {
        if (this._localStreamError) {
          if (this.onResult) {
            this.onResult(this._localStreamError, rs3);
          } else {
            this.emit("error", this._localStreamError);
          }
          return null;
        }
        this._rows.push(rs3);
        this._fields.push(void 0);
        this.emit("fields", void 0);
        this.emit("result", rs3);
        if (rs3.serverStatus & ServerStatus.SERVER_MORE_RESULTS_EXISTS) {
          this._resultIndex++;
          return this.resultsetHeader;
        }
        return this.done();
      }
      resultsetHeader(packet, connection2) {
        const rs3 = new Packets.ResultSetHeader(packet, connection2);
        this._fieldCount = rs3.fieldCount;
        if (connection2.config.debug) {
          console.log(
            `        Resultset header received, expecting ${rs3.fieldCount} column definition packets`
          );
        }
        if (this._fieldCount === 0) {
          return this.doneInsert(rs3);
        }
        if (this._fieldCount === null) {
          return this._streamLocalInfile(connection2, rs3.infileName);
        }
        this._receivedFieldsCount = 0;
        this._rows.push([]);
        this._fields.push([]);
        return this.readField;
      }
      _streamLocalInfile(connection2, path3) {
        if (this._streamFactory) {
          this._localStream = this._streamFactory(path3);
        } else {
          this._localStreamError = new Error(
            `As a result of LOCAL INFILE command server wants to read ${path3} file, but as of v2.0 you must provide streamFactory option returning ReadStream.`
          );
          connection2.writePacket(EmptyPacket);
          return this.infileOk;
        }
        const onConnectionError = () => {
          this._unpipeStream();
        };
        const onDrain = () => {
          this._localStream.resume();
        };
        const onPause = () => {
          this._localStream.pause();
        };
        const onData = function(data) {
          const dataWithHeader = Buffer.allocUnsafe(data.length + 4);
          data.copy(dataWithHeader, 4);
          connection2.writePacket(
            new Packets.Packet(0, dataWithHeader, 0, dataWithHeader.length)
          );
        };
        const onEnd = () => {
          connection2.removeListener("error", onConnectionError);
          connection2.writePacket(EmptyPacket);
        };
        const onError = (err3) => {
          this._localStreamError = err3;
          connection2.removeListener("error", onConnectionError);
          connection2.writePacket(EmptyPacket);
        };
        this._unpipeStream = () => {
          connection2.stream.removeListener("pause", onPause);
          connection2.stream.removeListener("drain", onDrain);
          this._localStream.removeListener("data", onData);
          this._localStream.removeListener("end", onEnd);
          this._localStream.removeListener("error", onError);
        };
        connection2.stream.on("pause", onPause);
        connection2.stream.on("drain", onDrain);
        this._localStream.on("data", onData);
        this._localStream.on("end", onEnd);
        this._localStream.on("error", onError);
        connection2.once("error", onConnectionError);
        return this.infileOk;
      }
      readField(packet, connection2) {
        this._receivedFieldsCount++;
        if (this._fields[this._resultIndex].length !== this._fieldCount) {
          const field = new Packets.ColumnDefinition(
            packet,
            connection2.clientEncoding
          );
          this._fields[this._resultIndex].push(field);
          if (connection2.config.debug) {
            console.log("        Column definition:");
            console.log(`          name: ${field.name}`);
            console.log(`          type: ${field.columnType}`);
            console.log(`         flags: ${field.flags}`);
          }
        }
        if (this._receivedFieldsCount === this._fieldCount) {
          const fields = this._fields[this._resultIndex];
          this.emit("fields", fields);
          if (this.options.disableEval) {
            this._rowParser = staticParser(fields, this.options, connection2.config);
          } else {
            this._rowParser = new (getTextParser(
              fields,
              this.options,
              connection2.config
            ))(fields);
          }
          return _Query.prototype.fieldsEOF;
        }
        return _Query.prototype.readField;
      }
      fieldsEOF(packet, connection2) {
        if (!packet.isEOF()) {
          return connection2.protocolError("Expected EOF packet");
        }
        return this.row;
      }
      /* eslint no-unused-vars: ["error", { "argsIgnorePattern": "^_" }] */
      row(packet, _connection) {
        if (packet.isEOF()) {
          const status = packet.eofStatusFlags();
          const moreResults = status & ServerStatus.SERVER_MORE_RESULTS_EXISTS;
          if (moreResults) {
            this._resultIndex++;
            return _Query.prototype.resultsetHeader;
          }
          return this.done();
        }
        let row;
        try {
          row = this._rowParser.next(
            packet,
            this._fields[this._resultIndex],
            this.options
          );
        } catch (err3) {
          this._localStreamError = err3;
          return this.doneInsert(null);
        }
        if (this.onResult) {
          this._rows[this._resultIndex].push(row);
        } else {
          this.emit("result", row, this._resultIndex);
        }
        return _Query.prototype.row;
      }
      infileOk(packet, connection2) {
        const rs3 = new Packets.ResultSetHeader(packet, connection2);
        return this.doneInsert(rs3);
      }
      stream(options) {
        options = options || {};
        options.objectMode = true;
        const stream = new Readable6(options);
        stream._read = () => {
          this._connection && this._connection.resume();
        };
        this.on("result", (row, resultSetIndex) => {
          if (!stream.push(row)) {
            this._connection.pause();
          }
          stream.emit("result", row, resultSetIndex);
        });
        this.on("error", (err3) => {
          stream.emit("error", err3);
        });
        this.on("end", () => {
          stream.push(null);
        });
        this.on("fields", (fields) => {
          stream.emit("fields", fields);
        });
        stream.on("end", () => {
          stream.emit("close");
        });
        return stream;
      }
      _setTimeout() {
        if (this.timeout) {
          const timeoutHandler = this._handleTimeoutError.bind(this);
          this.queryTimeout = Timers.setTimeout(timeoutHandler, this.timeout);
        }
      }
      _handleTimeoutError() {
        if (this.queryTimeout) {
          Timers.clearTimeout(this.queryTimeout);
          this.queryTimeout = null;
        }
        const err3 = new Error("Query inactivity timeout");
        err3.errorno = "PROTOCOL_SEQUENCE_TIMEOUT";
        err3.code = "PROTOCOL_SEQUENCE_TIMEOUT";
        err3.syscall = "query";
        if (this.onResult) {
          this.onResult(err3);
        } else {
          this.emit("error", err3);
        }
      }
    };
    Query3.prototype.catch = Query3.prototype.then;
    module2.exports = Query3;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/close_statement.js
var require_close_statement2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/close_statement.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var Packets = require_packets();
    var CloseStatement = class extends Command2 {
      constructor(id) {
        super();
        this.id = id;
      }
      start(packet, connection2) {
        connection2.writePacket(new Packets.CloseStatement(this.id).toPacket(1));
        return null;
      }
    };
    module2.exports = CloseStatement;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/binary_parser.js
var require_binary_parser = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/binary_parser.js"(exports2, module2) {
    "use strict";
    var FieldFlags = require_field_flags();
    var Charsets = require_charsets();
    var Types = require_types2();
    var helpers = require_helpers();
    var genFunc = require_generate_function();
    var parserCache = require_parser_cache();
    var typeNames = [];
    for (const t6 in Types) {
      typeNames[Types[t6]] = t6;
    }
    function readCodeFor(field, config, options, fieldNum) {
      const supportBigNumbers = Boolean(
        options.supportBigNumbers || config.supportBigNumbers
      );
      const bigNumberStrings = Boolean(
        options.bigNumberStrings || config.bigNumberStrings
      );
      const timezone = options.timezone || config.timezone;
      const dateStrings = options.dateStrings || config.dateStrings;
      const unsigned = field.flags & FieldFlags.UNSIGNED;
      switch (field.columnType) {
        case Types.TINY:
          return unsigned ? "packet.readInt8();" : "packet.readSInt8();";
        case Types.SHORT:
          return unsigned ? "packet.readInt16();" : "packet.readSInt16();";
        case Types.LONG:
        case Types.INT24:
          return unsigned ? "packet.readInt32();" : "packet.readSInt32();";
        case Types.YEAR:
          return "packet.readInt16()";
        case Types.FLOAT:
          return "packet.readFloat();";
        case Types.DOUBLE:
          return "packet.readDouble();";
        case Types.NULL:
          return "null;";
        case Types.DATE:
        case Types.DATETIME:
        case Types.TIMESTAMP:
        case Types.NEWDATE:
          if (helpers.typeMatch(field.columnType, dateStrings, Types)) {
            return `packet.readDateTimeString(${parseInt(field.decimals, 10)}, ${null}, ${field.columnType});`;
          }
          return `packet.readDateTime(${helpers.srcEscape(timezone)});`;
        case Types.TIME:
          return "packet.readTimeString()";
        case Types.DECIMAL:
        case Types.NEWDECIMAL:
          if (config.decimalNumbers) {
            return "packet.parseLengthCodedFloat();";
          }
          return 'packet.readLengthCodedString("ascii");';
        case Types.GEOMETRY:
          return "packet.parseGeometryValue();";
        case Types.VECTOR:
          return "packet.parseVector()";
        case Types.JSON:
          return config.jsonStrings ? 'packet.readLengthCodedString("utf8")' : 'JSON.parse(packet.readLengthCodedString("utf8"));';
        case Types.LONGLONG:
          if (!supportBigNumbers) {
            return unsigned ? "packet.readInt64JSNumber();" : "packet.readSInt64JSNumber();";
          }
          if (bigNumberStrings) {
            return unsigned ? "packet.readInt64String();" : "packet.readSInt64String();";
          }
          return unsigned ? "packet.readInt64();" : "packet.readSInt64();";
        default:
          if (field.characterSet === Charsets.BINARY) {
            return "packet.readLengthCodedBuffer();";
          }
          return `packet.readLengthCodedString(fields[${fieldNum}].encoding)`;
      }
    }
    function compile(fields, options, config) {
      const parserFn = genFunc();
      const nullBitmapLength = Math.floor((fields.length + 7 + 2) / 8);
      function wrap(field, packet) {
        return {
          type: typeNames[field.columnType],
          length: field.columnLength,
          db: field.schema,
          table: field.table,
          name: field.name,
          string: function(encoding = field.encoding) {
            if (field.columnType === Types.JSON && encoding === field.encoding) {
              console.warn(
                `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\``
              );
            }
            if ([Types.DATETIME, Types.NEWDATE, Types.TIMESTAMP, Types.DATE].includes(
              field.columnType
            )) {
              return packet.readDateTimeString(parseInt(field.decimals, 10));
            }
            if (field.columnType === Types.TINY) {
              const unsigned = field.flags & FieldFlags.UNSIGNED;
              return String(unsigned ? packet.readInt8() : packet.readSInt8());
            }
            if (field.columnType === Types.TIME) {
              return packet.readTimeString();
            }
            return packet.readLengthCodedString(encoding);
          },
          buffer: function() {
            return packet.readLengthCodedBuffer();
          },
          geometry: function() {
            return packet.parseGeometryValue();
          }
        };
      }
      parserFn("(function(){");
      parserFn("return class BinaryRow {");
      parserFn("constructor() {");
      parserFn("}");
      parserFn("next(packet, fields, options) {");
      if (options.rowsAsArray) {
        parserFn(`const result = new Array(${fields.length});`);
      } else {
        parserFn("const result = {};");
      }
      if (typeof config.typeCast === "function" && typeof options.typeCast !== "function") {
        options.typeCast = config.typeCast;
      }
      parserFn("packet.readInt8();");
      for (let i8 = 0; i8 < nullBitmapLength; ++i8) {
        parserFn(`const nullBitmaskByte${i8} = packet.readInt8();`);
      }
      let lvalue = "";
      let currentFieldNullBit = 4;
      let nullByteIndex = 0;
      let fieldName = "";
      let tableName = "";
      for (let i8 = 0; i8 < fields.length; i8++) {
        fieldName = helpers.fieldEscape(fields[i8].name);
        if (typeof options.nestTables === "string") {
          lvalue = `result[${helpers.fieldEscape(fields[i8].table + options.nestTables + fields[i8].name)}]`;
        } else if (options.nestTables === true) {
          tableName = helpers.fieldEscape(fields[i8].table);
          parserFn(`if (!result[${tableName}]) result[${tableName}] = {};`);
          lvalue = `result[${tableName}][${fieldName}]`;
        } else if (options.rowsAsArray) {
          lvalue = `result[${i8.toString(10)}]`;
        } else {
          lvalue = `result[${fieldName}]`;
        }
        parserFn(`if (nullBitmaskByte${nullByteIndex} & ${currentFieldNullBit}) `);
        parserFn(`${lvalue} = null;`);
        parserFn("else {");
        if (options.typeCast === false) {
          parserFn(`${lvalue} = packet.readLengthCodedBuffer();`);
        } else {
          const fieldWrapperVar = `fieldWrapper${i8}`;
          parserFn(`const ${fieldWrapperVar} = wrap(fields[${i8}], packet);`);
          const readCode = readCodeFor(fields[i8], config, options, i8);
          if (typeof options.typeCast === "function") {
            parserFn(
              `${lvalue} = options.typeCast(${fieldWrapperVar}, function() { return ${readCode} });`
            );
          } else {
            parserFn(`${lvalue} = ${readCode};`);
          }
        }
        parserFn("}");
        currentFieldNullBit *= 2;
        if (currentFieldNullBit === 256) {
          currentFieldNullBit = 1;
          nullByteIndex++;
        }
      }
      parserFn("return result;");
      parserFn("}");
      parserFn("};")("})()");
      if (config.debug) {
        helpers.printDebugWithCode(
          "Compiled binary protocol row parser",
          parserFn.toString()
        );
      }
      return parserFn.toFunction({ wrap });
    }
    function getBinaryParser(fields, options, config) {
      return parserCache.getParser("binary", fields, options, config, compile);
    }
    module2.exports = getBinaryParser;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/static_binary_parser.js
var require_static_binary_parser = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/parsers/static_binary_parser.js"(exports2, module2) {
    "use strict";
    var FieldFlags = require_field_flags();
    var Charsets = require_charsets();
    var Types = require_types2();
    var helpers = require_helpers();
    var typeNames = [];
    for (const t6 in Types) {
      typeNames[Types[t6]] = t6;
    }
    function getBinaryParser(fields, _options2, config) {
      function readCode(field, config2, options, fieldNum, packet) {
        const supportBigNumbers = Boolean(
          options.supportBigNumbers || config2.supportBigNumbers
        );
        const bigNumberStrings = Boolean(
          options.bigNumberStrings || config2.bigNumberStrings
        );
        const timezone = options.timezone || config2.timezone;
        const dateStrings = options.dateStrings || config2.dateStrings;
        const unsigned = field.flags & FieldFlags.UNSIGNED;
        switch (field.columnType) {
          case Types.TINY:
            return unsigned ? packet.readInt8() : packet.readSInt8();
          case Types.SHORT:
            return unsigned ? packet.readInt16() : packet.readSInt16();
          case Types.LONG:
          case Types.INT24:
            return unsigned ? packet.readInt32() : packet.readSInt32();
          case Types.YEAR:
            return packet.readInt16();
          case Types.FLOAT:
            return packet.readFloat();
          case Types.DOUBLE:
            return packet.readDouble();
          case Types.NULL:
            return null;
          case Types.DATE:
          case Types.DATETIME:
          case Types.TIMESTAMP:
          case Types.NEWDATE:
            return helpers.typeMatch(field.columnType, dateStrings, Types) ? packet.readDateTimeString(
              parseInt(field.decimals, 10),
              null,
              field.columnType
            ) : packet.readDateTime(timezone);
          case Types.TIME:
            return packet.readTimeString();
          case Types.DECIMAL:
          case Types.NEWDECIMAL:
            return config2.decimalNumbers ? packet.parseLengthCodedFloat() : packet.readLengthCodedString("ascii");
          case Types.GEOMETRY:
            return packet.parseGeometryValue();
          case Types.VECTOR:
            return packet.parseVector();
          case Types.JSON:
            return config2.jsonStrings ? packet.readLengthCodedString("utf8") : JSON.parse(packet.readLengthCodedString("utf8"));
          case Types.LONGLONG:
            if (!supportBigNumbers)
              return unsigned ? packet.readInt64JSNumber() : packet.readSInt64JSNumber();
            return bigNumberStrings ? unsigned ? packet.readInt64String() : packet.readSInt64String() : unsigned ? packet.readInt64() : packet.readSInt64();
          default:
            return field.characterSet === Charsets.BINARY ? packet.readLengthCodedBuffer() : packet.readLengthCodedString(fields[fieldNum].encoding);
        }
      }
      return class BinaryRow {
        constructor() {
        }
        next(packet, fields2, options) {
          packet.readInt8();
          const nullBitmapLength = Math.floor((fields2.length + 7 + 2) / 8);
          const nullBitmaskBytes = new Array(nullBitmapLength);
          for (let i8 = 0; i8 < nullBitmapLength; i8++) {
            nullBitmaskBytes[i8] = packet.readInt8();
          }
          const result = options.rowsAsArray ? new Array(fields2.length) : {};
          let currentFieldNullBit = 4;
          let nullByteIndex = 0;
          for (let i8 = 0; i8 < fields2.length; i8++) {
            const field = fields2[i8];
            const typeCast = options.typeCast !== void 0 ? options.typeCast : config.typeCast;
            let value;
            if (nullBitmaskBytes[nullByteIndex] & currentFieldNullBit) {
              value = null;
            } else if (options.typeCast === false) {
              value = packet.readLengthCodedBuffer();
            } else {
              const next = () => readCode(field, config, options, i8, packet);
              value = typeof typeCast === "function" ? typeCast(
                {
                  type: typeNames[field.columnType],
                  length: field.columnLength,
                  db: field.schema,
                  table: field.table,
                  name: field.name,
                  string: function(encoding = field.encoding) {
                    if (field.columnType === Types.JSON && encoding === field.encoding) {
                      console.warn(
                        `typeCast: JSON column "${field.name}" is interpreted as BINARY by default, recommended to manually set utf8 encoding: \`field.string("utf8")\``
                      );
                    }
                    if ([
                      Types.DATETIME,
                      Types.NEWDATE,
                      Types.TIMESTAMP,
                      Types.DATE
                    ].includes(field.columnType)) {
                      return packet.readDateTimeString(
                        parseInt(field.decimals, 10)
                      );
                    }
                    if (field.columnType === Types.TINY) {
                      const unsigned = field.flags & FieldFlags.UNSIGNED;
                      return String(
                        unsigned ? packet.readInt8() : packet.readSInt8()
                      );
                    }
                    if (field.columnType === Types.TIME) {
                      return packet.readTimeString();
                    }
                    return packet.readLengthCodedString(encoding);
                  },
                  buffer: function() {
                    return packet.readLengthCodedBuffer();
                  },
                  geometry: function() {
                    return packet.parseGeometryValue();
                  }
                },
                next
              ) : next();
            }
            if (options.rowsAsArray) {
              result[i8] = value;
            } else if (typeof options.nestTables === "string") {
              const key = helpers.fieldEscape(
                field.table + options.nestTables + field.name,
                false
              );
              result[key] = value;
            } else if (options.nestTables === true) {
              const tableName = helpers.fieldEscape(field.table, false);
              if (!result[tableName]) {
                result[tableName] = {};
              }
              const fieldName = helpers.fieldEscape(field.name, false);
              result[tableName][fieldName] = value;
            } else {
              const key = helpers.fieldEscape(field.name, false);
              result[key] = value;
            }
            currentFieldNullBit *= 2;
            if (currentFieldNullBit === 256) {
              currentFieldNullBit = 1;
              nullByteIndex++;
            }
          }
          return result;
        }
      };
    }
    module2.exports = getBinaryParser;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/execute.js
var require_execute2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/execute.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var Query3 = require_query4();
    var Packets = require_packets();
    var getBinaryParser = require_binary_parser();
    var getStaticBinaryParser = require_static_binary_parser();
    var Execute = class _Execute extends Command2 {
      constructor(options, callback) {
        super();
        this.statement = options.statement;
        this.sql = options.sql;
        this.values = options.values;
        this.onResult = callback;
        this.parameters = options.values;
        this.insertId = 0;
        this.timeout = options.timeout;
        this.queryTimeout = null;
        this._rows = [];
        this._fields = [];
        this._result = [];
        this._fieldCount = 0;
        this._rowParser = null;
        this._executeOptions = options;
        this._resultIndex = 0;
        this._localStream = null;
        this._unpipeStream = function() {
        };
        this._streamFactory = options.infileStreamFactory;
        this._connection = null;
      }
      buildParserFromFields(fields, connection2) {
        if (this.options.disableEval) {
          return getStaticBinaryParser(fields, this.options, connection2.config);
        }
        return getBinaryParser(fields, this.options, connection2.config);
      }
      start(packet, connection2) {
        this._connection = connection2;
        this.options = Object.assign({}, connection2.config, this._executeOptions);
        this._setTimeout();
        const executePacket = new Packets.Execute(
          this.statement.id,
          this.parameters,
          connection2.config.charsetNumber,
          connection2.config.timezone
        );
        try {
          connection2.writePacket(executePacket.toPacket(1));
        } catch (error2) {
          this.onResult(error2);
        }
        return _Execute.prototype.resultsetHeader;
      }
      readField(packet, connection2) {
        let fields;
        const field = new Packets.ColumnDefinition(
          packet,
          connection2.clientEncoding
        );
        this._receivedFieldsCount++;
        this._fields[this._resultIndex].push(field);
        if (this._receivedFieldsCount === this._fieldCount) {
          fields = this._fields[this._resultIndex];
          this.emit("fields", fields, this._resultIndex);
          return _Execute.prototype.fieldsEOF;
        }
        return _Execute.prototype.readField;
      }
      fieldsEOF(packet, connection2) {
        if (!packet.isEOF()) {
          return connection2.protocolError("Expected EOF packet");
        }
        this._rowParser = new (this.buildParserFromFields(
          this._fields[this._resultIndex],
          connection2
        ))();
        return _Execute.prototype.row;
      }
    };
    Execute.prototype.done = Query3.prototype.done;
    Execute.prototype.doneInsert = Query3.prototype.doneInsert;
    Execute.prototype.resultsetHeader = Query3.prototype.resultsetHeader;
    Execute.prototype._findOrCreateReadStream = Query3.prototype._findOrCreateReadStream;
    Execute.prototype._streamLocalInfile = Query3.prototype._streamLocalInfile;
    Execute.prototype._setTimeout = Query3.prototype._setTimeout;
    Execute.prototype._handleTimeoutError = Query3.prototype._handleTimeoutError;
    Execute.prototype.row = Query3.prototype.row;
    Execute.prototype.stream = Query3.prototype.stream;
    module2.exports = Execute;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/prepare.js
var require_prepare = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/prepare.js"(exports2, module2) {
    "use strict";
    var Packets = require_packets();
    var Command2 = require_command();
    var CloseStatement = require_close_statement2();
    var Execute = require_execute2();
    var PreparedStatementInfo = class {
      constructor(query, id, columns, parameters, connection2) {
        this.query = query;
        this.id = id;
        this.columns = columns;
        this.parameters = parameters;
        this.rowParser = null;
        this._connection = connection2;
      }
      close() {
        return this._connection.addCommand(new CloseStatement(this.id));
      }
      execute(parameters, callback) {
        if (typeof parameters === "function") {
          callback = parameters;
          parameters = [];
        }
        return this._connection.addCommand(
          new Execute({ statement: this, values: parameters }, callback)
        );
      }
    };
    var Prepare = class _Prepare extends Command2 {
      constructor(options, callback) {
        super();
        this.query = options.sql;
        this.onResult = callback;
        this.id = 0;
        this.fieldCount = 0;
        this.parameterCount = 0;
        this.fields = [];
        this.parameterDefinitions = [];
        this.options = options;
      }
      start(packet, connection2) {
        const Connection4 = connection2.constructor;
        this.key = Connection4.statementKey(this.options);
        const statement = connection2._statements.get(this.key);
        if (statement) {
          if (this.onResult) {
            this.onResult(null, statement);
          }
          return null;
        }
        const cmdPacket = new Packets.PrepareStatement(
          this.query,
          connection2.config.charsetNumber,
          this.options.values
        );
        connection2.writePacket(cmdPacket.toPacket(1));
        return _Prepare.prototype.prepareHeader;
      }
      prepareHeader(packet, connection2) {
        const header = new Packets.PreparedStatementHeader(packet);
        this.id = header.id;
        this.fieldCount = header.fieldCount;
        this.parameterCount = header.parameterCount;
        if (this.parameterCount > 0) {
          return _Prepare.prototype.readParameter;
        }
        if (this.fieldCount > 0) {
          return _Prepare.prototype.readField;
        }
        return this.prepareDone(connection2);
      }
      readParameter(packet, connection2) {
        if (packet.isEOF()) {
          if (this.fieldCount > 0) {
            return _Prepare.prototype.readField;
          }
          return this.prepareDone(connection2);
        }
        const def = new Packets.ColumnDefinition(packet, connection2.clientEncoding);
        this.parameterDefinitions.push(def);
        if (this.parameterDefinitions.length === this.parameterCount) {
          return _Prepare.prototype.parametersEOF;
        }
        return this.readParameter;
      }
      readField(packet, connection2) {
        if (packet.isEOF()) {
          return this.prepareDone(connection2);
        }
        const def = new Packets.ColumnDefinition(packet, connection2.clientEncoding);
        this.fields.push(def);
        if (this.fields.length === this.fieldCount) {
          return _Prepare.prototype.fieldsEOF;
        }
        return _Prepare.prototype.readField;
      }
      parametersEOF(packet, connection2) {
        if (!packet.isEOF()) {
          return connection2.protocolError("Expected EOF packet after parameters");
        }
        if (this.fieldCount > 0) {
          return _Prepare.prototype.readField;
        }
        return this.prepareDone(connection2);
      }
      fieldsEOF(packet, connection2) {
        if (!packet.isEOF()) {
          return connection2.protocolError("Expected EOF packet after fields");
        }
        return this.prepareDone(connection2);
      }
      prepareDone(connection2) {
        const statement = new PreparedStatementInfo(
          this.query,
          this.id,
          this.fields,
          this.parameterDefinitions,
          connection2
        );
        connection2._statements.set(this.key, statement);
        if (this.onResult) {
          this.onResult(null, statement);
        }
        return null;
      }
    };
    module2.exports = Prepare;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/ping.js
var require_ping = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/ping.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var CommandCode = require_commands();
    var Packet = require_packet();
    var Ping = class _Ping extends Command2 {
      constructor(callback) {
        super();
        this.onResult = callback;
      }
      start(packet, connection2) {
        const ping = new Packet(
          0,
          Buffer.from([1, 0, 0, 0, CommandCode.PING]),
          0,
          5
        );
        connection2.writePacket(ping);
        return _Ping.prototype.pingResponse;
      }
      pingResponse() {
        if (this.onResult) {
          process.nextTick(this.onResult.bind(this));
        }
        return null;
      }
    };
    module2.exports = Ping;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/register_slave.js
var require_register_slave2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/register_slave.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var Packets = require_packets();
    var RegisterSlave = class _RegisterSlave extends Command2 {
      constructor(opts, callback) {
        super();
        this.onResult = callback;
        this.opts = opts;
      }
      start(packet, connection2) {
        const newPacket = new Packets.RegisterSlave(this.opts);
        connection2.writePacket(newPacket.toPacket(1));
        return _RegisterSlave.prototype.registerResponse;
      }
      registerResponse() {
        if (this.onResult) {
          process.nextTick(this.onResult.bind(this));
        }
        return null;
      }
    };
    module2.exports = RegisterSlave;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/binlog_query_statusvars.js
var require_binlog_query_statusvars = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/packets/binlog_query_statusvars.js"(exports2, module2) {
    "use strict";
    var keys = {
      FLAGS2: 0,
      SQL_MODE: 1,
      CATALOG: 2,
      AUTO_INCREMENT: 3,
      CHARSET: 4,
      TIME_ZONE: 5,
      CATALOG_NZ: 6,
      LC_TIME_NAMES: 7,
      CHARSET_DATABASE: 8,
      TABLE_MAP_FOR_UPDATE: 9,
      MASTER_DATA_WRITTEN: 10,
      INVOKERS: 11,
      UPDATED_DB_NAMES: 12,
      MICROSECONDS: 3
    };
    module2.exports = function parseStatusVars(buffer2) {
      const result = {};
      let offset = 0;
      let key, length, prevOffset;
      while (offset < buffer2.length) {
        key = buffer2[offset++];
        switch (key) {
          case keys.FLAGS2:
            result.flags = buffer2.readUInt32LE(offset);
            offset += 4;
            break;
          case keys.SQL_MODE:
            result.sqlMode = buffer2.readUInt32LE(offset);
            offset += 8;
            break;
          case keys.CATALOG:
            length = buffer2[offset++];
            result.catalog = buffer2.toString("utf8", offset, offset + length);
            offset += length + 1;
            break;
          case keys.CHARSET:
            result.clientCharset = buffer2.readUInt16LE(offset);
            result.connectionCollation = buffer2.readUInt16LE(offset + 2);
            result.serverCharset = buffer2.readUInt16LE(offset + 4);
            offset += 6;
            break;
          case keys.TIME_ZONE:
            length = buffer2[offset++];
            result.timeZone = buffer2.toString("utf8", offset, offset + length);
            offset += length;
            break;
          case keys.CATALOG_NZ:
            length = buffer2[offset++];
            result.catalogNz = buffer2.toString("utf8", offset, offset + length);
            offset += length;
            break;
          case keys.LC_TIME_NAMES:
            result.lcTimeNames = buffer2.readUInt16LE(offset);
            offset += 2;
            break;
          case keys.CHARSET_DATABASE:
            result.schemaCharset = buffer2.readUInt16LE(offset);
            offset += 2;
            break;
          case keys.TABLE_MAP_FOR_UPDATE:
            result.mapForUpdate1 = buffer2.readUInt32LE(offset);
            result.mapForUpdate2 = buffer2.readUInt32LE(offset + 4);
            offset += 8;
            break;
          case keys.MASTER_DATA_WRITTEN:
            result.masterDataWritten = buffer2.readUInt32LE(offset);
            offset += 4;
            break;
          case keys.INVOKERS:
            length = buffer2[offset++];
            result.invokerUsername = buffer2.toString(
              "utf8",
              offset,
              offset + length
            );
            offset += length;
            length = buffer2[offset++];
            result.invokerHostname = buffer2.toString(
              "utf8",
              offset,
              offset + length
            );
            offset += length;
            break;
          case keys.UPDATED_DB_NAMES:
            length = buffer2[offset++];
            result.updatedDBs = [];
            for (; length; --length) {
              prevOffset = offset;
              while (buffer2[offset++] && offset < buffer2.length) {
              }
              result.updatedDBs.push(
                buffer2.toString("utf8", prevOffset, offset - 1)
              );
            }
            break;
          case keys.MICROSECONDS:
            result.microseconds = // REVIEW: INVALID UNKNOWN VARIABLE!
            buffer2.readInt16LE(offset) + (buffer2[offset + 2] << 16);
            offset += 3;
        }
      }
      return result;
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/binlog_dump.js
var require_binlog_dump2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/binlog_dump.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var Packets = require_packets();
    var eventParsers = [];
    var BinlogEventHeader = class {
      constructor(packet) {
        this.timestamp = packet.readInt32();
        this.eventType = packet.readInt8();
        this.serverId = packet.readInt32();
        this.eventSize = packet.readInt32();
        this.logPos = packet.readInt32();
        this.flags = packet.readInt16();
      }
    };
    var BinlogDump = class _BinlogDump extends Command2 {
      constructor(opts) {
        super();
        this.opts = opts;
      }
      start(packet, connection2) {
        const newPacket = new Packets.BinlogDump(this.opts);
        connection2.writePacket(newPacket.toPacket(1));
        return _BinlogDump.prototype.binlogData;
      }
      binlogData(packet) {
        if (packet.isEOF()) {
          this.emit("eof");
          return null;
        }
        packet.readInt8();
        const header = new BinlogEventHeader(packet);
        const EventParser = eventParsers[header.eventType];
        let event;
        if (EventParser) {
          event = new EventParser(packet);
        } else {
          event = {
            name: "UNKNOWN"
          };
        }
        event.header = header;
        this.emit("event", event);
        return _BinlogDump.prototype.binlogData;
      }
    };
    var RotateEvent = class {
      constructor(packet) {
        this.pposition = packet.readInt32();
        packet.readInt32();
        this.nextBinlog = packet.readString();
        this.name = "RotateEvent";
      }
    };
    var FormatDescriptionEvent = class {
      constructor(packet) {
        this.binlogVersion = packet.readInt16();
        this.serverVersion = packet.readString(50).replace(/\u0000.*/, "");
        this.createTimestamp = packet.readInt32();
        this.eventHeaderLength = packet.readInt8();
        this.eventsLength = packet.readBuffer();
        this.name = "FormatDescriptionEvent";
      }
    };
    var QueryEvent = class {
      constructor(packet) {
        const parseStatusVars = require_binlog_query_statusvars();
        this.slaveProxyId = packet.readInt32();
        this.executionTime = packet.readInt32();
        const schemaLength = packet.readInt8();
        this.errorCode = packet.readInt16();
        const statusVarsLength = packet.readInt16();
        const statusVars = packet.readBuffer(statusVarsLength);
        this.schema = packet.readString(schemaLength);
        packet.readInt8();
        this.statusVars = parseStatusVars(statusVars);
        this.query = packet.readString();
        this.name = "QueryEvent";
      }
    };
    var XidEvent = class {
      constructor(packet) {
        this.binlogVersion = packet.readInt16();
        this.xid = packet.readInt64();
        this.name = "XidEvent";
      }
    };
    eventParsers[2] = QueryEvent;
    eventParsers[4] = RotateEvent;
    eventParsers[15] = FormatDescriptionEvent;
    eventParsers[16] = XidEvent;
    module2.exports = BinlogDump;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/change_user.js
var require_change_user2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/change_user.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var Packets = require_packets();
    var ClientConstants = require_client3();
    var ClientHandshake = require_client_handshake();
    var CharsetToEncoding = require_charset_encodings();
    var ChangeUser = class _ChangeUser extends Command2 {
      constructor(options, callback) {
        super();
        this.onResult = callback;
        this.user = options.user;
        this.password = options.password;
        this.password1 = options.password;
        this.password2 = options.password2;
        this.password3 = options.password3;
        this.database = options.database;
        this.passwordSha1 = options.passwordSha1;
        this.charsetNumber = options.charsetNumber;
        this.currentConfig = options.currentConfig;
        this.authenticationFactor = 0;
      }
      start(packet, connection2) {
        const newPacket = new Packets.ChangeUser({
          flags: connection2.config.clientFlags,
          user: this.user,
          database: this.database,
          charsetNumber: this.charsetNumber,
          password: this.password,
          passwordSha1: this.passwordSha1,
          authPluginData1: connection2._handshakePacket.authPluginData1,
          authPluginData2: connection2._handshakePacket.authPluginData2
        });
        this.currentConfig.user = this.user;
        this.currentConfig.password = this.password;
        this.currentConfig.database = this.database;
        this.currentConfig.charsetNumber = this.charsetNumber;
        connection2.clientEncoding = CharsetToEncoding[this.charsetNumber];
        connection2._statements.clear();
        connection2.writePacket(newPacket.toPacket());
        const multiFactorAuthentication = connection2.serverCapabilityFlags & ClientConstants.MULTI_FACTOR_AUTHENTICATION;
        if (multiFactorAuthentication) {
          this.authenticationFactor = 1;
        }
        return _ChangeUser.prototype.handshakeResult;
      }
    };
    ChangeUser.prototype.handshakeResult = ClientHandshake.prototype.handshakeResult;
    ChangeUser.prototype.calculateNativePasswordAuthToken = ClientHandshake.prototype.calculateNativePasswordAuthToken;
    module2.exports = ChangeUser;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/quit.js
var require_quit = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/quit.js"(exports2, module2) {
    "use strict";
    var Command2 = require_command();
    var CommandCode = require_commands();
    var Packet = require_packet();
    var Quit = class extends Command2 {
      constructor(callback) {
        super();
        this.onResult = callback;
      }
      start(packet, connection2) {
        connection2._closing = true;
        const quit = new Packet(
          0,
          Buffer.from([1, 0, 0, 0, CommandCode.QUIT]),
          0,
          5
        );
        if (this.onResult) {
          this.onResult();
        }
        connection2.writePacket(quit);
        return null;
      }
    };
    module2.exports = Quit;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/index.js
var require_commands2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/commands/index.js"(exports2, module2) {
    "use strict";
    var ClientHandshake = require_client_handshake();
    var ServerHandshake = require_server_handshake();
    var Query3 = require_query4();
    var Prepare = require_prepare();
    var CloseStatement = require_close_statement2();
    var Execute = require_execute2();
    var Ping = require_ping();
    var RegisterSlave = require_register_slave2();
    var BinlogDump = require_binlog_dump2();
    var ChangeUser = require_change_user2();
    var Quit = require_quit();
    module2.exports = {
      ClientHandshake,
      ServerHandshake,
      Query: Query3,
      Prepare,
      CloseStatement,
      Execute,
      Ping,
      RegisterSlave,
      BinlogDump,
      ChangeUser,
      Quit
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/package.json
var require_package = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/package.json"(exports2, module2) {
    module2.exports = {
      name: "mysql2",
      version: "3.14.1",
      description: "fast mysql driver. Implements core protocol, prepared statements, ssl and compression in native JS",
      main: "index.js",
      typings: "typings/mysql/index",
      type: "commonjs",
      scripts: {
        lint: "eslint . && prettier --check .",
        "lint:fix": "eslint . --fix && prettier --write .",
        test: "poku -d -r=verbose --sequential test/esm test/unit test/integration",
        "test:bun": "bun poku -d --sequential test/esm test/unit test/integration",
        "test:deno": 'deno run --allow-read --allow-env --allow-run npm:poku -d --sequential --denoAllow="read,env,net,sys" test/esm test/unit test/integration',
        "test:tsc-build": 'cd "test/tsc-build" && npx tsc -p "tsconfig.json"',
        "coverage-test": "c8 npm run test",
        benchmark: "node ./benchmarks/benchmark.js",
        "wait-port": "wait-on"
      },
      repository: {
        type: "git",
        url: "git+https://github.com/sidorares/node-mysql2.git"
      },
      homepage: "https://sidorares.github.io/node-mysql2/docs",
      keywords: [
        "mysql",
        "client",
        "server"
      ],
      files: [
        "lib",
        "typings/mysql",
        "index.js",
        "index.d.ts",
        "promise.js",
        "promise.d.ts"
      ],
      exports: {
        ".": "./index.js",
        "./package.json": "./package.json",
        "./promise": "./promise.js",
        "./promise.js": "./promise.js"
      },
      engines: {
        node: ">= 8.0"
      },
      author: "Andrey Sidorov <andrey.sidorov@gmail.com>",
      license: "MIT",
      dependencies: {
        "aws-ssl-profiles": "^1.1.1",
        denque: "^2.1.0",
        "generate-function": "^2.3.1",
        "iconv-lite": "^0.6.3",
        long: "^5.2.1",
        "lru.min": "^1.0.0",
        "named-placeholders": "^1.1.3",
        "seq-queue": "^0.0.5",
        sqlstring: "^2.3.2"
      },
      devDependencies: {
        "@eslint/eslintrc": "^3.3.0",
        "@eslint/js": "^9.21.0",
        "@eslint/markdown": "^6.2.2",
        "@types/node": "^22.0.0",
        "@typescript-eslint/eslint-plugin": "^8.26.0",
        "@typescript-eslint/parser": "^8.26.0",
        "assert-diff": "^3.0.2",
        benchmark: "^2.1.4",
        c8: "^10.1.1",
        "error-stack-parser": "^2.0.3",
        "eslint-config-prettier": "^10.0.2",
        "eslint-plugin-async-await": "^0.0.0",
        "eslint-plugin-markdown": "^5.1.0",
        "eslint-plugin-prettier": "^5.2.3",
        globals: "^16.0.0",
        poku: "^3.0.0",
        portfinder: "^1.0.28",
        prettier: "^3.0.0",
        typescript: "^5.0.2"
      }
    };
  }
});

// ../node_modules/.pnpm/aws-ssl-profiles@1.1.2/node_modules/aws-ssl-profiles/lib/profiles/ca/defaults.js
var require_defaults2 = __commonJS({
  "../node_modules/.pnpm/aws-ssl-profiles@1.1.2/node_modules/aws-ssl-profiles/lib/profiles/ca/defaults.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.defaults = void 0;
    exports2.defaults = [
      "-----BEGIN CERTIFICATE-----\nMIIEEjCCAvqgAwIBAgIJAM2ZN/+nPi27MA0GCSqGSIb3DQEBCwUAMIGVMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEmMCQGA1UEAwwdQW1hem9uIFJEUyBhZi1zb3V0aC0xIFJvb3QgQ0Ew\nHhcNMTkxMDI4MTgwNTU4WhcNMjQxMDI2MTgwNTU4WjCBlTELMAkGA1UEBhMCVVMx\nEDAOBgNVBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoM\nGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\nJjAkBgNVBAMMHUFtYXpvbiBSRFMgYWYtc291dGgtMSBSb290IENBMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwR2351uPMZaJk2gMGT+1sk8HE9MQh2rc\n/sCnbxGn2p1c7Oi9aBbd/GiFijeJb2BXvHU+TOq3d3Jjqepq8tapXVt4ojbTJNyC\nJ5E7r7KjTktKdLxtBE1MK25aY+IRJjtdU6vG3KiPKUT1naO3xs3yt0F76WVuFivd\n9OHv2a+KHvPkRUWIxpmAHuMY9SIIMmEZtVE7YZGx5ah0iO4JzItHcbVR0y0PBH55\narpFBddpIVHCacp1FUPxSEWkOpI7q0AaU4xfX0fe1BV5HZYRKpBOIp1TtZWvJD+X\njGUtL1BEsT5vN5g9MkqdtYrC+3SNpAk4VtpvJrdjraI/hhvfeXNnAwIDAQABo2Mw\nYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUEEi/\nWWMcBJsoGXg+EZwkQ0MscZQwHwYDVR0jBBgwFoAUEEi/WWMcBJsoGXg+EZwkQ0Ms\ncZQwDQYJKoZIhvcNAQELBQADggEBAGDZ5js5Pc/gC58LJrwMPXFhJDBS8QuDm23C\nFFUdlqucskwOS3907ErK1ZkmVJCIqFLArHqskFXMAkRZ2PNR7RjWLqBs+0znG5yH\nhRKb4DXzhUFQ18UBRcvT6V6zN97HTRsEEaNhM/7k8YLe7P8vfNZ28VIoJIGGgv9D\nwQBBvkxQ71oOmAG0AwaGD0ORGUfbYry9Dz4a4IcUsZyRWRMADixgrFv6VuETp26s\n/+z+iqNaGWlELBKh3iQCT6Y/1UnkPLO42bxrCSyOvshdkYN58Q2gMTE1SVTqyo8G\nLw8lLAz9bnvUSgHzB3jRrSx6ggF/WRMRYlR++y6LXP4SAsSAaC0=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEEjCCAvqgAwIBAgIJAJYM4LxvTZA6MA0GCSqGSIb3DQEBCwUAMIGVMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEmMCQGA1UEAwwdQW1hem9uIFJEUyBldS1zb3V0aC0xIFJvb3QgQ0Ew\nHhcNMTkxMDMwMjAyMDM2WhcNMjQxMDI4MjAyMDM2WjCBlTELMAkGA1UEBhMCVVMx\nEDAOBgNVBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoM\nGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\nJjAkBgNVBAMMHUFtYXpvbiBSRFMgZXUtc291dGgtMSBSb290IENBMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAqM921jXCXeqpRNCS9CBPOe5N7gMaEt+D\ns5uR3riZbqzRlHGiF1jZihkXfHAIQewDwy+Yz+Oec1aEZCQMhUHxZJPusuX0cJfj\nb+UluFqHIijL2TfXJ3D0PVLLoNTQJZ8+GAPECyojAaNuoHbdVqxhOcznMsXIXVFq\nyVLKDGvyKkJjai/iSPDrQMXufg3kWt0ISjNLvsG5IFXgP4gttsM8i0yvRd4QcHoo\nDjvH7V3cS+CQqW5SnDrGnHToB0RLskE1ET+oNOfeN9PWOxQprMOX/zmJhnJQlTqD\nQP7jcf7SddxrKFjuziFiouskJJyNDsMjt1Lf60+oHZhed2ogTeifGwIDAQABo2Mw\nYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUFBAF\ncgJe/BBuZiGeZ8STfpkgRYQwHwYDVR0jBBgwFoAUFBAFcgJe/BBuZiGeZ8STfpkg\nRYQwDQYJKoZIhvcNAQELBQADggEBAKAYUtlvDuX2UpZW9i1QgsjFuy/ErbW0dLHU\ne/IcFtju2z6RLZ+uF+5A8Kme7IKG1hgt8s+w9TRVQS/7ukQzoK3TaN6XKXRosjtc\no9Rm4gYWM8bmglzY1TPNaiI4HC7546hSwJhubjN0bXCuj/0sHD6w2DkiGuwKNAef\nyTu5vZhPkeNyXLykxkzz7bNp2/PtMBnzIp+WpS7uUDmWyScGPohKMq5PqvL59z+L\nZI3CYeMZrJ5VpXUg3fNNIz/83N3G0sk7wr0ohs/kHTP7xPOYB0zD7Ku4HA0Q9Swf\nWX0qr6UQgTPMjfYDLffI7aEId0gxKw1eGYc6Cq5JAZ3ipi/cBFc=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEEjCCAvqgAwIBAgIJANew34ehz5l8MA0GCSqGSIb3DQEBCwUAMIGVMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEmMCQGA1UEAwwdQW1hem9uIFJEUyBtZS1zb3V0aC0xIFJvb3QgQ0Ew\nHhcNMTkwNTEwMjE0ODI3WhcNMjQwNTA4MjE0ODI3WjCBlTELMAkGA1UEBhMCVVMx\nEDAOBgNVBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoM\nGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMx\nJjAkBgNVBAMMHUFtYXpvbiBSRFMgbWUtc291dGgtMSBSb290IENBMIIBIjANBgkq\nhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAp7BYV88MukcY+rq0r79+C8UzkT30fEfT\naPXbx1d6M7uheGN4FMaoYmL+JE1NZPaMRIPTHhFtLSdPccInvenRDIatcXX+jgOk\nUA6lnHQ98pwN0pfDUyz/Vph4jBR9LcVkBbe0zdoKKp+HGbMPRU0N2yNrog9gM5O8\ngkU/3O2csJ/OFQNnj4c2NQloGMUpEmedwJMOyQQfcUyt9CvZDfIPNnheUS29jGSw\nERpJe/AENu8Pxyc72jaXQuD+FEi2Ck6lBkSlWYQFhTottAeGvVFNCzKszCntrtqd\nrdYUwurYsLTXDHv9nW2hfDUQa0mhXf9gNDOBIVAZugR9NqNRNyYLHQIDAQABo2Mw\nYTAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU54cf\nDjgwBx4ycBH8+/r8WXdaiqYwHwYDVR0jBBgwFoAU54cfDjgwBx4ycBH8+/r8WXda\niqYwDQYJKoZIhvcNAQELBQADggEBAIIMTSPx/dR7jlcxggr+O6OyY49Rlap2laKA\neC/XI4ySP3vQkIFlP822U9Kh8a9s46eR0uiwV4AGLabcu0iKYfXjPkIprVCqeXV7\nny9oDtrbflyj7NcGdZLvuzSwgl9SYTJp7PVCZtZutsPYlbJrBPHwFABvAkMvRtDB\nhitIg4AESDGPoCl94sYHpfDfjpUDMSrAMDUyO6DyBdZH5ryRMAs3lGtsmkkNUrso\naTW6R05681Z0mvkRdb+cdXtKOSuDZPoe2wJJIaz3IlNQNSrB5TImMYgmt6iAsFhv\n3vfTSTKrZDNTJn4ybG6pq1zWExoXsktZPylJly6R3RBwV6nwqBM=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBjCCAu6gAwIBAgIJAMc0ZzaSUK51MA0GCSqGSIb3DQEBCwUAMIGPMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkw\nODIyMTcwODUwWhcNMjQwODIyMTcwODUwWjCBjzELMAkGA1UEBhMCVVMxEDAOBgNV\nBAcMB1NlYXR0bGUxEzARBgNVBAgMCldhc2hpbmd0b24xIjAgBgNVBAoMGUFtYXpv\nbiBXZWIgU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxIDAeBgNV\nBAMMF0FtYXpvbiBSRFMgUm9vdCAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEArXnF/E6/Qh+ku3hQTSKPMhQQlCpoWvnIthzX6MK3p5a0eXKZ\noWIjYcNNG6UwJjp4fUXl6glp53Jobn+tWNX88dNH2n8DVbppSwScVE2LpuL+94vY\n0EYE/XxN7svKea8YvlrqkUBKyxLxTjh+U/KrGOaHxz9v0l6ZNlDbuaZw3qIWdD/I\n6aNbGeRUVtpM6P+bWIoxVl/caQylQS6CEYUk+CpVyJSkopwJlzXT07tMoDL5WgX9\nO08KVgDNz9qP/IGtAcRduRcNioH3E9v981QO1zt/Gpb2f8NqAjUUCUZzOnij6mx9\nMcZ+9cWX88CRzR0vQODWuZscgI08NvM69Fn2SQIDAQABo2MwYTAOBgNVHQ8BAf8E\nBAMCAQYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUc19g2LzLA5j0Kxc0LjZa\npmD/vB8wHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJKoZIhvcN\nAQELBQADggEBAHAG7WTmyjzPRIM85rVj+fWHsLIvqpw6DObIjMWokpliCeMINZFV\nynfgBKsf1ExwbvJNzYFXW6dihnguDG9VMPpi2up/ctQTN8tm9nDKOy08uNZoofMc\nNUZxKCEkVKZv+IL4oHoeayt8egtv3ujJM6V14AstMQ6SwvwvA93EP/Ug2e4WAXHu\ncbI1NAbUgVDqp+DRdfvZkgYKryjTWd/0+1fS8X1bBZVWzl7eirNVnHbSH2ZDpNuY\n0SBd8dj5F6ld3t58ydZbrTHze7JJOd8ijySAp4/kiu9UfZWuTPABzDa/DSdz9Dk/\nzPW4CXXvhLmE02TA9/HeCw3KEHIwicNuEfw=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEEDCCAvigAwIBAgIJAKFMXyltvuRdMA0GCSqGSIb3DQEBCwUAMIGUMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzElMCMGA1UEAwwcQW1hem9uIFJEUyBCZXRhIFJvb3QgMjAxOSBDQTAe\nFw0xOTA4MTkxNzM4MjZaFw0yNDA4MTkxNzM4MjZaMIGUMQswCQYDVQQGEwJVUzEQ\nMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UECgwZ\nQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEl\nMCMGA1UEAwwcQW1hem9uIFJEUyBCZXRhIFJvb3QgMjAxOSBDQTCCASIwDQYJKoZI\nhvcNAQEBBQADggEPADCCAQoCggEBAMkZdnIH9ndatGAcFo+DppGJ1HUt4x+zeO+0\nZZ29m0sfGetVulmTlv2d5b66e+QXZFWpcPQMouSxxYTW08TbrQiZngKr40JNXftA\natvzBqIImD4II0ZX5UEVj2h98qe/ypW5xaDN7fEa5e8FkYB1TEemPaWIbNXqchcL\ntV7IJPr3Cd7Z5gZJlmujIVDPpMuSiNaal9/6nT9oqN+JSM1fx5SzrU5ssg1Vp1vv\n5Xab64uOg7wCJRB9R2GC9XD04odX6VcxUAGrZo6LR64ZSifupo3l+R5sVOc5i8NH\nskdboTzU9H7+oSdqoAyhIU717PcqeDum23DYlPE2nGBWckE+eT8CAwEAAaNjMGEw\nDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFK2hDBWl\nsbHzt/EHd0QYOooqcFPhMB8GA1UdIwQYMBaAFK2hDBWlsbHzt/EHd0QYOooqcFPh\nMA0GCSqGSIb3DQEBCwUAA4IBAQAO/718k8EnOqJDx6wweUscGTGL/QdKXUzTVRAx\nJUsjNUv49mH2HQVEW7oxszfH6cPCaupNAddMhQc4C/af6GHX8HnqfPDk27/yBQI+\nyBBvIanGgxv9c9wBbmcIaCEWJcsLp3HzXSYHmjiqkViXwCpYfkoV3Ns2m8bp+KCO\ny9XmcCKRaXkt237qmoxoh2sGmBHk2UlQtOsMC0aUQ4d7teAJG0q6pbyZEiPyKZY1\nXR/UVxMJL0Q4iVpcRS1kaNCMfqS2smbLJeNdsan8pkw1dvPhcaVTb7CvjhJtjztF\nYfDzAI5794qMlWxwilKMmUvDlPPOTen8NNHkLwWvyFCH7Doh\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEFjCCAv6gAwIBAgIJAMzYZJ+R9NBVMA0GCSqGSIb3DQEBCwUAMIGXMQswCQYD\nVQQGEwJVUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEi\nMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1h\nem9uIFJEUzEoMCYGA1UEAwwfQW1hem9uIFJEUyBQcmV2aWV3IFJvb3QgMjAxOSBD\nQTAeFw0xOTA4MjEyMjI5NDlaFw0yNDA4MjEyMjI5NDlaMIGXMQswCQYDVQQGEwJV\nUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\nCgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\nUzEoMCYGA1UEAwwfQW1hem9uIFJEUyBQcmV2aWV3IFJvb3QgMjAxOSBDQTCCASIw\nDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM7kkS6vjgKKQTPynC2NjdN5aPPV\nO71G0JJS/2ARVBVJd93JLiGovVJilfWYfwZCs4gTRSSjrUD4D4HyqCd6A+eEEtJq\nM0DEC7i0dC+9WNTsPszuB206Jy2IUmxZMIKJAA1NHSbIMjB+b6/JhbSUi7nKdbR/\nbrj83bF+RoSA+ogrgX7mQbxhmFcoZN9OGaJgYKsKWUt5Wqv627KkGodUK8mDepgD\nS3ZfoRQRx3iceETpcmHJvaIge6+vyDX3d9Z22jmvQ4AKv3py2CmU2UwuhOltFDwB\n0ddtb39vgwrJxaGfiMRHpEP1DfNLWHAnA69/pgZPwIggidS+iBPUhgucMp8CAwEA\nAaNjMGEwDgYDVR0PAQH/BAQDAgEGMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFGnTGpQuQ2H/DZlXMQijZEhjs7TdMB8GA1UdIwQYMBaAFGnTGpQuQ2H/DZlXMQij\nZEhjs7TdMA0GCSqGSIb3DQEBCwUAA4IBAQC3xz1vQvcXAfpcZlngiRWeqU8zQAMQ\nLZPCFNv7PVk4pmqX+ZiIRo4f9Zy7TrOVcboCnqmP/b/mNq0gVF4O+88jwXJZD+f8\n/RnABMZcnGU+vK0YmxsAtYU6TIb1uhRFmbF8K80HHbj9vSjBGIQdPCbvmR2zY6VJ\nBYM+w9U9hp6H4DVMLKXPc1bFlKA5OBTgUtgkDibWJKFOEPW3UOYwp9uq6pFoN0AO\nxMTldqWFsOF3bJIlvOY0c/1EFZXu3Ns6/oCP//Ap9vumldYMUZWmbK+gK33FPOXV\n8BQ6jNC29icv7lLDpRPwjibJBXX+peDR5UK4FdYcswWEB1Tix5X8dYu6\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZUxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSYwJAYDVQQDDB1BbWF6b24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQTAeFw0xOTEw\nMjgxODA2NTNaFw0yNDEwMjgxODA2NTNaMIGQMQswCQYDVQQGEwJVUzETMBEGA1UE\nCAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9u\nIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEhMB8GA1UE\nAwwYQW1hem9uIFJEUyBhZi1zb3V0aC0xIENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEAvtV1OqmFa8zCVQSKOvPUJERLVFtd4rZmDpImc5rIoeBk7w/P\n9lcKUJjO8R/w1a2lJXx3oQ81tiY0Piw6TpT62YWVRMWrOw8+Vxq1dNaDSFp9I8d0\nUHillSSbOk6FOrPDp+R6AwbGFqUDebbN5LFFoDKbhNmH1BVS0a6YNKpGigLRqhka\ncClPslWtPqtjbaP3Jbxl26zWzLo7OtZl98dR225pq8aApNBwmtgA7Gh60HK/cX0t\n32W94n8D+GKSg6R4MKredVFqRTi9hCCNUu0sxYPoELuM+mHiqB5NPjtm92EzCWs+\n+vgWhMc6GxG+82QSWx1Vj8sgLqtE/vLrWddf5QIDAQABo2YwZDAOBgNVHQ8BAf8E\nBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUuLB4gYVJrSKJj/Gz\npqc6yeA+RcAwHwYDVR0jBBgwFoAUEEi/WWMcBJsoGXg+EZwkQ0MscZQwDQYJKoZI\nhvcNAQELBQADggEBABauYOZxUhe9/RhzGJ8MsWCz8eKcyDVd4FCnY6Qh+9wcmYNT\nLtnD88LACtJKb/b81qYzcB0Em6+zVJ3Z9jznfr6buItE6es9wAoja22Xgv44BTHL\nrimbgMwpTt3uEMXDffaS0Ww6YWb3pSE0XYI2ISMWz+xRERRf+QqktSaL39zuiaW5\ntfZMre+YhohRa/F0ZQl3RCd6yFcLx4UoSPqQsUl97WhYzwAxZZfwvLJXOc4ATt3u\nVlCUylNDkaZztDJc/yN5XQoK9W5nOt2cLu513MGYKbuarQr8f+gYU8S+qOyuSRSP\nNRITzwCRVnsJE+2JmcRInn/NcanB7uOGqTvJ9+c=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZUxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSYwJAYDVQQDDB1BbWF6b24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQTAeFw0xOTEw\nMzAyMDIxMzBaFw0yNDEwMzAyMDIxMzBaMIGQMQswCQYDVQQGEwJVUzETMBEGA1UE\nCAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9u\nIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEhMB8GA1UE\nAwwYQW1hem9uIFJEUyBldS1zb3V0aC0xIENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEAtEyjYcajx6xImJn8Vz1zjdmL4ANPgQXwF7+tF7xccmNAZETb\nbzb3I9i5fZlmrRaVznX+9biXVaGxYzIUIR3huQ3Q283KsDYnVuGa3mk690vhvJbB\nQIPgKa5mVwJppnuJm78KqaSpi0vxyCPe3h8h6LLFawVyWrYNZ4okli1/U582eef8\nRzJp/Ear3KgHOLIiCdPDF0rjOdCG1MOlDLixVnPn9IYOciqO+VivXBg+jtfc5J+L\nAaPm0/Yx4uELt1tkbWkm4BvTU/gBOODnYziITZM0l6Fgwvbwgq5duAtKW+h031lC\n37rEvrclqcp4wrsUYcLAWX79ZyKIlRxcAdvEhQIDAQABo2YwZDAOBgNVHQ8BAf8E\nBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQU7zPyc0azQxnBCe7D\nb9KAadH1QSEwHwYDVR0jBBgwFoAUFBAFcgJe/BBuZiGeZ8STfpkgRYQwDQYJKoZI\nhvcNAQELBQADggEBAFGaNiYxg7yC/xauXPlaqLCtwbm2dKyK9nIFbF/7be8mk7Q3\nMOA0of1vGHPLVQLr6bJJpD9MAbUcm4cPAwWaxwcNpxOjYOFDaq10PCK4eRAxZWwF\nNJRIRmGsl8NEsMNTMCy8X+Kyw5EzH4vWFl5Uf2bGKOeFg0zt43jWQVOX6C+aL3Cd\npRS5MhmYpxMG8irrNOxf4NVFE2zpJOCm3bn0STLhkDcV/ww4zMzObTJhiIb5wSWn\nEXKKWhUXuRt7A2y1KJtXpTbSRHQxE++69Go1tWhXtRiULCJtf7wF2Ksm0RR/AdXT\n1uR1vKyH5KBJPX3ppYkQDukoHTFR0CpB+G84NLo=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZUxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSYwJAYDVQQDDB1BbWF6b24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQTAeFw0xOTA1\nMTAyMTU4NDNaFw0yNTA2MDExMjAwMDBaMIGQMQswCQYDVQQGEwJVUzETMBEGA1UE\nCAwKV2FzaGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9u\nIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEhMB8GA1UE\nAwwYQW1hem9uIFJEUyBtZS1zb3V0aC0xIENBMIIBIjANBgkqhkiG9w0BAQEFAAOC\nAQ8AMIIBCgKCAQEAudOYPZH+ihJAo6hNYMB5izPVBe3TYhnZm8+X3IoaaYiKtsp1\nJJhkTT0CEejYIQ58Fh4QrMUyWvU8qsdK3diNyQRoYLbctsBPgxBR1u07eUJDv38/\nC1JlqgHmMnMi4y68Iy7ymv50QgAMuaBqgEBRI1R6Lfbyrb2YvH5txjJyTVMwuCfd\nYPAtZVouRz0JxmnfsHyxjE+So56uOKTDuw++Ho4HhZ7Qveej7XB8b+PIPuroknd3\nFQB5RVbXRvt5ZcVD4F2fbEdBniF7FAF4dEiofVCQGQ2nynT7dZdEIPfPdH3n7ZmE\nlAOmwHQ6G83OsiHRBLnbp+QZRgOsjkHJxT20bQIDAQABo2YwZDAOBgNVHQ8BAf8E\nBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUOEVDM7VomRH4HVdA\nQvIMNq2tXOcwHwYDVR0jBBgwFoAU54cfDjgwBx4ycBH8+/r8WXdaiqYwDQYJKoZI\nhvcNAQELBQADggEBAHhvMssj+Th8IpNePU6RH0BiL6o9c437R3Q4IEJeFdYL+nZz\nPW/rELDPvLRUNMfKM+KzduLZ+l29HahxefejYPXtvXBlq/E/9czFDD4fWXg+zVou\nuDXhyrV4kNmP4S0eqsAP/jQHPOZAMFA4yVwO9hlqmePhyDnszCh9c1PfJSBh49+b\n4w7i/L3VBOMt8j3EKYvqz0gVfpeqhJwL4Hey8UbVfJRFJMJzfNHpePqtDRAY7yjV\nPYquRaV2ab/E+/7VFkWMM4tazYz/qsYA2jSH+4xDHvYk8LnsbcrF9iuidQmEc5sb\nFgcWaSKG4DJjcI5k7AJLWcXyTDt21Ci43LE+I9Q=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgICVIYwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MDQxNzEz\nMDRaFw0yNDA4MjIxNzA4NTBaMIGVMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEmMCQGA1UEAwwdQW1h\nem9uIFJEUyBhcC1zb3V0aC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQDUYOz1hGL42yUCrcsMSOoU8AeD/3KgZ4q7gP+vAz1WnY9K/kim\neWN/2Qqzlo3+mxSFQFyD4MyV3+CnCPnBl9Sh1G/F6kThNiJ7dEWSWBQGAB6HMDbC\nBaAsmUc1UIz8sLTL3fO+S9wYhA63Wun0Fbm/Rn2yk/4WnJAaMZcEtYf6e0KNa0LM\np/kN/70/8cD3iz3dDR8zOZFpHoCtf0ek80QqTich0A9n3JLxR6g6tpwoYviVg89e\nqCjQ4axxOkWWeusLeTJCcY6CkVyFvDAKvcUl1ytM5AiaUkXblE7zDFXRM4qMMRdt\nlPm8d3pFxh0fRYk8bIKnpmtOpz3RIctDrZZxAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBT99wKJftD3jb4sHoHG\ni3uGlH6W6TAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAZ17hhr3dII3hUfuHQ1hPWGrpJOX/G9dLzkprEIcCidkmRYl+\nhu1Pe3caRMh/17+qsoEErmnVq5jNY9X1GZL04IZH8YbHc7iRHw3HcWAdhN8633+K\njYEB2LbJ3vluCGnCejq9djDb6alOugdLMJzxOkHDhMZ6/gYbECOot+ph1tQuZXzD\ntZ7prRsrcuPBChHlPjmGy8M9z8u+kF196iNSUGC4lM8vLkHM7ycc1/ZOwRq9aaTe\niOghbQQyAEe03MWCyDGtSmDfr0qEk+CHN+6hPiaL8qKt4s+V9P7DeK4iW08ny8Ox\nAVS7u0OK/5+jKMAMrKwpYrBydOjTUTHScocyNw==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICQ2QwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MDUxODQ2\nMjlaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBzYS1lYXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAMMvR+ReRnOzqJzoaPipNTt1Z2VA968jlN1+SYKUrYM3No+Vpz0H\nM6Tn0oYB66ByVsXiGc28ulsqX1HbHsxqDPwvQTKvO7SrmDokoAkjJgLocOLUAeld\n5AwvUjxGRP6yY90NV7X786MpnYb2Il9DIIaV9HjCmPt+rjy2CZjS0UjPjCKNfB8J\nbFjgW6GGscjeyGb/zFwcom5p4j0rLydbNaOr9wOyQrtt3ZQWLYGY9Zees/b8pmcc\nJt+7jstZ2UMV32OO/kIsJ4rMUn2r/uxccPwAc1IDeRSSxOrnFKhW3Cu69iB3bHp7\nJbawY12g7zshE4I14sHjv3QoXASoXjx4xgMCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFI1Fc/Ql2jx+oJPgBVYq\nccgP0pQ8MB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQB4VVVabVp70myuYuZ3vltQIWqSUMhkaTzehMgGcHjMf9iLoZ/I\n93KiFUSGnek5cRePyS9wcpp0fcBT3FvkjpUdCjVtdttJgZFhBxgTd8y26ImdDDMR\n4+BUuhI5msvjL08f+Vkkpu1GQcGmyFVPFOy/UY8iefu+QyUuiBUnUuEDd49Hw0Fn\n/kIPII6Vj82a2mWV/Q8e+rgN8dIRksRjKI03DEoP8lhPlsOkhdwU6Uz9Vu6NOB2Q\nLs1kbcxAc7cFSyRVJEhh12Sz9d0q/CQSTFsVJKOjSNQBQfVnLz1GwO/IieUEAr4C\njkTntH0r1LX5b/GwN4R887LvjAEdTbg1his7\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgIDAIkHMA0GCSqGSIb3DQEBCwUAMIGPMQswCQYDVQQGEwJV\nUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\nCgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\nUzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkwOTA2MTc0\nMDIxWhcNMjQwODIyMTcwODUwWjCBlDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldh\nc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoMGUFtYXpvbiBXZWIg\nU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxJTAjBgNVBAMMHEFt\nYXpvbiBSRFMgdXMtd2VzdC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQDD2yzbbAl77OofTghDMEf624OvU0eS9O+lsdO0QlbfUfWa1Kd6\n0WkgjkLZGfSRxEHMCnrv4UPBSK/Qwn6FTjkDLgemhqBtAnplN4VsoDL+BkRX4Wwq\n/dSQJE2b+0hm9w9UMVGFDEq1TMotGGTD2B71eh9HEKzKhGzqiNeGsiX4VV+LJzdH\nuM23eGisNqmd4iJV0zcAZ+Gbh2zK6fqTOCvXtm7Idccv8vZZnyk1FiWl3NR4WAgK\nAkvWTIoFU3Mt7dIXKKClVmvssG8WHCkd3Xcb4FHy/G756UZcq67gMMTX/9fOFM/v\nl5C0+CHl33Yig1vIDZd+fXV1KZD84dEJfEvHAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBR+ap20kO/6A7pPxo3+\nT3CfqZpQWjAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAHCJky2tPjPttlDM/RIqExupBkNrnSYnOK4kr9xJ3sl8UF2DA\nPAnYsjXp3rfcjN/k/FVOhxwzi3cXJF/2Tjj39Bm/OEfYTOJDNYtBwB0VVH4ffa/6\ntZl87jaIkrxJcreeeHqYMnIxeN0b/kliyA+a5L2Yb0VPjt9INq34QDc1v74FNZ17\n4z8nr1nzg4xsOWu0Dbjo966lm4nOYIGBRGOKEkHZRZ4mEiMgr3YLkv8gSmeitx57\nZ6dVemNtUic/LVo5Iqw4n3TBS0iF2C1Q1xT/s3h+0SXZlfOWttzSluDvoMv5PvCd\npFjNn+aXLAALoihL1MJSsxydtsLjOBro5eK0Vw==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICOFAwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTAxNzQ2\nMjFaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMiAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAzU72e6XbaJbi4HjJoRNjKxzUEuChKQIt7k3CWzNnmjc5\n8I1MjCpa2W1iw1BYVysXSNSsLOtUsfvBZxi/1uyMn5ZCaf9aeoA9UsSkFSZBjOCN\nDpKPCmfV1zcEOvJz26+1m8WDg+8Oa60QV0ou2AU1tYcw98fOQjcAES0JXXB80P2s\n3UfkNcnDz+l4k7j4SllhFPhH6BQ4lD2NiFAP4HwoG6FeJUn45EPjzrydxjq6v5Fc\ncQ8rGuHADVXotDbEhaYhNjIrsPL+puhjWfhJjheEw8c4whRZNp6gJ/b6WEes/ZhZ\nh32DwsDsZw0BfRDUMgUn8TdecNexHUw8vQWeC181hwIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUwW9bWgkWkr0U\nlrOsq2kvIdrECDgwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAEugF0Gj7HVhX0ehPZoGRYRt3PBuI2YjfrrJRTZ9X5wc\n9T8oHmw07mHmNy1qqWvooNJg09bDGfB0k5goC2emDiIiGfc/kvMLI7u+eQOoMKj6\nmkfCncyRN3ty08Po45vTLBFZGUvtQmjM6yKewc4sXiASSBmQUpsMbiHRCL72M5qV\nobcJOjGcIdDTmV1BHdWT+XcjynsGjUqOvQWWhhLPrn4jWe6Xuxll75qlrpn3IrIx\nCRBv/5r7qbcQJPOgwQsyK4kv9Ly8g7YT1/vYBlR3cRsYQjccw5ceWUj2DrMVWhJ4\nprf+E3Aa4vYmLLOUUvKnDQ1k3RGNu56V0tonsQbfsaM=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECjCCAvKgAwIBAgICEzUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTAyMDUy\nMjVaFw0yNDA4MjIxNzA4NTBaMIGXMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEoMCYGA1UEAwwfQW1h\nem9uIFJEUyBjYS1jZW50cmFsLTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQAD\nggEPADCCAQoCggEBAOxHqdcPSA2uBjsCP4DLSlqSoPuQ/X1kkJLusVRKiQE2zayB\nviuCBt4VB9Qsh2rW3iYGM+usDjltGnI1iUWA5KHcvHszSMkWAOYWLiMNKTlg6LCp\nXnE89tvj5dIH6U8WlDvXLdjB/h30gW9JEX7S8supsBSci2GxEzb5mRdKaDuuF/0O\nqvz4YE04pua3iZ9QwmMFuTAOYzD1M72aOpj+7Ac+YLMM61qOtU+AU6MndnQkKoQi\nqmUN2A9IFaqHFzRlSdXwKCKUA4otzmz+/N3vFwjb5F4DSsbsrMfjeHMo6o/nb6Nh\nYDb0VJxxPee6TxSuN7CQJ2FxMlFUezcoXqwqXD0CAwEAAaNmMGQwDgYDVR0PAQH/\nBAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFDGGpon9WfIpsggE\nCxHq8hZ7E2ESMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqG\nSIb3DQEBCwUAA4IBAQAvpeQYEGZvoTVLgV9rd2+StPYykMsmFjWQcyn3dBTZRXC2\nlKq7QhQczMAOhEaaN29ZprjQzsA2X/UauKzLR2Uyqc2qOeO9/YOl0H3qauo8C/W9\nr8xqPbOCDLEXlOQ19fidXyyEPHEq5WFp8j+fTh+s8WOx2M7IuC0ANEetIZURYhSp\nxl9XOPRCJxOhj7JdelhpweX0BJDNHeUFi0ClnFOws8oKQ7sQEv66d5ddxqqZ3NVv\nRbCvCtEutQMOUMIuaygDlMn1anSM8N7Wndx8G6+Uy67AnhjGx7jw/0YPPxopEj6x\nJXP8j0sJbcT9K/9/fPVLNT25RvQ/93T2+IQL4Ca2\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICYpgwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTExNzMx\nNDhaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBldS13ZXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAMk3YdSZ64iAYp6MyyKtYJtNzv7zFSnnNf6vv0FB4VnfITTMmOyZ\nLXqKAT2ahZ00hXi34ewqJElgU6eUZT/QlzdIu359TEZyLVPwURflL6SWgdG01Q5X\nO++7fSGcBRyIeuQWs9FJNIIqK8daF6qw0Rl5TXfu7P9dBc3zkgDXZm2DHmxGDD69\n7liQUiXzoE1q2Z9cA8+jirDioJxN9av8hQt12pskLQumhlArsMIhjhHRgF03HOh5\ntvi+RCfihVOxELyIRTRpTNiIwAqfZxxTWFTgfn+gijTmd0/1DseAe82aYic8JbuS\nEMbrDduAWsqrnJ4GPzxHKLXX0JasCUcWyMECAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFPLtsq1NrwJXO13C9eHt\nsLY11AGwMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQAnWBKj5xV1A1mYd0kIgDdkjCwQkiKF5bjIbGkT3YEFFbXoJlSP\n0lZZ/hDaOHI8wbLT44SzOvPEEmWF9EE7SJzkvSdQrUAWR9FwDLaU427ALI3ngNHy\nlGJ2hse1fvSRNbmg8Sc9GBv8oqNIBPVuw+AJzHTacZ1OkyLZrz1c1QvwvwN2a+Jd\nvH0V0YIhv66llKcYDMUQJAQi4+8nbRxXWv6Gq3pvrFoorzsnkr42V3JpbhnYiK+9\nnRKd4uWl62KRZjGkfMbmsqZpj2fdSWMY1UGyN1k+kDmCSWYdrTRDP0xjtIocwg+A\nJ116n4hV/5mbA0BaPiS2krtv17YAeHABZcvz\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECjCCAvKgAwIBAgICV2YwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTExOTM2\nMjBaFw0yNDA4MjIxNzA4NTBaMIGXMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEoMCYGA1UEAwwfQW1h\nem9uIFJEUyBldS1jZW50cmFsLTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQAD\nggEPADCCAQoCggEBAMEx54X2pHVv86APA0RWqxxRNmdkhAyp2R1cFWumKQRofoFv\nn+SPXdkpIINpMuEIGJANozdiEz7SPsrAf8WHyD93j/ZxrdQftRcIGH41xasetKGl\nI67uans8d+pgJgBKGb/Z+B5m+UsIuEVekpvgpwKtmmaLFC/NCGuSsJoFsRqoa6Gh\nm34W6yJoY87UatddCqLY4IIXaBFsgK9Q/wYzYLbnWM6ZZvhJ52VMtdhcdzeTHNW0\n5LGuXJOF7Ahb4JkEhoo6TS2c0NxB4l4MBfBPgti+O7WjR3FfZHpt18A6Zkq6A2u6\nD/oTSL6c9/3sAaFTFgMyL3wHb2YlW0BPiljZIqECAwEAAaNmMGQwDgYDVR0PAQH/\nBAQDAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFOcAToAc6skWffJa\nTnreaswAfrbcMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqG\nSIb3DQEBCwUAA4IBAQA1d0Whc1QtspK496mFWfFEQNegLh0a9GWYlJm+Htcj5Nxt\nDAIGXb+8xrtOZFHmYP7VLCT5Zd2C+XytqseK/+s07iAr0/EPF+O2qcyQWMN5KhgE\ncXw2SwuP9FPV3i+YAm11PBVeenrmzuk9NrdHQ7TxU4v7VGhcsd2C++0EisrmquWH\nmgIfmVDGxphwoES52cY6t3fbnXmTkvENvR+h3rj+fUiSz0aSo+XZUGHPgvuEKM/W\nCBD9Smc9CBoBgvy7BgHRgRUmwtABZHFUIEjHI5rIr7ZvYn+6A0O6sogRfvVYtWFc\nqpyrW1YX8mD0VlJ8fGKM3G+aCOsiiPKDV/Uafrm+\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgICGAcwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTIxODE5\nNDRaFw0yNDA4MjIxNzA4NTBaMIGVMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEmMCQGA1UEAwwdQW1h\nem9uIFJEUyBldS1ub3J0aC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQCiIYnhe4UNBbdBb/nQxl5giM0XoVHWNrYV5nB0YukA98+TPn9v\nAoj1RGYmtryjhrf01Kuv8SWO+Eom95L3zquoTFcE2gmxCfk7bp6qJJ3eHOJB+QUO\nXsNRh76fwDzEF1yTeZWH49oeL2xO13EAx4PbZuZpZBttBM5zAxgZkqu4uWQczFEs\nJXfla7z2fvWmGcTagX10O5C18XaFroV0ubvSyIi75ue9ykg/nlFAeB7O0Wxae88e\nuhiBEFAuLYdqWnsg3459NfV8Yi1GnaitTym6VI3tHKIFiUvkSiy0DAlAGV2iiyJE\nq+DsVEO4/hSINJEtII4TMtysOsYPpINqeEzRAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBRR0UpnbQyjnHChgmOc\nhnlc0PogzTAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAKJD4xVzSf4zSGTBJrmamo86jl1NHQxXUApAZuBZEc8tqC6TI\nT5CeoSr9CMuVC8grYyBjXblC4OsM5NMvmsrXl/u5C9dEwtBFjo8mm53rOOIm1fxl\nI1oYB/9mtO9ANWjkykuLzWeBlqDT/i7ckaKwalhLODsRDO73vRhYNjsIUGloNsKe\npxw3dzHwAZx4upSdEVG4RGCZ1D0LJ4Gw40OfD69hfkDfRVVxKGrbEzqxXRvovmDc\ntKLdYZO/6REoca36v4BlgIs1CbUXJGLSXUwtg7YXGLSVBJ/U0+22iGJmBSNcoyUN\ncjPFD9JQEhDDIYYKSGzIYpvslvGc4T5ISXFiuQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICZIEwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTIyMTMy\nMzJaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBldS13ZXN0LTIgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBALGiwqjiF7xIjT0Sx7zB3764K2T2a1DHnAxEOr+/EIftWKxWzT3u\nPFwS2eEZcnKqSdRQ+vRzonLBeNLO4z8aLjQnNbkizZMBuXGm4BqRm1Kgq3nlLDQn\n7YqdijOq54SpShvR/8zsO4sgMDMmHIYAJJOJqBdaus2smRt0NobIKc0liy7759KB\n6kmQ47Gg+kfIwxrQA5zlvPLeQImxSoPi9LdbRoKvu7Iot7SOa+jGhVBh3VdqndJX\n7tm/saj4NE375csmMETFLAOXjat7zViMRwVorX4V6AzEg1vkzxXpA9N7qywWIT5Y\nfYaq5M8i6vvLg0CzrH9fHORtnkdjdu1y+0MCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFFOhOx1yt3Z7mvGB9jBv\n2ymdZwiOMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQBehqY36UGDvPVU9+vtaYGr38dBbp+LzkjZzHwKT1XJSSUc2wqM\nhnCIQKilonrTIvP1vmkQi8qHPvDRtBZKqvz/AErW/ZwQdZzqYNFd+BmOXaeZWV0Q\noHtDzXmcwtP8aUQpxN0e1xkWb1E80qoy+0uuRqb/50b/R4Q5qqSfJhkn6z8nwB10\n7RjLtJPrK8igxdpr3tGUzfAOyiPrIDncY7UJaL84GFp7WWAkH0WG3H8Y8DRcRXOU\nmqDxDLUP3rNuow3jnGxiUY+gGX5OqaZg4f4P6QzOSmeQYs6nLpH0PiN00+oS1BbD\nbpWdZEttILPI+vAYkU4QuBKKDjJL6HbSd+cn\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgIDAIVCMA0GCSqGSIb3DQEBCwUAMIGPMQswCQYDVQQGEwJV\nUzEQMA4GA1UEBwwHU2VhdHRsZTETMBEGA1UECAwKV2FzaGluZ3RvbjEiMCAGA1UE\nCgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJE\nUzEgMB4GA1UEAwwXQW1hem9uIFJEUyBSb290IDIwMTkgQ0EwHhcNMTkwOTEzMTcw\nNjQxWhcNMjQwODIyMTcwODUwWjCBlDELMAkGA1UEBhMCVVMxEzARBgNVBAgMCldh\nc2hpbmd0b24xEDAOBgNVBAcMB1NlYXR0bGUxIjAgBgNVBAoMGUFtYXpvbiBXZWIg\nU2VydmljZXMsIEluYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxJTAjBgNVBAMMHEFt\nYXpvbiBSRFMgdXMtZWFzdC0yIDIwMTkgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IB\nDwAwggEKAoIBAQDE+T2xYjUbxOp+pv+gRA3FO24+1zCWgXTDF1DHrh1lsPg5k7ht\n2KPYzNc+Vg4E+jgPiW0BQnA6jStX5EqVh8BU60zELlxMNvpg4KumniMCZ3krtMUC\nau1NF9rM7HBh+O+DYMBLK5eSIVt6lZosOb7bCi3V6wMLA8YqWSWqabkxwN4w0vXI\n8lu5uXXFRemHnlNf+yA/4YtN4uaAyd0ami9+klwdkZfkrDOaiy59haOeBGL8EB/c\ndbJJlguHH5CpCscs3RKtOOjEonXnKXldxarFdkMzi+aIIjQ8GyUOSAXHtQHb3gZ4\nnS6Ey0CMlwkB8vUObZU9fnjKJcL5QCQqOfwvAgMBAAGjZjBkMA4GA1UdDwEB/wQE\nAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBQUPuRHohPxx4VjykmH\n6usGrLL1ETAfBgNVHSMEGDAWgBRzX2DYvMsDmPQrFzQuNlqmYP+8HzANBgkqhkiG\n9w0BAQsFAAOCAQEAUdR9Vb3y33Yj6X6KGtuthZ08SwjImVQPtknzpajNE5jOJAh8\nquvQnU9nlnMO85fVDU1Dz3lLHGJ/YG1pt1Cqq2QQ200JcWCvBRgdvH6MjHoDQpqZ\nHvQ3vLgOGqCLNQKFuet9BdpsHzsctKvCVaeBqbGpeCtt3Hh/26tgx0rorPLw90A2\nV8QSkZJjlcKkLa58N5CMM8Xz8KLWg3MZeT4DmlUXVCukqK2RGuP2L+aME8dOxqNv\nOnOz1zrL5mR2iJoDpk8+VE/eBDmJX40IJk6jBjWoxAO/RXq+vBozuF5YHN1ujE92\ntO8HItgTp37XT8bJBAiAnt5mxw+NLSqtxk2QdQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICY4kwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTMyMDEx\nNDJaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMSAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAr5u9OuLL/OF/fBNUX2kINJLzFl4DnmrhnLuSeSnBPgbb\nqddjf5EFFJBfv7IYiIWEFPDbDG5hoBwgMup5bZDbas+ZTJTotnnxVJTQ6wlhTmns\neHECcg2pqGIKGrxZfbQhlj08/4nNAPvyYCTS0bEcmQ1emuDPyvJBYDDLDU6AbCB5\n6Z7YKFQPTiCBblvvNzchjLWF9IpkqiTsPHiEt21sAdABxj9ityStV3ja/W9BfgxH\nwzABSTAQT6FbDwmQMo7dcFOPRX+hewQSic2Rn1XYjmNYzgEHisdUsH7eeXREAcTw\n61TRvaLH8AiOWBnTEJXPAe6wYfrcSd1pD0MXpoB62wIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUytwMiomQOgX5\nIchd+2lDWRUhkikwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBACf6lRDpfCD7BFRqiWM45hqIzffIaysmVfr+Jr+fBTjP\nuYe/ba1omSrNGG23bOcT9LJ8hkQJ9d+FxUwYyICQNWOy6ejicm4z0C3VhphbTPqj\nyjpt9nG56IAcV8BcRJh4o/2IfLNzC/dVuYJV8wj7XzwlvjysenwdrJCoLadkTr1h\neIdG6Le07sB9IxrGJL9e04afk37h7c8ESGSE4E+oS4JQEi3ATq8ne1B9DQ9SasXi\nIRmhNAaISDzOPdyLXi9N9V9Lwe/DHcja7hgLGYx3UqfjhLhOKwp8HtoZORixAmOI\nHfILgNmwyugAbuZoCazSKKBhQ0wgO0WZ66ZKTMG8Oho=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICUYkwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTYxODIx\nMTVaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyB1cy13ZXN0LTIgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBANCEZBZyu6yJQFZBJmSUZfSZd3Ui2gitczMKC4FLr0QzkbxY+cLa\nuVONIOrPt4Rwi+3h/UdnUg917xao3S53XDf1TDMFEYp4U8EFPXqCn/GXBIWlU86P\nPvBN+gzw3nS+aco7WXb+woTouvFVkk8FGU7J532llW8o/9ydQyDIMtdIkKTuMfho\nOiNHSaNc+QXQ32TgvM9A/6q7ksUoNXGCP8hDOkSZ/YOLiI5TcdLh/aWj00ziL5bj\npvytiMZkilnc9dLY9QhRNr0vGqL0xjmWdoEXz9/OwjmCihHqJq+20MJPsvFm7D6a\n2NKybR9U+ddrjb8/iyLOjURUZnj5O+2+OPcCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFEBxMBdv81xuzqcK5TVu\npHj+Aor8MB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQBZkfiVqGoJjBI37aTlLOSjLcjI75L5wBrwO39q+B4cwcmpj58P\n3sivv+jhYfAGEbQnGRzjuFoyPzWnZ1DesRExX+wrmHsLLQbF2kVjLZhEJMHF9eB7\nGZlTPdTzHErcnuXkwA/OqyXMpj9aghcQFuhCNguEfnROY9sAoK2PTfnTz9NJHL+Q\nUpDLEJEUfc0GZMVWYhahc0x38ZnSY2SKacIPECQrTI0KpqZv/P+ijCEcMD9xmYEb\njL4en+XKS1uJpw5fIU5Sj0MxhdGstH6S84iAE5J3GM3XHklGSFwwqPYvuTXvANH6\nuboynxRgSae59jIlAK6Jrr6GWMwQRbgcaAlW\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICEkYwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTYxOTUz\nNDdaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMiAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAufodI2Flker8q7PXZG0P0vmFSlhQDw907A6eJuF/WeMo\nGHnll3b4S6nC3oRS3nGeRMHbyU2KKXDwXNb3Mheu+ox+n5eb/BJ17eoj9HbQR1cd\ngEkIciiAltf8gpMMQH4anP7TD+HNFlZnP7ii3geEJB2GGXSxgSWvUzH4etL67Zmn\nTpGDWQMB0T8lK2ziLCMF4XAC/8xDELN/buHCNuhDpxpPebhct0T+f6Arzsiswt2j\n7OeNeLLZwIZvVwAKF7zUFjC6m7/VmTQC8nidVY559D6l0UhhU0Co/txgq3HVsMOH\nPbxmQUwJEKAzQXoIi+4uZzHFZrvov/nDTNJUhC6DqwIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUwaZpaCme+EiV\nM5gcjeHZSTgOn4owHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAAR6a2meCZuXO2TF9bGqKGtZmaah4pH2ETcEVUjkvXVz\nsl+ZKbYjrun+VkcMGGKLUjS812e7eDF726ptoku9/PZZIxlJB0isC/0OyixI8N4M\nNsEyvp52XN9QundTjkl362bomPnHAApeU0mRbMDRR2JdT70u6yAzGLGsUwMkoNnw\n1VR4XKhXHYGWo7KMvFrZ1KcjWhubxLHxZWXRulPVtGmyWg/MvE6KF+2XMLhojhUL\n+9jB3Fpn53s6KMx5tVq1x8PukHmowcZuAF8k+W4gk8Y68wIwynrdZrKRyRv6CVtR\nFZ8DeJgoNZT3y/GT254VqMxxfuy2Ccb/RInd16tEvVk=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICOYIwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTcyMDA1\nMjlaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMyAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEA4dMak8W+XW8y/2F6nRiytFiA4XLwePadqWebGtlIgyCS\nkbug8Jv5w7nlMkuxOxoUeD4WhI6A9EkAn3r0REM/2f0aYnd2KPxeqS2MrtdxxHw1\nxoOxk2x0piNSlOz6yog1idsKR5Wurf94fvM9FdTrMYPPrDabbGqiBMsZZmoHLvA3\nZ+57HEV2tU0Ei3vWeGIqnNjIekS+E06KhASxrkNU5vi611UsnYZlSi0VtJsH4UGV\nLhnHl53aZL0YFO5mn/fzuNG/51qgk/6EFMMhaWInXX49Dia9FnnuWXwVwi6uX1Wn\n7kjoHi5VtmC8ZlGEHroxX2DxEr6bhJTEpcLMnoQMqwIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQUsUI5Cb3SWB8+\ngv1YLN/ABPMdxSAwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAJAF3E9PM1uzVL8YNdzb6fwJrxxqI2shvaMVmC1mXS+w\nG0zh4v2hBZOf91l1EO0rwFD7+fxoI6hzQfMxIczh875T6vUXePKVOCOKI5wCrDad\nzQbVqbFbdhsBjF4aUilOdtw2qjjs9JwPuB0VXN4/jY7m21oKEOcnpe36+7OiSPjN\nxngYewCXKrSRqoj3mw+0w/+exYj3Wsush7uFssX18av78G+ehKPIVDXptOCP/N7W\n8iKVNeQ2QGTnu2fzWsGUSvMGyM7yqT+h1ILaT//yQS8er511aHMLc142bD4D9VSy\nDgactwPDTShK/PXqhvNey9v/sKXm4XatZvwcc8KYlW4=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEDDCCAvSgAwIBAgICcEUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTgxNjU2\nMjBaFw0yNDA4MjIxNzA4NTBaMIGZMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzEqMCgGA1UEAwwhQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMSAyMDE5IENBMIIBIjANBgkqhkiG9w0BAQEF\nAAOCAQ8AMIIBCgKCAQEAndtkldmHtk4TVQAyqhAvtEHSMb6pLhyKrIFved1WO3S7\n+I+bWwv9b2W/ljJxLq9kdT43bhvzonNtI4a1LAohS6bqyirmk8sFfsWT3akb+4Sx\n1sjc8Ovc9eqIWJCrUiSvv7+cS7ZTA9AgM1PxvHcsqrcUXiK3Jd/Dax9jdZE1e15s\nBEhb2OEPE+tClFZ+soj8h8Pl2Clo5OAppEzYI4LmFKtp1X/BOf62k4jviXuCSst3\nUnRJzE/CXtjmN6oZySVWSe0rQYuyqRl6//9nK40cfGKyxVnimB8XrrcxUN743Vud\nQQVU0Esm8OVTX013mXWQXJHP2c0aKkog8LOga0vobQIDAQABo2YwZDAOBgNVHQ8B\nAf8EBAMCAQYwEgYDVR0TAQH/BAgwBgEB/wIBADAdBgNVHQ4EFgQULmoOS1mFSjj+\nsnUPx4DgS3SkLFYwHwYDVR0jBBgwFoAUc19g2LzLA5j0Kxc0LjZapmD/vB8wDQYJ\nKoZIhvcNAQELBQADggEBAAkVL2P1M2/G9GM3DANVAqYOwmX0Xk58YBHQu6iiQg4j\nb4Ky/qsZIsgT7YBsZA4AOcPKQFgGTWhe9pvhmXqoN3RYltN8Vn7TbUm/ZVDoMsrM\ngwv0+TKxW1/u7s8cXYfHPiTzVSJuOogHx99kBW6b2f99GbP7O1Sv3sLq4j6lVvBX\nFiacf5LAWC925nvlTzLlBgIc3O9xDtFeAGtZcEtxZJ4fnGXiqEnN4539+nqzIyYq\nnvlgCzyvcfRAxwltrJHuuRu6Maw5AGcd2Y0saMhqOVq9KYKFKuD/927BTrbd2JVf\n2sGWyuPZPCk3gq+5pCjbD0c6DkhcMGI6WwxvM5V/zSM=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICJDQwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTgxNzAz\nMTVaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyBldS13ZXN0LTMgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAL9bL7KE0n02DLVtlZ2PL+g/BuHpMYFq2JnE2RgompGurDIZdjmh\n1pxfL3nT+QIVMubuAOy8InRfkRxfpxyjKYdfLJTPJG+jDVL+wDcPpACFVqoV7Prg\npVYEV0lc5aoYw4bSeYFhdzgim6F8iyjoPnObjll9mo4XsHzSoqJLCd0QC+VG9Fw2\nq+GDRZrLRmVM2oNGDRbGpGIFg77aRxRapFZa8SnUgs2AqzuzKiprVH5i0S0M6dWr\ni+kk5epmTtkiDHceX+dP/0R1NcnkCPoQ9TglyXyPdUdTPPRfKCq12dftqll+u4mV\nARdN6WFjovxax8EAP2OAUTi1afY+1JFMj+sCAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFLfhrbrO5exkCVgxW0x3\nY2mAi8lNMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQAigQ5VBNGyw+OZFXwxeJEAUYaXVoP/qrhTOJ6mCE2DXUVEoJeV\nSxScy/TlFA9tJXqmit8JH8VQ/xDL4ubBfeMFAIAo4WzNWDVoeVMqphVEcDWBHsI1\nAETWzfsapRS9yQekOMmxg63d/nV8xewIl8aNVTHdHYXMqhhik47VrmaVEok1UQb3\nO971RadLXIEbVd9tjY5bMEHm89JsZDnDEw1hQXBb67Elu64OOxoKaHBgUH8AZn/2\nzFsL1ynNUjOhCSAA15pgd1vjwc0YsBbAEBPcHBWYBEyME6NLNarjOzBl4FMtATSF\nwWCKRGkvqN8oxYhwR2jf2rR5Mu4DWkK5Q8Ep\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBzCCAu+gAwIBAgICJVUwDQYJKoZIhvcNAQELBQAwgY8xCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSAwHgYDVQQDDBdBbWF6b24gUkRTIFJvb3QgMjAxOSBDQTAeFw0xOTA5MTkxODE2\nNTNaFw0yNDA4MjIxNzA4NTBaMIGUMQswCQYDVQQGEwJVUzETMBEGA1UECAwKV2Fz\naGluZ3RvbjEQMA4GA1UEBwwHU2VhdHRsZTEiMCAGA1UECgwZQW1hem9uIFdlYiBT\nZXJ2aWNlcywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzElMCMGA1UEAwwcQW1h\nem9uIFJEUyB1cy1lYXN0LTEgMjAxOSBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEP\nADCCAQoCggEBAM3i/k2u6cqbMdcISGRvh+m+L0yaSIoOXjtpNEoIftAipTUYoMhL\nInXGlQBVA4shkekxp1N7HXe1Y/iMaPEyb3n+16pf3vdjKl7kaSkIhjdUz3oVUEYt\ni8Z/XeJJ9H2aEGuiZh3kHixQcZczn8cg3dA9aeeyLSEnTkl/npzLf//669Ammyhs\nXcAo58yvT0D4E0D/EEHf2N7HRX7j/TlyWvw/39SW0usiCrHPKDLxByLojxLdHzso\nQIp/S04m+eWn6rmD+uUiRteN1hI5ncQiA3wo4G37mHnUEKo6TtTUh+sd/ku6a8HK\nglMBcgqudDI90s1OpuIAWmuWpY//8xEG2YECAwEAAaNmMGQwDgYDVR0PAQH/BAQD\nAgEGMBIGA1UdEwEB/wQIMAYBAf8CAQAwHQYDVR0OBBYEFPqhoWZcrVY9mU7tuemR\nRBnQIj1jMB8GA1UdIwQYMBaAFHNfYNi8ywOY9CsXNC42WqZg/7wfMA0GCSqGSIb3\nDQEBCwUAA4IBAQB6zOLZ+YINEs72heHIWlPZ8c6WY8MDU+Be5w1M+BK2kpcVhCUK\nPJO4nMXpgamEX8DIiaO7emsunwJzMSvavSPRnxXXTKIc0i/g1EbiDjnYX9d85DkC\nE1LaAUCmCZBVi9fIe0H2r9whIh4uLWZA41oMnJx/MOmo3XyMfQoWcqaSFlMqfZM4\n0rNoB/tdHLNuV4eIdaw2mlHxdWDtF4oH+HFm+2cVBUVC1jXKrFv/euRVtsTT+A6i\nh2XBHKxQ1Y4HgAn0jACP2QSPEmuoQEIa57bEKEcZsBR8SDY6ZdTd2HLRIApcCOSF\nMRM8CKLeF658I0XgF8D5EsYoKPsA+74Z+jDH\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEETCCAvmgAwIBAgICEAAwDQYJKoZIhvcNAQELBQAwgZQxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSUwIwYDVQQDDBxBbWF6b24gUkRTIEJldGEgUm9vdCAyMDE5IENBMB4XDTE5MDgy\nMDE3MTAwN1oXDTI0MDgxOTE3MzgyNlowgZkxCzAJBgNVBAYTAlVTMRMwEQYDVQQI\nDApXYXNoaW5ndG9uMRAwDgYDVQQHDAdTZWF0dGxlMSIwIAYDVQQKDBlBbWF6b24g\nV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMSowKAYDVQQD\nDCFBbWF6b24gUkRTIEJldGEgdXMtZWFzdC0xIDIwMTkgQ0EwggEiMA0GCSqGSIb3\nDQEBAQUAA4IBDwAwggEKAoIBAQDTNCOlotQcLP8TP82U2+nk0bExVuuMVOgFeVMx\nvbUHZQeIj9ikjk+jm6eTDnnkhoZcmJiJgRy+5Jt69QcRbb3y3SAU7VoHgtraVbxF\nQDh7JEHI9tqEEVOA5OvRrDRcyeEYBoTDgh76ROco2lR+/9uCvGtHVrMCtG7BP7ZB\nsSVNAr1IIRZZqKLv2skKT/7mzZR2ivcw9UeBBTUf8xsfiYVBvMGoEsXEycjYdf6w\nWV+7XS7teNOc9UgsFNN+9AhIBc1jvee5E//72/4F8pAttAg/+mmPUyIKtekNJ4gj\nOAR2VAzGx1ybzWPwIgOudZFHXFduxvq4f1hIRPH0KbQ/gkRrAgMBAAGjZjBkMA4G\nA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQWBBTkvpCD\n6C43rar9TtJoXr7q8dkrrjAfBgNVHSMEGDAWgBStoQwVpbGx87fxB3dEGDqKKnBT\n4TANBgkqhkiG9w0BAQsFAAOCAQEAJd9fOSkwB3uVdsS+puj6gCER8jqmhd3g/J5V\nZjk9cKS8H0e8pq/tMxeJ8kpurPAzUk5RkCspGt2l0BSwmf3ahr8aJRviMX6AuW3/\ng8aKplTvq/WMNGKLXONa3Sq8591J+ce8gtOX/1rDKmFI4wQ/gUzOSYiT991m7QKS\nFr6HMgFuz7RNJbb3Fy5cnurh8eYWA7mMv7laiLwTNsaro5qsqErD5uXuot6o9beT\na+GiKinEur35tNxAr47ax4IRubuIzyfCrezjfKc5raVV2NURJDyKP0m0CCaffAxE\nqn2dNfYc3v1D8ypg3XjHlOzRo32RB04o8ALHMD9LSwsYDLpMag==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEFzCCAv+gAwIBAgICFSUwDQYJKoZIhvcNAQELBQAwgZcxCzAJBgNVBAYTAlVT\nMRAwDgYDVQQHDAdTZWF0dGxlMRMwEQYDVQQIDApXYXNoaW5ndG9uMSIwIAYDVQQK\nDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRT\nMSgwJgYDVQQDDB9BbWF6b24gUkRTIFByZXZpZXcgUm9vdCAyMDE5IENBMB4XDTE5\nMDgyMTIyMzk0N1oXDTI0MDgyMTIyMjk0OVowgZwxCzAJBgNVBAYTAlVTMRMwEQYD\nVQQIDApXYXNoaW5ndG9uMRAwDgYDVQQHDAdTZWF0dGxlMSIwIAYDVQQKDBlBbWF6\nb24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMS0wKwYD\nVQQDDCRBbWF6b24gUkRTIFByZXZpZXcgdXMtZWFzdC0yIDIwMTkgQ0EwggEiMA0G\nCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQD0dB/U7qRnSf05wOi7m10Pa2uPMTJv\nr6U/3Y17a5prq5Zr4++CnSUYarG51YuIf355dKs+7Lpzs782PIwCmLpzAHKWzix6\npOaTQ+WZ0+vUMTxyqgqWbsBgSCyP7pVBiyqnmLC/L4az9XnscrbAX4pNaoJxsuQe\nmzBo6yofjQaAzCX69DuqxFkVTRQnVy7LCFkVaZtjNAftnAHJjVgQw7lIhdGZp9q9\nIafRt2gteihYfpn+EAQ/t/E4MnhrYs4CPLfS7BaYXBycEKC5Muj1l4GijNNQ0Efo\nxG8LSZz7SNgUvfVwiNTaqfLP3AtEAWiqxyMyh3VO+1HpCjT7uNBFtmF3AgMBAAGj\nZjBkMA4GA1UdDwEB/wQEAwIBBjASBgNVHRMBAf8ECDAGAQH/AgEAMB0GA1UdDgQW\nBBQtinkdrj+0B2+qdXngV2tgHnPIujAfBgNVHSMEGDAWgBRp0xqULkNh/w2ZVzEI\no2RIY7O03TANBgkqhkiG9w0BAQsFAAOCAQEAtJdqbCxDeMc8VN1/RzCabw9BIL/z\n73Auh8eFTww/sup26yn8NWUkfbckeDYr1BrXa+rPyLfHpg06kwR8rBKyrs5mHwJx\nbvOzXD/5WTdgreB+2Fb7mXNvWhenYuji1MF+q1R2DXV3I05zWHteKX6Dajmx+Uuq\nYq78oaCBSV48hMxWlp8fm40ANCL1+gzQ122xweMFN09FmNYFhwuW+Ao+Vv90ZfQG\nPYwTvN4n/gegw2TYcifGZC2PNX74q3DH03DXe5fvNgRW5plgz/7f+9mS+YHd5qa9\ntYTPUvoRbi169ou6jicsMKUKPORHWhiTpSCWR1FMMIbsAcsyrvtIsuaGCQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQdOCSuA9psBpQd8EI368/0DANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIHNhLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTE5MTgwNjI2WhgPMjA2MTA1MTkxOTA2MjZaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgc2EtZWFzdC0xIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAN6ftL6w8v3dB2yW\nLjCxSP1D7ZsOTeLZOSCz1Zv0Gkd0XLhil5MdHOHBvwH/DrXqFU2oGzCRuAy+aZis\nDardJU6ChyIQIciXCO37f0K23edhtpXuruTLLwUwzeEPdcnLPCX+sWEn9Y5FPnVm\npCd6J8edH2IfSGoa9LdErkpuESXdidLym/w0tWG/O2By4TabkNSmpdrCL00cqI+c\nprA8Bx1jX8/9sY0gpAovtuFaRN+Ivg3PAnWuhqiSYyQ5nC2qDparOWuDiOhpY56E\nEgmTvjwqMMjNtExfYx6Rv2Ndu50TriiNKEZBzEtkekwXInTupmYTvc7U83P/959V\nUiQ+WSMCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU4uYHdH0+\nbUeh81Eq2l5/RJbW+vswDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQBhxcExJ+w74bvDknrPZDRgTeMLYgbVJjx2ExH7/Ac5FZZWcpUpFwWMIJJxtewI\nAnhryzM3tQYYd4CG9O+Iu0+h/VVfW7e4O3joWVkxNMb820kQSEwvZfA78aItGwOY\nWSaFNVRyloVicZRNJSyb1UL9EiJ9ldhxm4LTT0ax+4ontI7zTx6n6h8Sr6r/UOvX\nd9T5aUUENWeo6M9jGupHNn3BobtL7BZm2oS8wX8IVYj4tl0q5T89zDi2x0MxbsIV\n5ZjwqBQ5JWKv7ASGPb+z286RjPA9R2knF4lJVZrYuNV90rHvI/ECyt/JrDqeljGL\nBLl1W/UsvZo6ldLIpoMbbrb5\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBDCCAuygAwIBAgIQUfVbqapkLYpUqcLajpTJWzANBgkqhkiG9w0BAQsFADCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIG1lLWNlbnRyYWwtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwIBcNMjIwNTA2MjMyMDA5WhgPMjA2MjA1MDcwMDIwMDlaMIGa\nMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5j\nLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMzAxBgNVBAMMKkFt\nYXpvbiBSRFMgbWUtY2VudHJhbC0xIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAJIeovu3\newI9FVitXMQzvkh34aQ6WyI4NO3YepfJaePiv3cnyFGYHN2S1cR3UQcLWgypP5va\nj6bfroqwGbCbZZcb+6cyOB4ceKO9Ws1UkcaGHnNDcy5gXR7aCW2OGTUfinUuhd2d\n5bOGgV7JsPbpw0bwJ156+MwfOK40OLCWVbzy8B1kITs4RUPNa/ZJnvIbiMu9rdj4\n8y7GSFJLnKCjlOFUkNI5LcaYvI1+ybuNgphT3nuu5ZirvTswGakGUT/Q0J3dxP0J\npDfg5Sj/2G4gXiaM0LppVOoU5yEwVewhQ250l0eQAqSrwPqAkdTg9ng360zqCFPE\nJPPcgI1tdGUgneECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU\n/2AJVxWdZxc8eJgdpbwpW7b0f7IwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB\nCwUAA4IBAQBYm63jTu2qYKJ94gKnqc+oUgqmb1mTXmgmp/lXDbxonjszJDOXFbri\n3CCO7xB2sg9bd5YWY8sGKHaWmENj3FZpCmoefbUx++8D7Mny95Cz8R32rNcwsPTl\nebpd9A/Oaw5ug6M0x/cNr0qzF8Wk9Dx+nFEimp8RYQdKvLDfNFZHjPa1itnTiD8M\nTorAqj+VwnUGHOYBsT/0NY12tnwXdD+ATWfpEHdOXV+kTMqFFwDyhfgRVNpTc+os\nygr8SwhnSCpJPB/EYl2S7r+tgAbJOkuwUvGT4pTqrzDQEhwE7swgepnHC87zhf6l\nqN6mVpSnQKQLm6Ob5TeCEFgcyElsF5bH\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAOxu0I1QuMAhIeszB3fJIlkwCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyB1cy13ZXN0LTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTI0MjIwNjU5WhgPMjEyMTA1MjQyMzA2NTlaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgdXMtd2VzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEz4bylRcGqqDWdP7gQIIoTHdBK6FNtKH1\n4SkEIXRXkYDmRvL9Bci1MuGrwuvrka5TDj4b7e+csY0llEzHpKfq6nJPFljoYYP9\nuqHFkv77nOpJJ633KOr8IxmeHW5RXgrZo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQQikVz8wmjd9eDFRXzBIU8OseiGzAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIwf06Mcrpw1O0EBLBBrp84m37NYtOkE/0Z0O+C7D41wnXi\nEQdn6PXUVgdD23Gj82SrAjEAklhKs+liO1PtN15yeZR1Io98nFve+lLptaLakZcH\n+hfFuUtCqMbaI8CdvJlKnPqT\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nl9Se1Hsq0ZU5f+OZKQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\n5zT5+Bs=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nHing\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRANxgyBbnxgTEOpDul2ZnC0UwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtMyBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNjEwMTgxOTA3WhgPMjA2MTA2MTAxOTE5MDda\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtc291dGhlYXN0LTMgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nxnwSDAChrMkfk5TA4Dk8hKzStDlSlONzmd3fTG0Wqr5+x3EmFT6Ksiu/WIwEl9J2\nK98UI7vYyuZfCxUKb1iMPeBdVGqk0zb92GpURd+Iz/+K1ps9ZLeGBkzR8mBmAi1S\nOfpwKiTBzIv6E8twhEn4IUpHsdcuX/2Y78uESpJyM8O5CpkG0JaV9FNEbDkJeBUQ\nAo2qqNcH4R0Qcr5pyeqA9Zto1RswgL06BQMI9dTpfwSP5VvkvcNUaLl7Zv5WzLQE\nJzORWePvdPzzvWEkY/3FPjxBypuYwssKaERW0fkPDmPtykktP9W/oJolKUFI6pXp\ny+Y6p6/AVdnQD2zZjW5FhQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBT+jEKs96LC+/X4BZkUYUkzPfXdqTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAIGQqgqcQ6XSGkmNebzR6DhadTbfDmbYeN5N0Vuzv+Tdmufb\ntMGjdjnYMg4B+IVnTKQb+Ox3pL9gbX6KglGK8HupobmIRtwKVth+gYYz3m0SL/Nk\nhaWPYzOm0x3tJm8jSdufJcEob4/ATce9JwseLl76pSWdl5A4lLjnhPPKudUDfH+1\nBLNUi3lxpp6GkC8aWUPtupnhZuXddolTLOuA3GwTZySI44NfaFRm+o83N1jp+EwD\n6e94M4cTRzjUv6J3MZmSbdtQP/Tk1uz2K4bQZGP0PZC3bVpqiesdE/xr+wbu8uHr\ncM1JXH0AmXf1yIkTgyWzmvt0k1/vgcw5ixAqvvE=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEATCCAumgAwIBAgIRAMhw98EQU18mIji+unM2YH8wDQYJKoZIhvcNAQELBQAw\ngZgxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTExMC8GA1UEAwwo\nQW1hem9uIFJEUyBhcC1zb3V0aC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTAgFw0yMjA2MDYyMTQyMjJaGA8yMDYyMDYwNjIyNDIyMlowgZgx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTExMC8GA1UEAwwoQW1h\nem9uIFJEUyBhcC1zb3V0aC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwH\nU2VhdHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAIeeRoLfTm+7\nvqm7ZlFSx+1/CGYHyYrOOryM4/Z3dqYVHFMgWTR7V3ziO8RZ6yUanrRcWVX3PZbF\nAfX0KFE8OgLsXEZIX8odSrq86+/Th5eZOchB2fDBsUB7GuN2rvFBbM8lTI9ivVOU\nlbuTnYyb55nOXN7TpmH2bK+z5c1y9RVC5iQsNAl6IJNvSN8VCqXh31eK5MlKB4DT\n+Y3OivCrSGsjM+UR59uZmwuFB1h+icE+U0p9Ct3Mjq3MzSX5tQb6ElTNGlfmyGpW\nKh7GQ5XU1KaKNZXoJ37H53woNSlq56bpVrKI4uv7ATpdpFubOnSLtpsKlpLdR3sy\nWs245200pC8CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUp0ki\n6+eWvsnBjQhMxwMW5pwn7DgwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUA\nA4IBAQB2V8lv0aqbYQpj/bmVv/83QfE4vOxKCJAHv7DQ35cJsTyBdF+8pBczzi3t\n3VNL5IUgW6WkyuUOWnE0eqAFOUVj0yTS1jSAtfl3vOOzGJZmWBbqm9BKEdu1D8O6\nsB8bnomwiab2tNDHPmUslpdDqdabbkWwNWzLJ97oGFZ7KNODMEPXWKWNxg33iHfS\n/nlmnrTVI3XgaNK9qLZiUrxu9Yz5gxi/1K+sG9/Dajd32ZxjRwDipOLiZbiXQrsd\nqzIMY4GcWf3g1gHL5mCTfk7dG22h/rhPyGV0svaDnsb+hOt6sv1McMN6Y3Ou0mtM\n/UaAXojREmJmTSCNvs2aBny3/2sy\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAMnRxsKLYscJV8Qv5pWbL7swCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyBzYS1lYXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTgxNjAxWhgPMjEyMTA1MTkxOTE2MDFaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgc2EtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEjFOCZgTNVKxLKhUxffiDEvTLFhrmIqdO\ndKqVdgDoELEzIHWDdC+19aDPitbCYtBVHl65ITu/9pn6mMUl5hhUNtfZuc6A+Iw1\nsBe0v0qI3y9Q9HdQYrGgeHDh8M5P7E2ho0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBS5L7/8M0TzoBZk39Ps7BkfTB4yJTAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIwI43O0NtWKTgnVv9z0LO5UMZYgSve7GvGTwqktZYCMObE\nrUI4QerXM9D6JwLy09mqAjEAypfkdLyVWtaElVDUyHFkihAS1I1oUxaaDrynLNQK\nOu/Ay+ns+J+GyvyDUjBpVVW1\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nzDY=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAK5EYG3iHserxMqgg+0EFjgwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMyBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTI0MjAyMzE2WhgPMjA2MTA1MjQyMTIzMTZa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTMgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\ns1L6TtB84LGraLHVC+rGPhLBW2P0oN/91Rq3AnYwqDOuTom7agANwEjvLq7dSRG/\nsIfZsSV/ABTgArZ5sCmLjHFZAo8Kd45yA9byx20RcYtAG8IZl+q1Cri+s0XefzyO\nU6mlfXZkVe6lzjlfXBkrlE/+5ifVbJK4dqOS1t9cWIpgKqv5fbE6Qbq4LVT+5/WM\nVd2BOljuBMGMzdZubqFKFq4mzTuIYfnBm7SmHlZfTdfBYPP1ScNuhpjuzw4n3NCR\nEdU6dQv04Q6th4r7eiOCwbWI9LkmVbvBe3ylhH63lApC7MiiPYLlB13xBubVHVhV\nq1NHoNTi+zA3MN9HWicRxQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSuxoqm0/wjNiZLvqv+JlQwsDvTPDAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAFfTK/j5kv90uIbM8VaFdVbr/6weKTwehafT0pAk1bfLVX+7\nuf8oHgYiyKTTl0DFQicXejghXTeyzwoEkWSR8c6XkhD5vYG3oESqmt/RGvvoxz11\nrHHy7yHYu7RIUc3VQG60c4qxXv/1mWySGwVwJrnuyNT9KZXPevu3jVaWOVHEILaK\nHvzQ2YEcWBPmde/zEseO2QeeGF8FL45Q1d66wqIP4nNUd2pCjeTS5SpB0MMx7yi9\nki1OH1pv8tOuIdimtZ7wkdB8+JSZoaJ81b8sRrydRwJyvB88rftuI3YB4WwGuONT\nZezUPsmaoK69B0RChB0ofDpAaviF9V3xOWvVZfo=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\n1axqeKpI0F5SBUPsaVNYY2uNFg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECDCCAvCgAwIBAgIQCREfzzVyDTMcNME+gWnTCTANBgkqhkiG9w0BAQsFADCB\nnDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTUwMwYDVQQDDCxB\nbWF6b24gUkRTIGFwLXNvdXRoZWFzdC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4G\nA1UEBwwHU2VhdHRsZTAgFw0yMTA1MjQyMDQyMzNaGA8yMDYxMDUyNDIxNDIzM1ow\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDL\n1MT6br3L/4Pq87DPXtcjlXN3cnbNk2YqRAZHJayStTz8VtsFcGPJOpk14geRVeVk\ne9uKFHRbcyr/RM4owrJTj5X4qcEuATYZbo6ou/rW2kYzuWFZpFp7lqm0vasV4Z9F\nfChlhwkNks0UbM3G+psCSMNSoF19ERunj7w2c4E62LwujkeYLvKGNepjnaH10TJL\n2krpERd+ZQ4jIpObtRcMH++bTrvklc+ei8W9lqrVOJL+89v2piN3Ecdd389uphst\nqQdb1BBVXbhUrtuGHgVf7zKqN1SkCoktoWxVuOprVWhSvr7akaWeq0UmlvbEsujU\nvADqxGMcJFyCzxx3CkJjAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0O\nBBYEFFk8UJmlhoxFT3PP12PvhvazHjT4MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG\n9w0BAQsFAAOCAQEAfFtr2lGoWVXmWAsIo2NYre7kzL8Xb9Tx7desKxCCz5HOOvIr\n8JMB1YK6A7IOvQsLJQ/f1UnKRh3X3mJZjKIywfrMSh0FiDf+rjcEzXxw2dGtUem4\nA+WMvIA3jwxnJ90OQj5rQ8bg3iPtE6eojzo9vWQGw/Vu48Dtw1DJo9210Lq/6hze\nhPhNkFh8fMXNT7Q1Wz/TJqJElyAQGNOXhyGpHKeb0jHMMhsy5UNoW5hLeMS5ffao\nTBFWEJ1gVfxIU9QRxSh+62m46JIg+dwDlWv8Aww14KgepspRbMqDuaM2cinoejv6\nt3dyOyHHrsOyv3ffZUKtQhQbQr+sUcL89lARsg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAIJLTMpzGNxqHZ4t+c1MlCIwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyBhcC1lYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIxMzAzM1oYDzIwNjEwNTI1MjIzMDMzWjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFwLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDtdHut0ZhJ9Nn2\nMpVafFcwHdoEzx06okmmhjJsNy4l9QYVeh0UUoek0SufRNMRF4d5ibzpgZol0Y92\n/qKWNe0jNxhEj6sXyHsHPeYtNBPuDMzThfbvsLK8z7pBP7vVyGPGuppqW/6m4ZBB\nlcc9fsf7xpZ689iSgoyjiT6J5wlVgmCx8hFYc/uvcRtfd8jAHvheug7QJ3zZmIye\nV4htOW+fRVWnBjf40Q+7uTv790UAqs0Zboj4Yil+hER0ibG62y1g71XcCyvcVpto\n2/XW7Y9NCgMNqQ7fGN3wR1gjtSYPd7DO32LTzYhutyvfbpAZjsAHnoObmoljcgXI\nQjfBcCFpAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFJI3aWLg\nCS5xqU5WYVaeT5s8lpO0MA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAUwATpJOcGVOs3hZAgJwznWOoTzOVJKfrqBum7lvkVH1vBwxBl9CahaKj3ZOt\nYYp2qJzhDUWludL164DL4ZjS6eRedLRviyy5cRy0581l1MxPWTThs27z+lCC14RL\nPJZNVYYdl7Jy9Q5NsQ0RBINUKYlRY6OqGDySWyuMPgno2GPbE8aynMdKP+f6G/uE\nYHOf08gFDqTsbyfa70ztgVEJaRooVf5JJq4UQtpDvVswW2reT96qi6tXPKHN5qp3\n3wI0I1Mp4ePmiBKku2dwYzPfrJK/pQlvu0Gu5lKOQ65QdotwLAAoaFqrf9za1yYs\nINUkHLWIxDds+4OHNYcerGp5Dw==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIGCTCCA/GgAwIBAgIRAIO6ldra1KZvNWJ0TA1ihXEwDQYJKoZIhvcNAQEMBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtMSBSb290IENBIFJTQTQwOTYgRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTIxMjE0NTA1WhgPMjEyMTA1MjEyMjQ1MDVa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtc291dGhlYXN0LTEgUm9vdCBDQSBSU0E0MDk2IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA\nsDN52Si9pFSyZ1ruh3xAN0nVqEs960o2IK5CPu/ZfshFmzAwnx/MM8EHt/jMeZtj\nSM58LADAsNDL01ELpFZATjgZQ6xNAyXRXE7RiTRUvNkK7O3o2qAGbLnJq/UqF7Sw\nLRnB8V6hYOv+2EjVnohtGCn9SUFGZtYDjWXsLd4ML4Zpxv0a5LK7oEC7AHzbUR7R\njsjkrXqSv7GE7bvhSOhMkmgxgj1F3J0b0jdQdtyyj109aO0ATUmIvf+Bzadg5AI2\nA9UA+TUcGeebhpHu8AP1Hf56XIlzPpaQv3ZJ4vzoLaVNUC7XKzAl1dlvCl7Klg/C\n84qmbD/tjZ6GHtzpLKgg7kQEV7mRoXq8X4wDX2AFPPQl2fv+Kbe+JODqm5ZjGegm\nuskABBi8IFv1hYx9jEulZPxC6uD/09W2+niFm3pirnlWS83BwVDTUBzF+CooUIMT\njhWkIIZGDDgMJTzouBHfoSJtS1KpUZi99m2WyVs21MNKHeWAbs+zmI6TO5iiMC+T\nuB8spaOiHFO1573Fmeer4sy3YA6qVoqVl6jjTQqOdy3frAMbCkwH22/crV8YA+08\nhLeHXrMK+6XUvU+EtHAM3VzcrLbuYJUI2XJbzTj5g0Eb8I8JWsHvWHR5K7Z7gceR\n78AzxQmoGEfV6KABNWKsgoCQnfb1BidDJIe3BsI0A6UCAwEAAaNCMEAwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUABp0MlB14MSHgAcuNSOhs3MOlUcwDgYDVR0P\nAQH/BAQDAgGGMA0GCSqGSIb3DQEBDAUAA4ICAQCv4CIOBSQi/QR9NxdRgVAG/pAh\ntFJhV7OWb/wqwsNKFDtg6tTxwaahdCfWpGWId15OUe7G9LoPiKiwM9C92n0ZeHRz\n4ewbrQVo7Eu1JI1wf0rnZJISL72hVYKmlvaWaacHhWxvsbKLrB7vt6Cknxa+S993\nKf8i2Psw8j5886gaxhiUtzMTBwoDWak8ZaK7m3Y6C6hXQk08+3pnIornVSFJ9dlS\nPAqt5UPwWmrEfF+0uIDORlT+cvrAwgSp7nUF1q8iasledycZ/BxFgQqzNwnkBDwQ\nZ/aM52ArGsTzfMhkZRz9HIEhz1/0mJw8gZtDVQroD8778h8zsx2SrIz7eWQ6uWsD\nQEeSWXpcheiUtEfzkDImjr2DLbwbA23c9LoexUD10nwohhoiQQg77LmvBVxeu7WU\nE63JqaYUlOLOzEmNJp85zekIgR8UTkO7Gc+5BD7P4noYscI7pPOL5rP7YLg15ZFi\nega+G53NTckRXz4metsd8XFWloDjZJJq4FfD60VuxgXzoMNT9wpFTNSH42PR2s9L\nI1vcl3w8yNccs9se2utM2nLsItZ3J0m/+QSRiw9hbrTYTcM9sXki0DtH2kyIOwYf\nlOrGJDiYOIrXSQK36H0gQ+8omlrUTvUj4msvkXuQjlfgx6sgp2duOAfnGxE7uHnc\nUhnJzzoe6M+LfGHkVQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICuDCCAj2gAwIBAgIQSAG6j2WHtWUUuLGJTPb1nTAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMDE2MzgyNloYDzIxMjEwNTIwMTczODI2WjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE2eqwU4FOzW8RV1W381Bd\nolhDOrqoMqzWli21oDUt7y8OnXM/lmAuOS6sr8Nt61BLVbONdbr+jgCYw75KabrK\nZGg3siqvMOgabIKkKuXO14wtrGyGDt7dnKXg5ERGYOZlo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBS1Acp2WYxOcblv5ikZ3ZIbRCCW+zAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaQAwZgIxAJL84J08PBprxmsAKPTotBuVI3MyW1r8\nxQ0i8lgCQUf8GcmYjQ0jI4oZyv+TuYJAcwIxAP9Xpzq0Docxb+4N1qVhpiOfWt1O\nFnemFiy9m1l+wv6p3riQMPV7mBVpklmijkIv3Q==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRALZLcqCVIJ25maDPE3sbPCIwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTIxMjEzOTM5WhgPMjA2MTA1MjEyMjM5Mzla\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtc291dGhlYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nypKc+6FfGx6Gl6fQ78WYS29QoKgQiur58oxR3zltWeg5fqh9Z85K5S3UbRSTqWWu\nXcfnkz0/FS07qHX+nWAGU27JiQb4YYqhjZNOAq8q0+ptFHJ6V7lyOqXBq5xOzO8f\n+0DlbJSsy7GEtJp7d7QCM3M5KVY9dENVZUKeJwa8PC5StvwPx4jcLeZRJC2rAVDG\nSW7NAInbATvr9ssSh03JqjXb+HDyywiqoQ7EVLtmtXWimX+0b3/2vhqcH5jgcKC9\nIGFydrjPbv4kwMrKnm6XlPZ9L0/3FMzanXPGd64LQVy51SI4d5Xymn0Mw2kMX8s6\nNf05OsWcDzJ1n6/Q1qHSxQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRmaIc8eNwGP7i6P7AJrNQuK6OpFzAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAIBeHfGwz3S2zwIUIpqEEI5/sMySDeS+3nJR+woWAHeO0C8i\nBJdDh+kzzkP0JkWpr/4NWz84/IdYo1lqASd1Kopz9aT1+iROXaWr43CtbzjXb7/X\nZv7eZZFC8/lS5SROq42pPWl4ekbR0w8XGQElmHYcWS41LBfKeHCUwv83ATF0XQ6I\n4t+9YSqZHzj4vvedrvcRInzmwWJaal9s7Z6GuwTGmnMsN3LkhZ+/GD6oW3pU/Pyh\nEtWqffjsLhfcdCs3gG8x9BbkcJPH5aPAVkPn4wc8wuXg6xxb9YGsQuY930GWTYRf\nschbgjsuqznW4HHakq4WNhs1UdTSTKkRdZz7FUQ=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEDzCCAvegAwIBAgIRAM2zAbhyckaqRim63b+Tib8wDQYJKoZIhvcNAQELBQAw\ngZ8xCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE4MDYGA1UEAwwv\nQW1hem9uIFJEUyBQcmV2aWV3IHVzLWVhc3QtMiBSb290IENBIFJTQTIwNDggRzEx\nEDAOBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTE4MjA0OTQ1WhgPMjA2MTA1MTgyMTQ5\nNDVaMIGfMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNl\ncywgSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExODA2BgNV\nBAMML0FtYXpvbiBSRFMgUHJldmlldyB1cy1lYXN0LTIgUm9vdCBDQSBSU0EyMDQ4\nIEcxMRAwDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIB\nCgKCAQEA1ybjQMH1MkbvfKsWJaCTXeCSN1SG5UYid+Twe+TjuSqaXWonyp4WRR5z\ntlkqq+L2MWUeQQAX3S17ivo/t84mpZ3Rla0cx39SJtP3BiA2BwfUKRjhPwOjmk7j\n3zrcJjV5k1vSeLNOfFFSlwyDiVyLAE61lO6onBx+cRjelu0egMGq6WyFVidTdCmT\nQ9Zw3W6LTrnPvPmEyjHy2yCHzH3E50KSd/5k4MliV4QTujnxYexI2eR8F8YQC4m3\nDYjXt/MicbqA366SOoJA50JbgpuVv62+LSBu56FpzY12wubmDZsdn4lsfYKiWxUy\nuc83a2fRXsJZ1d3whxrl20VFtLFHFQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/\nMB0GA1UdDgQWBBRC0ytKmDYbfz0Bz0Psd4lRQV3aNTAOBgNVHQ8BAf8EBAMCAYYw\nDQYJKoZIhvcNAQELBQADggEBAGv8qZu4uaeoF6zsbumauz6ea6tdcWt+hGFuwGrb\ntRbI85ucAmVSX06x59DJClsb4MPhL1XmqO3RxVMIVVfRwRHWOsZQPnXm8OYQ2sny\nrYuFln1COOz1U/KflZjgJmxbn8x4lYiTPZRLarG0V/OsCmnLkQLPtEl/spMu8Un7\nr3K8SkbWN80gg17Q8EV5mnFwycUx9xsTAaFItuG0en9bGsMgMmy+ZsDmTRbL+lcX\nFq8r4LT4QjrFz0shrzCwuuM4GmcYtBSxlacl+HxYEtAs5k10tmzRf6OYlY33tGf6\n1tkYvKryxDPF/EDgGp/LiBwx6ixYMBfISoYASt4V/ylAlHA=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICtTCCAjqgAwIBAgIRAK9BSZU6nIe6jqfODmuVctYwCgYIKoZIzj0EAwMwgZkx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1h\nem9uIFJEUyBjYS1jZW50cmFsLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTIxMjIxMzA5WhgPMjEyMTA1MjEyMzEzMDlaMIGZMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMjAwBgNVBAMMKUFtYXpv\nbiBSRFMgY2EtY2VudHJhbC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEUkEERcgxneT5H+P+fERcbGmf\nbVx+M7rNWtgWUr6w+OBENebQA9ozTkeSg4c4M+qdYSObFqjxITdYxT1z/nHz1gyx\nOKAhLjWu+nkbRefqy3RwXaWT680uUaAP6ccnkZOMo0IwQDAPBgNVHRMBAf8EBTAD\nAQH/MB0GA1UdDgQWBBSN6fxlg0s5Wny08uRBYZcQ3TUoyzAOBgNVHQ8BAf8EBAMC\nAYYwCgYIKoZIzj0EAwMDaQAwZgIxAORaz+MBVoFBTmZ93j2G2vYTwA6T5hWzBWrx\nCrI54pKn5g6At56DBrkjrwZF5T1enAIxAJe/LZ9xpDkAdxDgGJFN8gZYLRWc0NRy\nRb4hihy5vj9L+w9uKc9VfEBIFuhT7Z3ljg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQB/57HSuaqUkLaasdjxUdPjANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGFwLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxOTE3NDAzNFoYDzIwNjEwNTE5MTg0MDM0WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGFwLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAtbkaoVsUS76o\nTgLFmcnaB8cswBk1M3Bf4IVRcwWT3a1HeJSnaJUqWHCJ+u3ip/zGVOYl0gN1MgBb\nMuQRIJiB95zGVcIa6HZtx00VezDTr3jgGWRHmRjNVCCHGmxOZWvJjsIE1xavT/1j\nQYV/ph4EZEIZ/qPq7e3rHohJaHDe23Z7QM9kbyqp2hANG2JtU/iUhCxqgqUHNozV\nZd0l5K6KnltZQoBhhekKgyiHqdTrH8fWajYl5seD71bs0Axowb+Oh0rwmrws3Db2\nDh+oc2PwREnjHeca9/1C6J2vhY+V0LGaJmnnIuOANrslx2+bgMlyhf9j0Bv8AwSi\ndSWsobOhNQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQb7vJT\nVciLN72yJGhaRKLn6Krn2TAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAAxEj8N9GslReAQnNOBpGl8SLgCMTejQ6AW/bapQvzxrZrfVOZOYwp/5oV0f\n9S1jcGysDM+DrmfUJNzWxq2Y586R94WtpH4UpJDGqZp+FuOVJL313te4609kopzO\nlDdmd+8z61+0Au93wB1rMiEfnIMkOEyt7D2eTFJfJRKNmnPrd8RjimRDlFgcLWJA\n3E8wca67Lz/G0eAeLhRHIXv429y8RRXDtKNNz0wA2RwURWIxyPjn1fHjA9SPDkeW\nE1Bq7gZj+tBnrqz+ra3yjZ2blss6Ds3/uRY6NYqseFTZWmQWT7FolZEnT9vMUitW\nI0VynUbShVpGf6946e0vgaaKw20=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQGyUVTaVjYJvWhroVEiHPpDANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIHVzLXdlc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTE5MTkwNDA2WhgPMjA2MTA1MTkyMDA0MDZaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgdXMtd2VzdC0xIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBANhyXpJ0t4nigRDZ\nEwNtFOem1rM1k8k5XmziHKDvDk831p7QsX9ZOxl/BT59Pu/P+6W6SvasIyKls1sW\nFJIjFF+6xRQcpoE5L5evMgN/JXahpKGeQJPOX9UEXVW5B8yi+/dyUitFT7YK5LZA\nMqWBN/LtHVPa8UmE88RCDLiKkqiv229tmwZtWT7nlMTTCqiAHMFcryZHx0pf9VPh\nx/iPV8p2gBJnuPwcz7z1kRKNmJ8/cWaY+9w4q7AYlAMaq/rzEqDaN2XXevdpsYAK\nTMMj2kji4x1oZO50+VPNfBl5ZgJc92qz1ocF95SAwMfOUsP8AIRZkf0CILJYlgzk\n/6u6qZECAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUm5jfcS9o\n+LwL517HpB6hG+PmpBswDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQAcQ6lsqxi63MtpGk9XK8mCxGRLCad51+MF6gcNz6i6PAqhPOoKCoFqdj4cEQTF\nF8dCfa3pvfJhxV6RIh+t5FCk/y6bWT8Ls/fYKVo6FhHj57bcemWsw/Z0XnROdVfK\nYqbc7zvjCPmwPHEqYBhjU34NcY4UF9yPmlLOL8uO1JKXa3CAR0htIoW4Pbmo6sA4\n6P0co/clW+3zzsQ92yUCjYmRNeSbdXbPfz3K/RtFfZ8jMtriRGuO7KNxp8MqrUho\nHK8O0mlSUxGXBZMNicfo7qY8FD21GIPH9w5fp5oiAl7lqFzt3E3sCLD3IiVJmxbf\nfUwpGd1XZBBSdIxysRLM6j48\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrTCCAjOgAwIBAgIQU+PAILXGkpoTcpF200VD/jAKBggqhkjOPQQDAzCBljEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMS8wLQYDVQQDDCZBbWF6\nb24gUkRTIGFwLWVhc3QtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTAgFw0yMTA1MjUyMTQ1MTFaGA8yMTIxMDUyNTIyNDUxMVowgZYxCzAJBgNV\nBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYD\nVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1hem9uIFJE\nUyBhcC1lYXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0bGUw\ndjAQBgcqhkjOPQIBBgUrgQQAIgNiAAT3tFKE8Kw1sGQAvNLlLhd8OcGhlc7MiW/s\nNXm3pOiCT4vZpawKvHBzD76Kcv+ZZzHRxQEmG1/muDzZGlKR32h8AAj+NNO2Wy3d\nCKTtYMiVF6Z2zjtuSkZQdjuQbe4eQ7qjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFAiSQOp16Vv0Ohpvqcbd2j5RmhYNMA4GA1UdDwEB/wQEAwIBhjAKBggq\nhkjOPQQDAwNoADBlAjBVsi+5Ape0kOhMt/WFkANkslD4qXA5uqhrfAtH29Xzz2NV\ntR7akiA771OaIGB/6xsCMQCZt2egCtbX7J0WkuZ2KivTh66jecJr5DHvAP4X2xtS\nF/5pS+AUhcKTEGjI9jDH3ew=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICuDCCAj2gAwIBAgIQT5mGlavQzFHsB7hV6Mmy6TAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNDIwNTAxNVoYDzIxMjEwNTI0MjE1MDE1WjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEcm4BBBjYK7clwm0HJRWS\nflt3iYwoJbIXiXn9c1y3E+Vb7bmuyKhS4eO8mwO4GefUcXObRfoHY2TZLhMJLVBQ\n7MN2xDc0RtZNj07BbGD3VAIFRTDX0mH9UNYd0JQM3t/Oo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBRrd5ITedfAwrGo4FA9UaDaGFK3rjAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaQAwZgIxAPBNqmVv1IIA3EZyQ6XuVf4gj79/DMO8\nbkicNS1EcBpUqbSuU4Zwt2BYc8c/t7KVOQIxAOHoWkoKZPiKyCxfMtJpCZySUG+n\nsXgB/LOyWE5BJcXUfm+T1ckeNoWeUUMOLmnJjg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAJcDeinvdNrDQBeJ8+t38WQwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1zb3V0aGVhc3QtNCBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjIwNTI1MTY0OTE2WhgPMjA2MjA1MjUxNzQ5MTZa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtc291dGhlYXN0LTQgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nk8DBNkr9tMoIM0NHoFiO7cQfSX0cOMhEuk/CHt0fFx95IBytx7GHCnNzpM27O5z6\nx6iRhfNnx+B6CrGyCzOjxvPizneY+h+9zfvNz9jj7L1I2uYMuiNyOKR6FkHR46CT\n1CiArfVLLPaTqgD/rQjS0GL2sLHS/0dmYipzynnZcs613XT0rAWdYDYgxDq7r/Yi\nXge5AkWQFkMUq3nOYDLCyGGfQqWKkwv6lZUHLCDKf+Y0Uvsrj8YGCI1O8mF0qPCQ\nlmlfaDvbuBu1AV+aabmkvyFj3b8KRIlNLEtQ4N8KGYR2Jdb82S4YUGIOAt4wuuFt\n1B7AUDLk3V/u+HTWiwfoLQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBSNpcjz6ArWBtAA+Gz6kyyZxrrgdDAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAGJEd7UgOzHYIcQRSF7nSYyjLROyalaIV9AX4WXW/Cqlul1c\nMblP5etDZm7A/thliZIWAuyqv2bNicmS3xKvNy6/QYi1YgxZyy/qwJ3NdFl067W0\nt8nGo29B+EVK94IPjzFHWShuoktIgp+dmpijB7wkTIk8SmIoe9yuY4+hzgqk+bo4\nms2SOXSN1DoQ75Xv+YmztbnZM8MuWhL1T7hA4AMorzTQLJ9Pof8SpSdMHeDsHp0R\n01jogNFkwy25nw7cL62nufSuH2fPYGWXyNDg+y42wKsKWYXLRgUQuDVEJ2OmTFMB\nT0Vf7VuNijfIA9hkN2d3K53m/9z5WjGPSdOjGhg=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQRiwspKyrO0xoxDgSkqLZczANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIHVzLXdlc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTI0MjE1OTAwWhgPMjA2MTA1MjQyMjU5MDBaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgdXMtd2VzdC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAL53Jk3GsKiu+4bx\njDfsevWbwPCNJ3H08Zp7GWhvI3Tgi39opfHYv2ku2BKFjK8N2L6RvNPSR8yplv5j\nY0tK0U+XVNl8o0ibhqRDhbTuh6KL8CFINWYzAajuxFS+CF0U6c1Q3tXLBdALxA7l\nFlXJ71QrP06W31kRe7kvgrvO7qWU3/OzUf9qYw4LSiR1/VkvvRCTqcVNw09clw/M\nJbw6FSgweN65M9j7zPbjGAXSHkXyxH1Erin2fa+B9PE4ZDgX9cp2C1DHewYJQL/g\nSepwwcudVNRN1ibKH7kpMrgPnaNIVNx5sXVsTjk6q2ZqYw3SVHegltJpLy/cZReP\nmlivF2kCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUmTcQd6o1\nCuS65MjBrMwQ9JJjmBwwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQAKSDSIzl956wVddPThf2VAzI8syw9ngSwsEHZvxVGHBvu5gg618rDyguVCYX9L\n4Kw/xJrk6S3qxOS2ZDyBcOpsrBskgahDFIunzoRP3a18ARQVq55LVgfwSDQiunch\nBd05cnFGLoiLkR5rrkgYaP2ftn3gRBRaf0y0S3JXZ2XB3sMZxGxavYq9mfiEcwB0\nLMTMQ1NYzahIeG6Jm3LqRqR8HkzP/Ztq4dT2AtSLvFebbNMiWqeqT7OcYp94HTYT\nzqrtaVdUg9bwyAUCDgy0GV9RHDIdNAOInU/4LEETovrtuBU7Z1q4tcHXvN6Hd1H8\ngMb0mCG5I393qW5hFsA/diFb\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAPQAvihfjBg/JDbj6U64K98wDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTIwMTYyODQxWhgPMjA2MTA1MjAxNzI4NDFa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\nvJ9lgyksCxkBlY40qOzI1TCj/Q0FVGuPL/Z1Mw2YN0l+41BDv0FHApjTUkIKOeIP\nnwDwpXTa3NjYbk3cOZ/fpH2rYJ++Fte6PNDGPgKppVCUh6x3jiVZ1L7wOgnTdK1Q\nTrw8440IDS5eLykRHvz8OmwvYDl0iIrt832V0QyOlHTGt6ZJ/aTQKl12Fy3QBLv7\nstClPzvHTrgWqVU6uidSYoDtzHbU7Vda7YH0wD9IUoMBf7Tu0rqcE4uH47s2XYkc\nSdLEoOg/Ngs7Y9B1y1GCyj3Ux7hnyvCoRTw014QyNB7dTatFMDvYlrRDGG14KeiU\nUL7Vo/+EejWI31eXNLw84wIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBQkgTWFsNg6wA3HbbihDQ4vpt1E2zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAGz1Asiw7hn5WYUj8RpOCzpE0h/oBZcnxP8wulzZ5Xd0YxWO\n0jYUcUk3tTQy1QvoY+Q5aCjg6vFv+oFBAxkib/SmZzp4xLisZIGlzpJQuAgRkwWA\n6BVMgRS+AaOMQ6wKPgz1x4v6T0cIELZEPq3piGxvvqkcLZKdCaeC3wCS6sxuafzZ\n4qA3zMwWuLOzRftgX2hQto7d/2YkRXga7jSvQl3id/EI+xrYoH6zIWgjdU1AUaNq\nNGT7DIo47vVMfnd9HFZNhREsd4GJE83I+JhTqIxiKPNxrKgESzyADmNPt0gXDnHo\ntbV1pMZz5HpJtjnP/qVZhEK5oB0tqlKPv9yx074=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICuTCCAj6gAwIBAgIRAKp1Rn3aL/g/6oiHVIXtCq8wCgYIKoZIzj0EAwMwgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMyBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTAgFw0yMTA1MjQyMDMyMTdaGA8yMTIxMDUyNDIxMzIxN1owgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1ub3J0aGVhc3QtMyBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABGTYWPILeBJXfcL3Dz4z\nEWMUq78xB1HpjBwHoTURYfcMd5r96BTVG6yaUBWnAVCMeeD6yTG9a1eVGNhG14Hk\nZAEjgLiNB7RRbEG5JZ/XV7W/vODh09WCst2y9SLKsdgeAaNCMEAwDwYDVR0TAQH/\nBAUwAwEB/zAdBgNVHQ4EFgQUoE0qZHmDCDB+Bnm8GUa/evpfPwgwDgYDVR0PAQH/\nBAQDAgGGMAoGCCqGSM49BAMDA2kAMGYCMQCnil5MMwhY3qoXv0xvcKZGxGPaBV15\n0CCssCKn0oVtdJQfJQ3Jrf3RSaEyijXIJsoCMQC35iJi4cWoNX3N/qfgnHohW52O\nB5dg0DYMqy5cNZ40+UcAanRMyqNQ6P7fy3umGco=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICtzCCAj2gAwIBAgIQPXnDTPegvJrI98qz8WxrMjAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIEJldGEgdXMtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxODIxNDAxMloYDzIxMjEwNTE4MjI0MDEyWjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIEJldGEgdXMtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEI0sR7gwutK5AB46hM761\ngcLTGBIYlURSEoM1jcBwy56CL+3CJKZwLLyJ7qoOKfWbu5GsVLUTWS8MV6Nw33cx\n2KQD2svb694wi+Px2f4n9+XHkEFQw8BbiodDD7RZA70fo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBTQSioOvnVLEMXwNSDg+zgln/vAkjAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIxAMwu1hqm5Bc98uE/E0B5iMYbBQ4kpMxO\ntP8FTfz5UR37HUn26nXE0puj6S/Ffj4oJgIwXI7s2c26tFQeqzq6u3lrNJHp5jC9\nUxlo/hEJOLoDj5jnpxo8dMAtCNoQPaHdfL0P\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjWgAwIBAgIQGKVv+5VuzEZEBzJ+bVfx2zAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFwLXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTc1MDU5WhgPMjEyMTA1MTkxODUwNTlaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgYXAtc291dGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABMqdLJ0tZF/DGFZTKZDrGRJZID8ivC2I\nJRCYTWweZKCKSCAzoiuGGHzJhr5RlLHQf/QgmFcgXsdmO2n3CggzhA4tOD9Ip7Lk\nP05eHd2UPInyPCHRgmGjGb0Z+RdQ6zkitKNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUC1yhRgVqU5bR8cGzOUCIxRpl4EYwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2cAMGQCMG0c/zLGECRPzGKJvYCkpFTCUvdP4J74YP0v/dPvKojL\nt/BrR1Tg4xlfhaib7hPc7wIwFvgqHes20CubQnZmswbTKLUrgSUW4/lcKFpouFd2\nt2/ewfi/0VhkeUW+IiHhOMdU\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIGCTCCA/GgAwIBAgIRAOXxJuyXVkbfhZCkS/dOpfEwDQYJKoZIhvcNAQEMBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMSBSb290IENBIFJTQTQwOTYgRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTI1MjE1OTEwWhgPMjEyMTA1MjUyMjU5MTBa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTEgUm9vdCBDQSBSU0E0MDk2IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA\nxiP4RDYm4tIS12hGgn1csfO8onQDmK5SZDswUpl0HIKXOUVVWkHNlINkVxbdqpqH\nFhbyZmNN6F/EWopotMDKe1B+NLrjNQf4zefv2vyKvPHJXhxoKmfyuTd5Wk8k1F7I\nlNwLQzznB+ElhrLIDJl9Ro8t31YBBNFRGAGEnxyACFGcdkjlsa52UwfYrwreEg2l\ngW5AzqHgjFfj9QRLydeU/n4bHm0F1adMsV7P3rVwilcUlqsENDwXnWyPEyv3sw6F\nwNemLEs1129mB77fwvySb+lLNGsnzr8w4wdioZ74co+T9z2ca+eUiP+EQccVw1Is\nD4Fh57IjPa6Wuc4mwiUYKkKY63+38aCfEWb0Qoi+zW+mE9nek6MOQ914cN12u5LX\ndBoYopphRO5YmubSN4xcBy405nIdSdbrAVWwxXnVVyjqjknmNeqQsPZaxAhdoKhV\nAqxNr8AUAdOAO6Sz3MslmcLlDXFihrEEOeUbpg/m1mSUUHGbu966ajTG1FuEHHwS\n7WB52yxoJo/tHvt9nAWnh3uH5BHmS8zn6s6CGweWKbX5yICnZ1QFR1e4pogxX39v\nXD6YcNOO+Vn+HY4nXmjgSYVC7l+eeP8eduMg1xJujzjrbmrXU+d+cBObgdTOAlpa\nJFHaGwYw1osAwPCo9cZ2f04yitBfj9aPFia8ASKldakCAwEAAaNCMEAwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUqKS+ltlior0SyZKYAkJ/efv55towDgYDVR0P\nAQH/BAQDAgGGMA0GCSqGSIb3DQEBDAUAA4ICAQAdElvp8bW4B+Cv+1WSN87dg6TN\nwGyIjJ14/QYURgyrZiYpUmZpj+/pJmprSWXu4KNyqHftmaidu7cdjL5nCAvAfnY5\n/6eDDbX4j8Gt9fb/6H9y0O0dn3mUPSEKG0crR+JRFAtPhn/2FNvst2P82yguWLv0\npHjHVUVcq+HqDMtUIJsTPYjSh9Iy77Q6TOZKln9dyDOWJpCSkiUWQtMAKbCSlvzd\nzTs/ahqpT+zLfGR1SR+T3snZHgQnbnemmz/XtlKl52NxccARwfcEEKaCRQyGq/pR\n0PVZasyJS9JY4JfQs4YOdeOt4UMZ8BmW1+BQWGSkkb0QIRl8CszoKofucAlqdPcO\nIT/ZaMVhI580LFGWiQIizWFskX6lqbCyHqJB3LDl8gJISB5vNTHOHpvpMOMs5PYt\ncRl5Mrksx5MKMqG7y5R734nMlZxQIHjL5FOoOxTBp9KeWIL/Ib89T2QDaLw1SQ+w\nihqWBJ4ZdrIMWYpP3WqM+MXWk7WAem+xsFJdR+MDgOOuobVQTy5dGBlPks/6gpjm\nrO9TjfQ36ppJ3b7LdKUPeRfnYmlR5RU4oyYJ//uLbClI443RZAgxaCXX/nyc12lr\neVLUMNF2abLX4/VF63m2/Z9ACgMRfqGshPssn1NN33OonrotQoj4S3N9ZrjvzKt8\niHcaqd60QKpfiH2A3A==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICuDCCAj2gAwIBAgIQPaVGRuu86nh/ylZVCLB0MzAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIyMDMxNloYDzIxMjEwNTI1MjMwMzE2WjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLW5vcnRoZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEexNURoB9KE93MEtEAlJG\nobz4LS/pD2hc8Gczix1WhVvpJ8bN5zCDXaKdnDMCebetyRQsmQ2LYlfmCwpZwSDu\n0zowB11Pt3I5Avu2EEcuKTlKIDMBeZ1WWuOd3Tf7MEAMo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBSaYbZPBvFLikSAjpa8mRJvyArMxzAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaQAwZgIxAOEJkuh3Zjb7Ih/zuNRd1RBqmIYcnyw0\nnwUZczKXry+9XebYj3VQxSRNadrarPWVqgIxAMg1dyGoDAYjY/L/9YElyMnvHltO\nPwpJShmqHvCLc/mXMgjjYb/akK7yGthvW6j/uQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\n6YYLNPRrj3mi9T/f\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAMkvdFnVDb0mWWFiXqnKH68wCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyB1cy13ZXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTkxMzI0WhgPMjEyMTA1MTkyMDEzMjRaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgdXMtd2VzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEy86DB+9th/0A5VcWqMSWDxIUblWTt/R0\nao6Z2l3vf2YDF2wt1A2NIOGpfQ5+WAOJO/IQmnV9LhYo+kacB8sOnXdQa6biZZkR\nIyouUfikVQAKWEJnh1Cuo5YMM4E2sUt5o0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBQ8u3OnecANmG8OoT7KLWDuFzZwBTAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIwQ817qkb7mWJFnieRAN+m9W3E0FLVKaV3zC5aYJUk2fcZ\nTaUx3oLp3jPLGvY5+wgeAjEA6wAicAki4ZiDfxvAIuYiIe1OS/7H5RA++R8BH6qG\niRzUBM/FItFpnkus7u/eTkvo\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQS/+Ryfgb/IOVEa1pWoe8oTAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFwLXNvdXRoLTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjIwNjA2MjE1NDQyWhgPMjEyMjA2MDYyMjU0NDJaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgYXAtc291dGgtMiBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDsX6fhdUWBQpYTdseBD/P3s96Dtw2Iw\nOrXKNToCnmX5nMkUGdRn9qKNiz1pw3EPzaPxShbYwQ7LYP09ENK/JN4QQjxMihxC\njLFxS85nhBQQQGRCWikDAe38mD8fSvREQKNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUIh1xZiseQYFjPYKJmGbruAgRH+AwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMFudS4zLy+UUGrtgNLtRMcu/DZ9BUzV4NdHxo0bkG44O\nthnjl4+wTKI6VbyAbj2rkgIxAOHps8NMITU5DpyiMnKTxV8ubb/WGHrLl0BjB8Lw\nETVJk5DNuZvsIIcm7ykk6iL4Tw==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\ncuLMVcQZceE=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQAhAteLRCvizAElaWORFU2zANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMDE3MDkxNloYDzIwNjEwNTIwMTgwOTE2WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA+qg7JAcOVKjh\nN83SACnBFZPyB63EusfDr/0V9ZdL8lKcmZX9sv/CqoBo3N0EvBqHQqUUX6JvFb7F\nXrMUZ740kr28gSRALfXTFgNODjXeDsCtEkKRTkac/UM8xXHn+hR7UFRPHS3e0GzI\niLiwQWDkr0Op74W8aM0CfaVKvh2bp4BI1jJbdDnQ9OKXpOxNHGUf0ZGb7TkNPkgI\nb2CBAc8J5o3H9lfw4uiyvl6Fz5JoP+A+zPELAioYBXDrbE7wJeqQDJrETWqR9VEK\nBXURCkVnHeaJy123MpAX2ozf4pqk0V0LOEOZRS29I+USF5DcWr7QIXR/w2I8ws1Q\n7ys+qbE+kQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQFJ16n\n1EcCMOIhoZs/F9sR+Jy++zAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAOc5nXbT3XTDEZsxX2iD15YrQvmL5m13B3ImZWpx/pqmObsgx3/dg75rF2nQ\nqS+Vl+f/HLh516pj2BPP/yWCq12TRYigGav8UH0qdT3CAClYy2o+zAzUJHm84oiB\nud+6pFVGkbqpsY+QMpJUbZWu52KViBpJMYsUEy+9cnPSFRVuRAHjYynSiLk2ZEjb\nWkdc4x0nOZR5tP0FgrX0Ve2KcjFwVQJVZLgOUqmFYQ/G0TIIGTNh9tcmR7yp+xJR\nA2tbPV2Z6m9Yxx4E8lLEPNuoeouJ/GR4CkMEmF8cLwM310t174o3lKKUXJ4Vs2HO\nWj2uN6R9oI+jGLMSswTzCNV1vgc=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICuDCCAj6gAwIBAgIRAOocLeZWjYkG/EbHmscuy8gwCgYIKoZIzj0EAwMwgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTAgFw0yMTA1MjEyMTUwMDFaGA8yMTIxMDUyMTIyNTAwMVowgZsx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE0MDIGA1UEAwwrQW1h\nem9uIFJEUyBhcC1zb3V0aGVhc3QtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABCEr3jq1KtRncnZfK5cq\nbtY0nW6ZG3FMbh7XwBIR6Ca0f8llGZ4vJEC1pXgiM/4Dh045B9ZIzNrR54rYOIfa\n2NcYZ7mk06DjIQML64hbAxbQzOAuNzLPx268MrlL2uW2XaNCMEAwDwYDVR0TAQH/\nBAUwAwEB/zAdBgNVHQ4EFgQUln75pChychwN4RfHl+tOinMrfVowDgYDVR0PAQH/\nBAQDAgGGMAoGCCqGSM49BAMDA2gAMGUCMGiyPINRU1mwZ4Crw01vpuPvxZxb2IOr\nyX3RNlOIu4We1H+5dQk5tIvH8KGYFbWEpAIxAO9NZ6/j9osMhLgZ0yj0WVjb+uZx\nYlZR9fyFisY/jNfX7QhSk+nrc3SFLRUNtpXrng==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBTCCAu2gAwIBAgIRAKiaRZatN8eiz9p0s0lu0rQwDQYJKoZIhvcNAQELBQAw\ngZoxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEzMDEGA1UEAwwq\nQW1hem9uIFJEUyBjYS1jZW50cmFsLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYD\nVQQHDAdTZWF0dGxlMCAXDTIxMDUyMTIyMDIzNVoYDzIwNjEwNTIxMjMwMjM1WjCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIGNhLWNlbnRyYWwtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCygVMf\nqB865IR9qYRBRFHn4eAqGJOCFx+UbraQZmjr/mnRqSkY+nhbM7Pn/DWOrRnxoh+w\nq5F9ZxdZ5D5T1v6kljVwxyfFgHItyyyIL0YS7e2h7cRRscCM+75kMedAP7icb4YN\nLfWBqfKHbHIOqvvQK8T6+Emu/QlG2B5LvuErrop9K0KinhITekpVIO4HCN61cuOe\nCADBKF/5uUJHwS9pWw3uUbpGUwsLBuhJzCY/OpJlDqC8Y9aToi2Ivl5u3/Q/sKjr\n6AZb9lx4q3J2z7tJDrm5MHYwV74elGSXoeoG8nODUqjgklIWAPrt6lQ3WJpO2kug\n8RhCdSbWkcXHfX95AgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFOIxhqTPkKVqKBZvMWtKewKWDvDBMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\nAQsFAAOCAQEAqoItII89lOl4TKvg0I1EinxafZLXIheLcdGCxpjRxlZ9QMQUN3yb\ny/8uFKBL0otbQgJEoGhxm4h0tp54g28M6TN1U0332dwkjYxUNwvzrMaV5Na55I2Z\n1hq4GB3NMXW+PvdtsgVOZbEN+zOyOZ5MvJHEQVkT3YRnf6avsdntltcRzHJ16pJc\nY8rR7yWwPXh1lPaPkxddrCtwayyGxNbNmRybjR48uHRhwu7v2WuAMdChL8H8bp89\nTQLMrMHgSbZfee9hKhO4Zebelf1/cslRSrhkG0ESq6G5MUINj6lMg2g6F0F7Xz2v\nncD/vuRN5P+vT8th/oZ0Q2Gc68Pun0cn/g==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAJYlnmkGRj4ju/2jBQsnXJYwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyB1cy1lYXN0LTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMTIzMDQ0NFoYDzIwNjEwNTIyMDAwNDQ0WjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIHVzLWVhc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQC74V3eigv+pCj5\nnqDBqplY0Jp16pTeNB06IKbzb4MOTvNde6QjsZxrE1xUmprT8LxQqN9tI3aDYEYk\nb9v4F99WtQVgCv3Y34tYKX9NwWQgwS1vQwnIR8zOFBYqsAsHEkeJuSqAB12AYUSd\nZv2RVFjiFmYJho2X30IrSLQfS/IE3KV7fCyMMm154+/K1Z2IJlcissydEAwgsUHw\nedrE6CxJVkkJ3EvIgG4ugK/suxd8eEMztaQYJwSdN8TdfT59LFuSPl7zmF3fIBdJ\n//WexcQmGabaJ7Xnx+6o2HTfkP8Zzzzaq8fvjAcvA7gyFH5EP26G2ZqMG+0y4pTx\nSPVTrQEXAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFIWWuNEF\nsUMOC82XlfJeqazzrkPDMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAgClmxcJaQTGpEZmjElL8G2Zc8lGc+ylGjiNlSIw8X25/bcLRptbDA90nuP+q\nzXAMhEf0ccbdpwxG/P5a8JipmHgqQLHfpkvaXx+0CuP++3k+chAJ3Gk5XtY587jX\n+MJfrPgjFt7vmMaKmynndf+NaIJAYczjhJj6xjPWmGrjM3MlTa9XesmelMwP3jep\nbApIWAvCYVjGndbK9byyMq1nyj0TUzB8oJZQooaR3MMjHTmADuVBylWzkRMxbKPl\n4Nlsk4Ef1JvIWBCzsMt+X17nuKfEatRfp3c9tbpGlAE/DSP0W2/Lnayxr4RpE9ds\nICF35uSis/7ZlsftODUe8wtpkQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nPqj2\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nKDPtFEk=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICtzCCAj2gAwIBAgIQVZ5Y/KqjR4XLou8MCD5pOjAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC00IFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIyMDUyNTE2NTgzM1oYDzIxMjIwNTI1MTc1ODMzWjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC00IFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEbo473OmpD5vkckdJajXg\nbrhmNFyoSa0WCY1njuZC2zMFp3zP6rX4I1r3imrYnJd9pFH/aSiV/r6L5ACE5RPx\n4qdg5SQ7JJUaZc3DWsTOiOed7BCZSzM+KTYK/2QzDMApo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBTmogc06+1knsej1ltKUOdWFvwgsjAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIxAIs7TlLMbGTWNXpGiKf9DxaM07d/iDHe\nF/Vv/wyWSTGdobxBL6iArQNVXz0Gr4dvPAIwd0rsoa6R0x5mtvhdRPtM37FYrbHJ\npbV+OMusQqcSLseunLBoCHenvJW0QOCQ8EDY\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICvTCCAkOgAwIBAgIQCIY7E/bFvFN2lK9Kckb0dTAKBggqhkjOPQQDAzCBnjEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTcwNQYDVQQDDC5BbWF6\nb24gUkRTIFByZXZpZXcgdXMtZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYD\nVQQHDAdTZWF0dGxlMCAXDTIxMDUxODIxMDUxMFoYDzIxMjEwNTE4MjIwNTEwWjCB\nnjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTcwNQYDVQQDDC5B\nbWF6b24gUkRTIFByZXZpZXcgdXMtZWFzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEMI0hzf1JCEOI\nEue4+DmcNnSs2i2UaJxHMrNGGfU7b42a7vwP53F7045ffHPBGP4jb9q02/bStZzd\nVHqfcgqkSRI7beBKjD2mfz82hF/wJSITTgCLs+NRpS6zKMFOFHUNo0IwQDAPBgNV\nHRMBAf8EBTADAQH/MB0GA1UdDgQWBBS8uF/6hk5mPLH4qaWv9NVZaMmyTjAOBgNV\nHQ8BAf8EBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIxAO7Pu9wzLyM0X7Q08uLIL+vL\nqaxe3UFuzFTWjM16MLJHbzLf1i9IDFKz+Q4hXCSiJwIwClMBsqT49BPUxVsJnjGr\nEbyEk6aOOVfY1p2yQL649zh3M4h8okLnwf+bYIb1YpeU\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQY+JhwFEQTe36qyRlUlF8ozANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxOTE5MjQxNloYDzIwNjEwNTE5MjAyNDE2WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAnIye77j6ev40\n8wRPyN2OdKFSUfI9jB20Or2RLO+RDoL43+USXdrze0Wv4HMRLqaen9BcmCfaKMp0\nE4SFo47bXK/O17r6G8eyq1sqnHE+v288mWtYH9lAlSamNFRF6YwA7zncmE/iKL8J\n0vePHMHP/B6svw8LULZCk+nZk3tgxQn2+r0B4FOz+RmpkoVddfqqUPMbKUxhM2wf\nfO7F6bJaUXDNMBPhCn/3ayKCjYr49ErmnpYV2ZVs1i34S+LFq39J7kyv6zAgbHv9\n+/MtRMoRB1CjpqW0jIOZkHBdYcd1o9p1zFn591Do1wPkmMsWdjIYj+6e7UXcHvOB\n2+ScIRAcnwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBQGtq2W\nYSyMMxpdQ3IZvcGE+nyZqTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAEgoP3ixJsKSD5FN8dQ01RNHERl/IFbA7TRXfwC+L1yFocKnQh4Mp/msPRSV\n+OeHIvemPW/wtZDJzLTOFJ6eTolGekHK1GRTQ6ZqsWiU2fmiOP8ks4oSpI+tQ9Lw\nVrfZqTiEcS5wEIqyfUAZZfKDo7W1xp+dQWzfczSBuZJZwI5iaha7+ILM0r8Ckden\nTVTapc5pLSoO15v0ziRuQ2bT3V3nwu/U0MRK44z+VWOJdSiKxdnOYDs8hFNnKhfe\nklbTZF7kW7WbiNYB43OaAQBJ6BALZsIskEaqfeZT8FD71uN928TcEQyBDXdZpRN+\niGQZDGhht0r0URGMDSs9waJtTfA=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\ndIA=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAPVSMfFitmM5PhmbaOFoGfUwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyB1cy1lYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIyMzQ1N1oYDzIwNjEwNTI1MjMzNDU3WjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIHVzLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDu9H7TBeGoDzMr\ndxN6H8COntJX4IR6dbyhnj5qMD4xl/IWvp50lt0VpmMd+z2PNZzx8RazeGC5IniV\n5nrLg0AKWRQ2A/lGGXbUrGXCSe09brMQCxWBSIYe1WZZ1iU1IJ/6Bp4D2YEHpXrW\nbPkOq5x3YPcsoitgm1Xh8ygz6vb7PsvJvPbvRMnkDg5IqEThapPjmKb8ZJWyEFEE\nQRrkCIRueB1EqQtJw0fvP4PKDlCJAKBEs/y049FoOqYpT3pRy0WKqPhWve+hScMd\n6obq8kxTFy1IHACjHc51nrGII5Bt76/MpTWhnJIJrCnq1/Uc3Qs8IVeb+sLaFC8K\nDI69Sw6bAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFE7PCopt\nlyOgtXX0Y1lObBUxuKaCMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAFj+bX8gLmMNefr5jRJfHjrL3iuZCjf7YEZgn89pS4z8408mjj9z6Q5D1H7yS\njNETVV8QaJip1qyhh5gRzRaArgGAYvi2/r0zPsy+Tgf7v1KGL5Lh8NT8iCEGGXwF\ng3Ir+Nl3e+9XUp0eyyzBIjHtjLBm6yy8rGk9p6OtFDQnKF5OxwbAgip42CD75r/q\np421maEDDvvRFR4D+99JZxgAYDBGqRRceUoe16qDzbMvlz0A9paCZFclxeftAxv6\nQlR5rItMz/XdzpBJUpYhdzM0gCzAzdQuVO5tjJxmXhkSMcDP+8Q+Uv6FA9k2VpUV\nE/O5jgpqUJJ2Hc/5rs9VkAPXeA==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQW0yuFCle3uj4vWiGU0SaGzAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGFmLXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTE5MTkzNTE2WhgPMjEyMTA1MTkyMDM1MTZaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgYWYtc291dGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABDPiKNZSaXs3Un/J/v+LTsFDANHpi7en\noL2qh0u0DoqNzEBTbBjvO23bLN3k599zh6CY3HKW0r2k1yaIdbWqt4upMCRCcUFi\nI4iedAmubgzh56wJdoMZztjXZRwDthTkJKNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUWbYkcrvVSnAWPR5PJhIzppcAnZIwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMCESGqpat93CjrSEjE7z+Hbvz0psZTHwqaxuiH64GKUm\nmYynIiwpKHyBrzjKBmeDoQIxANGrjIo6/b8Jl6sdIZQI18V0pAyLfLiZjlHVOnhM\nMOTVgr82ZuPoEHTX78MxeMnYlw==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAIbsx8XOl0sgTNiCN4O+18QwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTI1MjE1NDU4WhgPMjA2MTA1MjUyMjU0NTha\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\ntROxwXWCgn5R9gI/2Ivjzaxc0g95ysBjoJsnhPdJEHQb7w3y2kWrVWU3Y9fOitgb\nCEsnEC3PrhRnzNVW0fPsK6kbvOeCmjvY30rdbxbc8h+bjXfGmIOgAkmoULEr6Hc7\nG1Q/+tvv4lEwIs7bEaf+abSZxRJbZ0MBxhbHn7UHHDiMZYvzK+SV1MGCxx7JVhrm\nxWu3GC1zZCsGDhB9YqY9eR6PmjbqA5wy8vqbC57dZZa1QVtWIQn3JaRXn+faIzHx\nnLMN5CEWihsdmHBXhnRboXprE/OS4MFv1UrQF/XM/h5RBeCywpHePpC+Oe1T3LNC\niP8KzRFrjC1MX/WXJnmOVQIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBS33XbXAUMs1znyZo4B0+B3D68WFTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBADuadd2EmlpueY2VlrIIPC30QkoA1EOSoCmZgN6124apkoY1\nHiV4r+QNPljN4WP8gmcARnNkS7ZeR4fvWi8xPh5AxQCpiaBMw4gcbTMCuKDV68Pw\nP2dZCTMspvR3CDfM35oXCufdtFnxyU6PAyINUqF/wyTHguO3owRFPz64+sk3r2pT\nWHmJjG9E7V+KOh0s6REgD17Gqn6C5ijLchSrPUHB0wOIkeLJZndHxN/76h7+zhMt\nfFeNxPWHY2MfpcaLjz4UREzZPSB2U9k+y3pW1omCIcl6MQU9itGx/LpQE+H3ZeX2\nM2bdYd5L+ow+bdbGtsVKOuN+R9Dm17YpswF+vyQ=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nEm4Hy3A=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\njGKc3k6UNxpg\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\n0Ws=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICtDCCAjqgAwIBAgIRAMyaTlVLN0ndGp4ffwKAfoMwCgYIKoZIzj0EAwMwgZkx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1h\nem9uIFJEUyBtZS1jZW50cmFsLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjIwNTA3MDA0NDM3WhgPMjEyMjA1MDcwMTQ0MzdaMIGZMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMjAwBgNVBAMMKUFtYXpv\nbiBSRFMgbWUtY2VudHJhbC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE19nCV1nsI6CohSor13+B25cr\nzg+IHdi9Y3L7ziQnHWI6yjBazvnKD+oC71aRRlR8b5YXsYGUQxWzPLHN7EGPcSGv\nbzA9SLG1KQYCJaQ0m9Eg/iGrwKWOgylbhVw0bCxoo0IwQDAPBgNVHRMBAf8EBTAD\nAQH/MB0GA1UdDgQWBBS4KsknsJXM9+QPEkBdZxUPaLr11zAOBgNVHQ8BAf8EBAMC\nAYYwCgYIKoZIzj0EAwMDaAAwZQIxAJaRgrYIEfXQMZQQDxMTYS0azpyWSseQooXo\nL3nYq4OHGBgYyQ9gVjvRYWU85PXbfgIwdi82DtANQFkCu+j+BU0JBY/uRKPEeYzo\nJG92igKIcXPqCoxIJ7lJbbzmuf73gQu5\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nTspdjbg=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIECTCCAvGgAwIBAgIRAJZFh4s9aZGzKaTMLrSb4acwDQYJKoZIhvcNAQELBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBCZXRhIHVzLWVhc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTE4MjEyODQxWhgPMjA2MTA1MTgyMjI4NDFa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgQmV0YSB1cy1lYXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA\n17i2yoU6diep+WrqxIn2CrDEO2NdJVwWTSckx4WMZlLpkQDoymSmkNHjq9ADIApD\nA31Cx+843apL7wub8QkFZD0Tk7/ThdHWJOzcAM3ov98QBPQfOC1W5zYIIRP2F+vQ\nTRETHQnLcW3rLv0NMk5oQvIKpJoC9ett6aeVrzu+4cU4DZVWYlJUoC/ljWzCluau\n8blfW0Vwin6OB7s0HCG5/wijQWJBU5SrP/KAIPeQi1GqG5efbqAXDr/ple0Ipwyo\nXjjl73LenGUgqpANlC9EAT4i7FkJcllLPeK3NcOHjuUG0AccLv1lGsHAxZLgjk/x\nz9ZcnVV9UFWZiyJTKxeKPwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1Ud\nDgQWBBRWyMuZUo4gxCR3Luf9/bd2AqZ7CjAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZI\nhvcNAQELBQADggEBAIqN2DlIKlvDFPO0QUZQVFbsi/tLdYM98/vvzBpttlTGVMyD\ngJuQeHVz+MnhGIwoCGOlGU3OOUoIlLAut0+WG74qYczn43oA2gbMd7HoD7oL/IGg\nnjorBwJVcuuLv2G//SqM3nxGcLRtkRnQ+lvqPxMz9+0fKFUn6QcIDuF0QSfthLs2\nWSiGEPKO9c9RSXdRQ4pXA7c3hXng8P4A2ZmdciPne5Nu4I4qLDGZYRrRLRkNTrOi\nTyS6r2HNGUfgF7eOSeKt3NWL+mNChcYj71/Vycf5edeczpUgfnWy9WbPrK1svKyl\naAs2xg+X6O8qB+Mnj2dNBzm+lZIS3sIlm+nO9sg=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAPAlEk8VJPmEzVRRaWvTh2AwCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyB1cy1lYXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTI1MjI0MTU1WhgPMjEyMTA1MjUyMzQxNTVaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgdXMtZWFzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEx5xjrup8II4HOJw15NTnS3H5yMrQGlbj\nEDA5MMGnE9DmHp5dACIxmPXPMe/99nO7wNdl7G71OYPCgEvWm0FhdvVUeTb3LVnV\nBnaXt32Ek7/oxGk1T+Df03C+W0vmuJ+wo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBTGXmqBWN/1tkSea4pNw0oHrjk2UDAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIxAIqqZWCSrIkZ7zsv/FygtAusW6yvlL935YAWYPVXU30m\njkMFLM+/RJ9GMvnO8jHfCgIwB+whlkcItzE9CRQ6CsMo/d5cEHDUu/QW6jSIh9BR\nOGh9pTYPVkUbBiKPA7lVVhre\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nnWS0\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nUfff2jrbfbzECn1ELg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nfejbXelUSJSzDIdY\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIGCTCCA/GgAwIBAgIRAN7Y9G9i4I+ZaslPobE7VL4wDQYJKoZIhvcNAQEMBQAw\ngZwxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTE1MDMGA1UEAwws\nQW1hem9uIFJEUyBhcC1ub3J0aGVhc3QtMiBSb290IENBIFJTQTQwOTYgRzExEDAO\nBgNVBAcMB1NlYXR0bGUwIBcNMjEwNTIwMTYzMzIzWhgPMjEyMTA1MjAxNzMzMjNa\nMIGcMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywg\nSW5jLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExNTAzBgNVBAMM\nLEFtYXpvbiBSRFMgYXAtbm9ydGhlYXN0LTIgUm9vdCBDQSBSU0E0MDk2IEcxMRAw\nDgYDVQQHDAdTZWF0dGxlMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEA\n4BEPCiIfiK66Q/qa8k+eqf1Q3qsa6Xuu/fPkpuStXVBShhtXd3eqrM0iT4Xxs420\nVa0vSB3oZ7l86P9zYfa60n6PzRxdYFckYX330aI7L/oFIdaodB/C9szvROI0oLG+\n6RwmIF2zcprH0cTby8MiM7G3v9ykpq27g4WhDC1if2j8giOQL3oHpUaByekZNIHF\ndIllsI3RkXmR3xmmxoOxJM1B9MZi7e1CvuVtTGOnSGpNCQiqofehTGwxCN2wFSK8\nxysaWlw48G0VzZs7cbxoXMH9QbMpb4tpk0d+T8JfAPu6uWO9UwCLWWydf0CkmA/+\nD50/xd1t33X9P4FEaPSg5lYbHXzSLWn7oLbrN2UqMLaQrkoEBg/VGvzmfN0mbflw\n+T87bJ/VEOVNlG+gepyCTf89qIQVWOjuYMox4sK0PjzZGsYEuYiq1+OUT3vk/e5K\nag1fCcq2Isy4/iwB2xcXrsQ6ljwdk1fc+EmOnjGKrhuOHJY3S+RFv4ToQBsVyYhC\nXGaC3EkqIX0xaCpDimxYhFjWhpDXAjG/zJ+hRLDAMCMhl/LPGRk/D1kzSbPmdjpl\nlEMK5695PeBvEBTQdBQdOiYgOU3vWU6tzwwHfiM2/wgvess/q0FDAHfJhppbgbb9\n3vgsIUcsvoC5o29JvMsUxsDRvsAfEmMSDGkJoA/X6GECAwEAAaNCMEAwDwYDVR0T\nAQH/BAUwAwEB/zAdBgNVHQ4EFgQUgEWm1mZCbGD6ytbwk2UU1aLaOUUwDgYDVR0P\nAQH/BAQDAgGGMA0GCSqGSIb3DQEBDAUAA4ICAQBb4+ABTGBGwxK1U/q4g8JDqTQM\n1Wh8Oz8yAk4XtPJMAmCctxbd81cRnSnePWw/hxViLVtkZ/GsemvXfqAQyOn1coN7\nQeYSw+ZOlu0j2jEJVynmgsR7nIRqE7QkCyZAU+d2FTJUfmee+IiBiGyFGgxz9n7A\nJhBZ/eahBbiuoOik/APW2JWLh0xp0W0GznfJ8lAlaQTyDa8iDXmVtbJg9P9qzkvl\nFgPXQttzEOyooF8Pb2LCZO4kUz+1sbU7tHdr2YE+SXxt6D3SBv+Yf0FlvyWLiqVk\nGDEOlPPTDSjAWgKnqST8UJ0RDcZK/v1ixs7ayqQJU0GUQm1I7LGTErWXHMnCuHKe\nUKYuiSZwmTcJ06NgdhcCnGZgPq13ryMDqxPeltQc3n5eO7f1cL9ERYLDLOzm6A9P\noQ3MfcVOsbHgGHZWaPSeNrQRN9xefqBXH0ZPasgcH9WJdsLlEjVUXoultaHOKx3b\nUCCb+d3EfqF6pRT488ippOL6bk7zNubwhRa/+y4wjZtwe3kAX78ACJVcjPobH9jZ\nErySads5zdQeaoee5wRKdp3TOfvuCe4bwLRdhOLCHWzEcXzY3g/6+ppLvNom8o+h\nBh5X26G6KSfr9tqhQ3O9IcbARjnuPbvtJnoPY0gz3EHHGPhy0RNW8i2gl3nUp0ah\nPtjwbKW0hYAhIttT0Q==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICtzCCAj2gAwIBAgIQQRBQTs6Y3H1DDbpHGta3lzAKBggqhkjOPQQDAzCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0zIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDYxMTAwMTI0M1oYDzIxMjEwNjExMDExMjQzWjCBmzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTQwMgYDVQQDDCtBbWF6\nb24gUkRTIGFwLXNvdXRoZWFzdC0zIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEs0942Xj4m/gKA+WA6F5h\nAHYuek9eGpzTRoLJddM4rEV1T3eSueytMVKOSlS3Ub9IhyQrH2D8EHsLYk9ktnGR\npATk0kCYTqFbB7onNo070lmMJmGT/Q7NgwC8cySChFxbo0IwQDAPBgNVHRMBAf8E\nBTADAQH/MB0GA1UdDgQWBBQ20iKBKiNkcbIZRu0y1uoF1yJTEzAOBgNVHQ8BAf8E\nBAMCAYYwCgYIKoZIzj0EAwMDaAAwZQIwYv0wTSrpQTaPaarfLN8Xcqrqu3hzl07n\nFrESIoRw6Cx77ZscFi2/MV6AFyjCV/TlAjEAhpwJ3tpzPXpThRML8DMJYZ3YgMh3\nCMuLqhPpla3cL0PhybrD27hJWl29C4el6aMO\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrDCCAjOgAwIBAgIQGcztRyV40pyMKbNeSN+vXTAKBggqhkjOPQQDAzCBljEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMS8wLQYDVQQDDCZBbWF6\nb24gUkRTIHVzLWVhc3QtMiBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTAgFw0yMTA1MjEyMzE1NTZaGA8yMTIxMDUyMjAwMTU1NlowgZYxCzAJBgNV\nBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYD\nVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1hem9uIFJE\nUyB1cy1lYXN0LTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0bGUw\ndjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQfDcv+GGRESD9wT+I5YIPRsD3L+/jsiIis\nTr7t9RSbFl+gYpO7ZbDXvNbV5UGOC5lMJo/SnqFRTC6vL06NF7qOHfig3XO8QnQz\n6T5uhhrhnX2RSY3/10d2kTyHq3ZZg3+jQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFLDyD3PRyNXpvKHPYYxjHXWOgfPnMA4GA1UdDwEB/wQEAwIBhjAKBggq\nhkjOPQQDAwNnADBkAjB20HQp6YL7CqYD82KaLGzgw305aUKw2aMrdkBR29J183jY\n6Ocj9+Wcif9xnRMS+7oCMAvrt03rbh4SU9BohpRUcQ2Pjkh7RoY0jDR4Xq4qzjNr\n5UFr3BXpFvACxXF51BksGQ==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjWgAwIBAgIQeKbS5zvtqDvRtwr5H48cAjAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIG1lLXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTIwMTcxOTU1WhgPMjEyMTA1MjAxODE5NTVaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgbWUtc291dGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABEKjgUaAPmUlRMEQdBC7BScAGosJ1zRV\nLDd38qTBjzgmwBfQJ5ZfGIvyEK5unB09MB4e/3qqK5I/L6Qn5Px/n5g4dq0c7MQZ\nu7G9GBYm90U3WRJBf7lQrPStXaRnS4A/O6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUNKcAbGEIn03/vkwd8g6jNyiRdD4wDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2cAMGQCMHIeTrjenCSYuGC6txuBt/0ZwnM/ciO9kHGWVCoK8QLs\njGghb5/YSFGZbmQ6qpGlSAIwVOQgdFfTpEfe5i+Vs9frLJ4QKAfc27cTNYzRIM0I\nE+AJgK4C4+DiyyMzOpiCfmvq\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nWT1QcNdw7ntUJP/w\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQARky6+5PNFRkFVOp3Ob1CTAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LXNvdXRoLTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjIwNTIzMTg0MTI4WhgPMjEyMjA1MjMxOTQxMjdaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgZXUtc291dGgtMiBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABNVGL5oF7cfIBxKyWd2PVK/S5yQfaJY3\nQFHWvEdt6951n9JhiiPrHzfVHsxZp1CBjILRMzjgRbYWmc8qRoLkgGE7htGdwudJ\nFa/WuKzO574Prv4iZXUnVGTboC7JdvKbh6NCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUgDeIIEKynwUbNXApdIPnmRWieZwwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMEOOJfucrST+FxuqJkMZyCM3gWGZaB+/w6+XUAJC6hFM\nuSTY0F44/bERkA4XhH+YGAIxAIpJQBakCA1/mXjsTnQ+0El9ty+LODp8ibkn031c\n8DKDS7pR9UK7ZYdR6zFg3ZCjQw==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjOgAwIBAgIQJvkWUcYLbnxtuwnyjMmntDAKBggqhkjOPQQDAzCBljEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMS8wLQYDVQQDDCZBbWF6\nb24gUkRTIGV1LXdlc3QtMyBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTAgFw0yMTA1MjUyMjI2MTJaGA8yMTIxMDUyNTIzMjYxMlowgZYxCzAJBgNV\nBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMwEQYD\nVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1hem9uIFJE\nUyBldS13ZXN0LTMgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0bGUw\ndjAQBgcqhkjOPQIBBgUrgQQAIgNiAARENn8uHCyjn1dFax4OeXxvbV861qsXFD9G\nDshumTmFzWWHN/69WN/AOsxy9XN5S7Cgad4gQgeYYYgZ5taw+tFo/jQvCLY//uR5\nuihcLuLJ78opvRPvD9kbWZ6oXfBtFkWjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYD\nVR0OBBYEFKiK3LpoF+gDnqPldGSwChBPCYciMA4GA1UdDwEB/wQEAwIBhjAKBggq\nhkjOPQQDAwNpADBmAjEA+7qfvRlnvF1Aosyp9HzxxCbN7VKu+QXXPhLEBWa5oeWW\nUOcifunf/IVLC4/FGCsLAjEAte1AYp+iJyOHDB8UYkhBE/1sxnFaTiEPbvQBU0wZ\nSuwWVLhu2wWDuSW+K7tTuL8p\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAKeDpqX5WFCGNo94M4v69sUwDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyBldS13ZXN0LTMgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNTIyMTgzM1oYDzIwNjEwNTI1MjMxODMzWjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LXdlc3QtMyBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCcKOTEMTfzvs4H\nWtJR8gI7GXN6xesulWtZPv21oT+fLGwJ+9Bv8ADCGDDrDxfeH/HxJmzG9hgVAzVn\n4g97Bn7q07tGZM5pVi96/aNp11velZT7spOJKfJDZTlGns6DPdHmx48whpdO+dOb\n6+eR0VwCIv+Vl1fWXgoACXYCoKjhxJs+R+fwY//0JJ1YG8yjZ+ghLCJmvlkOJmE1\nTCPUyIENaEONd6T+FHGLVYRRxC2cPO65Jc4yQjsXvvQypoGgx7FwD5voNJnFMdyY\n754JGPOOe/SZdepN7Tz7UEq8kn7NQSbhmCsgA/Hkjkchz96qN/YJ+H/okiQUTNB0\neG9ogiVFAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFFjayw9Y\nMjbxfF14XAhMM2VPl0PfMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAAtmx6d9+9CWlMoU0JCirtp4dSS41bBfb9Oor6GQ8WIr2LdfZLL6uES/ubJPE\n1Sh5Vu/Zon5/MbqLMVrfniv3UpQIof37jKXsjZJFE1JVD/qQfRzG8AlBkYgHNEiS\nVtD4lFxERmaCkY1tjKB4Dbd5hfhdrDy29618ZjbSP7NwAfnwb96jobCmMKgxVGiH\nUqsLSiEBZ33b2hI7PJ6iTJnYBWGuiDnsWzKRmheA4nxwbmcQSfjbrNwa93w3caL2\nv/4u54Kcasvcu3yFsUwJygt8z43jsGAemNZsS7GWESxVVlW93MJRn6M+MMakkl9L\ntWaXdHZ+KUV7LhfYLb0ajvb40w==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBDCCAuygAwIBAgIQJ5oxPEjefCsaESSwrxk68DANBgkqhkiG9w0BAQsFADCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIGV1LWNlbnRyYWwtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwIBcNMjIwNjA2MjExNzA1WhgPMjA2MjA2MDYyMjE3MDVaMIGa\nMQswCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5j\nLjETMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMzAxBgNVBAMMKkFt\nYXpvbiBSRFMgZXUtY2VudHJhbC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UE\nBwwHU2VhdHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALTQt5eX\ng+VP3BjO9VBkWJhE0GfLrU/QIk32I6WvrnejayTrlup9H1z4QWlXF7GNJrqScRMY\nKhJHlcP05aPsx1lYco6pdFOf42ybXyWHHJdShj4A5glU81GTT+VrXGzHSarLmtua\neozkQgPpDsSlPt0RefyTyel7r3Cq+5K/4vyjCTcIqbfgaGwTU36ffjM1LaPCuE4O\nnINMeD6YuImt2hU/mFl20FZ+IZQUIFZZU7pxGLqTRz/PWcH8tDDxnkYg7tNuXOeN\nJbTpXrw7St50/E9ZQ0llGS+MxJD8jGRAa/oL4G/cwnV8P2OEPVVkgN9xDDQeieo0\n3xkzolkDkmeKOnUCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQU\nbwu8635iQGQMRanekesORM8Hkm4wDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEB\nCwUAA4IBAQAgN6LE9mUgjsj6xGCX1afYE69fnmCjjb0rC6eEe1mb/QZNcyw4XBIW\n6+zTXo4mjZ4ffoxb//R0/+vdTE7IvaLgfAZgFsLKJCtYDDstXZj8ujQnGR9Pig3R\nW+LpNacvOOSJSawNQq0Xrlcu55AU4buyD5VjcICnfF1dqBMnGTnh27m/scd/ZMx/\nkapHZ/fMoK2mAgSX/NvUKF3UkhT85vSSM2BTtET33DzCPDQTZQYxFBa4rFRmFi4c\nBLlmIReiCGyh3eJhuUUuYAbK6wLaRyPsyEcIOLMQmZe1+gAFm1+1/q5Ke9ugBmjf\nPbTWjsi/lfZ5CdVAhc5lmZj/l5aKqwaS\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAKKPTYKln9L4NTx9dpZGUjowCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyBldS13ZXN0LTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTIxMjI1NTIxWhgPMjEyMTA1MjEyMzU1MjFaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgZXUtd2VzdC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAE/owTReDvaRqdmbtTzXbyRmEpKCETNj6O\nhZMKH0F8oU9Tmn8RU7kQQj6xUKEyjLPrFBN7c+26TvrVO1KmJAvbc8bVliiJZMbc\nC0yV5PtJTalvlMZA1NnciZuhxaxrzlK1o0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBT4i5HaoHtrs7Mi8auLhMbKM1XevDAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIxAK9A+8/lFdX4XJKgfP+ZLy5ySXC2E0Spoy12Gv2GdUEZ\np1G7c1KbWVlyb1d6subzkQIwKyH0Naf/3usWfftkmq8SzagicKz5cGcEUaULq4tO\nGzA/AMpr63IDBAqkZbMDTCmH\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrzCCAjWgAwIBAgIQTgIvwTDuNWQo0Oe1sOPQEzAKBggqhkjOPQQDAzCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LW5vcnRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTI0MjEwNjM4WhgPMjEyMTA1MjQyMjA2MzhaMIGXMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpvbiBS\nRFMgZXUtbm9ydGgtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwHU2VhdHRs\nZTB2MBAGByqGSM49AgEGBSuBBAAiA2IABJuzXLU8q6WwSKXBvx8BbdIi3mPhb7Xo\nrNJBfuMW1XRj5BcKH1ZoGaDGw+BIIwyBJg8qNmCK8kqIb4cH8/Hbo3Y+xBJyoXq/\ncuk8aPrxiNoRsKWwiDHCsVxaK9L7GhHHAqNCMEAwDwYDVR0TAQH/BAUwAwEB/zAd\nBgNVHQ4EFgQUYgcsdU4fm5xtuqLNppkfTHM2QMYwDgYDVR0PAQH/BAQDAgGGMAoG\nCCqGSM49BAMDA2gAMGUCMQDz/Rm89+QJOWJecYAmYcBWCcETASyoK1kbr4vw7Hsg\n7Ew3LpLeq4IRmTyuiTMl0gMCMAa0QSjfAnxBKGhAnYxcNJSntUyyMpaXzur43ec0\n3D8npJghwC4DuICtKEkQiI5cSg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nu3UBpZI=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICtDCCAjmgAwIBAgIQenQbcP/Zbj9JxvZ+jXbRnTAKBggqhkjOPQQDAzCBmTEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTIwMAYDVQQDDClBbWF6\nb24gUkRTIGV1LWNlbnRyYWwtMSBSb290IENBIEVDQzM4NCBHMTEQMA4GA1UEBwwH\nU2VhdHRsZTAgFw0yMTA1MjEyMjMzMjRaGA8yMTIxMDUyMTIzMzMyNFowgZkxCzAJ\nBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMuMRMw\nEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1hem9u\nIFJEUyBldS1jZW50cmFsLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAATlBHiEM9LoEb1Hdnd5j2VpCDOU\n5nGuFoBD8ROUCkFLFh5mHrHfPXwBc63heW9WrP3qnDEm+UZEUvW7ROvtWCTPZdLz\nZ4XaqgAlSqeE2VfUyZOZzBSgUUJk7OlznXfkCMOjQjBAMA8GA1UdEwEB/wQFMAMB\nAf8wHQYDVR0OBBYEFDT/ThjQZl42Nv/4Z/7JYaPNMly2MA4GA1UdDwEB/wQEAwIB\nhjAKBggqhkjOPQQDAwNpADBmAjEAnZWmSgpEbmq+oiCa13l5aGmxSlfp9h12Orvw\nDq/W5cENJz891QD0ufOsic5oGq1JAjEAp5kSJj0MxJBTHQze1Aa9gG4sjHBxXn98\n4MP1VGsQuhfndNHQb4V0Au7OWnOeiobq\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/zCCAuegAwIBAgIRAMgnyikWz46xY6yRgiYwZ3swDQYJKoZIhvcNAQELBQAw\ngZcxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwn\nQW1hem9uIFJEUyBldS13ZXN0LTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyMDE2NDkxMloYDzIwNjEwNTIwMTc0OTEyWjCBlzEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6\nb24gUkRTIGV1LXdlc3QtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCi8JYOc9cYSgZH\ngYPxLk6Xcc7HqzamvsnjYU98Dcb98y6iDqS46Ra2Ne02MITtU5MDL+qjxb8WGDZV\nRUA9ZS69tkTO3gldW8QdiSh3J6hVNJQW81F0M7ZWgV0gB3n76WCmfT4IWos0AXHM\n5v7M/M4tqVmCPViQnZb2kdVlM3/Xc9GInfSMCgNfwHPTXl+PXX+xCdNBePaP/A5C\n5S0oK3HiXaKGQAy3K7VnaQaYdiv32XUatlM4K2WS4AMKt+2cw3hTCjlmqKRHvYFQ\nveWCXAuc+U5PQDJ9SuxB1buFJZhT4VP3JagOuZbh5NWpIbOTxlAJOb5pGEDuJTKi\n1gQQQVEFAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYEFNXm+N87\nOFxK9Af/bjSxDCiulGUzMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0BAQsFAAOC\nAQEAkqIbkgZ45spvrgRQ6n9VKzDLvNg+WciLtmVrqyohwwJbj4pYvWwnKQCkVc7c\nhUOSBmlSBa5REAPbH5o8bdt00FPRrD6BdXLXhaECKgjsHe1WW08nsequRKD8xVmc\n8bEX6sw/utBeBV3mB+3Zv7ejYAbDFM4vnRsWtO+XqgReOgrl+cwdA6SNQT9oW3e5\nrSQ+VaXgJtl9NhkiIysq9BeYigxqS/A13pHQp0COMwS8nz+kBPHhJTsajHCDc8F4\nHfLi6cgs9G0gaRhT8FCH66OdGSqn196sE7Y3bPFFFs/3U+vxvmQgoZC6jegQXAg5\nPrxd+VNXtNI/azitTysQPumH7A==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEBTCCAu2gAwIBAgIRAO8bekN7rUReuNPG8pSTKtEwDQYJKoZIhvcNAQELBQAw\ngZoxCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJ\nbmMuMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEzMDEGA1UEAwwq\nQW1hem9uIFJEUyBldS1jZW50cmFsLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYD\nVQQHDAdTZWF0dGxlMCAXDTIxMDUyMTIyMjM0N1oYDzIwNjEwNTIxMjMyMzQ3WjCB\nmjELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTMwMQYDVQQDDCpB\nbWF6b24gUkRTIGV1LWNlbnRyYWwtMSBSb290IENBIFJTQTIwNDggRzExEDAOBgNV\nBAcMB1NlYXR0bGUwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQCTTYds\nTray+Q9VA5j5jTh5TunHKFQzn68ZbOzdqaoi/Rq4ohfC0xdLrxCpfqn2TGDHN6Zi\n2qGK1tWJZEd1H0trhzd9d1CtGK+3cjabUmz/TjSW/qBar7e9MA67/iJ74Gc+Ww43\nA0xPNIWcL4aLrHaLm7sHgAO2UCKsrBUpxErOAACERScVYwPAfu79xeFcX7DmcX+e\nlIqY16pQAvK2RIzrekSYfLFxwFq2hnlgKHaVgZ3keKP+nmXcXmRSHQYUUr72oYNZ\nHcNYl2+gxCc9ccPEHM7xncVEKmb5cWEWvVoaysgQ+osi5f5aQdzgC2X2g2daKbyA\nXL/z5FM9GHpS5BJjAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMBAf8wHQYDVR0OBBYE\nFBDAiJ7Py9/A9etNa/ebOnx5l5MGMA4GA1UdDwEB/wQEAwIBhjANBgkqhkiG9w0B\nAQsFAAOCAQEALMh/+81fFPdJV/RrJUeoUvFCGMp8iaANu97NpeJyKitNOv7RoeVP\nWjivS0KcCqZaDBs+p6IZ0sLI5ZH098LDzzytcfZg0PsGqUAb8a0MiU/LfgDCI9Ee\njsOiwaFB8k0tfUJK32NPcIoQYApTMT2e26lPzYORSkfuntme2PTHUnuC7ikiQrZk\nP+SZjWgRuMcp09JfRXyAYWIuix4Gy0eZ4rpRuaTK6mjAb1/LYoNK/iZ/gTeIqrNt\nl70OWRsWW8jEmSyNTIubGK/gGGyfuZGSyqoRX6OKHESkP6SSulbIZHyJ5VZkgtXo\n2XvyRyJ7w5pFyoofrL3Wv0UF8yt/GDszmg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\n2jpC\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIGADCCA+igAwIBAgIQYe0HgSuFFP9ivYM2vONTrTANBgkqhkiG9w0BAQwFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBSU0E0MDk2IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxOTE4MzMyMVoYDzIxMjEwNTE5MTkzMzIxWjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBSU0E0MDk2IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAuO7QPKfPMTo2\nPOQWvzDLwi5f++X98hGjORI1zkN9kotCYH5pAzSBwBPoMNaIfedgmsIxGHj2fq5G\n4oXagNhNuGP79Zl6uKW5H7S74W7aWM8C0s8zuxMOI4GZy5h2IfQk3m/3AzZEX5w8\nUtNPkzo2feDVOkerHT+j+vjXgAxZ4wHnuMDcRT+K4r9EXlAH6X9b/RO0JlfEwmNz\nxlqqGxocq9qRC66N6W0HF2fNEAKP84n8H80xcZBOBthQORRi8HSmKcPdmrvwCuPz\nM+L+j18q6RAVaA0ABbD0jMWcTf0UvjUfBStn5mvu/wGlLjmmRkZsppUTRukfwqXK\nyltUsTq0tOIgCIpne5zA4v+MebbR5JBnsvd4gdh5BI01QH470yB7BkUefZ9bobOm\nOseAAVXcYFJKe4DAA6uLDrqOfFSxV+CzVvEp3IhLRaik4G5MwI/h2c/jEYDqkg2J\nHMflxc2gcSMdk7E5ByLz5f6QrFfSDFk02ZJTs4ssbbUEYohht9znPMQEaWVqATWE\n3n0VspqZyoBNkH/agE5GiGZ/k/QyeqzMNj+c9kr43Upu8DpLrz8v2uAp5xNj3YVg\nihaeD6GW8+PQoEjZ3mrCmH7uGLmHxh7Am59LfEyNrDn+8Rq95WvkmbyHSVxZnBmo\nh/6O3Jk+0/QhIXZ2hryMflPcYWeRGH0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB\n/zAdBgNVHQ4EFgQU2eFK7+R3x/me8roIBNxBrplkM6EwDgYDVR0PAQH/BAQDAgGG\nMA0GCSqGSIb3DQEBDAUAA4ICAQB5gWFe5s7ObQFj1fTO9L6gYgtFhnwdmxU0q8Ke\nHWCrdFmyXdC39qdAFOwM5/7fa9zKmiMrZvy9HNvCXEp4Z7z9mHhBmuqPZQx0qPgU\nuLdP8wGRuWryzp3g2oqkX9t31Z0JnkbIdp7kfRT6ME4I4VQsaY5Y3mh+hIHOUvcy\np+98i3UuEIcwJnVAV9wTTzrWusZl9iaQ1nSYbmkX9bBssJ2GmtW+T+VS/1hJ/Q4f\nAlE3dOQkLFoPPb3YRWBHr2n1LPIqMVwDNAuWavRA2dSfaLl+kzbn/dua7HTQU5D4\nb2Fu2vLhGirwRJe+V7zdef+tI7sngXqjgObyOeG5O2BY3s+um6D4fS0Th3QchMO7\n0+GwcIgSgcjIjlrt6/xJwJLE8cRkUUieYKq1C4McpZWTF30WnzOPUzRzLHkcNzNA\n0A7sKMK6QoYWo5Rmo8zewUxUqzc9oQSrYADP7PEwGncLtFe+dlRFx+PA1a+lcIgo\n1ZGfXigYtQ3VKkcknyYlJ+hN4eCMBHtD81xDy9iP2MLE41JhLnoB2rVEtewO5diF\n7o95Mwl84VMkLhhHPeGKSKzEbBtYYBifHNct+Bst8dru8UumTltgfX6urH3DN+/8\nJF+5h3U8oR2LL5y76cyeb+GWDXXy9zoQe2QvTyTy88LwZq1JzujYi2k8QiLLhFIf\nFEv9Bg==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICsDCCAjagAwIBAgIRAMgApnfGYPpK/fD0dbN2U4YwCgYIKoZIzj0EAwMwgZcx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEwMC4GA1UEAwwnQW1h\nem9uIFJEUyBldS1zb3V0aC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMCAXDTIxMDUxOTE4MzgxMVoYDzIxMjEwNTE5MTkzODExWjCBlzELMAkG\nA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4xEzAR\nBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdBbWF6b24g\nUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1NlYXR0\nbGUwdjAQBgcqhkjOPQIBBgUrgQQAIgNiAAQfEWl6d4qSuIoECdZPp+39LaKsfsX7\nTHs3/RrtT0+h/jl3bjZ7Qc68k16x+HGcHbaayHfqD0LPdzH/kKtNSfQKqemdxDQh\nZ4pwkixJu8T1VpXZ5zzCvBXCl75UqgEFS92jQjBAMA8GA1UdEwEB/wQFMAMBAf8w\nHQYDVR0OBBYEFFPrSNtWS5JU+Tvi6ABV231XbjbEMA4GA1UdDwEB/wQEAwIBhjAK\nBggqhkjOPQQDAwNoADBlAjEA+a7hF1IrNkBd2N/l7IQYAQw8chnRZDzh4wiGsZsC\n6A83maaKFWUKIb3qZYXFSi02AjAbp3wxH3myAmF8WekDHhKcC2zDvyOiKLkg9Y6v\nZVmyMR043dscQbcsVoacOYv198c=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICtDCCAjqgAwIBAgIRAPhVkIsQ51JFhD2kjFK5uAkwCgYIKoZIzj0EAwMwgZkx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEyMDAGA1UEAwwpQW1h\nem9uIFJEUyBldS1jZW50cmFsLTIgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjIwNjA2MjEyOTE3WhgPMjEyMjA2MDYyMjI5MTdaMIGZMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMjAwBgNVBAMMKUFtYXpv\nbiBSRFMgZXUtY2VudHJhbC0yIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEA5xnIEBtG5b2nmbj49UEwQza\nyX0844fXjccYzZ8xCDUe9dS2XOUi0aZlGblgSe/3lwjg8fMcKXLObGGQfgIx1+5h\nAIBjORis/dlyN5q/yH4U5sjS8tcR0GDGVHrsRUZCo0IwQDAPBgNVHRMBAf8EBTAD\nAQH/MB0GA1UdDgQWBBRK+lSGutXf4DkTjR3WNfv4+KeNFTAOBgNVHQ8BAf8EBAMC\nAYYwCgYIKoZIzj0EAwMDaAAwZQIxAJ4NxQ1Gerqr70ZrnUqc62Vl8NNqTzInamCG\nKce3FTsMWbS9qkgrjZkO9QqOcGIw/gIwSLrwUT+PKr9+H9eHyGvpq9/3AIYSnFkb\nCf3dyWPiLKoAtLFwjzB/CkJlsAS1c8dS\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nr1o=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nwOx+\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\n89cEIGdbjsA=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQYjbPSg4+RNRD3zNxO1fuKDANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGV1LW5vcnRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUyNDIwNTkyMVoYDzIwNjEwNTI0MjE1OTIxWjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGV1LW5vcnRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA179eQHxcV0YL\nXMkqEmhSBazHhnRVd8yICbMq82PitE3BZcnv1Z5Zs/oOgNmMkOKae4tCXO/41JCX\nwAgbs/eWWi+nnCfpQ/FqbLPg0h3dqzAgeszQyNl9IzTzX4Nd7JFRBVJXPIIKzlRf\n+GmFsAhi3rYgDgO27pz3ciahVSN+CuACIRYnA0K0s9lhYdddmrW/SYeWyoB7jPa2\nLmWpAs7bDOgS4LlP2H3eFepBPgNufRytSQUVA8f58lsE5w25vNiUSnrdlvDrIU5n\nQwzc7NIZCx4qJpRbSKWrUtbyJriWfAkGU7i0IoainHLn0eHp9bWkwb9D+C/tMk1X\nERZw2PDGkwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBSFmR7s\ndAblusFN+xhf1ae0KUqhWTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAHsXOpjPMyH9lDhPM61zYdja1ebcMVgfUvsDvt+w0xKMKPhBzYDMs/cFOi1N\nQ8LV79VNNfI2NuvFmGygcvTIR+4h0pqqZ+wjWl3Kk5jVxCrbHg3RBX02QLumKd/i\nkwGcEtTUvTssn3SM8bgM0/1BDXgImZPC567ciLvWDo0s/Fe9dJJC3E0G7d/4s09n\nOMdextcxFuWBZrBm/KK3QF0ByA8MG3//VXaGO9OIeeOJCpWn1G1PjT1UklYhkg61\nEbsTiZVA2DLd1BGzfU4o4M5mo68l0msse/ndR1nEY6IywwpgIFue7+rEleDh6b9d\nPYkG1rHVw2I0XDG4o17aOn5E94I=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQC6W4HFghUkkgyQw14a6JljANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGV1LXNvdXRoLTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIyMDUyMzE4MTYzMloYDzIwNjIwNTIzMTkxNjMyWjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGV1LXNvdXRoLTIgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAiM/t4FV2R9Nx\nUQG203UY83jInTa/6TMq0SPyg617FqYZxvz2kkx09x3dmxepUg9ttGMlPgjsRZM5\nLCFEi1FWk+hxHzt7vAdhHES5tdjwds3aIkgNEillmRDVrUsbrDwufLaa+MMDO2E1\nwQ/JYFXw16WBCCi2g1EtyQ2Xp+tZDX5IWOTnvhZpW8vVDptZ2AcJ5rMhfOYO3OsK\n5EF0GGA5ldzuezP+BkrBYGJ4wVKGxeaq9+5AT8iVZrypjwRkD7Y5CurywK3+aBwm\ns9Q5Nd8t45JCOUzYp92rFKsCriD86n/JnEvgDfdP6Hvtm0/DkwXK40Wz2q0Zrd0k\nmjP054NRPwIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBRR7yqd\nSfKcX2Q8GzhcVucReIpewTAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAEszBRDwXcZyNm07VcFwI1Im94oKwKccuKYeJEsizTBsVon8VpEiMwDs+yGu\n3p8kBhvkLwWybkD/vv6McH7T5b9jDX2DoOudqYnnaYeypsPH/00Vh3LvKagqzQza\norWLx+0tLo8xW4BtU+Wrn3JId8LvAhxyYXTn9bm+EwPcStp8xGLwu53OPD1RXYuy\nuu+3ps/2piP7GVfou7H6PRaqbFHNfiGg6Y+WA0HGHiJzn8uLmrRJ5YRdIOOG9/xi\nqTmAZloUNM7VNuurcMM2hWF494tQpsQ6ysg2qPjbBqzlGoOt3GfBTOZmqmwmqtam\nK7juWM/mdMQAJ3SMlE5wI8nVdx4=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIICrjCCAjSgAwIBAgIRAL9SdzVPcpq7GOpvdGoM80IwCgYIKoZIzj0EAwMwgZYx\nCzAJBgNVBAYTAlVTMSIwIAYDVQQKDBlBbWF6b24gV2ViIFNlcnZpY2VzLCBJbmMu\nMRMwEQYDVQQLDApBbWF6b24gUkRTMQswCQYDVQQIDAJXQTEvMC0GA1UEAwwmQW1h\nem9uIFJEUyBldS13ZXN0LTEgUm9vdCBDQSBFQ0MzODQgRzExEDAOBgNVBAcMB1Nl\nYXR0bGUwIBcNMjEwNTIwMTY1ODA3WhgPMjEyMTA1MjAxNzU4MDdaMIGWMQswCQYD\nVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjETMBEG\nA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExLzAtBgNVBAMMJkFtYXpvbiBS\nRFMgZXUtd2VzdC0xIFJvb3QgQ0EgRUNDMzg0IEcxMRAwDgYDVQQHDAdTZWF0dGxl\nMHYwEAYHKoZIzj0CAQYFK4EEACIDYgAEJWDgXebvwjR+Ce+hxKOLbnsfN5W5dOlP\nZn8kwWnD+SLkU81Eac/BDJsXGrMk6jFD1vg16PEkoSevsuYWlC8xR6FmT6F6pmeh\nfsMGOyJpfK4fyoEPhKeQoT23lFIc5Orjo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0G\nA1UdDgQWBBSVNAN1CHAz0eZ77qz2adeqjm31TzAOBgNVHQ8BAf8EBAMCAYYwCgYI\nKoZIzj0EAwMDaAAwZQIxAMlQeHbcjor49jqmcJ9gRLWdEWpXG8thIf6zfYQ/OEAg\nd7GDh4fR/OUk0VfjsBUN/gIwZB0bGdXvK38s6AAE/9IT051cz/wMe9GIrX1MnL1T\n1F5OqnXJdiwfZRRTHsRQ/L00\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\n1YfpdH2jp30=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID/jCCAuagAwIBAgIQTDc+UgTRtYO7ZGTQ8UWKDDANBgkqhkiG9w0BAQsFADCB\nlzELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTAwLgYDVQQDDCdB\nbWF6b24gUkRTIGV1LXdlc3QtMiBSb290IENBIFJTQTIwNDggRzExEDAOBgNVBAcM\nB1NlYXR0bGUwIBcNMjEwNTIxMjI0NjI0WhgPMjA2MTA1MjEyMzQ2MjRaMIGXMQsw\nCQYDVQQGEwJVUzEiMCAGA1UECgwZQW1hem9uIFdlYiBTZXJ2aWNlcywgSW5jLjET\nMBEGA1UECwwKQW1hem9uIFJEUzELMAkGA1UECAwCV0ExMDAuBgNVBAMMJ0FtYXpv\nbiBSRFMgZXUtd2VzdC0yIFJvb3QgQ0EgUlNBMjA0OCBHMTEQMA4GA1UEBwwHU2Vh\ndHRsZTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAM1oGtthQ1YiVIC2\ni4u4swMAGxAjc/BZp0yq0eP5ZQFaxnxs7zFAPabEWsrjeDzrRhdVO0h7zskrertP\ngblGhfD20JfjvCHdP1RUhy/nzG+T+hn6Takan/GIgs8grlBMRHMgBYHW7tklhjaH\n3F7LujhceAHhhgp6IOrpb6YTaTTaJbF3GTmkqxSJ3l1LtEoWz8Al/nL/Ftzxrtez\nVs6ebpvd7sw37sxmXBWX2OlvUrPCTmladw9OrllGXtCFw4YyLe3zozBlZ3cHzQ0q\nlINhpRcajTMfZrsiGCkQtoJT+AqVJPS2sHjqsEH8yiySW9Jbq4zyMbM1yqQ2vnnx\nMJgoYMcCAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUaQG88UnV\nJPTI+Pcti1P+q3H7pGYwDgYDVR0PAQH/BAQDAgGGMA0GCSqGSIb3DQEBCwUAA4IB\nAQBAkgr75V0sEJimC6QRiTVWEuj2Khy7unjSfudbM6zumhXEU2/sUaVLiYy6cA/x\n3v0laDle6T07x9g64j5YastE/4jbzrGgIINFlY0JnaYmR3KZEjgi1s1fkRRf3llL\nPJm9u4Q1mbwAMQK/ZjLuuRcL3uRIHJek18nRqT5h43GB26qXyvJqeYYpYfIjL9+/\nYiZAbSRRZG+Li23cmPWrbA1CJY121SB+WybCbysbOXzhD3Sl2KSZRwSw4p2HrFtV\n1Prk0dOBtZxCG9luf87ultuDZpfS0w6oNBAMXocgswk24ylcADkkFxBWW+7BETn1\nEpK+t1Lm37mU4sxtuha00XAi\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIEADCCAuigAwIBAgIQcY44/8NUvBwr6LlHfRy7KjANBgkqhkiG9w0BAQsFADCB\nmDELMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIElu\nYy4xEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChB\nbWF6b24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQH\nDAdTZWF0dGxlMCAXDTIxMDUxOTE4MjcxOFoYDzIwNjEwNTE5MTkyNzE4WjCBmDEL\nMAkGA1UEBhMCVVMxIjAgBgNVBAoMGUFtYXpvbiBXZWIgU2VydmljZXMsIEluYy4x\nEzARBgNVBAsMCkFtYXpvbiBSRFMxCzAJBgNVBAgMAldBMTEwLwYDVQQDDChBbWF6\nb24gUkRTIGV1LXNvdXRoLTEgUm9vdCBDQSBSU0EyMDQ4IEcxMRAwDgYDVQQHDAdT\nZWF0dGxlMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA0UaBeC+Usalu\nEtXnV7+PnH+gi7/71tI/jkKVGKuhD2JDVvqLVoqbMHRh3+wGMvqKCjbHPcC2XMWv\n566fpAj4UZ9CLB5fVzss+QVNTl+FH2XhEzigopp+872ajsNzcZxrMkifxGb4i0U+\nt0Zi+UrbL5tsfP2JonKR1crOrbS6/DlzHBjIiJazGOQcMsJjNuTOItLbMohLpraA\n/nApa3kOvI7Ufool1/34MG0+wL3UUA4YkZ6oBJVxjZvvs6tI7Lzz/SnhK2widGdc\nsnbLqBpHNIZQSorVoiwcFaRBGYX/uzYkiw44Yfa4cK2V/B5zgu1Fbr0gbI2am4eh\nyVYyg4jPawIDAQABo0IwQDAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBS9gM1m\nIIjyh9O5H/7Vj0R/akI7UzAOBgNVHQ8BAf8EBAMCAYYwDQYJKoZIhvcNAQELBQAD\nggEBAF0Sm9HC2AUyedBVnwgkVXMibnYChOzz7T+0Y+fOLXYAEXex2s8oqGeZdGYX\nJHkjBn7JXu7LM+TpTbPbFFDoc1sgMguD/ls+8XsqAl1CssW+amryIL+jfcfbgQ+P\nICwEUD9hGdjBgJ5WcuS+qqxHsEIlFNci3HxcxfBa9VsWs5TjI7Vsl4meL5lf7ZyL\nwDV7dHRuU+cImqG1MIvPRIlvPnT7EghrCYi2VCPhP2pM/UvShuwVnkz4MJ29ebIk\nWR9kpblFxFdE92D5UUvMCjC2kmtgzNiErvTcwIvOO9YCbBHzRB1fFiWrXUHhJWq9\nIkaxR5icb/IpAV0A1lYZEWMVsfQ=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----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\nrM2p0kk=\n-----END CERTIFICATE-----\n"
    ];
  }
});

// ../node_modules/.pnpm/aws-ssl-profiles@1.1.2/node_modules/aws-ssl-profiles/lib/profiles/ca/proxies.js
var require_proxies = __commonJS({
  "../node_modules/.pnpm/aws-ssl-profiles@1.1.2/node_modules/aws-ssl-profiles/lib/profiles/ca/proxies.js"(exports2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.proxies = void 0;
    exports2.proxies = [
      "-----BEGIN CERTIFICATE-----\nMIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv\nb3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj\nca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM\n9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw\nIFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6\nVOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L\n93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm\njgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC\nAYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA\nA4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI\nU5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs\nN+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv\no/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU\n5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy\nrqXRfboQnoZsG4q5WTP468SQvvG5\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIFQTCCAymgAwIBAgITBmyf0pY1hp8KD+WGePhbJruKNzANBgkqhkiG9w0BAQwF\nADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6\nb24gUm9vdCBDQSAyMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTEL\nMAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv\nb3QgQ0EgMjCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK2Wny2cSkxK\ngXlRmeyKy2tgURO8TW0G/LAIjd0ZEGrHJgw12MBvIITplLGbhQPDW9tK6Mj4kHbZ\nW0/jTOgGNk3Mmqw9DJArktQGGWCsN0R5hYGCrVo34A3MnaZMUnbqQ523BNFQ9lXg\n1dKmSYXpN+nKfq5clU1Imj+uIFptiJXZNLhSGkOQsL9sBbm2eLfq0OQ6PBJTYv9K\n8nu+NQWpEjTj82R0Yiw9AElaKP4yRLuH3WUnAnE72kr3H9rN9yFVkE8P7K6C4Z9r\n2UXTu/Bfh+08LDmG2j/e7HJV63mjrdvdfLC6HM783k81ds8P+HgfajZRRidhW+me\nz/CiVX18JYpvL7TFz4QuK/0NURBs+18bvBt+xa47mAExkv8LV/SasrlX6avvDXbR\n8O70zoan4G7ptGmh32n2M8ZpLpcTnqWHsFcQgTfJU7O7f/aS0ZzQGPSSbtqDT6Zj\nmUyl+17vIWR6IF9sZIUVyzfpYgwLKhbcAS4y2j5L9Z469hdAlO+ekQiG+r5jqFoz\n7Mt0Q5X5bGlSNscpb/xVA1wf+5+9R+vnSUeVC06JIglJ4PVhHvG/LopyboBZ/1c6\n+XUyo05f7O0oYtlNc/LMgRdg7c3r3NunysV+Ar3yVAhU/bQtCSwXVEqY0VThUWcI\n0u1ufm8/0i2BWSlmy5A5lREedCf+3euvAgMBAAGjQjBAMA8GA1UdEwEB/wQFMAMB\nAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSwDPBMMPQFWAJI/TPlUq9LhONm\nUjANBgkqhkiG9w0BAQwFAAOCAgEAqqiAjw54o+Ci1M3m9Zh6O+oAA7CXDpO8Wqj2\nLIxyh6mx/H9z/WNxeKWHWc8w4Q0QshNabYL1auaAn6AFC2jkR2vHat+2/XcycuUY\n+gn0oJMsXdKMdYV2ZZAMA3m3MSNjrXiDCYZohMr/+c8mmpJ5581LxedhpxfL86kS\nk5Nrp+gvU5LEYFiwzAJRGFuFjWJZY7attN6a+yb3ACfAXVU3dJnJUH/jWS5E4ywl\n7uxMMne0nxrpS10gxdr9HIcWxkPo1LsmmkVwXqkLN1PiRnsn/eBG8om3zEK2yygm\nbtmlyTrIQRNg91CMFa6ybRoVGld45pIq2WWQgj9sAq+uEjonljYE1x2igGOpm/Hl\nurR8FLBOybEfdF849lHqm/osohHUqS0nGkWxr7JOcQ3AWEbWaQbLU8uz/mtBzUF+\nfUwPfHJ5elnNXkoOrJupmHN5fLT0zLm4BwyydFy4x2+IoZCn9Kr5v2c69BoVYh63\nn749sSmvZ6ES8lgQGVMDMBu4Gon2nL2XA46jCfMdiyHxtN/kHNGfZQIG6lzWE7OE\n76KlXIx3KadowGuuQNKotOrN8I1LOJwZmhsoVLiJkO/KdYE+HvJkJMcYr07/R54H\n9jVlpNMKVv/1F2Rs76giJUmTtt8AF9pYfl3uxRuw0dFfIRDH+fO6AgonB8Xx1sfT\n4PsJYGw=\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIBtjCCAVugAwIBAgITBmyf1XSXNmY/Owua2eiedgPySjAKBggqhkjOPQQDAjA5\nMQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g\nUm9vdCBDQSAzMB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG\nA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg\nQ0EgMzBZMBMGByqGSM49AgEGCCqGSM49AwEHA0IABCmXp8ZBf8ANm+gBG1bG8lKl\nui2yEujSLtf6ycXYqm0fc4E7O5hrOXwzpcVOho6AF2hiRVd9RFgdszflZwjrZt6j\nQjBAMA8GA1UdEwEB/wQFMAMBAf8wDgYDVR0PAQH/BAQDAgGGMB0GA1UdDgQWBBSr\nttvXBp43rDCGB5Fwx5zEGbF4wDAKBggqhkjOPQQDAgNJADBGAiEA4IWSoxe3jfkr\nBqWTrBqYaGFy+uGh0PsceGCmQ5nFuMQCIQCcAu/xlJyzlvnrxir4tiz+OpAUFteM\nYyRIHN8wfdVoOw==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIIB8jCCAXigAwIBAgITBmyf18G7EEwpQ+Vxe3ssyBrBDjAKBggqhkjOPQQDAzA5\nMQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6b24g\nUm9vdCBDQSA0MB4XDTE1MDUyNjAwMDAwMFoXDTQwMDUyNjAwMDAwMFowOTELMAkG\nA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJvb3Qg\nQ0EgNDB2MBAGByqGSM49AgEGBSuBBAAiA2IABNKrijdPo1MN/sGKe0uoe0ZLY7Bi\n9i0b2whxIdIA6GO9mif78DluXeo9pcmBqqNbIJhFXRbb/egQbeOc4OO9X4Ri83Bk\nM6DLJC9wuoihKqB1+IGuYgbEgds5bimwHvouXKNCMEAwDwYDVR0TAQH/BAUwAwEB\n/zAOBgNVHQ8BAf8EBAMCAYYwHQYDVR0OBBYEFNPsxzplbszh2naaVvuc84ZtV+WB\nMAoGCCqGSM49BAMDA2gAMGUCMDqLIfG9fhGt0O9Yli/W651+kI0rz2ZVwyzjKKlw\nCkcO8DdZEv8tmZQoTipPNU0zWgIxAOp1AE47xDqUEpHJWEadIRNyp4iciuRMStuW\n1KyLa2tJElMzrdfkviT8tQp21KW8EA==\n-----END CERTIFICATE-----\n",
      "-----BEGIN CERTIFICATE-----\nMIID7zCCAtegAwIBAgIBADANBgkqhkiG9w0BAQsFADCBmDELMAkGA1UEBhMCVVMx\nEDAOBgNVBAgTB0FyaXpvbmExEzARBgNVBAcTClNjb3R0c2RhbGUxJTAjBgNVBAoT\nHFN0YXJmaWVsZCBUZWNobm9sb2dpZXMsIEluYy4xOzA5BgNVBAMTMlN0YXJmaWVs\nZCBTZXJ2aWNlcyBSb290IENlcnRpZmljYXRlIEF1dGhvcml0eSAtIEcyMB4XDTA5\nMDkwMTAwMDAwMFoXDTM3MTIzMTIzNTk1OVowgZgxCzAJBgNVBAYTAlVTMRAwDgYD\nVQQIEwdBcml6b25hMRMwEQYDVQQHEwpTY290dHNkYWxlMSUwIwYDVQQKExxTdGFy\nZmllbGQgVGVjaG5vbG9naWVzLCBJbmMuMTswOQYDVQQDEzJTdGFyZmllbGQgU2Vy\ndmljZXMgUm9vdCBDZXJ0aWZpY2F0ZSBBdXRob3JpdHkgLSBHMjCCASIwDQYJKoZI\nhvcNAQEBBQADggEPADCCAQoCggEBANUMOsQq+U7i9b4Zl1+OiFOxHz/Lz58gE20p\nOsgPfTz3a3Y4Y9k2YKibXlwAgLIvWX/2h/klQ4bnaRtSmpDhcePYLQ1Ob/bISdm2\n8xpWriu2dBTrz/sm4xq6HZYuajtYlIlHVv8loJNwU4PahHQUw2eeBGg6345AWh1K\nTs9DkTvnVtYAcMtS7nt9rjrnvDH5RfbCYM8TWQIrgMw0R9+53pBlbQLPLJGmpufe\nhRhJfGZOozptqbXuNC66DQO4M99H67FrjSXZm86B0UVGMpZwh94CDklDhbZsc7tk\n6mFBrMnUVN+HL8cisibMn1lUaJ/8viovxFUcdUBgF4UCVTmLfwUCAwEAAaNCMEAw\nDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMCAQYwHQYDVR0OBBYEFJxfAN+q\nAdcwKziIorhtSpzyEZGDMA0GCSqGSIb3DQEBCwUAA4IBAQBLNqaEd2ndOxmfZyMI\nbw5hyf2E3F/YNoHN2BtBLZ9g3ccaaNnRbobhiCPPE95Dz+I0swSdHynVv/heyNXB\nve6SbzJ08pGCL72CQnqtKrcgfU28elUSwhXqvfdqlS5sdJ/PHLTyxQGjhdByPq1z\nqwubdQxtRbeOlKyWN7Wg0I8VRw7j6IPdj/3vQQF3zCepYoUz8jcI73HPdwbeyBkd\niEDPfUYd/x7H4c7/I9vG+o1VTqkC50cRRj70/b17KSa7qWFiNyi2LSr2EIZkyXCn\n0q23KXB56jzaYyWf/Wi3MOxw+3WKt21gZ7IeyLnp2KhvAotnDU0mV3HaIPzBSlCN\nsSi6\n-----END CERTIFICATE-----\n"
    ];
  }
});

// ../node_modules/.pnpm/aws-ssl-profiles@1.1.2/node_modules/aws-ssl-profiles/lib/index.js
var require_lib7 = __commonJS({
  "../node_modules/.pnpm/aws-ssl-profiles@1.1.2/node_modules/aws-ssl-profiles/lib/index.js"(exports2, module2) {
    "use strict";
    Object.defineProperty(exports2, "__esModule", { value: true });
    var defaults_js_1 = require_defaults2();
    var proxies_js_1 = require_proxies();
    var proxyBundle = {
      ca: proxies_js_1.proxies
    };
    var profiles = {
      ca: [...defaults_js_1.defaults, ...proxies_js_1.proxies]
    };
    module2.exports = profiles;
    module2.exports.proxyBundle = proxyBundle;
    module2.exports.default = profiles;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/ssl_profiles.js
var require_ssl_profiles = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/constants/ssl_profiles.js"(exports2) {
    "use strict";
    var awsCaBundle = require_lib7();
    exports2["Amazon RDS"] = {
      ca: awsCaBundle.ca
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/connection_config.js
var require_connection_config = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/connection_config.js"(exports2, module2) {
    "use strict";
    var { URL: URL2 } = require("url");
    var ClientConstants = require_client3();
    var Charsets = require_charsets();
    var { version: version3 } = require_package();
    var SSLProfiles = null;
    var validOptions = {
      authPlugins: 1,
      authSwitchHandler: 1,
      bigNumberStrings: 1,
      charset: 1,
      charsetNumber: 1,
      compress: 1,
      connectAttributes: 1,
      connectTimeout: 1,
      database: 1,
      dateStrings: 1,
      debug: 1,
      decimalNumbers: 1,
      enableKeepAlive: 1,
      flags: 1,
      host: 1,
      insecureAuth: 1,
      infileStreamFactory: 1,
      isServer: 1,
      keepAliveInitialDelay: 1,
      localAddress: 1,
      maxPreparedStatements: 1,
      multipleStatements: 1,
      namedPlaceholders: 1,
      nestTables: 1,
      password: 1,
      // with multi-factor authentication, the main password (used for the first
      // authentication factor) can be provided via password1
      password1: 1,
      password2: 1,
      password3: 1,
      passwordSha1: 1,
      pool: 1,
      port: 1,
      queryFormat: 1,
      rowsAsArray: 1,
      socketPath: 1,
      ssl: 1,
      stream: 1,
      stringifyObjects: 1,
      supportBigNumbers: 1,
      timezone: 1,
      trace: 1,
      typeCast: 1,
      uri: 1,
      user: 1,
      disableEval: 1,
      // These options are used for Pool
      connectionLimit: 1,
      maxIdle: 1,
      idleTimeout: 1,
      Promise: 1,
      queueLimit: 1,
      waitForConnections: 1,
      jsonStrings: 1
    };
    var ConnectionConfig = class _ConnectionConfig {
      constructor(options) {
        if (typeof options === "string") {
          options = _ConnectionConfig.parseUrl(options);
        } else if (options && options.uri) {
          const uriOptions = _ConnectionConfig.parseUrl(options.uri);
          for (const key in uriOptions) {
            if (!Object.prototype.hasOwnProperty.call(uriOptions, key)) continue;
            if (options[key]) continue;
            options[key] = uriOptions[key];
          }
        }
        for (const key in options) {
          if (!Object.prototype.hasOwnProperty.call(options, key)) continue;
          if (validOptions[key] !== 1) {
            console.error(
              `Ignoring invalid configuration option passed to Connection: ${key}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection`
            );
          }
        }
        this.isServer = options.isServer;
        this.stream = options.stream;
        this.host = options.host || "localhost";
        this.port = (typeof options.port === "string" ? parseInt(options.port, 10) : options.port) || 3306;
        this.localAddress = options.localAddress;
        this.socketPath = options.socketPath;
        this.user = options.user || void 0;
        this.password = options.password || options.password1 || void 0;
        this.password2 = options.password2 || void 0;
        this.password3 = options.password3 || void 0;
        this.passwordSha1 = options.passwordSha1 || void 0;
        this.database = options.database;
        this.connectTimeout = isNaN(options.connectTimeout) ? 10 * 1e3 : options.connectTimeout;
        this.insecureAuth = options.insecureAuth || false;
        this.infileStreamFactory = options.infileStreamFactory || void 0;
        this.supportBigNumbers = options.supportBigNumbers || false;
        this.bigNumberStrings = options.bigNumberStrings || false;
        this.decimalNumbers = options.decimalNumbers || false;
        this.dateStrings = options.dateStrings || false;
        this.debug = options.debug;
        this.trace = options.trace !== false;
        this.stringifyObjects = options.stringifyObjects || false;
        this.enableKeepAlive = options.enableKeepAlive !== false;
        this.keepAliveInitialDelay = options.keepAliveInitialDelay;
        if (options.timezone && !/^(?:local|Z|[ +-]\d\d:\d\d)$/.test(options.timezone)) {
          console.error(
            `Ignoring invalid timezone passed to Connection: ${options.timezone}. This is currently a warning, but in future versions of MySQL2, an error will be thrown if you pass an invalid configuration option to a Connection`
          );
          this.timezone = "Z";
        } else {
          this.timezone = options.timezone || "local";
        }
        this.queryFormat = options.queryFormat;
        this.pool = options.pool || void 0;
        this.ssl = typeof options.ssl === "string" ? _ConnectionConfig.getSSLProfile(options.ssl) : options.ssl || false;
        this.multipleStatements = options.multipleStatements || false;
        this.rowsAsArray = options.rowsAsArray || false;
        this.namedPlaceholders = options.namedPlaceholders || false;
        this.nestTables = options.nestTables === void 0 ? void 0 : options.nestTables;
        this.typeCast = options.typeCast === void 0 ? true : options.typeCast;
        this.disableEval = Boolean(options.disableEval);
        if (this.timezone[0] === " ") {
          this.timezone = `+${this.timezone.slice(1)}`;
        }
        if (this.ssl) {
          if (typeof this.ssl !== "object") {
            throw new TypeError(
              `SSL profile must be an object, instead it's a ${typeof this.ssl}`
            );
          }
          this.ssl.rejectUnauthorized = this.ssl.rejectUnauthorized !== false;
        }
        this.maxPacketSize = 0;
        this.charsetNumber = options.charset ? _ConnectionConfig.getCharsetNumber(options.charset) : options.charsetNumber || Charsets.UTF8MB4_UNICODE_CI;
        this.compress = options.compress || false;
        this.authPlugins = options.authPlugins;
        this.authSwitchHandler = options.authSwitchHandler;
        this.clientFlags = _ConnectionConfig.mergeFlags(
          _ConnectionConfig.getDefaultFlags(options),
          options.flags || ""
        );
        const defaultConnectAttributes = {
          _client_name: "Node-MySQL-2",
          _client_version: version3
        };
        this.connectAttributes = {
          ...defaultConnectAttributes,
          ...options.connectAttributes || {}
        };
        this.maxPreparedStatements = options.maxPreparedStatements || 16e3;
        this.jsonStrings = options.jsonStrings || false;
      }
      static mergeFlags(default_flags, user_flags) {
        let flags2 = 0, i8;
        if (!Array.isArray(user_flags)) {
          user_flags = String(user_flags || "").toUpperCase().split(/\s*,+\s*/);
        }
        for (i8 in default_flags) {
          if (user_flags.indexOf(`-${default_flags[i8]}`) >= 0) {
            continue;
          }
          flags2 |= ClientConstants[default_flags[i8]] || 0;
        }
        for (i8 in user_flags) {
          if (user_flags[i8][0] === "-") {
            continue;
          }
          if (default_flags.indexOf(user_flags[i8]) >= 0) {
            continue;
          }
          flags2 |= ClientConstants[user_flags[i8]] || 0;
        }
        return flags2;
      }
      static getDefaultFlags(options) {
        const defaultFlags = [
          "LONG_PASSWORD",
          "FOUND_ROWS",
          "LONG_FLAG",
          "CONNECT_WITH_DB",
          "ODBC",
          "LOCAL_FILES",
          "IGNORE_SPACE",
          "PROTOCOL_41",
          "IGNORE_SIGPIPE",
          "TRANSACTIONS",
          "RESERVED",
          "SECURE_CONNECTION",
          "MULTI_RESULTS",
          "TRANSACTIONS",
          "SESSION_TRACK",
          "CONNECT_ATTRS"
        ];
        if (options && options.multipleStatements) {
          defaultFlags.push("MULTI_STATEMENTS");
        }
        defaultFlags.push("PLUGIN_AUTH");
        defaultFlags.push("PLUGIN_AUTH_LENENC_CLIENT_DATA");
        return defaultFlags;
      }
      static getCharsetNumber(charset) {
        const num = Charsets[charset.toUpperCase()];
        if (num === void 0) {
          throw new TypeError(`Unknown charset '${charset}'`);
        }
        return num;
      }
      static getSSLProfile(name3) {
        if (!SSLProfiles) {
          SSLProfiles = require_ssl_profiles();
        }
        const ssl = SSLProfiles[name3];
        if (ssl === void 0) {
          throw new TypeError(`Unknown SSL profile '${name3}'`);
        }
        return ssl;
      }
      static parseUrl(url) {
        const parsedUrl = new URL2(url);
        const options = {
          host: decodeURIComponent(parsedUrl.hostname),
          port: parseInt(parsedUrl.port, 10),
          database: decodeURIComponent(parsedUrl.pathname.slice(1)),
          user: decodeURIComponent(parsedUrl.username),
          password: decodeURIComponent(parsedUrl.password)
        };
        parsedUrl.searchParams.forEach((value, key) => {
          try {
            options[key] = JSON.parse(value);
          } catch (err3) {
            options[key] = value;
          }
        });
        return options;
      }
    };
    module2.exports = ConnectionConfig;
  }
});

// ../node_modules/.pnpm/lru-cache@7.18.3/node_modules/lru-cache/index.js
var require_lru_cache = __commonJS({
  "../node_modules/.pnpm/lru-cache@7.18.3/node_modules/lru-cache/index.js"(exports2, module2) {
    "use strict";
    var perf = typeof performance === "object" && performance && typeof performance.now === "function" ? performance : Date;
    var hasAbortController = typeof AbortController === "function";
    var AC = hasAbortController ? AbortController : class AbortController {
      constructor() {
        this.signal = new AS();
      }
      abort(reason = new Error("This operation was aborted")) {
        this.signal.reason = this.signal.reason || reason;
        this.signal.aborted = true;
        this.signal.dispatchEvent({
          type: "abort",
          target: this.signal
        });
      }
    };
    var hasAbortSignal = typeof AbortSignal === "function";
    var hasACAbortSignal = typeof AC.AbortSignal === "function";
    var AS = hasAbortSignal ? AbortSignal : hasACAbortSignal ? AC.AbortController : class AbortSignal {
      constructor() {
        this.reason = void 0;
        this.aborted = false;
        this._listeners = [];
      }
      dispatchEvent(e6) {
        if (e6.type === "abort") {
          this.aborted = true;
          this.onabort(e6);
          this._listeners.forEach((f9) => f9(e6), this);
        }
      }
      onabort() {
      }
      addEventListener(ev, fn3) {
        if (ev === "abort") {
          this._listeners.push(fn3);
        }
      }
      removeEventListener(ev, fn3) {
        if (ev === "abort") {
          this._listeners = this._listeners.filter((f9) => f9 !== fn3);
        }
      }
    };
    var warned = /* @__PURE__ */ new Set();
    var deprecatedOption = (opt, instead) => {
      const code = `LRU_CACHE_OPTION_${opt}`;
      if (shouldWarn(code)) {
        warn(code, `${opt} option`, `options.${instead}`, LRUCache);
      }
    };
    var deprecatedMethod = (method, instead) => {
      const code = `LRU_CACHE_METHOD_${method}`;
      if (shouldWarn(code)) {
        const { prototype } = LRUCache;
        const { get: get2 } = Object.getOwnPropertyDescriptor(prototype, method);
        warn(code, `${method} method`, `cache.${instead}()`, get2);
      }
    };
    var deprecatedProperty = (field, instead) => {
      const code = `LRU_CACHE_PROPERTY_${field}`;
      if (shouldWarn(code)) {
        const { prototype } = LRUCache;
        const { get: get2 } = Object.getOwnPropertyDescriptor(prototype, field);
        warn(code, `${field} property`, `cache.${instead}`, get2);
      }
    };
    var emitWarning = (...a9) => {
      typeof process === "object" && process && typeof process.emitWarning === "function" ? process.emitWarning(...a9) : console.error(...a9);
    };
    var shouldWarn = (code) => !warned.has(code);
    var warn = (code, what, instead, fn3) => {
      warned.add(code);
      const msg = `The ${what} is deprecated. Please use ${instead} instead.`;
      emitWarning(msg, "DeprecationWarning", code, fn3);
    };
    var isPosInt = (n7) => n7 && n7 === Math.floor(n7) && n7 > 0 && isFinite(n7);
    var getUintArray = (max2) => !isPosInt(max2) ? null : max2 <= Math.pow(2, 8) ? Uint8Array : max2 <= Math.pow(2, 16) ? Uint16Array : max2 <= Math.pow(2, 32) ? Uint32Array : max2 <= Number.MAX_SAFE_INTEGER ? ZeroArray : null;
    var ZeroArray = class extends Array {
      constructor(size2) {
        super(size2);
        this.fill(0);
      }
    };
    var Stack = class {
      constructor(max2) {
        if (max2 === 0) {
          return [];
        }
        const UintArray = getUintArray(max2);
        this.heap = new UintArray(max2);
        this.length = 0;
      }
      push(n7) {
        this.heap[this.length++] = n7;
      }
      pop() {
        return this.heap[--this.length];
      }
    };
    var LRUCache = class _LRUCache {
      constructor(options = {}) {
        const {
          max: max2 = 0,
          ttl,
          ttlResolution = 1,
          ttlAutopurge,
          updateAgeOnGet,
          updateAgeOnHas,
          allowStale,
          dispose,
          disposeAfter,
          noDisposeOnSet,
          noUpdateTTL,
          maxSize = 0,
          maxEntrySize = 0,
          sizeCalculation,
          fetchMethod,
          fetchContext,
          noDeleteOnFetchRejection,
          noDeleteOnStaleGet,
          allowStaleOnFetchRejection,
          allowStaleOnFetchAbort,
          ignoreFetchAbort
        } = options;
        const { length, maxAge, stale } = options instanceof _LRUCache ? {} : options;
        if (max2 !== 0 && !isPosInt(max2)) {
          throw new TypeError("max option must be a nonnegative integer");
        }
        const UintArray = max2 ? getUintArray(max2) : Array;
        if (!UintArray) {
          throw new Error("invalid max value: " + max2);
        }
        this.max = max2;
        this.maxSize = maxSize;
        this.maxEntrySize = maxEntrySize || this.maxSize;
        this.sizeCalculation = sizeCalculation || length;
        if (this.sizeCalculation) {
          if (!this.maxSize && !this.maxEntrySize) {
            throw new TypeError(
              "cannot set sizeCalculation without setting maxSize or maxEntrySize"
            );
          }
          if (typeof this.sizeCalculation !== "function") {
            throw new TypeError("sizeCalculation set to non-function");
          }
        }
        this.fetchMethod = fetchMethod || null;
        if (this.fetchMethod && typeof this.fetchMethod !== "function") {
          throw new TypeError(
            "fetchMethod must be a function if specified"
          );
        }
        this.fetchContext = fetchContext;
        if (!this.fetchMethod && fetchContext !== void 0) {
          throw new TypeError(
            "cannot set fetchContext without fetchMethod"
          );
        }
        this.keyMap = /* @__PURE__ */ new Map();
        this.keyList = new Array(max2).fill(null);
        this.valList = new Array(max2).fill(null);
        this.next = new UintArray(max2);
        this.prev = new UintArray(max2);
        this.head = 0;
        this.tail = 0;
        this.free = new Stack(max2);
        this.initialFill = 1;
        this.size = 0;
        if (typeof dispose === "function") {
          this.dispose = dispose;
        }
        if (typeof disposeAfter === "function") {
          this.disposeAfter = disposeAfter;
          this.disposed = [];
        } else {
          this.disposeAfter = null;
          this.disposed = null;
        }
        this.noDisposeOnSet = !!noDisposeOnSet;
        this.noUpdateTTL = !!noUpdateTTL;
        this.noDeleteOnFetchRejection = !!noDeleteOnFetchRejection;
        this.allowStaleOnFetchRejection = !!allowStaleOnFetchRejection;
        this.allowStaleOnFetchAbort = !!allowStaleOnFetchAbort;
        this.ignoreFetchAbort = !!ignoreFetchAbort;
        if (this.maxEntrySize !== 0) {
          if (this.maxSize !== 0) {
            if (!isPosInt(this.maxSize)) {
              throw new TypeError(
                "maxSize must be a positive integer if specified"
              );
            }
          }
          if (!isPosInt(this.maxEntrySize)) {
            throw new TypeError(
              "maxEntrySize must be a positive integer if specified"
            );
          }
          this.initializeSizeTracking();
        }
        this.allowStale = !!allowStale || !!stale;
        this.noDeleteOnStaleGet = !!noDeleteOnStaleGet;
        this.updateAgeOnGet = !!updateAgeOnGet;
        this.updateAgeOnHas = !!updateAgeOnHas;
        this.ttlResolution = isPosInt(ttlResolution) || ttlResolution === 0 ? ttlResolution : 1;
        this.ttlAutopurge = !!ttlAutopurge;
        this.ttl = ttl || maxAge || 0;
        if (this.ttl) {
          if (!isPosInt(this.ttl)) {
            throw new TypeError(
              "ttl must be a positive integer if specified"
            );
          }
          this.initializeTTLTracking();
        }
        if (this.max === 0 && this.ttl === 0 && this.maxSize === 0) {
          throw new TypeError(
            "At least one of max, maxSize, or ttl is required"
          );
        }
        if (!this.ttlAutopurge && !this.max && !this.maxSize) {
          const code = "LRU_CACHE_UNBOUNDED";
          if (shouldWarn(code)) {
            warned.add(code);
            const msg = "TTL caching without ttlAutopurge, max, or maxSize can result in unbounded memory consumption.";
            emitWarning(msg, "UnboundedCacheWarning", code, _LRUCache);
          }
        }
        if (stale) {
          deprecatedOption("stale", "allowStale");
        }
        if (maxAge) {
          deprecatedOption("maxAge", "ttl");
        }
        if (length) {
          deprecatedOption("length", "sizeCalculation");
        }
      }
      getRemainingTTL(key) {
        return this.has(key, { updateAgeOnHas: false }) ? Infinity : 0;
      }
      initializeTTLTracking() {
        this.ttls = new ZeroArray(this.max);
        this.starts = new ZeroArray(this.max);
        this.setItemTTL = (index7, ttl, start2 = perf.now()) => {
          this.starts[index7] = ttl !== 0 ? start2 : 0;
          this.ttls[index7] = ttl;
          if (ttl !== 0 && this.ttlAutopurge) {
            const t6 = setTimeout(() => {
              if (this.isStale(index7)) {
                this.delete(this.keyList[index7]);
              }
            }, ttl + 1);
            if (t6.unref) {
              t6.unref();
            }
          }
        };
        this.updateItemAge = (index7) => {
          this.starts[index7] = this.ttls[index7] !== 0 ? perf.now() : 0;
        };
        this.statusTTL = (status, index7) => {
          if (status) {
            status.ttl = this.ttls[index7];
            status.start = this.starts[index7];
            status.now = cachedNow || getNow();
            status.remainingTTL = status.now + status.ttl - status.start;
          }
        };
        let cachedNow = 0;
        const getNow = () => {
          const n7 = perf.now();
          if (this.ttlResolution > 0) {
            cachedNow = n7;
            const t6 = setTimeout(
              () => cachedNow = 0,
              this.ttlResolution
            );
            if (t6.unref) {
              t6.unref();
            }
          }
          return n7;
        };
        this.getRemainingTTL = (key) => {
          const index7 = this.keyMap.get(key);
          if (index7 === void 0) {
            return 0;
          }
          return this.ttls[index7] === 0 || this.starts[index7] === 0 ? Infinity : this.starts[index7] + this.ttls[index7] - (cachedNow || getNow());
        };
        this.isStale = (index7) => {
          return this.ttls[index7] !== 0 && this.starts[index7] !== 0 && (cachedNow || getNow()) - this.starts[index7] > this.ttls[index7];
        };
      }
      updateItemAge(_index2) {
      }
      statusTTL(_status2, _index2) {
      }
      setItemTTL(_index2, _ttl, _start) {
      }
      isStale(_index2) {
        return false;
      }
      initializeSizeTracking() {
        this.calculatedSize = 0;
        this.sizes = new ZeroArray(this.max);
        this.removeItemSize = (index7) => {
          this.calculatedSize -= this.sizes[index7];
          this.sizes[index7] = 0;
        };
        this.requireSize = (k9, v11, size2, sizeCalculation) => {
          if (this.isBackgroundFetch(v11)) {
            return 0;
          }
          if (!isPosInt(size2)) {
            if (sizeCalculation) {
              if (typeof sizeCalculation !== "function") {
                throw new TypeError("sizeCalculation must be a function");
              }
              size2 = sizeCalculation(v11, k9);
              if (!isPosInt(size2)) {
                throw new TypeError(
                  "sizeCalculation return invalid (expect positive integer)"
                );
              }
            } else {
              throw new TypeError(
                "invalid size value (must be positive integer). When maxSize or maxEntrySize is used, sizeCalculation or size must be set."
              );
            }
          }
          return size2;
        };
        this.addItemSize = (index7, size2, status) => {
          this.sizes[index7] = size2;
          if (this.maxSize) {
            const maxSize = this.maxSize - this.sizes[index7];
            while (this.calculatedSize > maxSize) {
              this.evict(true);
            }
          }
          this.calculatedSize += this.sizes[index7];
          if (status) {
            status.entrySize = size2;
            status.totalCalculatedSize = this.calculatedSize;
          }
        };
      }
      removeItemSize(_index2) {
      }
      addItemSize(_index2, _size2) {
      }
      requireSize(_k, _v, size2, sizeCalculation) {
        if (size2 || sizeCalculation) {
          throw new TypeError(
            "cannot set size without setting maxSize or maxEntrySize on cache"
          );
        }
      }
      *indexes({ allowStale = this.allowStale } = {}) {
        if (this.size) {
          for (let i8 = this.tail; true; ) {
            if (!this.isValidIndex(i8)) {
              break;
            }
            if (allowStale || !this.isStale(i8)) {
              yield i8;
            }
            if (i8 === this.head) {
              break;
            } else {
              i8 = this.prev[i8];
            }
          }
        }
      }
      *rindexes({ allowStale = this.allowStale } = {}) {
        if (this.size) {
          for (let i8 = this.head; true; ) {
            if (!this.isValidIndex(i8)) {
              break;
            }
            if (allowStale || !this.isStale(i8)) {
              yield i8;
            }
            if (i8 === this.tail) {
              break;
            } else {
              i8 = this.next[i8];
            }
          }
        }
      }
      isValidIndex(index7) {
        return index7 !== void 0 && this.keyMap.get(this.keyList[index7]) === index7;
      }
      *entries() {
        for (const i8 of this.indexes()) {
          if (this.valList[i8] !== void 0 && this.keyList[i8] !== void 0 && !this.isBackgroundFetch(this.valList[i8])) {
            yield [this.keyList[i8], this.valList[i8]];
          }
        }
      }
      *rentries() {
        for (const i8 of this.rindexes()) {
          if (this.valList[i8] !== void 0 && this.keyList[i8] !== void 0 && !this.isBackgroundFetch(this.valList[i8])) {
            yield [this.keyList[i8], this.valList[i8]];
          }
        }
      }
      *keys() {
        for (const i8 of this.indexes()) {
          if (this.keyList[i8] !== void 0 && !this.isBackgroundFetch(this.valList[i8])) {
            yield this.keyList[i8];
          }
        }
      }
      *rkeys() {
        for (const i8 of this.rindexes()) {
          if (this.keyList[i8] !== void 0 && !this.isBackgroundFetch(this.valList[i8])) {
            yield this.keyList[i8];
          }
        }
      }
      *values() {
        for (const i8 of this.indexes()) {
          if (this.valList[i8] !== void 0 && !this.isBackgroundFetch(this.valList[i8])) {
            yield this.valList[i8];
          }
        }
      }
      *rvalues() {
        for (const i8 of this.rindexes()) {
          if (this.valList[i8] !== void 0 && !this.isBackgroundFetch(this.valList[i8])) {
            yield this.valList[i8];
          }
        }
      }
      [Symbol.iterator]() {
        return this.entries();
      }
      find(fn3, getOptions) {
        for (const i8 of this.indexes()) {
          const v11 = this.valList[i8];
          const value = this.isBackgroundFetch(v11) ? v11.__staleWhileFetching : v11;
          if (value === void 0) continue;
          if (fn3(value, this.keyList[i8], this)) {
            return this.get(this.keyList[i8], getOptions);
          }
        }
      }
      forEach(fn3, thisp = this) {
        for (const i8 of this.indexes()) {
          const v11 = this.valList[i8];
          const value = this.isBackgroundFetch(v11) ? v11.__staleWhileFetching : v11;
          if (value === void 0) continue;
          fn3.call(thisp, value, this.keyList[i8], this);
        }
      }
      rforEach(fn3, thisp = this) {
        for (const i8 of this.rindexes()) {
          const v11 = this.valList[i8];
          const value = this.isBackgroundFetch(v11) ? v11.__staleWhileFetching : v11;
          if (value === void 0) continue;
          fn3.call(thisp, value, this.keyList[i8], this);
        }
      }
      get prune() {
        deprecatedMethod("prune", "purgeStale");
        return this.purgeStale;
      }
      purgeStale() {
        let deleted = false;
        for (const i8 of this.rindexes({ allowStale: true })) {
          if (this.isStale(i8)) {
            this.delete(this.keyList[i8]);
            deleted = true;
          }
        }
        return deleted;
      }
      dump() {
        const arr = [];
        for (const i8 of this.indexes({ allowStale: true })) {
          const key = this.keyList[i8];
          const v11 = this.valList[i8];
          const value = this.isBackgroundFetch(v11) ? v11.__staleWhileFetching : v11;
          if (value === void 0) continue;
          const entry = { value };
          if (this.ttls) {
            entry.ttl = this.ttls[i8];
            const age = perf.now() - this.starts[i8];
            entry.start = Math.floor(Date.now() - age);
          }
          if (this.sizes) {
            entry.size = this.sizes[i8];
          }
          arr.unshift([key, entry]);
        }
        return arr;
      }
      load(arr) {
        this.clear();
        for (const [key, entry] of arr) {
          if (entry.start) {
            const age = Date.now() - entry.start;
            entry.start = perf.now() - age;
          }
          this.set(key, entry.value, entry);
        }
      }
      dispose(_v, _k, _reason) {
      }
      set(k9, v11, {
        ttl = this.ttl,
        start: start2,
        noDisposeOnSet = this.noDisposeOnSet,
        size: size2 = 0,
        sizeCalculation = this.sizeCalculation,
        noUpdateTTL = this.noUpdateTTL,
        status
      } = {}) {
        size2 = this.requireSize(k9, v11, size2, sizeCalculation);
        if (this.maxEntrySize && size2 > this.maxEntrySize) {
          if (status) {
            status.set = "miss";
            status.maxEntrySizeExceeded = true;
          }
          this.delete(k9);
          return this;
        }
        let index7 = this.size === 0 ? void 0 : this.keyMap.get(k9);
        if (index7 === void 0) {
          index7 = this.newIndex();
          this.keyList[index7] = k9;
          this.valList[index7] = v11;
          this.keyMap.set(k9, index7);
          this.next[this.tail] = index7;
          this.prev[index7] = this.tail;
          this.tail = index7;
          this.size++;
          this.addItemSize(index7, size2, status);
          if (status) {
            status.set = "add";
          }
          noUpdateTTL = false;
        } else {
          this.moveToTail(index7);
          const oldVal = this.valList[index7];
          if (v11 !== oldVal) {
            if (this.isBackgroundFetch(oldVal)) {
              oldVal.__abortController.abort(new Error("replaced"));
            } else {
              if (!noDisposeOnSet) {
                this.dispose(oldVal, k9, "set");
                if (this.disposeAfter) {
                  this.disposed.push([oldVal, k9, "set"]);
                }
              }
            }
            this.removeItemSize(index7);
            this.valList[index7] = v11;
            this.addItemSize(index7, size2, status);
            if (status) {
              status.set = "replace";
              const oldValue = oldVal && this.isBackgroundFetch(oldVal) ? oldVal.__staleWhileFetching : oldVal;
              if (oldValue !== void 0) status.oldValue = oldValue;
            }
          } else if (status) {
            status.set = "update";
          }
        }
        if (ttl !== 0 && this.ttl === 0 && !this.ttls) {
          this.initializeTTLTracking();
        }
        if (!noUpdateTTL) {
          this.setItemTTL(index7, ttl, start2);
        }
        this.statusTTL(status, index7);
        if (this.disposeAfter) {
          while (this.disposed.length) {
            this.disposeAfter(...this.disposed.shift());
          }
        }
        return this;
      }
      newIndex() {
        if (this.size === 0) {
          return this.tail;
        }
        if (this.size === this.max && this.max !== 0) {
          return this.evict(false);
        }
        if (this.free.length !== 0) {
          return this.free.pop();
        }
        return this.initialFill++;
      }
      pop() {
        if (this.size) {
          const val2 = this.valList[this.head];
          this.evict(true);
          return val2;
        }
      }
      evict(free) {
        const head = this.head;
        const k9 = this.keyList[head];
        const v11 = this.valList[head];
        if (this.isBackgroundFetch(v11)) {
          v11.__abortController.abort(new Error("evicted"));
        } else {
          this.dispose(v11, k9, "evict");
          if (this.disposeAfter) {
            this.disposed.push([v11, k9, "evict"]);
          }
        }
        this.removeItemSize(head);
        if (free) {
          this.keyList[head] = null;
          this.valList[head] = null;
          this.free.push(head);
        }
        this.head = this.next[head];
        this.keyMap.delete(k9);
        this.size--;
        return head;
      }
      has(k9, { updateAgeOnHas = this.updateAgeOnHas, status } = {}) {
        const index7 = this.keyMap.get(k9);
        if (index7 !== void 0) {
          if (!this.isStale(index7)) {
            if (updateAgeOnHas) {
              this.updateItemAge(index7);
            }
            if (status) status.has = "hit";
            this.statusTTL(status, index7);
            return true;
          } else if (status) {
            status.has = "stale";
            this.statusTTL(status, index7);
          }
        } else if (status) {
          status.has = "miss";
        }
        return false;
      }
      // like get(), but without any LRU updating or TTL expiration
      peek(k9, { allowStale = this.allowStale } = {}) {
        const index7 = this.keyMap.get(k9);
        if (index7 !== void 0 && (allowStale || !this.isStale(index7))) {
          const v11 = this.valList[index7];
          return this.isBackgroundFetch(v11) ? v11.__staleWhileFetching : v11;
        }
      }
      backgroundFetch(k9, index7, options, context) {
        const v11 = index7 === void 0 ? void 0 : this.valList[index7];
        if (this.isBackgroundFetch(v11)) {
          return v11;
        }
        const ac = new AC();
        if (options.signal) {
          options.signal.addEventListener(
            "abort",
            () => ac.abort(options.signal.reason)
          );
        }
        const fetchOpts = {
          signal: ac.signal,
          options,
          context
        };
        const cb = (v12, updateCache = false) => {
          const { aborted } = ac.signal;
          const ignoreAbort = options.ignoreFetchAbort && v12 !== void 0;
          if (options.status) {
            if (aborted && !updateCache) {
              options.status.fetchAborted = true;
              options.status.fetchError = ac.signal.reason;
              if (ignoreAbort) options.status.fetchAbortIgnored = true;
            } else {
              options.status.fetchResolved = true;
            }
          }
          if (aborted && !ignoreAbort && !updateCache) {
            return fetchFail(ac.signal.reason);
          }
          if (this.valList[index7] === p11) {
            if (v12 === void 0) {
              if (p11.__staleWhileFetching) {
                this.valList[index7] = p11.__staleWhileFetching;
              } else {
                this.delete(k9);
              }
            } else {
              if (options.status) options.status.fetchUpdated = true;
              this.set(k9, v12, fetchOpts.options);
            }
          }
          return v12;
        };
        const eb = (er3) => {
          if (options.status) {
            options.status.fetchRejected = true;
            options.status.fetchError = er3;
          }
          return fetchFail(er3);
        };
        const fetchFail = (er3) => {
          const { aborted } = ac.signal;
          const allowStaleAborted = aborted && options.allowStaleOnFetchAbort;
          const allowStale = allowStaleAborted || options.allowStaleOnFetchRejection;
          const noDelete = allowStale || options.noDeleteOnFetchRejection;
          if (this.valList[index7] === p11) {
            const del = !noDelete || p11.__staleWhileFetching === void 0;
            if (del) {
              this.delete(k9);
            } else if (!allowStaleAborted) {
              this.valList[index7] = p11.__staleWhileFetching;
            }
          }
          if (allowStale) {
            if (options.status && p11.__staleWhileFetching !== void 0) {
              options.status.returnedStale = true;
            }
            return p11.__staleWhileFetching;
          } else if (p11.__returned === p11) {
            throw er3;
          }
        };
        const pcall = (res, rej) => {
          this.fetchMethod(k9, v11, fetchOpts).then((v12) => res(v12), rej);
          ac.signal.addEventListener("abort", () => {
            if (!options.ignoreFetchAbort || options.allowStaleOnFetchAbort) {
              res();
              if (options.allowStaleOnFetchAbort) {
                res = (v12) => cb(v12, true);
              }
            }
          });
        };
        if (options.status) options.status.fetchDispatched = true;
        const p11 = new Promise(pcall).then(cb, eb);
        p11.__abortController = ac;
        p11.__staleWhileFetching = v11;
        p11.__returned = null;
        if (index7 === void 0) {
          this.set(k9, p11, { ...fetchOpts.options, status: void 0 });
          index7 = this.keyMap.get(k9);
        } else {
          this.valList[index7] = p11;
        }
        return p11;
      }
      isBackgroundFetch(p11) {
        return p11 && typeof p11 === "object" && typeof p11.then === "function" && Object.prototype.hasOwnProperty.call(
          p11,
          "__staleWhileFetching"
        ) && Object.prototype.hasOwnProperty.call(p11, "__returned") && (p11.__returned === p11 || p11.__returned === null);
      }
      // this takes the union of get() and set() opts, because it does both
      async fetch(k9, {
        // get options
        allowStale = this.allowStale,
        updateAgeOnGet = this.updateAgeOnGet,
        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
        // set options
        ttl = this.ttl,
        noDisposeOnSet = this.noDisposeOnSet,
        size: size2 = 0,
        sizeCalculation = this.sizeCalculation,
        noUpdateTTL = this.noUpdateTTL,
        // fetch exclusive options
        noDeleteOnFetchRejection = this.noDeleteOnFetchRejection,
        allowStaleOnFetchRejection = this.allowStaleOnFetchRejection,
        ignoreFetchAbort = this.ignoreFetchAbort,
        allowStaleOnFetchAbort = this.allowStaleOnFetchAbort,
        fetchContext = this.fetchContext,
        forceRefresh = false,
        status,
        signal
      } = {}) {
        if (!this.fetchMethod) {
          if (status) status.fetch = "get";
          return this.get(k9, {
            allowStale,
            updateAgeOnGet,
            noDeleteOnStaleGet,
            status
          });
        }
        const options = {
          allowStale,
          updateAgeOnGet,
          noDeleteOnStaleGet,
          ttl,
          noDisposeOnSet,
          size: size2,
          sizeCalculation,
          noUpdateTTL,
          noDeleteOnFetchRejection,
          allowStaleOnFetchRejection,
          allowStaleOnFetchAbort,
          ignoreFetchAbort,
          status,
          signal
        };
        let index7 = this.keyMap.get(k9);
        if (index7 === void 0) {
          if (status) status.fetch = "miss";
          const p11 = this.backgroundFetch(k9, index7, options, fetchContext);
          return p11.__returned = p11;
        } else {
          const v11 = this.valList[index7];
          if (this.isBackgroundFetch(v11)) {
            const stale = allowStale && v11.__staleWhileFetching !== void 0;
            if (status) {
              status.fetch = "inflight";
              if (stale) status.returnedStale = true;
            }
            return stale ? v11.__staleWhileFetching : v11.__returned = v11;
          }
          const isStale = this.isStale(index7);
          if (!forceRefresh && !isStale) {
            if (status) status.fetch = "hit";
            this.moveToTail(index7);
            if (updateAgeOnGet) {
              this.updateItemAge(index7);
            }
            this.statusTTL(status, index7);
            return v11;
          }
          const p11 = this.backgroundFetch(k9, index7, options, fetchContext);
          const hasStale = p11.__staleWhileFetching !== void 0;
          const staleVal = hasStale && allowStale;
          if (status) {
            status.fetch = hasStale && isStale ? "stale" : "refresh";
            if (staleVal && isStale) status.returnedStale = true;
          }
          return staleVal ? p11.__staleWhileFetching : p11.__returned = p11;
        }
      }
      get(k9, {
        allowStale = this.allowStale,
        updateAgeOnGet = this.updateAgeOnGet,
        noDeleteOnStaleGet = this.noDeleteOnStaleGet,
        status
      } = {}) {
        const index7 = this.keyMap.get(k9);
        if (index7 !== void 0) {
          const value = this.valList[index7];
          const fetching = this.isBackgroundFetch(value);
          this.statusTTL(status, index7);
          if (this.isStale(index7)) {
            if (status) status.get = "stale";
            if (!fetching) {
              if (!noDeleteOnStaleGet) {
                this.delete(k9);
              }
              if (status) status.returnedStale = allowStale;
              return allowStale ? value : void 0;
            } else {
              if (status) {
                status.returnedStale = allowStale && value.__staleWhileFetching !== void 0;
              }
              return allowStale ? value.__staleWhileFetching : void 0;
            }
          } else {
            if (status) status.get = "hit";
            if (fetching) {
              return value.__staleWhileFetching;
            }
            this.moveToTail(index7);
            if (updateAgeOnGet) {
              this.updateItemAge(index7);
            }
            return value;
          }
        } else if (status) {
          status.get = "miss";
        }
      }
      connect(p11, n7) {
        this.prev[n7] = p11;
        this.next[p11] = n7;
      }
      moveToTail(index7) {
        if (index7 !== this.tail) {
          if (index7 === this.head) {
            this.head = this.next[index7];
          } else {
            this.connect(this.prev[index7], this.next[index7]);
          }
          this.connect(this.tail, index7);
          this.tail = index7;
        }
      }
      get del() {
        deprecatedMethod("del", "delete");
        return this.delete;
      }
      delete(k9) {
        let deleted = false;
        if (this.size !== 0) {
          const index7 = this.keyMap.get(k9);
          if (index7 !== void 0) {
            deleted = true;
            if (this.size === 1) {
              this.clear();
            } else {
              this.removeItemSize(index7);
              const v11 = this.valList[index7];
              if (this.isBackgroundFetch(v11)) {
                v11.__abortController.abort(new Error("deleted"));
              } else {
                this.dispose(v11, k9, "delete");
                if (this.disposeAfter) {
                  this.disposed.push([v11, k9, "delete"]);
                }
              }
              this.keyMap.delete(k9);
              this.keyList[index7] = null;
              this.valList[index7] = null;
              if (index7 === this.tail) {
                this.tail = this.prev[index7];
              } else if (index7 === this.head) {
                this.head = this.next[index7];
              } else {
                this.next[this.prev[index7]] = this.next[index7];
                this.prev[this.next[index7]] = this.prev[index7];
              }
              this.size--;
              this.free.push(index7);
            }
          }
        }
        if (this.disposed) {
          while (this.disposed.length) {
            this.disposeAfter(...this.disposed.shift());
          }
        }
        return deleted;
      }
      clear() {
        for (const index7 of this.rindexes({ allowStale: true })) {
          const v11 = this.valList[index7];
          if (this.isBackgroundFetch(v11)) {
            v11.__abortController.abort(new Error("deleted"));
          } else {
            const k9 = this.keyList[index7];
            this.dispose(v11, k9, "delete");
            if (this.disposeAfter) {
              this.disposed.push([v11, k9, "delete"]);
            }
          }
        }
        this.keyMap.clear();
        this.valList.fill(null);
        this.keyList.fill(null);
        if (this.ttls) {
          this.ttls.fill(0);
          this.starts.fill(0);
        }
        if (this.sizes) {
          this.sizes.fill(0);
        }
        this.head = 0;
        this.tail = 0;
        this.initialFill = 1;
        this.free.length = 0;
        this.calculatedSize = 0;
        this.size = 0;
        if (this.disposed) {
          while (this.disposed.length) {
            this.disposeAfter(...this.disposed.shift());
          }
        }
      }
      get reset() {
        deprecatedMethod("reset", "clear");
        return this.clear;
      }
      get length() {
        deprecatedProperty("length", "size");
        return this.size;
      }
      static get AbortController() {
        return AC;
      }
      static get AbortSignal() {
        return AS;
      }
    };
    module2.exports = LRUCache;
  }
});

// ../node_modules/.pnpm/named-placeholders@1.1.3/node_modules/named-placeholders/index.js
var require_named_placeholders = __commonJS({
  "../node_modules/.pnpm/named-placeholders@1.1.3/node_modules/named-placeholders/index.js"(exports2, module2) {
    "use strict";
    var RE_PARAM = /(?:\?)|(?::(\d+|(?:[a-zA-Z][a-zA-Z0-9_]*)))/g;
    var DQUOTE = 34;
    var SQUOTE = 39;
    var BSLASH = 92;
    function parse6(query) {
      let ppos = RE_PARAM.exec(query);
      let curpos = 0;
      let start2 = 0;
      let end;
      const parts2 = [];
      let inQuote = false;
      let escape4 = false;
      let qchr;
      const tokens = [];
      let qcnt = 0;
      let lastTokenEndPos = 0;
      let i8;
      if (ppos) {
        do {
          for (i8 = curpos, end = ppos.index; i8 < end; ++i8) {
            let chr = query.charCodeAt(i8);
            if (chr === BSLASH)
              escape4 = !escape4;
            else {
              if (escape4) {
                escape4 = false;
                continue;
              }
              if (inQuote && chr === qchr) {
                if (query.charCodeAt(i8 + 1) === qchr) {
                  ++i8;
                  continue;
                }
                inQuote = false;
              } else if (chr === DQUOTE || chr === SQUOTE) {
                inQuote = true;
                qchr = chr;
              }
            }
          }
          if (!inQuote) {
            parts2.push(query.substring(start2, end));
            tokens.push(ppos[0].length === 1 ? qcnt++ : ppos[1]);
            start2 = end + ppos[0].length;
            lastTokenEndPos = start2;
          }
          curpos = end + ppos[0].length;
        } while (ppos = RE_PARAM.exec(query));
        if (tokens.length) {
          if (curpos < query.length) {
            parts2.push(query.substring(lastTokenEndPos));
          }
          return [parts2, tokens];
        }
      }
      return [query];
    }
    function createCompiler(config) {
      if (!config)
        config = {};
      if (!config.placeholder) {
        config.placeholder = "?";
      }
      let ncache = 100;
      let cache5;
      if (typeof config.cache === "number") {
        ncache = config.cache;
      }
      if (typeof config.cache === "object") {
        cache5 = config.cache;
      }
      if (config.cache !== false && !cache5) {
        cache5 = new (require_lru_cache())({ max: ncache });
      }
      function toArrayParams(tree, params) {
        const arr = [];
        if (tree.length == 1) {
          return [tree[0], []];
        }
        if (typeof params == "undefined")
          throw new Error("Named query contains placeholders, but parameters object is undefined");
        const tokens = tree[1];
        for (let i8 = 0; i8 < tokens.length; ++i8) {
          arr.push(params[tokens[i8]]);
        }
        return [tree[0], arr];
      }
      function noTailingSemicolon(s10) {
        if (s10.slice(-1) == ":") {
          return s10.slice(0, -1);
        }
        return s10;
      }
      function join7(tree) {
        if (tree.length == 1) {
          return tree;
        }
        let unnamed = noTailingSemicolon(tree[0][0]);
        for (let i8 = 1; i8 < tree[0].length; ++i8) {
          if (tree[0][i8 - 1].slice(-1) == ":") {
            unnamed += config.placeholder;
          }
          unnamed += config.placeholder;
          unnamed += noTailingSemicolon(tree[0][i8]);
        }
        const last = tree[0][tree[0].length - 1];
        if (tree[0].length == tree[1].length) {
          if (last.slice(-1) == ":") {
            unnamed += config.placeholder;
          }
          unnamed += config.placeholder;
        }
        return [unnamed, tree[1]];
      }
      function compile(query, paramsObj) {
        let tree;
        if (cache5 && (tree = cache5.get(query))) {
          return toArrayParams(tree, paramsObj);
        }
        tree = join7(parse6(query));
        if (cache5) {
          cache5.set(query, tree);
        }
        return toArrayParams(tree, paramsObj);
      }
      compile.parse = parse6;
      return compile;
    }
    function toNumbered(q7, params) {
      const tree = parse6(q7);
      const paramsArr = [];
      if (tree.length == 1) {
        return [tree[0], paramsArr];
      }
      const pIndexes = {};
      let pLastIndex = 0;
      let qs2 = "";
      let varIndex;
      const varNames = [];
      for (let i8 = 0; i8 < tree[0].length; ++i8) {
        varIndex = pIndexes[tree[1][i8]];
        if (!varIndex) {
          varIndex = ++pLastIndex;
          pIndexes[tree[1][i8]] = varIndex;
        }
        if (tree[1][i8]) {
          varNames[varIndex - 1] = tree[1][i8];
          qs2 += tree[0][i8] + "$" + varIndex;
        } else {
          qs2 += tree[0][i8];
        }
      }
      return [qs2, varNames.map((n7) => params[n7])];
    }
    module2.exports = createCompiler;
    module2.exports.toNumbered = toNumbered;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/base/connection.js
var require_connection2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/base/connection.js"(exports2, module2) {
    "use strict";
    var Net = require("net");
    var Tls = require("tls");
    var Timers = require("timers");
    var EventEmitter = require("events").EventEmitter;
    var Readable6 = require("stream").Readable;
    var Queue3 = require_denque();
    var SqlString = require_sqlstring();
    var { createLRU } = require_lib5();
    var PacketParser = require_packet_parser();
    var Packets = require_packets();
    var Commands = require_commands2();
    var ConnectionConfig = require_connection_config();
    var CharsetToEncoding = require_charset_encodings();
    var _connectionId = 0;
    var convertNamedPlaceholders = null;
    var BaseConnection = class _BaseConnection extends EventEmitter {
      constructor(opts) {
        super();
        this.config = opts.config;
        if (!opts.config.stream) {
          if (opts.config.socketPath) {
            this.stream = Net.connect(opts.config.socketPath);
          } else {
            this.stream = Net.connect(opts.config.port, opts.config.host);
            if (this.config.enableKeepAlive) {
              this.stream.on("connect", () => {
                this.stream.setKeepAlive(true, this.config.keepAliveInitialDelay);
              });
            }
            this.stream.setNoDelay(true);
          }
        } else if (typeof opts.config.stream === "function") {
          this.stream = opts.config.stream(opts);
        } else {
          this.stream = opts.config.stream;
        }
        this._internalId = _connectionId++;
        this._commands = new Queue3();
        this._command = null;
        this._paused = false;
        this._paused_packets = new Queue3();
        this._statements = createLRU({
          max: this.config.maxPreparedStatements,
          onEviction: function(_7, statement) {
            statement.close();
          }
        });
        this.serverCapabilityFlags = 0;
        this.authorized = false;
        this.sequenceId = 0;
        this.compressedSequenceId = 0;
        this.threadId = null;
        this._handshakePacket = null;
        this._fatalError = null;
        this._protocolError = null;
        this._outOfOrderPackets = [];
        this.clientEncoding = CharsetToEncoding[this.config.charsetNumber];
        this.stream.on("error", this._handleNetworkError.bind(this));
        this.packetParser = new PacketParser((p11) => {
          this.handlePacket(p11);
        });
        this.stream.on("data", (data) => {
          if (this.connectTimeout) {
            Timers.clearTimeout(this.connectTimeout);
            this.connectTimeout = null;
          }
          this.packetParser.execute(data);
        });
        this.stream.on("end", () => {
          this.emit("end");
        });
        this.stream.on("close", () => {
          if (this._closing) {
            return;
          }
          if (!this._protocolError) {
            this._protocolError = new Error(
              "Connection lost: The server closed the connection."
            );
            this._protocolError.fatal = true;
            this._protocolError.code = "PROTOCOL_CONNECTION_LOST";
          }
          this._notifyError(this._protocolError);
        });
        let handshakeCommand;
        if (!this.config.isServer) {
          handshakeCommand = new Commands.ClientHandshake(this.config.clientFlags);
          handshakeCommand.on("end", () => {
            if (!handshakeCommand.handshake || this._fatalError || this._protocolError) {
              return;
            }
            this._handshakePacket = handshakeCommand.handshake;
            this.threadId = handshakeCommand.handshake.connectionId;
            this.emit("connect", handshakeCommand.handshake);
          });
          handshakeCommand.on("error", (err3) => {
            this._closing = true;
            this._notifyError(err3);
          });
          this.addCommand(handshakeCommand);
        }
        this.serverEncoding = "utf8";
        if (this.config.connectTimeout) {
          const timeoutHandler = this._handleTimeoutError.bind(this);
          this.connectTimeout = Timers.setTimeout(
            timeoutHandler,
            this.config.connectTimeout
          );
        }
      }
      _addCommandClosedState(cmd) {
        const err3 = new Error(
          "Can't add new command when connection is in closed state"
        );
        err3.fatal = true;
        if (cmd.onResult) {
          cmd.onResult(err3);
        } else {
          this.emit("error", err3);
        }
      }
      _handleFatalError(err3) {
        err3.fatal = true;
        this.stream.removeAllListeners("data");
        this.addCommand = this._addCommandClosedState;
        this.write = () => {
          this.emit("error", new Error("Can't write in closed state"));
        };
        this._notifyError(err3);
        this._fatalError = err3;
      }
      _handleNetworkError(err3) {
        if (this.connectTimeout) {
          Timers.clearTimeout(this.connectTimeout);
          this.connectTimeout = null;
        }
        if (err3.code === "ECONNRESET" && this._closing) {
          return;
        }
        this._handleFatalError(err3);
      }
      _handleTimeoutError() {
        if (this.connectTimeout) {
          Timers.clearTimeout(this.connectTimeout);
          this.connectTimeout = null;
        }
        this.stream.destroy && this.stream.destroy();
        const err3 = new Error("connect ETIMEDOUT");
        err3.errorno = "ETIMEDOUT";
        err3.code = "ETIMEDOUT";
        err3.syscall = "connect";
        this._handleNetworkError(err3);
      }
      // notify all commands in the queue and bubble error as connection "error"
      // called on stream error or unexpected termination
      _notifyError(err3) {
        if (this.connectTimeout) {
          Timers.clearTimeout(this.connectTimeout);
          this.connectTimeout = null;
        }
        if (this._fatalError) {
          return;
        }
        let command;
        let bubbleErrorToConnection = !this._command;
        if (this._command && this._command.onResult) {
          this._command.onResult(err3);
          this._command = null;
        } else if (!(this._command && this._command.constructor === Commands.ClientHandshake && this._commands.length > 0)) {
          bubbleErrorToConnection = true;
        }
        while (command = this._commands.shift()) {
          if (command.onResult) {
            command.onResult(err3);
          } else {
            bubbleErrorToConnection = true;
          }
        }
        if (bubbleErrorToConnection || this._pool) {
          this.emit("error", err3);
        }
        if (err3.fatal) {
          this.close();
        }
      }
      write(buffer2) {
        const result = this.stream.write(buffer2, (err3) => {
          if (err3) {
            this._handleNetworkError(err3);
          }
        });
        if (!result) {
          this.stream.emit("pause");
        }
      }
      // http://dev.mysql.com/doc/internals/en/sequence-id.html
      //
      // The sequence-id is incremented with each packet and may wrap around.
      // It starts at 0 and is reset to 0 when a new command
      // begins in the Command Phase.
      // http://dev.mysql.com/doc/internals/en/example-several-mysql-packets.html
      _resetSequenceId() {
        this.sequenceId = 0;
        this.compressedSequenceId = 0;
      }
      _bumpCompressedSequenceId(numPackets) {
        this.compressedSequenceId += numPackets;
        this.compressedSequenceId %= 256;
      }
      _bumpSequenceId(numPackets) {
        this.sequenceId += numPackets;
        this.sequenceId %= 256;
      }
      writePacket(packet) {
        const MAX_PACKET_LENGTH = 16777215;
        const length = packet.length();
        let chunk, offset, header;
        if (length < MAX_PACKET_LENGTH) {
          packet.writeHeader(this.sequenceId);
          if (this.config.debug) {
            console.log(
              `${this._internalId} ${this.connectionId} <== ${this._command._commandName}#${this._command.stateName()}(${[this.sequenceId, packet._name, packet.length()].join(",")})`
            );
            console.log(
              `${this._internalId} ${this.connectionId} <== ${packet.buffer.toString("hex")}`
            );
          }
          this._bumpSequenceId(1);
          this.write(packet.buffer);
        } else {
          if (this.config.debug) {
            console.log(
              `${this._internalId} ${this.connectionId} <== Writing large packet, raw content not written:`
            );
            console.log(
              `${this._internalId} ${this.connectionId} <== ${this._command._commandName}#${this._command.stateName()}(${[this.sequenceId, packet._name, packet.length()].join(",")})`
            );
          }
          for (offset = 4; offset < 4 + length; offset += MAX_PACKET_LENGTH) {
            chunk = packet.buffer.slice(offset, offset + MAX_PACKET_LENGTH);
            if (chunk.length === MAX_PACKET_LENGTH) {
              header = Buffer.from([255, 255, 255, this.sequenceId]);
            } else {
              header = Buffer.from([
                chunk.length & 255,
                chunk.length >> 8 & 255,
                chunk.length >> 16 & 255,
                this.sequenceId
              ]);
            }
            this._bumpSequenceId(1);
            this.write(header);
            this.write(chunk);
          }
        }
      }
      // 0.11+ environment
      startTLS(onSecure) {
        if (this.config.debug) {
          console.log("Upgrading connection to TLS");
        }
        const secureContext = Tls.createSecureContext({
          ca: this.config.ssl.ca,
          cert: this.config.ssl.cert,
          ciphers: this.config.ssl.ciphers,
          key: this.config.ssl.key,
          passphrase: this.config.ssl.passphrase,
          minVersion: this.config.ssl.minVersion,
          maxVersion: this.config.ssl.maxVersion
        });
        const rejectUnauthorized = this.config.ssl.rejectUnauthorized;
        const verifyIdentity = this.config.ssl.verifyIdentity;
        const servername = this.config.host;
        let secureEstablished = false;
        this.stream.removeAllListeners("data");
        const secureSocket = Tls.connect(
          {
            rejectUnauthorized,
            requestCert: rejectUnauthorized,
            checkServerIdentity: verifyIdentity ? Tls.checkServerIdentity : function() {
              return void 0;
            },
            secureContext,
            isServer: false,
            socket: this.stream,
            servername
          },
          () => {
            secureEstablished = true;
            if (rejectUnauthorized) {
              if (typeof servername === "string" && verifyIdentity) {
                const cert = secureSocket.getPeerCertificate(true);
                const serverIdentityCheckError = Tls.checkServerIdentity(
                  servername,
                  cert
                );
                if (serverIdentityCheckError) {
                  onSecure(serverIdentityCheckError);
                  return;
                }
              }
            }
            onSecure();
          }
        );
        secureSocket.on("error", (err3) => {
          if (secureEstablished) {
            this._handleNetworkError(err3);
          } else {
            onSecure(err3);
          }
        });
        secureSocket.on("data", (data) => {
          this.packetParser.execute(data);
        });
        this.write = (buffer2) => secureSocket.write(buffer2);
      }
      protocolError(message, code) {
        if (this._closing) {
          return;
        }
        const err3 = new Error(message);
        err3.fatal = true;
        err3.code = code || "PROTOCOL_ERROR";
        this.emit("error", err3);
      }
      get fatalError() {
        return this._fatalError;
      }
      handlePacket(packet) {
        if (this._paused) {
          this._paused_packets.push(packet);
          return;
        }
        if (this.config.debug) {
          if (packet) {
            console.log(
              ` raw: ${packet.buffer.slice(packet.offset, packet.offset + packet.length()).toString("hex")}`
            );
            console.trace();
            const commandName = this._command ? this._command._commandName : "(no command)";
            const stateName = this._command ? this._command.stateName() : "(no command)";
            console.log(
              `${this._internalId} ${this.connectionId} ==> ${commandName}#${stateName}(${[packet.sequenceId, packet.type(), packet.length()].join(",")})`
            );
          }
        }
        if (!this._command) {
          const marker = packet.peekByte();
          if (marker === 255) {
            const error2 = Packets.Error.fromPacket(packet);
            this.protocolError(error2.message, error2.code);
          } else {
            this.protocolError(
              "Unexpected packet while no commands in the queue",
              "PROTOCOL_UNEXPECTED_PACKET"
            );
          }
          this.close();
          return;
        }
        if (packet) {
          if (this.sequenceId !== packet.sequenceId) {
            const err3 = new Error(
              `Warning: got packets out of order. Expected ${this.sequenceId} but received ${packet.sequenceId}`
            );
            err3.expected = this.sequenceId;
            err3.received = packet.sequenceId;
            this.emit("warn", err3);
            console.error(err3.message);
          }
          this._bumpSequenceId(packet.numPackets);
        }
        try {
          if (this._fatalError) {
            return;
          }
          const done = this._command.execute(packet, this);
          if (done) {
            this._command = this._commands.shift();
            if (this._command) {
              this.sequenceId = 0;
              this.compressedSequenceId = 0;
              this.handlePacket();
            }
          }
        } catch (err3) {
          this._handleFatalError(err3);
          this.stream.destroy();
        }
      }
      addCommand(cmd) {
        if (this.config.debug) {
          const commandName = cmd.constructor.name;
          console.log(`Add command: ${commandName}`);
          cmd._commandName = commandName;
        }
        if (!this._command) {
          this._command = cmd;
          this.handlePacket();
        } else {
          this._commands.push(cmd);
        }
        return cmd;
      }
      format(sql3, values2) {
        if (typeof this.config.queryFormat === "function") {
          return this.config.queryFormat.call(
            this,
            sql3,
            values2,
            this.config.timezone
          );
        }
        const opts = {
          sql: sql3,
          values: values2
        };
        this._resolveNamedPlaceholders(opts);
        return SqlString.format(
          opts.sql,
          opts.values,
          this.config.stringifyObjects,
          this.config.timezone
        );
      }
      escape(value) {
        return SqlString.escape(value, false, this.config.timezone);
      }
      escapeId(value) {
        return SqlString.escapeId(value, false);
      }
      raw(sql3) {
        return SqlString.raw(sql3);
      }
      _resolveNamedPlaceholders(options) {
        let unnamed;
        if (this.config.namedPlaceholders || options.namedPlaceholders) {
          if (Array.isArray(options.values)) {
            return;
          }
          if (convertNamedPlaceholders === null) {
            convertNamedPlaceholders = require_named_placeholders()();
          }
          unnamed = convertNamedPlaceholders(options.sql, options.values);
          options.sql = unnamed[0];
          options.values = unnamed[1];
        }
      }
      query(sql3, values2, cb) {
        let cmdQuery;
        if (sql3.constructor === Commands.Query) {
          cmdQuery = sql3;
        } else {
          cmdQuery = _BaseConnection.createQuery(sql3, values2, cb, this.config);
        }
        this._resolveNamedPlaceholders(cmdQuery);
        const rawSql = this.format(
          cmdQuery.sql,
          cmdQuery.values !== void 0 ? cmdQuery.values : []
        );
        cmdQuery.sql = rawSql;
        return this.addCommand(cmdQuery);
      }
      pause() {
        this._paused = true;
        this.stream.pause();
      }
      resume() {
        let packet;
        this._paused = false;
        while (packet = this._paused_packets.shift()) {
          this.handlePacket(packet);
          if (this._paused) {
            return;
          }
        }
        this.stream.resume();
      }
      // TODO: named placeholders support
      prepare(options, cb) {
        if (typeof options === "string") {
          options = { sql: options };
        }
        return this.addCommand(new Commands.Prepare(options, cb));
      }
      unprepare(sql3) {
        let options = {};
        if (typeof sql3 === "object") {
          options = sql3;
        } else {
          options.sql = sql3;
        }
        const key = _BaseConnection.statementKey(options);
        const stmt = this._statements.get(key);
        if (stmt) {
          this._statements.delete(key);
          stmt.close();
        }
        return stmt;
      }
      execute(sql3, values2, cb) {
        let options = {
          infileStreamFactory: this.config.infileStreamFactory
        };
        if (typeof sql3 === "object") {
          options = {
            ...options,
            ...sql3,
            sql: sql3.sql,
            values: sql3.values
          };
          if (typeof values2 === "function") {
            cb = values2;
          } else {
            options.values = options.values || values2;
          }
        } else if (typeof values2 === "function") {
          cb = values2;
          options.sql = sql3;
          options.values = void 0;
        } else {
          options.sql = sql3;
          options.values = values2;
        }
        this._resolveNamedPlaceholders(options);
        if (options.values) {
          if (!Array.isArray(options.values)) {
            throw new TypeError(
              "Bind parameters must be array if namedPlaceholders parameter is not enabled"
            );
          }
          options.values.forEach((val2) => {
            if (!Array.isArray(options.values)) {
              throw new TypeError(
                "Bind parameters must be array if namedPlaceholders parameter is not enabled"
              );
            }
            if (val2 === void 0) {
              throw new TypeError(
                "Bind parameters must not contain undefined. To pass SQL NULL specify JS null"
              );
            }
            if (typeof val2 === "function") {
              throw new TypeError(
                "Bind parameters must not contain function(s). To pass the body of a function as a string call .toString() first"
              );
            }
          });
        }
        const executeCommand = new Commands.Execute(options, cb);
        const prepareCommand = new Commands.Prepare(options, (err3, stmt) => {
          if (err3) {
            executeCommand.start = function() {
              return null;
            };
            if (cb) {
              cb(err3);
            } else {
              executeCommand.emit("error", err3);
            }
            executeCommand.emit("end");
            return;
          }
          executeCommand.statement = stmt;
        });
        this.addCommand(prepareCommand);
        this.addCommand(executeCommand);
        return executeCommand;
      }
      changeUser(options, callback) {
        if (!callback && typeof options === "function") {
          callback = options;
          options = {};
        }
        const charsetNumber = options.charset ? ConnectionConfig.getCharsetNumber(options.charset) : this.config.charsetNumber;
        return this.addCommand(
          new Commands.ChangeUser(
            {
              user: options.user || this.config.user,
              // for the purpose of multi-factor authentication, or not, the main
              // password (used for the 1st authentication factor) can also be
              // provided via the "password1" option
              password: options.password || options.password1 || this.config.password || this.config.password1,
              password2: options.password2 || this.config.password2,
              password3: options.password3 || this.config.password3,
              passwordSha1: options.passwordSha1 || this.config.passwordSha1,
              database: options.database || this.config.database,
              timeout: options.timeout,
              charsetNumber,
              currentConfig: this.config
            },
            (err3) => {
              if (err3) {
                err3.fatal = true;
              }
              if (callback) {
                callback(err3);
              }
            }
          )
        );
      }
      // transaction helpers
      beginTransaction(cb) {
        return this.query("START TRANSACTION", cb);
      }
      commit(cb) {
        return this.query("COMMIT", cb);
      }
      rollback(cb) {
        return this.query("ROLLBACK", cb);
      }
      ping(cb) {
        return this.addCommand(new Commands.Ping(cb));
      }
      _registerSlave(opts, cb) {
        return this.addCommand(new Commands.RegisterSlave(opts, cb));
      }
      _binlogDump(opts, cb) {
        return this.addCommand(new Commands.BinlogDump(opts, cb));
      }
      // currently just alias to close
      destroy() {
        this.close();
      }
      close() {
        if (this.connectTimeout) {
          Timers.clearTimeout(this.connectTimeout);
          this.connectTimeout = null;
        }
        this._closing = true;
        this.stream.end();
        this.addCommand = this._addCommandClosedState;
      }
      createBinlogStream(opts) {
        let test = 1;
        const stream = new Readable6({ objectMode: true });
        stream._read = function() {
          return {
            data: test++
          };
        };
        this._registerSlave(opts, () => {
          const dumpCmd = this._binlogDump(opts);
          dumpCmd.on("event", (ev) => {
            stream.push(ev);
          });
          dumpCmd.on("eof", () => {
            stream.push(null);
            if (opts.flags && opts.flags & 1) {
              this.close();
            }
          });
        });
        return stream;
      }
      connect(cb) {
        if (!cb) {
          return;
        }
        if (this._fatalError || this._protocolError) {
          return cb(this._fatalError || this._protocolError);
        }
        if (this._handshakePacket) {
          return cb(null, this);
        }
        let connectCalled = 0;
        function callbackOnce(isErrorHandler) {
          return function(param2) {
            if (!connectCalled) {
              if (isErrorHandler) {
                cb(param2);
              } else {
                cb(null, param2);
              }
            }
            connectCalled = 1;
          };
        }
        this.once("error", callbackOnce(true));
        this.once("connect", callbackOnce(false));
      }
      // ===================================
      // outgoing server connection methods
      // ===================================
      writeColumns(columns) {
        this.writePacket(Packets.ResultSetHeader.toPacket(columns.length));
        columns.forEach((column6) => {
          this.writePacket(
            Packets.ColumnDefinition.toPacket(column6, this.serverConfig.encoding)
          );
        });
        this.writeEof();
      }
      // row is array of columns, not hash
      writeTextRow(column6) {
        this.writePacket(
          Packets.TextRow.toPacket(column6, this.serverConfig.encoding)
        );
      }
      writeBinaryRow(column6) {
        this.writePacket(
          Packets.BinaryRow.toPacket(column6, this.serverConfig.encoding)
        );
      }
      writeTextResult(rows, columns, binary4 = false) {
        this.writeColumns(columns);
        rows.forEach((row) => {
          const arrayRow = new Array(columns.length);
          columns.forEach((column6) => {
            arrayRow.push(row[column6.name]);
          });
          if (binary4) {
            this.writeBinaryRow(arrayRow);
          } else this.writeTextRow(arrayRow);
        });
        this.writeEof();
      }
      writeEof(warnings, statusFlags) {
        this.writePacket(Packets.EOF.toPacket(warnings, statusFlags));
      }
      writeOk(args2) {
        if (!args2) {
          args2 = { affectedRows: 0 };
        }
        this.writePacket(Packets.OK.toPacket(args2, this.serverConfig.encoding));
      }
      writeError(args2) {
        const encoding = this.serverConfig ? this.serverConfig.encoding : "cesu8";
        this.writePacket(Packets.Error.toPacket(args2, encoding));
      }
      serverHandshake(args2) {
        this.serverConfig = args2;
        this.serverConfig.encoding = CharsetToEncoding[this.serverConfig.characterSet];
        return this.addCommand(new Commands.ServerHandshake(args2));
      }
      // ===============================================================
      end(callback) {
        if (this.config.isServer) {
          this._closing = true;
          const quitCmd2 = new EventEmitter();
          setImmediate(() => {
            this.stream.end();
            quitCmd2.emit("end");
          });
          return quitCmd2;
        }
        const quitCmd = this.addCommand(new Commands.Quit(callback));
        this.addCommand = this._addCommandClosedState;
        return quitCmd;
      }
      static createQuery(sql3, values2, cb, config) {
        let options = {
          rowsAsArray: config.rowsAsArray,
          infileStreamFactory: config.infileStreamFactory
        };
        if (typeof sql3 === "object") {
          options = {
            ...options,
            ...sql3,
            sql: sql3.sql,
            values: sql3.values
          };
          if (typeof values2 === "function") {
            cb = values2;
          } else if (values2 !== void 0) {
            options.values = values2;
          }
        } else if (typeof values2 === "function") {
          cb = values2;
          options.sql = sql3;
          options.values = void 0;
        } else {
          options.sql = sql3;
          options.values = values2;
        }
        return new Commands.Query(options, cb);
      }
      static statementKey(options) {
        return `${typeof options.nestTables}/${options.nestTables}/${options.rowsAsArray}${options.sql}`;
      }
    };
    module2.exports = BaseConnection;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/base/pool_connection.js
var require_pool_connection = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/base/pool_connection.js"(exports2, module2) {
    "use strict";
    var BaseConnection = require_connection2();
    var BasePoolConnection = class extends BaseConnection {
      constructor(pool2, options) {
        super(options);
        this._pool = pool2;
        this.lastActiveTime = Date.now();
        this.once("end", () => {
          this._removeFromPool();
        });
        this.once("error", () => {
          this._removeFromPool();
        });
      }
      release() {
        if (!this._pool || this._pool._closed) {
          return;
        }
        this.lastActiveTime = Date.now();
        this._pool.releaseConnection(this);
      }
      end() {
        const err3 = new Error(
          "Calling conn.end() to release a pooled connection is deprecated. In next version calling conn.end() will be restored to default conn.end() behavior. Use conn.release() instead."
        );
        this.emit("warn", err3);
        console.warn(err3.message);
        this.release();
      }
      destroy() {
        this._removeFromPool();
        super.destroy();
      }
      _removeFromPool() {
        if (!this._pool || this._pool._closed) {
          return;
        }
        const pool2 = this._pool;
        this._pool = null;
        pool2._removeConnection(this);
      }
    };
    BasePoolConnection.statementKey = BaseConnection.statementKey;
    module2.exports = BasePoolConnection;
    BasePoolConnection.prototype._realEnd = BaseConnection.prototype.end;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/make_done_cb.js
var require_make_done_cb = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/make_done_cb.js"(exports2, module2) {
    "use strict";
    function makeDoneCb(resolve2, reject, localErr) {
      return function(err3, rows, fields) {
        if (err3) {
          localErr.message = err3.message;
          localErr.code = err3.code;
          localErr.errno = err3.errno;
          localErr.sql = err3.sql;
          localErr.sqlState = err3.sqlState;
          localErr.sqlMessage = err3.sqlMessage;
          reject(localErr);
        } else {
          resolve2([rows, fields]);
        }
      };
    }
    module2.exports = makeDoneCb;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/prepared_statement_info.js
var require_prepared_statement_info = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/prepared_statement_info.js"(exports2, module2) {
    "use strict";
    var makeDoneCb = require_make_done_cb();
    var PromisePreparedStatementInfo = class {
      constructor(statement, promiseImpl) {
        this.statement = statement;
        this.Promise = promiseImpl;
      }
      execute(parameters) {
        const s10 = this.statement;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          if (parameters) {
            s10.execute(parameters, done);
          } else {
            s10.execute(done);
          }
        });
      }
      close() {
        return new this.Promise((resolve2) => {
          this.statement.close();
          resolve2();
        });
      }
    };
    module2.exports = PromisePreparedStatementInfo;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/inherit_events.js
var require_inherit_events = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/inherit_events.js"(exports2, module2) {
    "use strict";
    function inheritEvents(source, target, events) {
      const listeners = {};
      target.on("newListener", (eventName) => {
        if (events.indexOf(eventName) >= 0 && !target.listenerCount(eventName)) {
          source.on(
            eventName,
            listeners[eventName] = function() {
              const args2 = [].slice.call(arguments);
              args2.unshift(eventName);
              target.emit.apply(target, args2);
            }
          );
        }
      }).on("removeListener", (eventName) => {
        if (events.indexOf(eventName) >= 0 && !target.listenerCount(eventName)) {
          source.removeListener(eventName, listeners[eventName]);
          delete listeners[eventName];
        }
      });
    }
    module2.exports = inheritEvents;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/connection.js
var require_connection3 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/connection.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var PromisePreparedStatementInfo = require_prepared_statement_info();
    var makeDoneCb = require_make_done_cb();
    var inheritEvents = require_inherit_events();
    var BaseConnection = require_connection2();
    var PromiseConnection = class extends EventEmitter {
      constructor(connection2, promiseImpl) {
        super();
        this.connection = connection2;
        this.Promise = promiseImpl || Promise;
        inheritEvents(connection2, this, [
          "error",
          "drain",
          "connect",
          "end",
          "enqueue"
        ]);
      }
      release() {
        this.connection.release();
      }
      query(query, params) {
        const c6 = this.connection;
        const localErr = new Error();
        if (typeof params === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          if (params !== void 0) {
            c6.query(query, params, done);
          } else {
            c6.query(query, done);
          }
        });
      }
      execute(query, params) {
        const c6 = this.connection;
        const localErr = new Error();
        if (typeof params === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          if (params !== void 0) {
            c6.execute(query, params, done);
          } else {
            c6.execute(query, done);
          }
        });
      }
      end() {
        return new this.Promise((resolve2) => {
          this.connection.end(resolve2);
        });
      }
      beginTransaction() {
        const c6 = this.connection;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          c6.beginTransaction(done);
        });
      }
      commit() {
        const c6 = this.connection;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          c6.commit(done);
        });
      }
      rollback() {
        const c6 = this.connection;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          c6.rollback(done);
        });
      }
      ping() {
        const c6 = this.connection;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          c6.ping((err3) => {
            if (err3) {
              localErr.message = err3.message;
              localErr.code = err3.code;
              localErr.errno = err3.errno;
              localErr.sqlState = err3.sqlState;
              localErr.sqlMessage = err3.sqlMessage;
              reject(localErr);
            } else {
              resolve2(true);
            }
          });
        });
      }
      connect() {
        const c6 = this.connection;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          c6.connect((err3, param2) => {
            if (err3) {
              localErr.message = err3.message;
              localErr.code = err3.code;
              localErr.errno = err3.errno;
              localErr.sqlState = err3.sqlState;
              localErr.sqlMessage = err3.sqlMessage;
              reject(localErr);
            } else {
              resolve2(param2);
            }
          });
        });
      }
      prepare(options) {
        const c6 = this.connection;
        const promiseImpl = this.Promise;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          c6.prepare(options, (err3, statement) => {
            if (err3) {
              localErr.message = err3.message;
              localErr.code = err3.code;
              localErr.errno = err3.errno;
              localErr.sqlState = err3.sqlState;
              localErr.sqlMessage = err3.sqlMessage;
              reject(localErr);
            } else {
              const wrappedStatement = new PromisePreparedStatementInfo(
                statement,
                promiseImpl
              );
              resolve2(wrappedStatement);
            }
          });
        });
      }
      changeUser(options) {
        const c6 = this.connection;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          c6.changeUser(options, (err3) => {
            if (err3) {
              localErr.message = err3.message;
              localErr.code = err3.code;
              localErr.errno = err3.errno;
              localErr.sqlState = err3.sqlState;
              localErr.sqlMessage = err3.sqlMessage;
              reject(localErr);
            } else {
              resolve2();
            }
          });
        });
      }
      get config() {
        return this.connection.config;
      }
      get threadId() {
        return this.connection.threadId;
      }
    };
    (function(functionsToWrap) {
      for (let i8 = 0; functionsToWrap && i8 < functionsToWrap.length; i8++) {
        const func2 = functionsToWrap[i8];
        if (typeof BaseConnection.prototype[func2] === "function" && PromiseConnection.prototype[func2] === void 0) {
          PromiseConnection.prototype[func2] = /* @__PURE__ */ function factory(funcName) {
            return function() {
              return BaseConnection.prototype[funcName].apply(
                this.connection,
                arguments
              );
            };
          }(func2);
        }
      }
    })([
      // synchronous functions
      "close",
      "createBinlogStream",
      "destroy",
      "escape",
      "escapeId",
      "format",
      "pause",
      "pipe",
      "resume",
      "unprepare"
    ]);
    module2.exports = PromiseConnection;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/pool_connection.js
var require_pool_connection2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/pool_connection.js"(exports2, module2) {
    "use strict";
    var PromiseConnection = require_connection3();
    var BasePoolConnection = require_pool_connection();
    var PromisePoolConnection = class extends PromiseConnection {
      constructor(connection2, promiseImpl) {
        super(connection2, promiseImpl);
      }
      destroy() {
        return BasePoolConnection.prototype.destroy.apply(
          this.connection,
          arguments
        );
      }
    };
    module2.exports = PromisePoolConnection;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool_connection.js
var require_pool_connection3 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool_connection.js"(exports2, module2) {
    "use strict";
    var BasePoolConnection = require_pool_connection();
    var PoolConnection = class extends BasePoolConnection {
      promise(promiseImpl) {
        const PromisePoolConnection = require_pool_connection2();
        return new PromisePoolConnection(this, promiseImpl);
      }
    };
    module2.exports = PoolConnection;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/base/pool.js
var require_pool = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/base/pool.js"(exports2, module2) {
    "use strict";
    var process4 = require("process");
    var SqlString = require_sqlstring();
    var EventEmitter = require("events").EventEmitter;
    var PoolConnection = require_pool_connection3();
    var Queue3 = require_denque();
    var BaseConnection = require_connection2();
    function spliceConnection(queue, connection2) {
      const len = queue.length;
      for (let i8 = 0; i8 < len; i8++) {
        if (queue.get(i8) === connection2) {
          queue.removeOne(i8);
          break;
        }
      }
    }
    var BasePool = class extends EventEmitter {
      constructor(options) {
        super();
        this.config = options.config;
        this.config.connectionConfig.pool = this;
        this._allConnections = new Queue3();
        this._freeConnections = new Queue3();
        this._connectionQueue = new Queue3();
        this._closed = false;
        if (this.config.maxIdle < this.config.connectionLimit) {
          this._removeIdleTimeoutConnections();
        }
      }
      getConnection(cb) {
        if (this._closed) {
          return process4.nextTick(() => cb(new Error("Pool is closed.")));
        }
        let connection2;
        if (this._freeConnections.length > 0) {
          connection2 = this._freeConnections.pop();
          this.emit("acquire", connection2);
          return process4.nextTick(() => cb(null, connection2));
        }
        if (this.config.connectionLimit === 0 || this._allConnections.length < this.config.connectionLimit) {
          connection2 = new PoolConnection(this, {
            config: this.config.connectionConfig
          });
          this._allConnections.push(connection2);
          return connection2.connect((err3) => {
            if (this._closed) {
              return cb(new Error("Pool is closed."));
            }
            if (err3) {
              return cb(err3);
            }
            this.emit("connection", connection2);
            this.emit("acquire", connection2);
            return cb(null, connection2);
          });
        }
        if (!this.config.waitForConnections) {
          return process4.nextTick(() => cb(new Error("No connections available.")));
        }
        if (this.config.queueLimit && this._connectionQueue.length >= this.config.queueLimit) {
          return cb(new Error("Queue limit reached."));
        }
        this.emit("enqueue");
        return this._connectionQueue.push(cb);
      }
      releaseConnection(connection2) {
        let cb;
        if (!connection2._pool) {
          if (this._connectionQueue.length) {
            cb = this._connectionQueue.shift();
            process4.nextTick(this.getConnection.bind(this, cb));
          }
        } else if (this._connectionQueue.length) {
          cb = this._connectionQueue.shift();
          process4.nextTick(cb.bind(null, null, connection2));
        } else {
          this._freeConnections.push(connection2);
          this.emit("release", connection2);
        }
      }
      end(cb) {
        this._closed = true;
        clearTimeout(this._removeIdleTimeoutConnectionsTimer);
        if (typeof cb !== "function") {
          cb = function(err3) {
            if (err3) {
              throw err3;
            }
          };
        }
        let calledBack = false;
        let closedConnections = 0;
        let connection2;
        const endCB = function(err3) {
          if (calledBack) {
            return;
          }
          if (err3 || ++closedConnections >= this._allConnections.length) {
            calledBack = true;
            cb(err3);
            return;
          }
        }.bind(this);
        if (this._allConnections.length === 0) {
          endCB();
          return;
        }
        for (let i8 = 0; i8 < this._allConnections.length; i8++) {
          connection2 = this._allConnections.get(i8);
          connection2._realEnd(endCB);
        }
      }
      query(sql3, values2, cb) {
        const cmdQuery = BaseConnection.createQuery(
          sql3,
          values2,
          cb,
          this.config.connectionConfig
        );
        if (typeof cmdQuery.namedPlaceholders === "undefined") {
          cmdQuery.namedPlaceholders = this.config.connectionConfig.namedPlaceholders;
        }
        this.getConnection((err3, conn) => {
          if (err3) {
            if (typeof cmdQuery.onResult === "function") {
              cmdQuery.onResult(err3);
            } else {
              cmdQuery.emit("error", err3);
            }
            return;
          }
          try {
            conn.query(cmdQuery).once("end", () => {
              conn.release();
            });
          } catch (e6) {
            conn.release();
            throw e6;
          }
        });
        return cmdQuery;
      }
      execute(sql3, values2, cb) {
        if (typeof values2 === "function") {
          cb = values2;
          values2 = [];
        }
        this.getConnection((err3, conn) => {
          if (err3) {
            return cb(err3);
          }
          try {
            conn.execute(sql3, values2, cb).once("end", () => {
              conn.release();
            });
          } catch (e6) {
            conn.release();
            return cb(e6);
          }
        });
      }
      _removeConnection(connection2) {
        spliceConnection(this._allConnections, connection2);
        spliceConnection(this._freeConnections, connection2);
        this.releaseConnection(connection2);
      }
      _removeIdleTimeoutConnections() {
        if (this._removeIdleTimeoutConnectionsTimer) {
          clearTimeout(this._removeIdleTimeoutConnectionsTimer);
        }
        this._removeIdleTimeoutConnectionsTimer = setTimeout(() => {
          try {
            while (this._freeConnections.length > this.config.maxIdle || this._freeConnections.length > 0 && Date.now() - this._freeConnections.get(0).lastActiveTime > this.config.idleTimeout) {
              this._freeConnections.get(0).destroy();
            }
          } finally {
            this._removeIdleTimeoutConnections();
          }
        }, 1e3);
      }
      format(sql3, values2) {
        return SqlString.format(
          sql3,
          values2,
          this.config.connectionConfig.stringifyObjects,
          this.config.connectionConfig.timezone
        );
      }
      escape(value) {
        return SqlString.escape(
          value,
          this.config.connectionConfig.stringifyObjects,
          this.config.connectionConfig.timezone
        );
      }
      escapeId(value) {
        return SqlString.escapeId(value, false);
      }
    };
    module2.exports = BasePool;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/pool.js
var require_pool2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/pool.js"(exports2, module2) {
    "use strict";
    var EventEmitter = require("events").EventEmitter;
    var makeDoneCb = require_make_done_cb();
    var PromisePoolConnection = require_pool_connection2();
    var inheritEvents = require_inherit_events();
    var BasePool = require_pool();
    var PromisePool = class extends EventEmitter {
      constructor(pool2, thePromise) {
        super();
        this.pool = pool2;
        this.Promise = thePromise || Promise;
        inheritEvents(pool2, this, ["acquire", "connection", "enqueue", "release"]);
      }
      getConnection() {
        const corePool = this.pool;
        return new this.Promise((resolve2, reject) => {
          corePool.getConnection((err3, coreConnection) => {
            if (err3) {
              reject(err3);
            } else {
              resolve2(new PromisePoolConnection(coreConnection, this.Promise));
            }
          });
        });
      }
      releaseConnection(connection2) {
        if (connection2 instanceof PromisePoolConnection) connection2.release();
      }
      query(sql3, args2) {
        const corePool = this.pool;
        const localErr = new Error();
        if (typeof args2 === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          if (args2 !== void 0) {
            corePool.query(sql3, args2, done);
          } else {
            corePool.query(sql3, done);
          }
        });
      }
      execute(sql3, args2) {
        const corePool = this.pool;
        const localErr = new Error();
        if (typeof args2 === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          if (args2) {
            corePool.execute(sql3, args2, done);
          } else {
            corePool.execute(sql3, done);
          }
        });
      }
      end() {
        const corePool = this.pool;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          corePool.end((err3) => {
            if (err3) {
              localErr.message = err3.message;
              localErr.code = err3.code;
              localErr.errno = err3.errno;
              localErr.sqlState = err3.sqlState;
              localErr.sqlMessage = err3.sqlMessage;
              reject(localErr);
            } else {
              resolve2();
            }
          });
        });
      }
    };
    (function(functionsToWrap) {
      for (let i8 = 0; functionsToWrap && i8 < functionsToWrap.length; i8++) {
        const func2 = functionsToWrap[i8];
        if (typeof BasePool.prototype[func2] === "function" && PromisePool.prototype[func2] === void 0) {
          PromisePool.prototype[func2] = /* @__PURE__ */ function factory(funcName) {
            return function() {
              return BasePool.prototype[funcName].apply(this.pool, arguments);
            };
          }(func2);
        }
      }
    })([
      // synchronous functions
      "escape",
      "escapeId",
      "format"
    ]);
    module2.exports = PromisePool;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool.js
var require_pool3 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool.js"(exports2, module2) {
    "use strict";
    var BasePool = require_pool();
    var Pool3 = class extends BasePool {
      promise(promiseImpl) {
        const PromisePool = require_pool2();
        return new PromisePool(this, promiseImpl);
      }
    };
    module2.exports = Pool3;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool_config.js
var require_pool_config = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool_config.js"(exports2, module2) {
    "use strict";
    var ConnectionConfig = require_connection_config();
    var PoolConfig = class {
      constructor(options) {
        if (typeof options === "string") {
          options = ConnectionConfig.parseUrl(options);
        }
        this.connectionConfig = new ConnectionConfig(options);
        this.waitForConnections = options.waitForConnections === void 0 ? true : Boolean(options.waitForConnections);
        this.connectionLimit = isNaN(options.connectionLimit) ? 10 : Number(options.connectionLimit);
        this.maxIdle = isNaN(options.maxIdle) ? this.connectionLimit : Number(options.maxIdle);
        this.idleTimeout = isNaN(options.idleTimeout) ? 6e4 : Number(options.idleTimeout);
        this.queueLimit = isNaN(options.queueLimit) ? 0 : Number(options.queueLimit);
      }
    };
    module2.exports = PoolConfig;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/connection.js
var require_connection4 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/connection.js"(exports2, module2) {
    "use strict";
    var BaseConnection = require_connection2();
    var Connection4 = class extends BaseConnection {
      promise(promiseImpl) {
        const PromiseConnection = require_connection3();
        return new PromiseConnection(this, promiseImpl);
      }
    };
    module2.exports = Connection4;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool_cluster.js
var require_pool_cluster = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/pool_cluster.js"(exports2, module2) {
    "use strict";
    var process4 = require("process");
    var Pool3 = require_pool3();
    var PoolConfig = require_pool_config();
    var Connection4 = require_connection4();
    var EventEmitter = require("events").EventEmitter;
    var makeSelector = {
      RR() {
        let index7 = 0;
        return (clusterIds) => clusterIds[index7++ % clusterIds.length];
      },
      RANDOM() {
        return (clusterIds) => clusterIds[Math.floor(Math.random() * clusterIds.length)];
      },
      ORDER() {
        return (clusterIds) => clusterIds[0];
      }
    };
    var getMonotonicMilliseconds = function() {
      let ms3;
      if (typeof process4.hrtime === "function") {
        ms3 = process4.hrtime();
        ms3 = ms3[0] * 1e3 + ms3[1] * 1e-6;
      } else {
        ms3 = process4.uptime() * 1e3;
      }
      return Math.floor(ms3);
    };
    var patternRegExp = function(pattern) {
      if (pattern instanceof RegExp) {
        return pattern;
      }
      const source = pattern.replace(/([.+?^=!:${}()|[\]/\\])/g, "\\$1").replace(/\*/g, ".*");
      return new RegExp(`^${source}$`);
    };
    var PoolNamespace = class {
      constructor(cluster, pattern, selector) {
        this._cluster = cluster;
        this._pattern = pattern;
        this._selector = makeSelector[selector]();
      }
      getConnection(cb) {
        const clusterNode = this._getClusterNode();
        if (clusterNode === null) {
          let err3 = new Error("Pool does Not exist.");
          err3.code = "POOL_NOEXIST";
          if (this._cluster._findNodeIds(this._pattern, true).length !== 0) {
            err3 = new Error("Pool does Not have online node.");
            err3.code = "POOL_NONEONLINE";
          }
          return cb(err3);
        }
        return this._cluster._getConnection(clusterNode, (err3, connection2) => {
          if (err3) {
            if (this._cluster._canRetry && this._cluster._findNodeIds(this._pattern).length !== 0) {
              this._cluster.emit("warn", err3);
              return this.getConnection(cb);
            }
            return cb(err3);
          }
          return cb(null, connection2);
        });
      }
      /**
       * pool cluster query
       * @param {*} sql
       * @param {*} values
       * @param {*} cb
       * @returns query
       */
      query(sql3, values2, cb) {
        const query = Connection4.createQuery(sql3, values2, cb, {});
        this.getConnection((err3, conn) => {
          if (err3) {
            if (typeof query.onResult === "function") {
              query.onResult(err3);
            } else {
              query.emit("error", err3);
            }
            return;
          }
          try {
            conn.query(query).once("end", () => {
              conn.release();
            });
          } catch (e6) {
            conn.release();
            throw e6;
          }
        });
        return query;
      }
      /**
       * pool cluster execute
       * @param {*} sql
       * @param {*} values
       * @param {*} cb
       */
      execute(sql3, values2, cb) {
        if (typeof values2 === "function") {
          cb = values2;
          values2 = [];
        }
        this.getConnection((err3, conn) => {
          if (err3) {
            return cb(err3);
          }
          try {
            conn.execute(sql3, values2, cb).once("end", () => {
              conn.release();
            });
          } catch (e6) {
            conn.release();
            throw e6;
          }
        });
      }
      _getClusterNode() {
        const foundNodeIds = this._cluster._findNodeIds(this._pattern);
        if (foundNodeIds.length === 0) {
          return null;
        }
        const nodeId = foundNodeIds.length === 1 ? foundNodeIds[0] : this._selector(foundNodeIds);
        return this._cluster._getNode(nodeId);
      }
    };
    var PoolCluster = class extends EventEmitter {
      constructor(config) {
        super();
        config = config || {};
        this._canRetry = typeof config.canRetry === "undefined" ? true : config.canRetry;
        this._removeNodeErrorCount = config.removeNodeErrorCount || 5;
        this._restoreNodeTimeout = config.restoreNodeTimeout || 0;
        this._defaultSelector = config.defaultSelector || "RR";
        this._closed = false;
        this._lastId = 0;
        this._nodes = {};
        this._serviceableNodeIds = [];
        this._namespaces = {};
        this._findCaches = {};
      }
      of(pattern, selector) {
        pattern = pattern || "*";
        selector = selector || this._defaultSelector;
        selector = selector.toUpperCase();
        if (!makeSelector[selector] === "undefined") {
          selector = this._defaultSelector;
        }
        const key = pattern + selector;
        if (typeof this._namespaces[key] === "undefined") {
          this._namespaces[key] = new PoolNamespace(this, pattern, selector);
        }
        return this._namespaces[key];
      }
      add(id, config) {
        if (typeof id === "object") {
          config = id;
          id = `CLUSTER::${++this._lastId}`;
        }
        if (typeof this._nodes[id] === "undefined") {
          this._nodes[id] = {
            id,
            errorCount: 0,
            pool: new Pool3({ config: new PoolConfig(config) }),
            _offlineUntil: 0
          };
          this._serviceableNodeIds.push(id);
          this._clearFindCaches();
        }
      }
      remove(pattern) {
        const foundNodeIds = this._findNodeIds(pattern, true);
        for (let i8 = 0; i8 < foundNodeIds.length; i8++) {
          const node = this._getNode(foundNodeIds[i8]);
          if (node) {
            this._removeNode(node);
          }
        }
      }
      getConnection(pattern, selector, cb) {
        let namespace;
        if (typeof pattern === "function") {
          cb = pattern;
          namespace = this.of();
        } else {
          if (typeof selector === "function") {
            cb = selector;
            selector = this._defaultSelector;
          }
          namespace = this.of(pattern, selector);
        }
        namespace.getConnection(cb);
      }
      end(callback) {
        const cb = callback !== void 0 ? callback : (err3) => {
          if (err3) {
            throw err3;
          }
        };
        if (this._closed) {
          process4.nextTick(cb);
          return;
        }
        this._closed = true;
        let calledBack = false;
        let waitingClose = 0;
        const onEnd = (err3) => {
          if (!calledBack && (err3 || --waitingClose <= 0)) {
            calledBack = true;
            return cb(err3);
          }
        };
        for (const id in this._nodes) {
          waitingClose++;
          this._nodes[id].pool.end(onEnd);
        }
        if (waitingClose === 0) {
          process4.nextTick(onEnd);
        }
      }
      _findNodeIds(pattern, includeOffline) {
        let currentTime = 0;
        let foundNodeIds = this._findCaches[pattern];
        if (foundNodeIds === void 0) {
          const expression = patternRegExp(pattern);
          foundNodeIds = this._serviceableNodeIds.filter(
            (id) => id.match(expression)
          );
        }
        this._findCaches[pattern] = foundNodeIds;
        if (includeOffline) {
          return foundNodeIds;
        }
        return foundNodeIds.filter((nodeId) => {
          const node = this._getNode(nodeId);
          if (!node._offlineUntil) {
            return true;
          }
          if (!currentTime) {
            currentTime = getMonotonicMilliseconds();
          }
          return node._offlineUntil <= currentTime;
        });
      }
      _getNode(id) {
        return this._nodes[id] || null;
      }
      _increaseErrorCount(node) {
        const errorCount = ++node.errorCount;
        if (this._removeNodeErrorCount > errorCount) {
          return;
        }
        if (this._restoreNodeTimeout > 0) {
          node._offlineUntil = getMonotonicMilliseconds() + this._restoreNodeTimeout;
          this.emit("offline", node.id);
          return;
        }
        this._removeNode(node);
        this.emit("remove", node.id);
      }
      _decreaseErrorCount(node) {
        let errorCount = node.errorCount;
        if (errorCount > this._removeNodeErrorCount) {
          errorCount = this._removeNodeErrorCount;
        }
        if (errorCount < 1) {
          errorCount = 1;
        }
        node.errorCount = errorCount - 1;
        if (node._offlineUntil) {
          node._offlineUntil = 0;
          this.emit("online", node.id);
        }
      }
      _getConnection(node, cb) {
        node.pool.getConnection((err3, connection2) => {
          if (err3) {
            this._increaseErrorCount(node);
            return cb(err3);
          }
          this._decreaseErrorCount(node);
          connection2._clusterId = node.id;
          return cb(null, connection2);
        });
      }
      _removeNode(node) {
        const index7 = this._serviceableNodeIds.indexOf(node.id);
        if (index7 !== -1) {
          this._serviceableNodeIds.splice(index7, 1);
          delete this._nodes[node.id];
          this._clearFindCaches();
          node.pool.end();
        }
      }
      _clearFindCaches() {
        this._findCaches = {};
      }
    };
    module2.exports = PoolCluster;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/create_connection.js
var require_create_connection = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/create_connection.js"(exports2, module2) {
    "use strict";
    var Connection4 = require_connection4();
    var ConnectionConfig = require_connection_config();
    function createConnection(opts) {
      return new Connection4({ config: new ConnectionConfig(opts) });
    }
    module2.exports = createConnection;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/create_pool.js
var require_create_pool = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/create_pool.js"(exports2, module2) {
    "use strict";
    var Pool3 = require_pool3();
    var PoolConfig = require_pool_config();
    function createPool4(config) {
      return new Pool3({ config: new PoolConfig(config) });
    }
    module2.exports = createPool4;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/create_pool_cluster.js
var require_create_pool_cluster = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/create_pool_cluster.js"(exports2, module2) {
    "use strict";
    var PoolCluster = require_pool_cluster();
    function createPoolCluster(config) {
      return new PoolCluster(config);
    }
    module2.exports = createPoolCluster;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/pool_cluster.js
var require_pool_cluster2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/promise/pool_cluster.js"(exports2, module2) {
    "use strict";
    var PromisePoolConnection = require_pool_connection2();
    var makeDoneCb = require_make_done_cb();
    var PromisePoolNamespace = class {
      constructor(poolNamespace, thePromise) {
        this.poolNamespace = poolNamespace;
        this.Promise = thePromise || Promise;
      }
      getConnection() {
        const corePoolNamespace = this.poolNamespace;
        return new this.Promise((resolve2, reject) => {
          corePoolNamespace.getConnection((err3, coreConnection) => {
            if (err3) {
              reject(err3);
            } else {
              resolve2(new PromisePoolConnection(coreConnection, this.Promise));
            }
          });
        });
      }
      query(sql3, values2) {
        const corePoolNamespace = this.poolNamespace;
        const localErr = new Error();
        if (typeof values2 === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          corePoolNamespace.query(sql3, values2, done);
        });
      }
      execute(sql3, values2) {
        const corePoolNamespace = this.poolNamespace;
        const localErr = new Error();
        if (typeof values2 === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          corePoolNamespace.execute(sql3, values2, done);
        });
      }
    };
    module2.exports = PromisePoolNamespace;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/promise.js
var require_promise = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/promise.js"(exports2) {
    "use strict";
    var SqlString = require_sqlstring();
    var EventEmitter = require("events").EventEmitter;
    var parserCache = require_parser_cache();
    var PoolCluster = require_pool_cluster();
    var createConnection = require_create_connection();
    var createPool4 = require_create_pool();
    var createPoolCluster = require_create_pool_cluster();
    var PromiseConnection = require_connection3();
    var PromisePool = require_pool2();
    var makeDoneCb = require_make_done_cb();
    var PromisePoolConnection = require_pool_connection2();
    var inheritEvents = require_inherit_events();
    var PromisePoolNamespace = require_pool_cluster2();
    function createConnectionPromise(opts) {
      const coreConnection = createConnection(opts);
      const createConnectionErr = new Error();
      const thePromise = opts.Promise || Promise;
      if (!thePromise) {
        throw new Error(
          "no Promise implementation available.Use promise-enabled node version or pass userland Promise implementation as parameter, for example: { Promise: require('bluebird') }"
        );
      }
      return new thePromise((resolve2, reject) => {
        coreConnection.once("connect", () => {
          resolve2(new PromiseConnection(coreConnection, thePromise));
        });
        coreConnection.once("error", (err3) => {
          createConnectionErr.message = err3.message;
          createConnectionErr.code = err3.code;
          createConnectionErr.errno = err3.errno;
          createConnectionErr.sqlState = err3.sqlState;
          reject(createConnectionErr);
        });
      });
    }
    function createPromisePool(opts) {
      const corePool = createPool4(opts);
      const thePromise = opts.Promise || Promise;
      if (!thePromise) {
        throw new Error(
          "no Promise implementation available.Use promise-enabled node version or pass userland Promise implementation as parameter, for example: { Promise: require('bluebird') }"
        );
      }
      return new PromisePool(corePool, thePromise);
    }
    var PromisePoolCluster = class extends EventEmitter {
      constructor(poolCluster, thePromise) {
        super();
        this.poolCluster = poolCluster;
        this.Promise = thePromise || Promise;
        inheritEvents(poolCluster, this, ["warn", "remove", "online", "offline"]);
      }
      getConnection(pattern, selector) {
        const corePoolCluster = this.poolCluster;
        return new this.Promise((resolve2, reject) => {
          corePoolCluster.getConnection(
            pattern,
            selector,
            (err3, coreConnection) => {
              if (err3) {
                reject(err3);
              } else {
                resolve2(new PromisePoolConnection(coreConnection, this.Promise));
              }
            }
          );
        });
      }
      query(sql3, args2) {
        const corePoolCluster = this.poolCluster;
        const localErr = new Error();
        if (typeof args2 === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          corePoolCluster.query(sql3, args2, done);
        });
      }
      execute(sql3, args2) {
        const corePoolCluster = this.poolCluster;
        const localErr = new Error();
        if (typeof args2 === "function") {
          throw new Error(
            "Callback function is not available with promise clients."
          );
        }
        return new this.Promise((resolve2, reject) => {
          const done = makeDoneCb(resolve2, reject, localErr);
          corePoolCluster.execute(sql3, args2, done);
        });
      }
      of(pattern, selector) {
        return new PromisePoolNamespace(
          this.poolCluster.of(pattern, selector),
          this.Promise
        );
      }
      end() {
        const corePoolCluster = this.poolCluster;
        const localErr = new Error();
        return new this.Promise((resolve2, reject) => {
          corePoolCluster.end((err3) => {
            if (err3) {
              localErr.message = err3.message;
              localErr.code = err3.code;
              localErr.errno = err3.errno;
              localErr.sqlState = err3.sqlState;
              localErr.sqlMessage = err3.sqlMessage;
              reject(localErr);
            } else {
              resolve2();
            }
          });
        });
      }
    };
    (function(functionsToWrap) {
      for (let i8 = 0; functionsToWrap && i8 < functionsToWrap.length; i8++) {
        const func2 = functionsToWrap[i8];
        if (typeof PoolCluster.prototype[func2] === "function" && PromisePoolCluster.prototype[func2] === void 0) {
          PromisePoolCluster.prototype[func2] = /* @__PURE__ */ function factory(funcName) {
            return function() {
              return PoolCluster.prototype[funcName].apply(
                this.poolCluster,
                arguments
              );
            };
          }(func2);
        }
      }
    })(["add", "remove"]);
    function createPromisePoolCluster(opts) {
      const corePoolCluster = createPoolCluster(opts);
      const thePromise = opts && opts.Promise || Promise;
      if (!thePromise) {
        throw new Error(
          "no Promise implementation available.Use promise-enabled node version or pass userland Promise implementation as parameter, for example: { Promise: require('bluebird') }"
        );
      }
      return new PromisePoolCluster(corePoolCluster, thePromise);
    }
    exports2.createConnection = createConnectionPromise;
    exports2.createPool = createPromisePool;
    exports2.createPoolCluster = createPromisePoolCluster;
    exports2.escape = SqlString.escape;
    exports2.escapeId = SqlString.escapeId;
    exports2.format = SqlString.format;
    exports2.raw = SqlString.raw;
    exports2.PromisePool = PromisePool;
    exports2.PromiseConnection = PromiseConnection;
    exports2.PromisePoolConnection = PromisePoolConnection;
    exports2.__defineGetter__("Types", () => require_types2());
    exports2.__defineGetter__(
      "Charsets",
      () => require_charsets()
    );
    exports2.__defineGetter__(
      "CharsetToEncoding",
      () => require_charset_encodings()
    );
    exports2.setMaxParserCache = function(max2) {
      parserCache.setMaxCache(max2);
    };
    exports2.clearParserCache = function() {
      parserCache.clearCache();
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/server.js
var require_server = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/server.js"(exports2, module2) {
    "use strict";
    var net2 = require("net");
    var EventEmitter = require("events").EventEmitter;
    var Connection4 = require_connection4();
    var ConnectionConfig = require_connection_config();
    var Server = class extends EventEmitter {
      constructor() {
        super();
        this.connections = [];
        this._server = net2.createServer(this._handleConnection.bind(this));
      }
      _handleConnection(socket) {
        const connectionConfig = new ConnectionConfig({
          stream: socket,
          isServer: true
        });
        const connection2 = new Connection4({ config: connectionConfig });
        this.emit("connection", connection2);
      }
      listen(port) {
        this._port = port;
        this._server.listen.apply(this._server, arguments);
        return this;
      }
      close(cb) {
        this._server.close(cb);
      }
    };
    module2.exports = Server;
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/index.js
var require_auth_plugins = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/lib/auth_plugins/index.js"(exports2, module2) {
    "use strict";
    module2.exports = {
      caching_sha2_password: require_caching_sha2_password(),
      mysql_clear_password: require_mysql_clear_password(),
      mysql_native_password: require_mysql_native_password(),
      sha256_password: require_sha256_password()
    };
  }
});

// ../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/index.js
var require_mysql2 = __commonJS({
  "../node_modules/.pnpm/mysql2@3.14.1/node_modules/mysql2/index.js"(exports2) {
    "use strict";
    var SqlString = require_sqlstring();
    var ConnectionConfig = require_connection_config();
    var parserCache = require_parser_cache();
    var Connection4 = require_connection4();
    exports2.createConnection = require_create_connection();
    exports2.connect = exports2.createConnection;
    exports2.Connection = Connection4;
    exports2.ConnectionConfig = ConnectionConfig;
    var Pool3 = require_pool3();
    var PoolCluster = require_pool_cluster();
    var createPool4 = require_create_pool();
    var createPoolCluster = require_create_pool_cluster();
    exports2.createPool = createPool4;
    exports2.createPoolCluster = createPoolCluster;
    exports2.createQuery = Connection4.createQuery;
    exports2.Pool = Pool3;
    exports2.PoolCluster = PoolCluster;
    exports2.createServer = function(handler) {
      const Server = require_server();
      const s10 = new Server();
      if (handler) {
        s10.on("connection", handler);
      }
      return s10;
    };
    exports2.PoolConnection = require_pool_connection3();
    exports2.authPlugins = require_auth_plugins();
    exports2.escape = SqlString.escape;
    exports2.escapeId = SqlString.escapeId;
    exports2.format = SqlString.format;
    exports2.raw = SqlString.raw;
    exports2.__defineGetter__(
      "createConnectionPromise",
      () => require_promise().createConnection
    );
    exports2.__defineGetter__(
      "createPoolPromise",
      () => require_promise().createPool
    );
    exports2.__defineGetter__(
      "createPoolClusterPromise",
      () => require_promise().createPoolCluster
    );
    exports2.__defineGetter__("Types", () => require_types2());
    exports2.__defineGetter__(
      "Charsets",
      () => require_charsets()
    );
    exports2.__defineGetter__(
      "CharsetToEncoding",
      () => require_charset_encodings()
    );
    exports2.setMaxParserCache = function(max2) {
      parserCache.setMaxCache(max2);
    };
    exports2.clearParserCache = function() {
      parserCache.clearCache();
    };
  }
});

// ../drizzle-orm/dist/singlestore/session.js
function isPool(client) {
  return "getConnection" in client;
}
var import_node_events, _a480, _b351, SingleStoreDriverPreparedQuery, _a481, _b352, _SingleStoreDriverSession, SingleStoreDriverSession, _a482, _b353, _SingleStoreDriverTransaction, SingleStoreDriverTransaction;
var init_session11 = __esm({
  "../drizzle-orm/dist/singlestore/session.js"() {
    "use strict";
    import_node_events = require("events");
    init_core();
    init_column();
    init_entity();
    init_logger();
    init_session3();
    init_sql();
    init_utils();
    SingleStoreDriverPreparedQuery = class extends (_b351 = SingleStorePreparedQuery, _a480 = entityKind, _b351) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, customResultMapper, generatedIds, returningIds) {
        super(cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQuery");
        __publicField(this, "query");
        this.client = client;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this.customResultMapper = customResultMapper;
        this.generatedIds = generatedIds;
        this.returningIds = returningIds;
        this.rawQuery = {
          sql: queryString,
          // rowsAsArray: true,
          typeCast: function(field, next) {
            if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") {
              return field.string();
            }
            return next();
          }
        };
        this.query = {
          sql: queryString,
          rowsAsArray: true,
          typeCast: function(field, next) {
            if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") {
              return field.string();
            }
            return next();
          }
        };
      }
      async execute(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQuery.sql, params);
        const { fields, client, rawQuery, query, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } = this;
        if (!fields && !customResultMapper) {
          const res = await this.queryWithCache(rawQuery.sql, params, async () => {
            return await client.query(rawQuery, params);
          });
          const insertId = res[0].insertId;
          const affectedRows = res[0].affectedRows;
          if (returningIds) {
            const returningResponse = [];
            let j7 = 0;
            for (let i8 = insertId; i8 < insertId + affectedRows; i8++) {
              for (const column6 of returningIds) {
                const key = returningIds[0].path[0];
                if (is(column6.field, Column)) {
                  if (column6.field.primary && column6.field.autoIncrement) {
                    returningResponse.push({ [key]: i8 });
                  }
                  if (column6.field.defaultFn && generatedIds) {
                    returningResponse.push({ [key]: generatedIds[j7][key] });
                  }
                }
              }
              j7++;
            }
            return returningResponse;
          }
          return res;
        }
        const result = await this.queryWithCache(query.sql, params, async () => {
          return await client.query(query, params);
        });
        const rows = result[0];
        if (customResultMapper) {
          return customResultMapper(rows);
        }
        return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      async *iterator(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        const conn = (isPool(this.client) ? await this.client.getConnection() : this.client).connection;
        const { fields, query, rawQuery, joinsNotNullableMap, client, customResultMapper } = this;
        const hasRowsMapper = Boolean(fields || customResultMapper);
        const driverQuery = hasRowsMapper ? conn.query(query, params) : conn.query(rawQuery, params);
        const stream = driverQuery.stream();
        function dataListener() {
          stream.pause();
        }
        stream.on("data", dataListener);
        try {
          const onEnd = (0, import_node_events.once)(stream, "end");
          const onError = (0, import_node_events.once)(stream, "error");
          while (true) {
            stream.resume();
            const row = await Promise.race([onEnd, onError, new Promise((resolve2) => stream.once("data", resolve2))]);
            if (row === void 0 || Array.isArray(row) && row.length === 0) {
              break;
            } else if (row instanceof Error) {
              throw row;
            } else {
              if (hasRowsMapper) {
                if (customResultMapper) {
                  const mappedRow = customResultMapper([row]);
                  yield Array.isArray(mappedRow) ? mappedRow[0] : mappedRow;
                } else {
                  yield mapResultRow(fields, row, joinsNotNullableMap);
                }
              } else {
                yield row;
              }
            }
          }
        } finally {
          stream.off("data", dataListener);
          if (isPool(client)) {
            conn.end();
          }
        }
      }
    };
    __publicField(SingleStoreDriverPreparedQuery, _a480, "SingleStoreDriverPreparedQuery");
    _SingleStoreDriverSession = class _SingleStoreDriverSession extends (_b352 = SingleStoreSession, _a481 = entityKind, _b352) {
      constructor(client, dialect6, schema6, options) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, customResultMapper, generatedIds, returningIds, queryMetadata, cacheConfig) {
        return new SingleStoreDriverPreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          customResultMapper,
          generatedIds,
          returningIds
        );
      }
      /**
       * @internal
       * What is its purpose?
       */
      async query(query, params) {
        this.logger.logQuery(query, params);
        const result = await this.client.query({
          sql: query,
          values: params,
          rowsAsArray: true,
          typeCast: function(field, next) {
            if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") {
              return field.string();
            }
            return next();
          }
        });
        return result;
      }
      all(query) {
        const querySql = this.dialect.sqlToQuery(query);
        this.logger.logQuery(querySql.sql, querySql.params);
        return this.client.execute(querySql.sql, querySql.params).then((result) => result[0]);
      }
      async transaction(transaction, config) {
        const session = isPool(this.client) ? new _SingleStoreDriverSession(
          await this.client.getConnection(),
          this.dialect,
          this.schema,
          this.options
        ) : this;
        const tx = new SingleStoreDriverTransaction(
          this.dialect,
          session,
          this.schema,
          0
        );
        if (config) {
          const setTransactionConfigSql = this.getSetTransactionSQL(config);
          if (setTransactionConfigSql) {
            await tx.execute(setTransactionConfigSql);
          }
          const startTransactionSql = this.getStartTransactionSQL(config);
          await (startTransactionSql ? tx.execute(startTransactionSql) : tx.execute(sql`begin`));
        } else {
          await tx.execute(sql`begin`);
        }
        try {
          const result = await transaction(tx);
          await tx.execute(sql`commit`);
          return result;
        } catch (err3) {
          await tx.execute(sql`rollback`);
          throw err3;
        } finally {
          if (isPool(this.client)) {
            session.client.release();
          }
        }
      }
    };
    __publicField(_SingleStoreDriverSession, _a481, "SingleStoreDriverSession");
    SingleStoreDriverSession = _SingleStoreDriverSession;
    _SingleStoreDriverTransaction = class _SingleStoreDriverTransaction extends (_b353 = SingleStoreTransaction, _a482 = entityKind, _b353) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _SingleStoreDriverTransaction(
          this.dialect,
          this.session,
          this.schema,
          this.nestedIndex + 1
        );
        await tx.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await tx.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_SingleStoreDriverTransaction, _a482, "SingleStoreDriverTransaction");
    SingleStoreDriverTransaction = _SingleStoreDriverTransaction;
  }
});

// ../drizzle-orm/dist/singlestore/driver.js
function construct7(client, config = {}) {
  const dialect6 = new SingleStoreDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  const clientForInstance = isCallbackClient(client) ? client.promise() : client;
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const driver2 = new SingleStoreDriverDriver(clientForInstance, dialect6, {
    logger: logger2,
    cache: config.cache
  });
  const session = driver2.createSession(schema6);
  const db2 = new SingleStoreDriverDatabase(dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function isCallbackClient(client) {
  return typeof client.promise === "function";
}
function drizzle7(...params) {
  if (typeof params[0] === "string") {
    const connectionString = params[0];
    const instance2 = (0, import_mysql22.createPool)({
      uri: connectionString,
      connectAttributes: CONNECTION_ATTRS
    });
    return construct7(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct7(client, drizzleConfig);
    let opts = {};
    opts = typeof connection2 === "string" ? {
      uri: connection2,
      supportBigNumbers: true,
      connectAttributes: CONNECTION_ATTRS
    } : {
      ...connection2,
      connectAttributes: {
        ...connection2.connectAttributes,
        ...CONNECTION_ATTRS
      }
    };
    const instance2 = (0, import_mysql22.createPool)(opts);
    const db2 = construct7(instance2, drizzleConfig);
    return db2;
  }
  return construct7(params[0], params[1]);
}
var import_mysql22, _a483, SingleStoreDriverDriver, _a484, _b354, SingleStoreDriverDatabase, CONNECTION_ATTRS;
var init_driver7 = __esm({
  "../drizzle-orm/dist/singlestore/driver.js"() {
    "use strict";
    import_mysql22 = __toESM(require_mysql2(), 1);
    init_entity();
    init_logger();
    init_relations();
    init_db3();
    init_dialect3();
    init_utils();
    init_version();
    init_session11();
    init_db3();
    _a483 = entityKind;
    SingleStoreDriverDriver = class {
      constructor(client, dialect6, options = {}) {
        this.client = client;
        this.dialect = dialect6;
        this.options = options;
      }
      createSession(schema6) {
        return new SingleStoreDriverSession(this.client, this.dialect, schema6, {
          logger: this.options.logger,
          cache: this.options.cache
        });
      }
    };
    __publicField(SingleStoreDriverDriver, _a483, "SingleStoreDriverDriver");
    SingleStoreDriverDatabase = class extends (_b354 = SingleStoreDatabase, _a484 = entityKind, _b354) {
    };
    __publicField(SingleStoreDriverDatabase, _a484, "SingleStoreDriverDatabase");
    CONNECTION_ATTRS = {
      _connector_name: "SingleStore Drizzle ORM Driver",
      _connector_version: version
    };
    ((drizzle22) => {
      function mock(config) {
        return construct7({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle7 || (drizzle7 = {}));
  }
});

// ../drizzle-orm/dist/singlestore/index.js
var singlestore_exports = {};
__export(singlestore_exports, {
  SingleStoreDatabase: () => SingleStoreDatabase,
  SingleStoreDriverDatabase: () => SingleStoreDriverDatabase,
  SingleStoreDriverDriver: () => SingleStoreDriverDriver,
  SingleStoreDriverPreparedQuery: () => SingleStoreDriverPreparedQuery,
  SingleStoreDriverSession: () => SingleStoreDriverSession,
  SingleStoreDriverTransaction: () => SingleStoreDriverTransaction,
  drizzle: () => drizzle7
});
var init_singlestore2 = __esm({
  "../drizzle-orm/dist/singlestore/index.js"() {
    "use strict";
    init_driver7();
    init_session11();
  }
});

// ../drizzle-orm/dist/singlestore/migrator.js
var migrator_exports7 = {};
__export(migrator_exports7, {
  migrate: () => migrate7
});
async function migrate7(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator8 = __esm({
  "../drizzle-orm/dist/singlestore/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../drizzle-orm/dist/mysql2/session.js
function isPool2(client) {
  return "getConnection" in client;
}
var import_node_events2, _a485, _b355, MySql2PreparedQuery, _a486, _b356, _MySql2Session, MySql2Session, _a487, _b357, _MySql2Transaction, MySql2Transaction;
var init_session12 = __esm({
  "../drizzle-orm/dist/mysql2/session.js"() {
    "use strict";
    import_node_events2 = require("events");
    init_core();
    init_column();
    init_entity();
    init_logger();
    init_session();
    init_sql();
    init_utils();
    MySql2PreparedQuery = class extends (_b355 = MySqlPreparedQuery, _a485 = entityKind, _b355) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, customResultMapper, generatedIds, returningIds) {
        super(cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQuery");
        __publicField(this, "query");
        this.client = client;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this.customResultMapper = customResultMapper;
        this.generatedIds = generatedIds;
        this.returningIds = returningIds;
        this.rawQuery = {
          sql: queryString,
          // rowsAsArray: true,
          typeCast: function(field, next) {
            if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") {
              return field.string();
            }
            return next();
          }
        };
        this.query = {
          sql: queryString,
          rowsAsArray: true,
          typeCast: function(field, next) {
            if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") {
              return field.string();
            }
            return next();
          }
        };
      }
      async execute(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.rawQuery.sql, params);
        const { fields, client, rawQuery, query, joinsNotNullableMap, customResultMapper, returningIds, generatedIds } = this;
        if (!fields && !customResultMapper) {
          const res = await this.queryWithCache(rawQuery.sql, params, async () => {
            return await client.query(rawQuery, params);
          });
          const insertId = res[0].insertId;
          const affectedRows = res[0].affectedRows;
          if (returningIds) {
            const returningResponse = [];
            let j7 = 0;
            for (let i8 = insertId; i8 < insertId + affectedRows; i8++) {
              for (const column6 of returningIds) {
                const key = returningIds[0].path[0];
                if (is(column6.field, Column)) {
                  if (column6.field.primary && column6.field.autoIncrement) {
                    returningResponse.push({ [key]: i8 });
                  }
                  if (column6.field.defaultFn && generatedIds) {
                    returningResponse.push({ [key]: generatedIds[j7][key] });
                  }
                }
              }
              j7++;
            }
            return returningResponse;
          }
          return res;
        }
        const result = await this.queryWithCache(query.sql, params, async () => {
          return await client.query(query, params);
        });
        const rows = result[0];
        if (customResultMapper) {
          return customResultMapper(rows);
        }
        return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      async *iterator(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        const conn = (isPool2(this.client) ? await this.client.getConnection() : this.client).connection;
        const { fields, query, rawQuery, joinsNotNullableMap, client, customResultMapper } = this;
        const hasRowsMapper = Boolean(fields || customResultMapper);
        const driverQuery = hasRowsMapper ? conn.query(query, params) : conn.query(rawQuery, params);
        const stream = driverQuery.stream();
        function dataListener() {
          stream.pause();
        }
        stream.on("data", dataListener);
        try {
          const onEnd = (0, import_node_events2.once)(stream, "end");
          const onError = (0, import_node_events2.once)(stream, "error");
          while (true) {
            stream.resume();
            const row = await Promise.race([onEnd, onError, new Promise((resolve2) => stream.once("data", resolve2))]);
            if (row === void 0 || Array.isArray(row) && row.length === 0) {
              break;
            } else if (row instanceof Error) {
              throw row;
            } else {
              if (hasRowsMapper) {
                if (customResultMapper) {
                  const mappedRow = customResultMapper([row]);
                  yield Array.isArray(mappedRow) ? mappedRow[0] : mappedRow;
                } else {
                  yield mapResultRow(fields, row, joinsNotNullableMap);
                }
              } else {
                yield row;
              }
            }
          }
        } finally {
          stream.off("data", dataListener);
          if (isPool2(client)) {
            conn.end();
          }
        }
      }
    };
    __publicField(MySql2PreparedQuery, _a485, "MySql2PreparedQuery");
    _MySql2Session = class _MySql2Session extends (_b356 = MySqlSession, _a486 = entityKind, _b356) {
      constructor(client, dialect6, schema6, options) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "mode");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
        this.mode = options.mode;
      }
      prepareQuery(query, fields, customResultMapper, generatedIds, returningIds, queryMetadata, cacheConfig) {
        return new MySql2PreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          customResultMapper,
          generatedIds,
          returningIds
        );
      }
      /**
       * @internal
       * What is its purpose?
       */
      async query(query, params) {
        this.logger.logQuery(query, params);
        const result = await this.client.query({
          sql: query,
          values: params,
          rowsAsArray: true,
          typeCast: function(field, next) {
            if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") {
              return field.string();
            }
            return next();
          }
        });
        return result;
      }
      all(query) {
        const querySql = this.dialect.sqlToQuery(query);
        this.logger.logQuery(querySql.sql, querySql.params);
        return this.client.execute(querySql.sql, querySql.params).then((result) => result[0]);
      }
      async transaction(transaction, config) {
        const session = isPool2(this.client) ? new _MySql2Session(
          await this.client.getConnection(),
          this.dialect,
          this.schema,
          this.options
        ) : this;
        const tx = new MySql2Transaction(
          this.dialect,
          session,
          this.schema,
          0,
          this.mode
        );
        if (config) {
          const setTransactionConfigSql = this.getSetTransactionSQL(config);
          if (setTransactionConfigSql) {
            await tx.execute(setTransactionConfigSql);
          }
          const startTransactionSql = this.getStartTransactionSQL(config);
          await (startTransactionSql ? tx.execute(startTransactionSql) : tx.execute(sql`begin`));
        } else {
          await tx.execute(sql`begin`);
        }
        try {
          const result = await transaction(tx);
          await tx.execute(sql`commit`);
          return result;
        } catch (err3) {
          await tx.execute(sql`rollback`);
          throw err3;
        } finally {
          if (isPool2(this.client)) {
            session.client.release();
          }
        }
      }
    };
    __publicField(_MySql2Session, _a486, "MySql2Session");
    MySql2Session = _MySql2Session;
    _MySql2Transaction = class _MySql2Transaction extends (_b357 = MySqlTransaction, _a487 = entityKind, _b357) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _MySql2Transaction(
          this.dialect,
          this.session,
          this.schema,
          this.nestedIndex + 1,
          this.mode
        );
        await tx.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await tx.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_MySql2Transaction, _a487, "MySql2Transaction");
    MySql2Transaction = _MySql2Transaction;
  }
});

// ../drizzle-orm/dist/mysql2/driver.js
function construct8(client, config = {}) {
  const dialect6 = new MySqlDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  const clientForInstance = isCallbackClient2(client) ? client.promise() : client;
  let schema6;
  if (config.schema) {
    if (config.mode === void 0) {
      throw new DrizzleError({
        message: 'You need to specify "mode": "planetscale" or "default" when providing a schema. Read more: https://orm.drizzle.team/docs/rqb#modes'
      });
    }
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const mode = config.mode ?? "default";
  const driver2 = new MySql2Driver(clientForInstance, dialect6, { logger: logger2, cache: config.cache });
  const session = driver2.createSession(schema6, mode);
  const db2 = new MySql2Database(dialect6, session, schema6, mode);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function isCallbackClient2(client) {
  return typeof client.promise === "function";
}
function drizzle8(...params) {
  if (typeof params[0] === "string") {
    const connectionString = params[0];
    const instance2 = (0, import_mysql23.createPool)({
      uri: connectionString
    });
    return construct8(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct8(client, drizzleConfig);
    const instance2 = typeof connection2 === "string" ? (0, import_mysql23.createPool)({
      uri: connection2,
      supportBigNumbers: true
    }) : (0, import_mysql23.createPool)(connection2);
    const db2 = construct8(instance2, drizzleConfig);
    return db2;
  }
  return construct8(params[0], params[1]);
}
var import_mysql23, _a488, MySql2Driver, _a489, _b358, MySql2Database;
var init_driver8 = __esm({
  "../drizzle-orm/dist/mysql2/driver.js"() {
    "use strict";
    import_mysql23 = __toESM(require_mysql2(), 1);
    init_entity();
    init_logger();
    init_db();
    init_dialect();
    init_relations();
    init_utils();
    init_errors();
    init_session12();
    init_db();
    _a488 = entityKind;
    MySql2Driver = class {
      constructor(client, dialect6, options = {}) {
        this.client = client;
        this.dialect = dialect6;
        this.options = options;
      }
      createSession(schema6, mode) {
        return new MySql2Session(this.client, this.dialect, schema6, {
          logger: this.options.logger,
          mode,
          cache: this.options.cache
        });
      }
    };
    __publicField(MySql2Driver, _a488, "MySql2Driver");
    MySql2Database = class extends (_b358 = MySqlDatabase, _a489 = entityKind, _b358) {
    };
    __publicField(MySql2Database, _a489, "MySql2Database");
    ((drizzle22) => {
      function mock(config) {
        return construct8({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle8 || (drizzle8 = {}));
  }
});

// ../drizzle-orm/dist/mysql2/index.js
var mysql2_exports = {};
__export(mysql2_exports, {
  MySql2Database: () => MySql2Database,
  MySql2Driver: () => MySql2Driver,
  MySql2PreparedQuery: () => MySql2PreparedQuery,
  MySql2Session: () => MySql2Session,
  MySql2Transaction: () => MySql2Transaction,
  MySqlDatabase: () => MySqlDatabase,
  drizzle: () => drizzle8
});
var init_mysql2 = __esm({
  "../drizzle-orm/dist/mysql2/index.js"() {
    "use strict";
    init_driver8();
    init_session12();
  }
});

// ../drizzle-orm/dist/mysql2/migrator.js
var migrator_exports8 = {};
__export(migrator_exports8, {
  migrate: () => migrate8
});
async function migrate8(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator9 = __esm({
  "../drizzle-orm/dist/mysql2/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/text.js
function decodeUtf8(text5) {
  return text5 ? decoder.decode(uint8Array(text5)) : "";
}
function hex(text5) {
  const digits = bytes(text5).map((b9) => b9.toString(16).padStart(2, "0"));
  return `0x${digits.join("")}`;
}
function uint8Array(text5) {
  return Uint8Array.from(bytes(text5));
}
function uint8ArrayToHex(uint8) {
  const digits = Array.from(uint8).map((i8) => i8.toString(16).padStart(2, "0"));
  return `x'${digits.join("")}'`;
}
function bytes(text5) {
  return text5.split("").map((c6) => c6.charCodeAt(0));
}
var decoder;
var init_text5 = __esm({
  "../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/text.js"() {
    "use strict";
    decoder = new TextDecoder("utf-8");
  }
});

// ../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/cast.js
function cast(field, value) {
  if (value == null) {
    return value;
  }
  if (isBigInt(field)) {
    return value;
  }
  if (isDateOrTime(field)) {
    return value;
  }
  if (isDecimal(field)) {
    return value;
  }
  if (isJson(field)) {
    return JSON.parse(decodeUtf8(value));
  }
  if (isIntegral(field)) {
    return parseInt(value, 10);
  }
  if (isFloat(field)) {
    return parseFloat(value);
  }
  if (isBinary(field)) {
    return uint8Array(value);
  }
  return decodeUtf8(value);
}
function isBigInt(field) {
  return BIG_INT_FIELD_TYPES.includes(field.type);
}
function isDateOrTime(field) {
  return DATE_OR_DATETIME_FIELD_TYPES.includes(field.type);
}
function isDecimal(field) {
  return field.type === "DECIMAL";
}
function isJson(field) {
  return field.type === "JSON";
}
function isIntegral(field) {
  return INTEGRAL_FIELD_TYPES.includes(field.type);
}
function isFloat(field) {
  return FLOAT_FIELD_TYPES.includes(field.type);
}
function isBinary(field) {
  return field.charset === BinaryId;
}
var BIG_INT_FIELD_TYPES, DATE_OR_DATETIME_FIELD_TYPES, INTEGRAL_FIELD_TYPES, FLOAT_FIELD_TYPES, BinaryId;
var init_cast = __esm({
  "../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/cast.js"() {
    "use strict";
    init_text5();
    BIG_INT_FIELD_TYPES = ["INT64", "UINT64"];
    DATE_OR_DATETIME_FIELD_TYPES = ["DATETIME", "DATE", "TIMESTAMP", "TIME"];
    INTEGRAL_FIELD_TYPES = ["INT8", "INT16", "INT24", "INT32", "UINT8", "UINT16", "UINT24", "UINT32", "YEAR"];
    FLOAT_FIELD_TYPES = ["FLOAT32", "FLOAT64"];
    BinaryId = 63;
  }
});

// ../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/sanitization.js
function format(query, values2) {
  return Array.isArray(values2) ? replacePosition(query, values2) : replaceNamed(query, values2);
}
function replacePosition(query, values2) {
  let index7 = 0;
  return query.replace(/\?/g, (match2) => {
    return index7 < values2.length ? sanitize(values2[index7++]) : match2;
  });
}
function replaceNamed(query, values2) {
  return query.replace(/:(\w+)/g, (match2, name3) => {
    return hasOwn(values2, name3) ? sanitize(values2[name3]) : match2;
  });
}
function hasOwn(obj, name3) {
  return Object.prototype.hasOwnProperty.call(obj, name3);
}
function sanitize(value) {
  if (value == null) {
    return "null";
  }
  if (["number", "bigint"].includes(typeof value)) {
    return String(value);
  }
  if (typeof value === "boolean") {
    return value ? "true" : "false";
  }
  if (typeof value === "string") {
    return quote(value);
  }
  if (Array.isArray(value)) {
    return value.map(sanitize).join(", ");
  }
  if (value instanceof Date) {
    return quote(value.toISOString().slice(0, -1));
  }
  if (value instanceof Uint8Array) {
    return uint8ArrayToHex(value);
  }
  return quote(value.toString());
}
function quote(text5) {
  return `'${escape3(text5)}'`;
}
function escape3(text5) {
  return text5.replace(re2, replacement);
}
function replacement(text5) {
  switch (text5) {
    case '"':
      return '\\"';
    case "'":
      return "\\'";
    case "\n":
      return "\\n";
    case "\r":
      return "\\r";
    case "	":
      return "\\t";
    case "\\":
      return "\\\\";
    case "\0":
      return "\\0";
    case "\b":
      return "\\b";
    case "":
      return "\\Z";
    default:
      return "";
  }
}
var re2;
var init_sanitization = __esm({
  "../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/sanitization.js"() {
    "use strict";
    init_text5();
    re2 = /[\0\b\n\r\t\x1a\\"']/g;
  }
});

// ../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/version.js
var Version;
var init_version2 = __esm({
  "../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/version.js"() {
    "use strict";
    Version = "1.19.0";
  }
});

// ../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/index.js
var dist_exports3 = {};
__export(dist_exports3, {
  Client: () => Client3,
  Connection: () => Connection3,
  DatabaseError: () => DatabaseError2,
  cast: () => cast,
  connect: () => connect,
  format: () => format,
  hex: () => hex
});
function protocol(protocol2) {
  return protocol2 === "http:" ? protocol2 : "https:";
}
function buildURL(url) {
  const scheme = `${protocol(url.protocol)}//`;
  return new URL(url.pathname, `${scheme}${url.host}`).toString();
}
async function postJSON(config, fetch3, url, body2 = {}) {
  const auth = btoa(`${config.username}:${config.password}`);
  const response = await fetch3(url.toString(), {
    method: "POST",
    body: JSON.stringify(body2),
    headers: {
      "Content-Type": "application/json",
      "User-Agent": `database-js/${Version}`,
      Authorization: `Basic ${auth}`
    },
    cache: "no-store"
  });
  if (response.ok) {
    return await response.json();
  } else {
    let error2 = null;
    try {
      const e6 = (await response.json()).error;
      error2 = new DatabaseError2(e6.message, response.status, e6);
    } catch {
      error2 = new DatabaseError2(response.statusText, response.status, {
        code: "internal",
        message: response.statusText
      });
    }
    throw error2;
  }
}
function connect(config) {
  return new Connection3(config);
}
function parseArrayRow(fields, rawRow, cast2) {
  const row = decodeRow(rawRow);
  return fields.map((field, ix) => {
    return cast2(field, row[ix]);
  });
}
function parseObjectRow(fields, rawRow, cast2) {
  const row = decodeRow(rawRow);
  return fields.reduce((acc, field, ix) => {
    acc[field.name] = cast2(field, row[ix]);
    return acc;
  }, {});
}
function parse5(result, cast2, returnAs) {
  const fields = result.fields ?? [];
  const rows = result.rows ?? [];
  return rows.map((row) => returnAs === "array" ? parseArrayRow(fields, row, cast2) : parseObjectRow(fields, row, cast2));
}
function decodeRow(row) {
  const values2 = row.values ? atob(row.values) : "";
  let offset = 0;
  return row.lengths.map((size2) => {
    const width = parseInt(size2, 10);
    if (width < 0)
      return null;
    const splice = values2.substring(offset, offset + width);
    offset += width;
    return splice;
  });
}
var DatabaseError2, Client3, Tx, Connection3;
var init_dist6 = __esm({
  "../node_modules/.pnpm/@planetscale+database@1.19.0/node_modules/@planetscale/database/dist/index.js"() {
    "use strict";
    init_cast();
    init_cast();
    init_sanitization();
    init_sanitization();
    init_text5();
    init_version2();
    DatabaseError2 = class extends Error {
      constructor(message, status, body2) {
        super(message);
        this.status = status;
        this.name = "DatabaseError";
        this.body = body2;
      }
    };
    Client3 = class {
      constructor(config) {
        this.config = config;
      }
      async transaction(fn3) {
        return this.connection().transaction(fn3);
      }
      async execute(query, args2 = null, options = { as: "object" }) {
        return this.connection().execute(query, args2, options);
      }
      connection() {
        return new Connection3(this.config);
      }
    };
    Tx = class {
      constructor(conn) {
        this.conn = conn;
      }
      async execute(query, args2 = null, options = { as: "object" }) {
        return this.conn.execute(query, args2, options);
      }
    };
    Connection3 = class _Connection {
      constructor(config) {
        this.config = config;
        this.fetch = config.fetch || fetch;
        this.session = null;
        if (config.url) {
          const url = new URL(config.url);
          this.config.username = url.username;
          this.config.password = url.password;
          this.config.host = url.hostname;
          this.url = buildURL(url);
        } else {
          this.url = new URL(`https://${this.config.host}`).toString();
        }
      }
      async transaction(fn3) {
        const conn = new _Connection(this.config);
        const tx = new Tx(conn);
        try {
          await tx.execute("BEGIN");
          const res = await fn3(tx);
          await tx.execute("COMMIT");
          return res;
        } catch (err3) {
          await tx.execute("ROLLBACK");
          throw err3;
        }
      }
      async refresh() {
        await this.createSession();
      }
      async execute(query, args2 = null, options = { as: "object" }) {
        const url = new URL("/psdb.v1alpha1.Database/Execute", this.url);
        const formatter = this.config.format || format;
        const sql3 = args2 ? formatter(query, args2) : query;
        const saved = await postJSON(this.config, this.fetch, url, {
          query: sql3,
          session: this.session
        });
        const { result, session, error: error2, timing: timing2 } = saved;
        if (session) {
          this.session = session;
        }
        if (error2) {
          throw new DatabaseError2(error2.message, 400, error2);
        }
        const rowsAffected = result?.rowsAffected ? parseInt(result.rowsAffected, 10) : 0;
        const insertId = result?.insertId ?? "0";
        const fields = result?.fields ?? [];
        for (const field of fields) {
          field.type || (field.type = "NULL");
        }
        const castFn = options.cast || this.config.cast || cast;
        const rows = result ? parse5(result, castFn, options.as || "object") : [];
        const headers = fields.map((f9) => f9.name);
        const typeByName = (acc, { name: name3, type }) => ({ ...acc, [name3]: type });
        const types6 = fields.reduce(typeByName, {});
        const timingSeconds = timing2 ?? 0;
        return {
          headers,
          types: types6,
          fields,
          rows,
          rowsAffected,
          insertId,
          size: rows.length,
          statement: sql3,
          time: timingSeconds * 1e3
        };
      }
      async createSession() {
        const url = new URL("/psdb.v1alpha1.Database/CreateSession", this.url);
        const { session } = await postJSON(this.config, this.fetch, url);
        this.session = session;
        return session;
      }
    };
  }
});

// ../drizzle-orm/dist/planetscale-serverless/session.js
var _a490, _b359, PlanetScalePreparedQuery, _a491, _b360, _PlanetscaleSession, PlanetscaleSession, _a492, _b361, _PlanetScaleTransaction, PlanetScaleTransaction;
var init_session13 = __esm({
  "../drizzle-orm/dist/planetscale-serverless/session.js"() {
    "use strict";
    init_core();
    init_column();
    init_entity();
    init_logger();
    init_session();
    init_sql();
    init_utils();
    PlanetScalePreparedQuery = class extends (_b359 = MySqlPreparedQuery, _a490 = entityKind, _b359) {
      constructor(client, queryString, params, logger2, cache5, queryMetadata, cacheConfig, fields, customResultMapper, generatedIds, returningIds) {
        super(cache5, queryMetadata, cacheConfig);
        __publicField(this, "rawQuery", { as: "object" });
        __publicField(this, "query", { as: "array" });
        this.client = client;
        this.queryString = queryString;
        this.params = params;
        this.logger = logger2;
        this.fields = fields;
        this.customResultMapper = customResultMapper;
        this.generatedIds = generatedIds;
        this.returningIds = returningIds;
      }
      async execute(placeholderValues = {}) {
        const params = fillPlaceholders(this.params, placeholderValues);
        this.logger.logQuery(this.queryString, params);
        const {
          fields,
          client,
          queryString,
          rawQuery,
          query,
          joinsNotNullableMap,
          customResultMapper,
          returningIds,
          generatedIds
        } = this;
        if (!fields && !customResultMapper) {
          const res = await this.queryWithCache(queryString, params, async () => {
            return await client.execute(queryString, params, rawQuery);
          });
          const insertId = Number.parseFloat(res.insertId);
          const affectedRows = res.rowsAffected;
          if (returningIds) {
            const returningResponse = [];
            let j7 = 0;
            for (let i8 = insertId; i8 < insertId + affectedRows; i8++) {
              for (const column6 of returningIds) {
                const key = returningIds[0].path[0];
                if (is(column6.field, Column)) {
                  if (column6.field.primary && column6.field.autoIncrement) {
                    returningResponse.push({ [key]: i8 });
                  }
                  if (column6.field.defaultFn && generatedIds) {
                    returningResponse.push({ [key]: generatedIds[j7][key] });
                  }
                }
              }
              j7++;
            }
            return returningResponse;
          }
          return res;
        }
        const { rows } = await this.queryWithCache(queryString, params, async () => {
          return await client.execute(queryString, params, query);
        });
        if (customResultMapper) {
          return customResultMapper(rows);
        }
        return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      iterator(_placeholderValues) {
        throw new Error("Streaming is not supported by the PlanetScale Serverless driver");
      }
    };
    __publicField(PlanetScalePreparedQuery, _a490, "PlanetScalePreparedQuery");
    _PlanetscaleSession = class _PlanetscaleSession extends (_b360 = MySqlSession, _a491 = entityKind, _b360) {
      constructor(baseClient, dialect6, tx, schema6, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "client");
        __publicField(this, "cache");
        this.baseClient = baseClient;
        this.schema = schema6;
        this.options = options;
        this.client = tx ?? baseClient;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, customResultMapper, generatedIds, returningIds, queryMetadata, cacheConfig) {
        return new PlanetScalePreparedQuery(
          this.client,
          query.sql,
          query.params,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          customResultMapper,
          generatedIds,
          returningIds
        );
      }
      async query(query, params) {
        this.logger.logQuery(query, params);
        return await this.client.execute(query, params, { as: "array" });
      }
      async queryObjects(query, params) {
        return this.client.execute(query, params, { as: "object" });
      }
      all(query) {
        const querySql = this.dialect.sqlToQuery(query);
        this.logger.logQuery(querySql.sql, querySql.params);
        return this.client.execute(querySql.sql, querySql.params, { as: "object" }).then((eQuery) => eQuery.rows);
      }
      async count(sql22) {
        const res = await this.execute(sql22);
        return Number(
          res["rows"][0]["count"]
        );
      }
      transaction(transaction) {
        return this.baseClient.transaction((pstx) => {
          const session = new _PlanetscaleSession(this.baseClient, this.dialect, pstx, this.schema, this.options);
          const tx = new PlanetScaleTransaction(
            this.dialect,
            session,
            this.schema
          );
          return transaction(tx);
        });
      }
    };
    __publicField(_PlanetscaleSession, _a491, "PlanetscaleSession");
    PlanetscaleSession = _PlanetscaleSession;
    _PlanetScaleTransaction = class _PlanetScaleTransaction extends (_b361 = MySqlTransaction, _a492 = entityKind, _b361) {
      constructor(dialect6, session, schema6, nestedIndex = 0) {
        super(dialect6, session, schema6, nestedIndex, "planetscale");
      }
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex + 1}`;
        const tx = new _PlanetScaleTransaction(
          this.dialect,
          this.session,
          this.schema,
          this.nestedIndex + 1
        );
        await tx.execute(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await tx.execute(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await tx.execute(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_PlanetScaleTransaction, _a492, "PlanetScaleTransaction");
    PlanetScaleTransaction = _PlanetScaleTransaction;
  }
});

// ../drizzle-orm/dist/planetscale-serverless/driver.js
function construct9(client, config = {}) {
  if (!(client instanceof Client3)) {
    throw new Error(`Warning: You need to pass an instance of Client:

import { Client } from "@planetscale/database";

const client = new Client({
  host: process.env["DATABASE_HOST"],
  username: process.env["DATABASE_USERNAME"],
  password: process.env["DATABASE_PASSWORD"],
});

const db = drizzle(client);
		`);
  }
  const dialect6 = new MySqlDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const session = new PlanetscaleSession(client, dialect6, void 0, schema6, { logger: logger2, cache: config.cache });
  const db2 = new PlanetScaleDatabase(dialect6, session, schema6, "planetscale");
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
function drizzle9(...params) {
  if (typeof params[0] === "string") {
    const instance2 = new Client3({
      url: params[0]
    });
    return construct9(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct9(client, drizzleConfig);
    const instance2 = typeof connection2 === "string" ? new Client3({
      url: connection2
    }) : new Client3(
      connection2
    );
    return construct9(instance2, drizzleConfig);
  }
  return construct9(params[0], params[1]);
}
var _a493, _b362, PlanetScaleDatabase;
var init_driver9 = __esm({
  "../drizzle-orm/dist/planetscale-serverless/driver.js"() {
    "use strict";
    init_dist6();
    init_entity();
    init_logger();
    init_db();
    init_dialect();
    init_relations();
    init_utils();
    init_session13();
    PlanetScaleDatabase = class extends (_b362 = MySqlDatabase, _a493 = entityKind, _b362) {
    };
    __publicField(PlanetScaleDatabase, _a493, "PlanetScaleDatabase");
    ((drizzle22) => {
      function mock(config) {
        return construct9({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle9 || (drizzle9 = {}));
  }
});

// ../drizzle-orm/dist/planetscale-serverless/index.js
var planetscale_serverless_exports = {};
__export(planetscale_serverless_exports, {
  PlanetScaleDatabase: () => PlanetScaleDatabase,
  PlanetScalePreparedQuery: () => PlanetScalePreparedQuery,
  PlanetScaleTransaction: () => PlanetScaleTransaction,
  PlanetscaleSession: () => PlanetscaleSession,
  drizzle: () => drizzle9
});
var init_planetscale_serverless = __esm({
  "../drizzle-orm/dist/planetscale-serverless/index.js"() {
    "use strict";
    init_driver9();
    init_session13();
  }
});

// ../drizzle-orm/dist/planetscale-serverless/migrator.js
var migrator_exports9 = {};
__export(migrator_exports9, {
  migrate: () => migrate9
});
async function migrate9(db2, config) {
  const migrations = readMigrationFiles(config);
  await db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator10 = __esm({
  "../drizzle-orm/dist/planetscale-serverless/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// ../drizzle-orm/dist/sqlite-proxy/session.js
var _a494, _b363, SQLiteRemoteSession, _a495, _b364, _SQLiteProxyTransaction, SQLiteProxyTransaction, _a496, _b365, RemotePreparedQuery;
var init_session14 = __esm({
  "../drizzle-orm/dist/sqlite-proxy/session.js"() {
    "use strict";
    init_core();
    init_entity();
    init_logger();
    init_sql();
    init_sqlite_core();
    init_session4();
    init_utils();
    SQLiteRemoteSession = class extends (_b363 = SQLiteSession, _a494 = entityKind, _b363) {
      constructor(client, dialect6, schema6, batchCLient, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.batchCLient = batchCLient;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return new RemotePreparedQuery(
          this.client,
          query,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          executeMethod,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      async batch(queries) {
        const preparedQueries = [];
        const builtQueries = [];
        for (const query of queries) {
          const preparedQuery = query._prepare();
          const builtQuery = preparedQuery.getQuery();
          preparedQueries.push(preparedQuery);
          builtQueries.push({ sql: builtQuery.sql, params: builtQuery.params, method: builtQuery.method });
        }
        const batchResults = await this.batchCLient(builtQueries);
        return batchResults.map((result, i8) => preparedQueries[i8].mapResult(result, true));
      }
      async transaction(transaction, config) {
        const tx = new SQLiteProxyTransaction("async", this.dialect, this, this.schema);
        await this.run(sql.raw(`begin${config?.behavior ? " " + config.behavior : ""}`));
        try {
          const result = await transaction(tx);
          await this.run(sql`commit`);
          return result;
        } catch (err3) {
          await this.run(sql`rollback`);
          throw err3;
        }
      }
      extractRawAllValueFromBatchResult(result) {
        return result.rows;
      }
      extractRawGetValueFromBatchResult(result) {
        return result.rows[0];
      }
      extractRawValuesValueFromBatchResult(result) {
        return result.rows;
      }
    };
    __publicField(SQLiteRemoteSession, _a494, "SQLiteRemoteSession");
    _SQLiteProxyTransaction = class _SQLiteProxyTransaction extends (_b364 = SQLiteTransaction, _a495 = entityKind, _b364) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex}`;
        const tx = new _SQLiteProxyTransaction("async", this.dialect, this.session, this.schema, this.nestedIndex + 1);
        await this.session.run(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await this.session.run(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_SQLiteProxyTransaction, _a495, "SQLiteProxyTransaction");
    SQLiteProxyTransaction = _SQLiteProxyTransaction;
    RemotePreparedQuery = class extends (_b365 = SQLitePreparedQuery, _a496 = entityKind, _b365) {
      constructor(client, query, logger2, cache5, queryMetadata, cacheConfig, fields, executeMethod, _isResponseInArrayMode, customResultMapper) {
        super("async", executeMethod, query, cache5, queryMetadata, cacheConfig);
        __publicField(this, "method");
        this.client = client;
        this.logger = logger2;
        this.fields = fields;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
        this.customResultMapper = customResultMapper;
        this.method = executeMethod;
      }
      getQuery() {
        return { ...this.query, method: this.method };
      }
      async run(placeholderValues) {
        const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
        this.logger.logQuery(this.query.sql, params);
        return await this.queryWithCache(this.query.sql, params, async () => {
          return await this.client(this.query.sql, params, "run");
        });
      }
      mapAllResult(rows, isFromBatch) {
        if (isFromBatch) {
          rows = rows.rows;
        }
        if (!this.fields && !this.customResultMapper) {
          return rows;
        }
        if (this.customResultMapper) {
          return this.customResultMapper(rows);
        }
        return rows.map((row) => {
          return mapResultRow(
            this.fields,
            row,
            this.joinsNotNullableMap
          );
        });
      }
      async all(placeholderValues) {
        const { query, logger: logger2, client } = this;
        const params = fillPlaceholders(query.params, placeholderValues ?? {});
        logger2.logQuery(query.sql, params);
        const { rows } = await this.queryWithCache(query.sql, params, async () => {
          return await client(query.sql, params, "all");
        });
        return this.mapAllResult(rows);
      }
      async get(placeholderValues) {
        const { query, logger: logger2, client } = this;
        const params = fillPlaceholders(query.params, placeholderValues ?? {});
        logger2.logQuery(query.sql, params);
        const clientResult = await this.queryWithCache(query.sql, params, async () => {
          return await client(query.sql, params, "get");
        });
        return this.mapGetResult(clientResult.rows);
      }
      mapGetResult(rows, isFromBatch) {
        if (isFromBatch) {
          rows = rows.rows;
        }
        const row = rows;
        if (!this.fields && !this.customResultMapper) {
          return row;
        }
        if (!row) {
          return void 0;
        }
        if (this.customResultMapper) {
          return this.customResultMapper([rows]);
        }
        return mapResultRow(
          this.fields,
          row,
          this.joinsNotNullableMap
        );
      }
      async values(placeholderValues) {
        const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
        this.logger.logQuery(this.query.sql, params);
        const clientResult = await this.queryWithCache(this.query.sql, params, async () => {
          return await this.client(this.query.sql, params, "values");
        });
        return clientResult.rows;
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(RemotePreparedQuery, _a496, "SQLiteProxyPreparedQuery");
  }
});

// ../drizzle-orm/dist/sqlite-proxy/driver.js
function drizzle10(callback, batchCallback, config) {
  const dialect6 = new SQLiteAsyncDialect({ casing: config?.casing });
  let logger2;
  let cache5;
  let _batchCallback;
  let _config = {};
  if (batchCallback) {
    if (typeof batchCallback === "function") {
      _batchCallback = batchCallback;
      _config = config ?? {};
    } else {
      _batchCallback = void 0;
      _config = batchCallback;
    }
    if (_config.logger === true) {
      logger2 = new DefaultLogger();
    } else if (_config.logger !== false) {
      logger2 = _config.logger;
      cache5 = _config.cache;
    }
  }
  let schema6;
  if (_config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      _config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: _config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const session = new SQLiteRemoteSession(callback, dialect6, schema6, _batchCallback, { logger: logger2, cache: cache5 });
  const db2 = new SqliteRemoteDatabase("async", dialect6, session, schema6);
  db2.$cache = cache5;
  if (db2.$cache) {
    db2.$cache["invalidate"] = cache5?.onMutate;
  }
  return db2;
}
var _a497, _b366, SqliteRemoteDatabase;
var init_driver10 = __esm({
  "../drizzle-orm/dist/sqlite-proxy/driver.js"() {
    "use strict";
    init_entity();
    init_logger();
    init_relations();
    init_db4();
    init_dialect4();
    init_session14();
    SqliteRemoteDatabase = class extends (_b366 = BaseSQLiteDatabase, _a497 = entityKind, _b366) {
      async batch(batch) {
        return this.session.batch(batch);
      }
    };
    __publicField(SqliteRemoteDatabase, _a497, "SqliteRemoteDatabase");
  }
});

// ../drizzle-orm/dist/sqlite-proxy/index.js
var sqlite_proxy_exports = {};
__export(sqlite_proxy_exports, {
  RemotePreparedQuery: () => RemotePreparedQuery,
  SQLiteProxyTransaction: () => SQLiteProxyTransaction,
  SQLiteRemoteSession: () => SQLiteRemoteSession,
  SqliteRemoteDatabase: () => SqliteRemoteDatabase,
  drizzle: () => drizzle10
});
var init_sqlite_proxy = __esm({
  "../drizzle-orm/dist/sqlite-proxy/index.js"() {
    "use strict";
    init_driver10();
    init_session14();
  }
});

// ../drizzle-orm/dist/sqlite-proxy/migrator.js
var migrator_exports10 = {};
__export(migrator_exports10, {
  migrate: () => migrate10
});
async function migrate10(db2, callback, config) {
  const migrations = readMigrationFiles(config);
  const migrationsTable = typeof config === "string" ? "__drizzle_migrations" : config.migrationsTable ?? "__drizzle_migrations";
  const migrationTableCreate = sql`
		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
			id SERIAL PRIMARY KEY,
			hash text NOT NULL,
			created_at numeric
		)
	`;
  await db2.run(migrationTableCreate);
  const dbMigrations = await db2.values(
    sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
  );
  const lastDbMigration = dbMigrations[0] ?? void 0;
  const queriesToRun = [];
  for (const migration of migrations) {
    if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
      queriesToRun.push(
        ...migration.sql,
        `INSERT INTO \`${migrationsTable}\` ("hash", "created_at") VALUES('${migration.hash}', '${migration.folderMillis}')`
      );
    }
  }
  await callback(queriesToRun);
}
var init_migrator11 = __esm({
  "../drizzle-orm/dist/sqlite-proxy/migrator.js"() {
    "use strict";
    init_migrator();
    init_sql();
  }
});

// ../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/api.js
var LibsqlError;
var init_api = __esm({
  "../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/api.js"() {
    "use strict";
    LibsqlError = class extends Error {
      constructor(message, code, rawCode, cause) {
        if (code !== void 0) {
          message = `${code}: ${message}`;
        }
        super(message, { cause });
        /** Machine-readable error code. */
        __publicField(this, "code");
        /** Raw numeric error code */
        __publicField(this, "rawCode");
        this.code = code;
        this.rawCode = rawCode;
        this.name = "LibsqlError";
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/uri.js
function parseUri(text5) {
  const match2 = URI_RE.exec(text5);
  if (match2 === null) {
    throw new LibsqlError(`The URL '${text5}' is not in a valid format`, "URL_INVALID");
  }
  const groups = match2.groups;
  const scheme = groups["scheme"];
  const authority = groups["authority"] !== void 0 ? parseAuthority(groups["authority"]) : void 0;
  const path3 = percentDecode(groups["path"]);
  const query = groups["query"] !== void 0 ? parseQuery(groups["query"]) : void 0;
  const fragment2 = groups["fragment"] !== void 0 ? percentDecode(groups["fragment"]) : void 0;
  return { scheme, authority, path: path3, query, fragment: fragment2 };
}
function parseAuthority(text5) {
  const match2 = AUTHORITY_RE.exec(text5);
  if (match2 === null) {
    throw new LibsqlError("The authority part of the URL is not in a valid format", "URL_INVALID");
  }
  const groups = match2.groups;
  const host = percentDecode(groups["host_br"] ?? groups["host"]);
  const port = groups["port"] ? parseInt(groups["port"], 10) : void 0;
  const userinfo = groups["username"] !== void 0 ? {
    username: percentDecode(groups["username"]),
    password: groups["password"] !== void 0 ? percentDecode(groups["password"]) : void 0
  } : void 0;
  return { host, port, userinfo };
}
function parseQuery(text5) {
  const sequences = text5.split("&");
  const pairs = [];
  for (const sequence of sequences) {
    if (sequence === "") {
      continue;
    }
    let key;
    let value;
    const splitIdx = sequence.indexOf("=");
    if (splitIdx < 0) {
      key = sequence;
      value = "";
    } else {
      key = sequence.substring(0, splitIdx);
      value = sequence.substring(splitIdx + 1);
    }
    pairs.push({
      key: percentDecode(key.replaceAll("+", " ")),
      value: percentDecode(value.replaceAll("+", " "))
    });
  }
  return { pairs };
}
function percentDecode(text5) {
  try {
    return decodeURIComponent(text5);
  } catch (e6) {
    if (e6 instanceof URIError) {
      throw new LibsqlError(`URL component has invalid percent encoding: ${e6}`, "URL_INVALID", void 0, e6);
    }
    throw e6;
  }
}
function encodeBaseUrl(scheme, authority, path3) {
  if (authority === void 0) {
    throw new LibsqlError(`URL with scheme ${JSON.stringify(scheme + ":")} requires authority (the "//" part)`, "URL_INVALID");
  }
  const schemeText = `${scheme}:`;
  const hostText = encodeHost(authority.host);
  const portText = encodePort(authority.port);
  const userinfoText = encodeUserinfo(authority.userinfo);
  const authorityText = `//${userinfoText}${hostText}${portText}`;
  let pathText = path3.split("/").map(encodeURIComponent).join("/");
  if (pathText !== "" && !pathText.startsWith("/")) {
    pathText = "/" + pathText;
  }
  return new URL(`${schemeText}${authorityText}${pathText}`);
}
function encodeHost(host) {
  return host.includes(":") ? `[${encodeURI(host)}]` : encodeURI(host);
}
function encodePort(port) {
  return port !== void 0 ? `:${port}` : "";
}
function encodeUserinfo(userinfo) {
  if (userinfo === void 0) {
    return "";
  }
  const usernameText = encodeURIComponent(userinfo.username);
  const passwordText = userinfo.password !== void 0 ? `:${encodeURIComponent(userinfo.password)}` : "";
  return `${usernameText}${passwordText}@`;
}
var URI_RE, AUTHORITY_RE;
var init_uri2 = __esm({
  "../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/uri.js"() {
    "use strict";
    init_api();
    URI_RE = (() => {
      const SCHEME = "(?<scheme>[A-Za-z][A-Za-z.+-]*)";
      const AUTHORITY = "(?<authority>[^/?#]*)";
      const PATH2 = "(?<path>[^?#]*)";
      const QUERY = "(?<query>[^#]*)";
      const FRAGMENT = "(?<fragment>.*)";
      return new RegExp(`^${SCHEME}:(//${AUTHORITY})?${PATH2}(\\?${QUERY})?(#${FRAGMENT})?$`, "su");
    })();
    AUTHORITY_RE = (() => {
      return new RegExp(`^((?<username>[^:]*)(:(?<password>.*))?@)?((?<host>[^:\\[\\]]*)|(\\[(?<host_br>[^\\[\\]]*)\\]))(:(?<port>[0-9]*))?$`, "su");
    })();
  }
});

// ../node_modules/.pnpm/js-base64@3.7.7/node_modules/js-base64/base64.mjs
var version2, VERSION, _hasBuffer, _TD, _TE, b64ch, b64chs, b64tab, b64re, _fromCC, _U8Afrom, _mkUriSafe, _tidyB64, btoaPolyfill, _btoa, _fromUint8Array, fromUint8Array, cb_utob, re_utob, utob, _encode, encode, encodeURI2, re_btou, cb_btou, btou, atobPolyfill, _atob, _toUint8Array, toUint8Array2, _decode, _unURI, decode, isValid2, _noEnum, extendString, extendUint8Array, extendBuiltins, gBase64;
var init_base64 = __esm({
  "../node_modules/.pnpm/js-base64@3.7.7/node_modules/js-base64/base64.mjs"() {
    "use strict";
    version2 = "3.7.7";
    VERSION = version2;
    _hasBuffer = typeof Buffer === "function";
    _TD = typeof TextDecoder === "function" ? new TextDecoder() : void 0;
    _TE = typeof TextEncoder === "function" ? new TextEncoder() : void 0;
    b64ch = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
    b64chs = Array.prototype.slice.call(b64ch);
    b64tab = ((a9) => {
      let tab = {};
      a9.forEach((c6, i8) => tab[c6] = i8);
      return tab;
    })(b64chs);
    b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
    _fromCC = String.fromCharCode.bind(String);
    _U8Afrom = typeof Uint8Array.from === "function" ? Uint8Array.from.bind(Uint8Array) : (it2) => new Uint8Array(Array.prototype.slice.call(it2, 0));
    _mkUriSafe = (src) => src.replace(/=/g, "").replace(/[+\/]/g, (m0) => m0 == "+" ? "-" : "_");
    _tidyB64 = (s10) => s10.replace(/[^A-Za-z0-9\+\/]/g, "");
    btoaPolyfill = (bin) => {
      let u32, c0, c1, c22, asc2 = "";
      const pad = bin.length % 3;
      for (let i8 = 0; i8 < bin.length; ) {
        if ((c0 = bin.charCodeAt(i8++)) > 255 || (c1 = bin.charCodeAt(i8++)) > 255 || (c22 = bin.charCodeAt(i8++)) > 255)
          throw new TypeError("invalid character found");
        u32 = c0 << 16 | c1 << 8 | c22;
        asc2 += b64chs[u32 >> 18 & 63] + b64chs[u32 >> 12 & 63] + b64chs[u32 >> 6 & 63] + b64chs[u32 & 63];
      }
      return pad ? asc2.slice(0, pad - 3) + "===".substring(pad) : asc2;
    };
    _btoa = typeof btoa === "function" ? (bin) => btoa(bin) : _hasBuffer ? (bin) => Buffer.from(bin, "binary").toString("base64") : btoaPolyfill;
    _fromUint8Array = _hasBuffer ? (u8a) => Buffer.from(u8a).toString("base64") : (u8a) => {
      const maxargs = 4096;
      let strs = [];
      for (let i8 = 0, l7 = u8a.length; i8 < l7; i8 += maxargs) {
        strs.push(_fromCC.apply(null, u8a.subarray(i8, i8 + maxargs)));
      }
      return _btoa(strs.join(""));
    };
    fromUint8Array = (u8a, urlsafe = false) => urlsafe ? _mkUriSafe(_fromUint8Array(u8a)) : _fromUint8Array(u8a);
    cb_utob = (c6) => {
      if (c6.length < 2) {
        var cc = c6.charCodeAt(0);
        return cc < 128 ? c6 : cc < 2048 ? _fromCC(192 | cc >>> 6) + _fromCC(128 | cc & 63) : _fromCC(224 | cc >>> 12 & 15) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
      } else {
        var cc = 65536 + (c6.charCodeAt(0) - 55296) * 1024 + (c6.charCodeAt(1) - 56320);
        return _fromCC(240 | cc >>> 18 & 7) + _fromCC(128 | cc >>> 12 & 63) + _fromCC(128 | cc >>> 6 & 63) + _fromCC(128 | cc & 63);
      }
    };
    re_utob = /[\uD800-\uDBFF][\uDC00-\uDFFFF]|[^\x00-\x7F]/g;
    utob = (u7) => u7.replace(re_utob, cb_utob);
    _encode = _hasBuffer ? (s10) => Buffer.from(s10, "utf8").toString("base64") : _TE ? (s10) => _fromUint8Array(_TE.encode(s10)) : (s10) => _btoa(utob(s10));
    encode = (src, urlsafe = false) => urlsafe ? _mkUriSafe(_encode(src)) : _encode(src);
    encodeURI2 = (src) => encode(src, true);
    re_btou = /[\xC0-\xDF][\x80-\xBF]|[\xE0-\xEF][\x80-\xBF]{2}|[\xF0-\xF7][\x80-\xBF]{3}/g;
    cb_btou = (cccc) => {
      switch (cccc.length) {
        case 4:
          var cp = (7 & cccc.charCodeAt(0)) << 18 | (63 & cccc.charCodeAt(1)) << 12 | (63 & cccc.charCodeAt(2)) << 6 | 63 & cccc.charCodeAt(3), offset = cp - 65536;
          return _fromCC((offset >>> 10) + 55296) + _fromCC((offset & 1023) + 56320);
        case 3:
          return _fromCC((15 & cccc.charCodeAt(0)) << 12 | (63 & cccc.charCodeAt(1)) << 6 | 63 & cccc.charCodeAt(2));
        default:
          return _fromCC((31 & cccc.charCodeAt(0)) << 6 | 63 & cccc.charCodeAt(1));
      }
    };
    btou = (b9) => b9.replace(re_btou, cb_btou);
    atobPolyfill = (asc2) => {
      asc2 = asc2.replace(/\s+/g, "");
      if (!b64re.test(asc2))
        throw new TypeError("malformed base64.");
      asc2 += "==".slice(2 - (asc2.length & 3));
      let u24, bin = "", r1, r22;
      for (let i8 = 0; i8 < asc2.length; ) {
        u24 = b64tab[asc2.charAt(i8++)] << 18 | b64tab[asc2.charAt(i8++)] << 12 | (r1 = b64tab[asc2.charAt(i8++)]) << 6 | (r22 = b64tab[asc2.charAt(i8++)]);
        bin += r1 === 64 ? _fromCC(u24 >> 16 & 255) : r22 === 64 ? _fromCC(u24 >> 16 & 255, u24 >> 8 & 255) : _fromCC(u24 >> 16 & 255, u24 >> 8 & 255, u24 & 255);
      }
      return bin;
    };
    _atob = typeof atob === "function" ? (asc2) => atob(_tidyB64(asc2)) : _hasBuffer ? (asc2) => Buffer.from(asc2, "base64").toString("binary") : atobPolyfill;
    _toUint8Array = _hasBuffer ? (a9) => _U8Afrom(Buffer.from(a9, "base64")) : (a9) => _U8Afrom(_atob(a9).split("").map((c6) => c6.charCodeAt(0)));
    toUint8Array2 = (a9) => _toUint8Array(_unURI(a9));
    _decode = _hasBuffer ? (a9) => Buffer.from(a9, "base64").toString("utf8") : _TD ? (a9) => _TD.decode(_toUint8Array(a9)) : (a9) => btou(_atob(a9));
    _unURI = (a9) => _tidyB64(a9.replace(/[-_]/g, (m0) => m0 == "-" ? "+" : "/"));
    decode = (src) => _decode(_unURI(src));
    isValid2 = (src) => {
      if (typeof src !== "string")
        return false;
      const s10 = src.replace(/\s+/g, "").replace(/={0,2}$/, "");
      return !/[^\s0-9a-zA-Z\+/]/.test(s10) || !/[^\s0-9a-zA-Z\-_]/.test(s10);
    };
    _noEnum = (v11) => {
      return {
        value: v11,
        enumerable: false,
        writable: true,
        configurable: true
      };
    };
    extendString = function() {
      const _add = (name3, body2) => Object.defineProperty(String.prototype, name3, _noEnum(body2));
      _add("fromBase64", function() {
        return decode(this);
      });
      _add("toBase64", function(urlsafe) {
        return encode(this, urlsafe);
      });
      _add("toBase64URI", function() {
        return encode(this, true);
      });
      _add("toBase64URL", function() {
        return encode(this, true);
      });
      _add("toUint8Array", function() {
        return toUint8Array2(this);
      });
    };
    extendUint8Array = function() {
      const _add = (name3, body2) => Object.defineProperty(Uint8Array.prototype, name3, _noEnum(body2));
      _add("toBase64", function(urlsafe) {
        return fromUint8Array(this, urlsafe);
      });
      _add("toBase64URI", function() {
        return fromUint8Array(this, true);
      });
      _add("toBase64URL", function() {
        return fromUint8Array(this, true);
      });
    };
    extendBuiltins = () => {
      extendString();
      extendUint8Array();
    };
    gBase64 = {
      version: version2,
      VERSION,
      atob: _atob,
      atobPolyfill,
      btoa: _btoa,
      btoaPolyfill,
      fromBase64: decode,
      toBase64: encode,
      encode,
      encodeURI: encodeURI2,
      encodeURL: encodeURI2,
      utob,
      btou,
      decode,
      isValid: isValid2,
      fromUint8Array,
      toUint8Array: toUint8Array2,
      extendString,
      extendUint8Array,
      extendBuiltins
    };
  }
});

// ../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/util.js
function transactionModeToBegin(mode) {
  if (mode === "write") {
    return "BEGIN IMMEDIATE";
  } else if (mode === "read") {
    return "BEGIN TRANSACTION READONLY";
  } else if (mode === "deferred") {
    return "BEGIN DEFERRED";
  } else {
    throw RangeError('Unknown transaction mode, supported values are "write", "read" and "deferred"');
  }
}
function rowToJson(row) {
  return Array.prototype.map.call(row, valueToJson);
}
function valueToJson(value) {
  if (typeof value === "bigint") {
    return "" + value;
  } else if (value instanceof ArrayBuffer) {
    return gBase64.fromUint8Array(new Uint8Array(value));
  } else {
    return value;
  }
}
var supportedUrlLink, ResultSetImpl;
var init_util4 = __esm({
  "../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/util.js"() {
    "use strict";
    init_base64();
    supportedUrlLink = "https://github.com/libsql/libsql-client-ts#supported-urls";
    ResultSetImpl = class {
      constructor(columns, columnTypes, rows, rowsAffected, lastInsertRowid) {
        __publicField(this, "columns");
        __publicField(this, "columnTypes");
        __publicField(this, "rows");
        __publicField(this, "rowsAffected");
        __publicField(this, "lastInsertRowid");
        this.columns = columns;
        this.columnTypes = columnTypes;
        this.rows = rows;
        this.rowsAffected = rowsAffected;
        this.lastInsertRowid = lastInsertRowid;
      }
      toJSON() {
        return {
          columns: this.columns,
          columnTypes: this.columnTypes,
          rows: this.rows.map(rowToJson),
          rowsAffected: this.rowsAffected,
          lastInsertRowid: this.lastInsertRowid !== void 0 ? "" + this.lastInsertRowid : null
        };
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/config.js
function isInMemoryConfig(config) {
  return config.scheme === "file" && (config.path === ":memory:" || config.path.startsWith(":memory:?"));
}
function expandConfig(config, preferHttp) {
  if (typeof config !== "object") {
    throw new TypeError(`Expected client configuration as object, got ${typeof config}`);
  }
  let { url, authToken, tls: tls2, intMode, concurrency } = config;
  concurrency = Math.max(0, concurrency || 20);
  intMode ??= "number";
  let connectionQueryParams = [];
  if (url === inMemoryMode) {
    url = "file::memory:";
  }
  const uri = parseUri(url);
  const originalUriScheme = uri.scheme.toLowerCase();
  const isInMemoryMode = originalUriScheme === "file" && uri.path === inMemoryMode && uri.authority === void 0;
  let queryParamsDef;
  if (isInMemoryMode) {
    queryParamsDef = {
      cache: {
        values: ["shared", "private"],
        update: (key, value) => connectionQueryParams.push(`${key}=${value}`)
      }
    };
  } else {
    queryParamsDef = {
      tls: {
        values: ["0", "1"],
        update: (_7, value) => tls2 = value === "1"
      },
      authToken: {
        update: (_7, value) => authToken = value
      }
    };
  }
  for (const { key, value } of uri.query?.pairs ?? []) {
    if (!Object.hasOwn(queryParamsDef, key)) {
      throw new LibsqlError(`Unsupported URL query parameter ${JSON.stringify(key)}`, "URL_PARAM_NOT_SUPPORTED");
    }
    const queryParamDef = queryParamsDef[key];
    if (queryParamDef.values !== void 0 && !queryParamDef.values.includes(value)) {
      throw new LibsqlError(`Unknown value for the "${key}" query argument: ${JSON.stringify(value)}. Supported values are: [${queryParamDef.values.map((x11) => '"' + x11 + '"').join(", ")}]`, "URL_INVALID");
    }
    if (queryParamDef.update !== void 0) {
      queryParamDef?.update(key, value);
    }
  }
  const connectionQueryParamsString = connectionQueryParams.length === 0 ? "" : `?${connectionQueryParams.join("&")}`;
  const path3 = uri.path + connectionQueryParamsString;
  let scheme;
  if (originalUriScheme === "libsql") {
    if (tls2 === false) {
      if (uri.authority?.port === void 0) {
        throw new LibsqlError('A "libsql:" URL with ?tls=0 must specify an explicit port', "URL_INVALID");
      }
      scheme = preferHttp ? "http" : "ws";
    } else {
      scheme = preferHttp ? "https" : "wss";
    }
  } else {
    scheme = originalUriScheme;
  }
  if (scheme === "http" || scheme === "ws") {
    tls2 ??= false;
  } else {
    tls2 ??= true;
  }
  if (scheme !== "http" && scheme !== "ws" && scheme !== "https" && scheme !== "wss" && scheme !== "file") {
    throw new LibsqlError(`The client supports only "libsql:", "wss:", "ws:", "https:", "http:" and "file:" URLs, got ${JSON.stringify(uri.scheme + ":")}. For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
  }
  if (intMode !== "number" && intMode !== "bigint" && intMode !== "string") {
    throw new TypeError(`Invalid value for intMode, expected "number", "bigint" or "string", got ${JSON.stringify(intMode)}`);
  }
  if (uri.fragment !== void 0) {
    throw new LibsqlError(`URL fragments are not supported: ${JSON.stringify("#" + uri.fragment)}`, "URL_INVALID");
  }
  if (isInMemoryMode) {
    return {
      scheme: "file",
      tls: false,
      path: path3,
      intMode,
      concurrency,
      syncUrl: config.syncUrl,
      syncInterval: config.syncInterval,
      fetch: config.fetch,
      authToken: void 0,
      encryptionKey: void 0,
      authority: void 0
    };
  }
  return {
    scheme,
    tls: tls2,
    authority: uri.authority,
    path: path3,
    authToken,
    intMode,
    concurrency,
    encryptionKey: config.encryptionKey,
    syncUrl: config.syncUrl,
    syncInterval: config.syncInterval,
    fetch: config.fetch
  };
}
var inMemoryMode;
var init_config5 = __esm({
  "../node_modules/.pnpm/@libsql+core@0.10.0/node_modules/@libsql/core/lib-esm/config.js"() {
    "use strict";
    init_api();
    init_uri2();
    init_util4();
    inMemoryMode = ":memory:";
  }
});

// ../node_modules/.pnpm/@neon-rs+load@0.0.4/node_modules/@neon-rs/load/dist/index.js
var require_dist3 = __commonJS({
  "../node_modules/.pnpm/@neon-rs+load@0.0.4/node_modules/@neon-rs/load/dist/index.js"(exports2) {
    "use strict";
    var __createBinding = exports2 && exports2.__createBinding || (Object.create ? function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      var desc2 = Object.getOwnPropertyDescriptor(m12, k9);
      if (!desc2 || ("get" in desc2 ? !m12.__esModule : desc2.writable || desc2.configurable)) {
        desc2 = { enumerable: true, get: function() {
          return m12[k9];
        } };
      }
      Object.defineProperty(o9, k22, desc2);
    } : function(o9, m12, k9, k22) {
      if (k22 === void 0) k22 = k9;
      o9[k22] = m12[k9];
    });
    var __setModuleDefault = exports2 && exports2.__setModuleDefault || (Object.create ? function(o9, v11) {
      Object.defineProperty(o9, "default", { enumerable: true, value: v11 });
    } : function(o9, v11) {
      o9["default"] = v11;
    });
    var __importStar = exports2 && exports2.__importStar || function(mod) {
      if (mod && mod.__esModule) return mod;
      var result = {};
      if (mod != null) {
        for (var k9 in mod) if (k9 !== "default" && Object.prototype.hasOwnProperty.call(mod, k9)) __createBinding(result, mod, k9);
      }
      __setModuleDefault(result, mod);
      return result;
    };
    Object.defineProperty(exports2, "__esModule", { value: true });
    exports2.load = exports2.currentTarget = void 0;
    var path3 = __importStar(require("path"));
    var fs9 = __importStar(require("fs"));
    function currentTarget() {
      let os4 = null;
      switch (process.platform) {
        case "android":
          switch (process.arch) {
            case "arm":
              return "android-arm-eabi";
            case "arm64":
              return "android-arm64";
          }
          os4 = "Android";
          break;
        case "win32":
          switch (process.arch) {
            case "x64":
              return "win32-x64-msvc";
            case "arm64":
              return "win32-arm64-msvc";
            case "ia32":
              return "win32-ia32-msvc";
          }
          os4 = "Windows";
          break;
        case "darwin":
          switch (process.arch) {
            case "x64":
              return "darwin-x64";
            case "arm64":
              return "darwin-arm64";
          }
          os4 = "macOS";
          break;
        case "linux":
          switch (process.arch) {
            case "x64":
            case "arm64":
              return isGlibc() ? `linux-${process.arch}-gnu` : `linux-${process.arch}-musl`;
            case "arm":
              return "linux-arm-gnueabihf";
          }
          os4 = "Linux";
          break;
        case "freebsd":
          if (process.arch === "x64") {
            return "freebsd-x64";
          }
          os4 = "FreeBSD";
          break;
      }
      if (os4) {
        throw new Error(`Neon: unsupported ${os4} architecture: ${process.arch}`);
      }
      throw new Error(`Neon: unsupported system: ${process.platform}`);
    }
    exports2.currentTarget = currentTarget;
    function isGlibc() {
      const report = process.report?.getReport();
      if (typeof report !== "object" || !report || !("header" in report)) {
        return false;
      }
      const header = report.header;
      return typeof header === "object" && !!header && "glibcVersionRuntime" in header;
    }
    function load(dirname) {
      const m12 = path3.join(dirname, "index.node");
      return fs9.existsSync(m12) ? require(m12) : null;
    }
    exports2.load = load;
  }
});

// ../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js
var require_process = __commonJS({
  "../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/process.js"(exports2, module2) {
    "use strict";
    var isLinux = () => process.platform === "linux";
    var report = null;
    var getReport = () => {
      if (!report) {
        report = isLinux() && process.report ? process.report.getReport() : {};
      }
      return report;
    };
    module2.exports = { isLinux, getReport };
  }
});

// ../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js
var require_filesystem = __commonJS({
  "../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/filesystem.js"(exports2, module2) {
    "use strict";
    var fs9 = require("fs");
    var LDD_PATH = "/usr/bin/ldd";
    var readFileSync2 = (path3) => fs9.readFileSync(path3, "utf-8");
    var readFile4 = (path3) => new Promise((resolve2, reject) => {
      fs9.readFile(path3, "utf-8", (err3, data) => {
        if (err3) {
          reject(err3);
        } else {
          resolve2(data);
        }
      });
    });
    module2.exports = {
      LDD_PATH,
      readFileSync: readFileSync2,
      readFile: readFile4
    };
  }
});

// ../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js
var require_detect_libc = __commonJS({
  "../node_modules/.pnpm/detect-libc@2.0.2/node_modules/detect-libc/lib/detect-libc.js"(exports2, module2) {
    "use strict";
    var childProcess = require("child_process");
    var { isLinux, getReport } = require_process();
    var { LDD_PATH, readFile: readFile4, readFileSync: readFileSync2 } = require_filesystem();
    var cachedFamilyFilesystem;
    var cachedVersionFilesystem;
    var command = "getconf GNU_LIBC_VERSION 2>&1 || true; ldd --version 2>&1 || true";
    var commandOut = "";
    var safeCommand = () => {
      if (!commandOut) {
        return new Promise((resolve2) => {
          childProcess.exec(command, (err3, out2) => {
            commandOut = err3 ? " " : out2;
            resolve2(commandOut);
          });
        });
      }
      return commandOut;
    };
    var safeCommandSync = () => {
      if (!commandOut) {
        try {
          commandOut = childProcess.execSync(command, { encoding: "utf8" });
        } catch (_err) {
          commandOut = " ";
        }
      }
      return commandOut;
    };
    var GLIBC = "glibc";
    var RE_GLIBC_VERSION = /GLIBC\s(\d+\.\d+)/;
    var MUSL = "musl";
    var GLIBC_ON_LDD = GLIBC.toUpperCase();
    var MUSL_ON_LDD = MUSL.toLowerCase();
    var isFileMusl = (f9) => f9.includes("libc.musl-") || f9.includes("ld-musl-");
    var familyFromReport = () => {
      const report = getReport();
      if (report.header && report.header.glibcVersionRuntime) {
        return GLIBC;
      }
      if (Array.isArray(report.sharedObjects)) {
        if (report.sharedObjects.some(isFileMusl)) {
          return MUSL;
        }
      }
      return null;
    };
    var familyFromCommand = (out2) => {
      const [getconf, ldd1] = out2.split(/[\r\n]+/);
      if (getconf && getconf.includes(GLIBC)) {
        return GLIBC;
      }
      if (ldd1 && ldd1.includes(MUSL)) {
        return MUSL;
      }
      return null;
    };
    var getFamilyFromLddContent = (content) => {
      if (content.includes(MUSL_ON_LDD)) {
        return MUSL;
      }
      if (content.includes(GLIBC_ON_LDD)) {
        return GLIBC;
      }
      return null;
    };
    var familyFromFilesystem = async () => {
      if (cachedFamilyFilesystem !== void 0) {
        return cachedFamilyFilesystem;
      }
      cachedFamilyFilesystem = null;
      try {
        const lddContent = await readFile4(LDD_PATH);
        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
      } catch (e6) {
      }
      return cachedFamilyFilesystem;
    };
    var familyFromFilesystemSync = () => {
      if (cachedFamilyFilesystem !== void 0) {
        return cachedFamilyFilesystem;
      }
      cachedFamilyFilesystem = null;
      try {
        const lddContent = readFileSync2(LDD_PATH);
        cachedFamilyFilesystem = getFamilyFromLddContent(lddContent);
      } catch (e6) {
      }
      return cachedFamilyFilesystem;
    };
    var family = async () => {
      let family2 = null;
      if (isLinux()) {
        family2 = await familyFromFilesystem();
        if (!family2) {
          family2 = familyFromReport();
        }
        if (!family2) {
          const out2 = await safeCommand();
          family2 = familyFromCommand(out2);
        }
      }
      return family2;
    };
    var familySync = () => {
      let family2 = null;
      if (isLinux()) {
        family2 = familyFromFilesystemSync();
        if (!family2) {
          family2 = familyFromReport();
        }
        if (!family2) {
          const out2 = safeCommandSync();
          family2 = familyFromCommand(out2);
        }
      }
      return family2;
    };
    var isNonGlibcLinux = async () => isLinux() && await family() !== GLIBC;
    var isNonGlibcLinuxSync = () => isLinux() && familySync() !== GLIBC;
    var versionFromFilesystem = async () => {
      if (cachedVersionFilesystem !== void 0) {
        return cachedVersionFilesystem;
      }
      cachedVersionFilesystem = null;
      try {
        const lddContent = await readFile4(LDD_PATH);
        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
        if (versionMatch) {
          cachedVersionFilesystem = versionMatch[1];
        }
      } catch (e6) {
      }
      return cachedVersionFilesystem;
    };
    var versionFromFilesystemSync = () => {
      if (cachedVersionFilesystem !== void 0) {
        return cachedVersionFilesystem;
      }
      cachedVersionFilesystem = null;
      try {
        const lddContent = readFileSync2(LDD_PATH);
        const versionMatch = lddContent.match(RE_GLIBC_VERSION);
        if (versionMatch) {
          cachedVersionFilesystem = versionMatch[1];
        }
      } catch (e6) {
      }
      return cachedVersionFilesystem;
    };
    var versionFromReport = () => {
      const report = getReport();
      if (report.header && report.header.glibcVersionRuntime) {
        return report.header.glibcVersionRuntime;
      }
      return null;
    };
    var versionSuffix = (s10) => s10.trim().split(/\s+/)[1];
    var versionFromCommand = (out2) => {
      const [getconf, ldd1, ldd2] = out2.split(/[\r\n]+/);
      if (getconf && getconf.includes(GLIBC)) {
        return versionSuffix(getconf);
      }
      if (ldd1 && ldd2 && ldd1.includes(MUSL)) {
        return versionSuffix(ldd2);
      }
      return null;
    };
    var version3 = async () => {
      let version4 = null;
      if (isLinux()) {
        version4 = await versionFromFilesystem();
        if (!version4) {
          version4 = versionFromReport();
        }
        if (!version4) {
          const out2 = await safeCommand();
          version4 = versionFromCommand(out2);
        }
      }
      return version4;
    };
    var versionSync = () => {
      let version4 = null;
      if (isLinux()) {
        version4 = versionFromFilesystemSync();
        if (!version4) {
          version4 = versionFromReport();
        }
        if (!version4) {
          const out2 = safeCommandSync();
          version4 = versionFromCommand(out2);
        }
      }
      return version4;
    };
    module2.exports = {
      GLIBC,
      MUSL,
      family,
      familySync,
      isNonGlibcLinux,
      isNonGlibcLinuxSync,
      version: version3,
      versionSync
    };
  }
});

// ../node_modules/.pnpm/libsql@0.4.7/node_modules/libsql/sqlite-error.js
var require_sqlite_error = __commonJS({
  "../node_modules/.pnpm/libsql@0.4.7/node_modules/libsql/sqlite-error.js"(exports2, module2) {
    "use strict";
    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
    function SqliteError(message, code, rawCode) {
      if (new.target !== SqliteError) {
        return new SqliteError(message, code);
      }
      if (typeof code !== "string") {
        throw new TypeError("Expected second argument to be a string");
      }
      Error.call(this, message);
      descriptor.value = "" + message;
      Object.defineProperty(this, "message", descriptor);
      Error.captureStackTrace(this, SqliteError);
      this.code = code;
      this.rawCode = rawCode;
    }
    Object.setPrototypeOf(SqliteError, Error);
    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
    Object.defineProperty(SqliteError.prototype, "name", descriptor);
    module2.exports = SqliteError;
  }
});

// ../node_modules/.pnpm/libsql@0.4.7/node_modules/libsql/index.js
var require_libsql = __commonJS({
  "../node_modules/.pnpm/libsql@0.4.7/node_modules/libsql/index.js"(exports2, module2) {
    "use strict";
    var { load, currentTarget } = require_dist3();
    var { familySync, GLIBC } = require_detect_libc();
    function requireNative() {
      if (process.env.LIBSQL_JS_DEV) {
        return load(__dirname);
      }
      let target = currentTarget();
      if (familySync() == GLIBC) {
        switch (target) {
          case "linux-x64-musl":
            target = "linux-x64-gnu";
            break;
          case "linux-arm64-musl":
            target = "linux-arm64-gnu";
            break;
        }
      }
      return require(`@libsql/${target}`);
    }
    var {
      databaseOpen,
      databaseOpenWithRpcSync,
      databaseInTransaction,
      databaseClose,
      databaseSyncSync,
      databaseSyncUntilSync,
      databaseExecSync,
      databasePrepareSync,
      databaseDefaultSafeIntegers,
      databaseLoadExtension,
      databaseMaxWriteReplicationIndex,
      statementRaw,
      statementIsReader,
      statementGet,
      statementRun,
      statementRowsSync,
      statementColumns,
      statementSafeIntegers,
      rowsNext
    } = requireNative();
    var SqliteError = require_sqlite_error();
    function convertError(err3) {
      if (err3.libsqlError) {
        return new SqliteError(err3.message, err3.code, err3.rawCode);
      }
      return err3;
    }
    var Database2 = class {
      /**
       * Creates a new database connection. If the database file pointed to by `path` does not exists, it will be created.
       *
       * @constructor
       * @param {string} path - Path to the database file.
       */
      constructor(path3, opts) {
        const encryptionCipher = opts?.encryptionCipher ?? "aes256cbc";
        if (opts && opts.syncUrl) {
          var authToken = "";
          if (opts.syncAuth) {
            console.warn("Warning: The `syncAuth` option is deprecated, please use `authToken` option instead.");
            authToken = opts.syncAuth;
          } else if (opts.authToken) {
            authToken = opts.authToken;
          }
          const encryptionKey = opts?.encryptionKey ?? "";
          const syncPeriod = opts?.syncPeriod ?? 0;
          const readYourWrites = opts?.readYourWrites ?? true;
          this.db = databaseOpenWithRpcSync(path3, opts.syncUrl, authToken, encryptionCipher, encryptionKey, syncPeriod, readYourWrites);
        } else {
          const authToken2 = opts?.authToken ?? "";
          const encryptionKey = opts?.encryptionKey ?? "";
          this.db = databaseOpen(path3, authToken2, encryptionCipher, encryptionKey);
        }
        this.memory = path3 === ":memory:";
        this.readonly = false;
        this.name = "";
        this.open = true;
        const db2 = this.db;
        Object.defineProperties(this, {
          inTransaction: {
            get() {
              return databaseInTransaction(db2);
            }
          }
        });
      }
      sync() {
        return databaseSyncSync.call(this.db);
      }
      syncUntil(replicationIndex) {
        return databaseSyncUntilSync.call(this.db, replicationIndex);
      }
      /**
       * Prepares a SQL statement for execution.
       *
       * @param {string} sql - The SQL statement string to prepare.
       */
      prepare(sql3) {
        try {
          const stmt = databasePrepareSync.call(this.db, sql3);
          return new Statement(stmt);
        } catch (err3) {
          throw convertError(err3);
        }
      }
      /**
       * Returns a function that executes the given function in a transaction.
       *
       * @param {function} fn - The function to wrap in a transaction.
       */
      transaction(fn3) {
        if (typeof fn3 !== "function")
          throw new TypeError("Expected first argument to be a function");
        const db2 = this;
        const wrapTxn = (mode) => {
          return (...bindParameters) => {
            db2.exec("BEGIN " + mode);
            try {
              const result = fn3(...bindParameters);
              db2.exec("COMMIT");
              return result;
            } catch (err3) {
              db2.exec("ROLLBACK");
              throw err3;
            }
          };
        };
        const properties = {
          default: { value: wrapTxn("") },
          deferred: { value: wrapTxn("DEFERRED") },
          immediate: { value: wrapTxn("IMMEDIATE") },
          exclusive: { value: wrapTxn("EXCLUSIVE") },
          database: { value: this, enumerable: true }
        };
        Object.defineProperties(properties.default.value, properties);
        Object.defineProperties(properties.deferred.value, properties);
        Object.defineProperties(properties.immediate.value, properties);
        Object.defineProperties(properties.exclusive.value, properties);
        return properties.default.value;
      }
      pragma(source, options) {
        if (options == null) options = {};
        if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
        if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
        const simple = options["simple"];
        const stmt = this.prepare(`PRAGMA ${source}`, this, true);
        return simple ? stmt.pluck().get() : stmt.all();
      }
      backup(filename, options) {
        throw new Error("not implemented");
      }
      serialize(options) {
        throw new Error("not implemented");
      }
      function(name3, options, fn3) {
        if (options == null) options = {};
        if (typeof options === "function") {
          fn3 = options;
          options = {};
        }
        if (typeof name3 !== "string")
          throw new TypeError("Expected first argument to be a string");
        if (typeof fn3 !== "function")
          throw new TypeError("Expected last argument to be a function");
        if (typeof options !== "object")
          throw new TypeError("Expected second argument to be an options object");
        if (!name3)
          throw new TypeError(
            "User-defined function name cannot be an empty string"
          );
        throw new Error("not implemented");
      }
      aggregate(name3, options) {
        if (typeof name3 !== "string")
          throw new TypeError("Expected first argument to be a string");
        if (typeof options !== "object" || options === null)
          throw new TypeError("Expected second argument to be an options object");
        if (!name3)
          throw new TypeError(
            "User-defined function name cannot be an empty string"
          );
        throw new Error("not implemented");
      }
      table(name3, factory) {
        if (typeof name3 !== "string")
          throw new TypeError("Expected first argument to be a string");
        if (!name3)
          throw new TypeError(
            "Virtual table module name cannot be an empty string"
          );
        throw new Error("not implemented");
      }
      loadExtension(...args2) {
        databaseLoadExtension.call(this.db, ...args2);
      }
      maxWriteReplicationIndex() {
        return databaseMaxWriteReplicationIndex.call(this.db);
      }
      /**
       * Executes a SQL statement.
       *
       * @param {string} sql - The SQL statement string to execute.
       */
      exec(sql3) {
        try {
          databaseExecSync.call(this.db, sql3);
        } catch (err3) {
          throw convertError(err3);
        }
      }
      /**
       * Closes the database connection.
       */
      close() {
        databaseClose.call(this.db);
        this.open = false;
      }
      /**
       * Toggle 64-bit integer support.
       */
      defaultSafeIntegers(toggle) {
        databaseDefaultSafeIntegers.call(this.db, toggle ?? true);
        return this;
      }
      unsafeMode(...args2) {
        throw new Error("not implemented");
      }
    };
    var Statement = class {
      constructor(stmt) {
        this.stmt = stmt;
      }
      /**
       * Toggle raw mode.
       *
       * @param raw Enable or disable raw mode. If you don't pass the parameter, raw mode is enabled.
       */
      raw(raw2) {
        statementRaw.call(this.stmt, raw2 ?? true);
        return this;
      }
      get reader() {
        return statementIsReader.call(this.stmt);
      }
      /**
       * Executes the SQL statement and returns an info object.
       */
      run(...bindParameters) {
        try {
          if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
            return statementRun.call(this.stmt, bindParameters[0]);
          } else {
            return statementRun.call(this.stmt, bindParameters.flat());
          }
        } catch (err3) {
          throw convertError(err3);
        }
      }
      /**
       * Executes the SQL statement and returns the first row.
       *
       * @param bindParameters - The bind parameters for executing the statement.
       */
      get(...bindParameters) {
        if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
          return statementGet.call(this.stmt, bindParameters[0]);
        } else {
          return statementGet.call(this.stmt, bindParameters.flat());
        }
      }
      /**
       * Executes the SQL statement and returns an iterator to the resulting rows.
       *
       * @param bindParameters - The bind parameters for executing the statement.
       */
      iterate(...bindParameters) {
        var rows = void 0;
        if (bindParameters.length == 1 && typeof bindParameters[0] === "object") {
          rows = statementRowsSync.call(this.stmt, bindParameters[0]);
        } else {
          rows = statementRowsSync.call(this.stmt, bindParameters.flat());
        }
        const iter = {
          nextRows: Array(100),
          nextRowIndex: 100,
          next() {
            if (this.nextRowIndex === 100) {
              rowsNext.call(rows, this.nextRows);
              this.nextRowIndex = 0;
            }
            const row = this.nextRows[this.nextRowIndex];
            this.nextRows[this.nextRowIndex] = void 0;
            if (!row) {
              return { done: true };
            }
            this.nextRowIndex++;
            return { value: row, done: false };
          },
          [Symbol.iterator]() {
            return this;
          }
        };
        return iter;
      }
      /**
       * Executes the SQL statement and returns an array of the resulting rows.
       *
       * @param bindParameters - The bind parameters for executing the statement.
       */
      all(...bindParameters) {
        const result = [];
        for (const row of this.iterate(...bindParameters)) {
          result.push(row);
        }
        return result;
      }
      /**
       * Returns the columns in the result set returned by this prepared statement.
       */
      columns() {
        return statementColumns.call(this.stmt);
      }
      /**
       * Toggle 64-bit integer support.
       */
      safeIntegers(toggle) {
        statementSafeIntegers.call(this.stmt, toggle ?? true);
        return this;
      }
    };
    module2.exports = Database2;
    module2.exports.SqliteError = SqliteError;
  }
});

// ../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/sqlite3.js
function _createClient(config) {
  if (config.scheme !== "file") {
    throw new LibsqlError(`URL scheme ${JSON.stringify(config.scheme + ":")} is not supported by the local sqlite3 client. For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
  }
  const authority = config.authority;
  if (authority !== void 0) {
    const host = authority.host.toLowerCase();
    if (host !== "" && host !== "localhost") {
      throw new LibsqlError(`Invalid host in file URL: ${JSON.stringify(authority.host)}. A "file:" URL with an absolute path should start with one slash ("file:/absolute/path.db") or with three slashes ("file:///absolute/path.db"). For more information, please read ${supportedUrlLink}`, "URL_INVALID");
    }
    if (authority.port !== void 0) {
      throw new LibsqlError("File URL cannot have a port", "URL_INVALID");
    }
    if (authority.userinfo !== void 0) {
      throw new LibsqlError("File URL cannot have username and password", "URL_INVALID");
    }
  }
  let isInMemory = isInMemoryConfig(config);
  if (isInMemory && config.syncUrl) {
    throw new LibsqlError(`Embedded replica must use file for local db but URI with in-memory mode were provided instead: ${config.path}`, "URL_INVALID");
  }
  let path3 = config.path;
  if (isInMemory) {
    path3 = `${config.scheme}:${config.path}`;
  }
  const options = {
    authToken: config.authToken,
    encryptionKey: config.encryptionKey,
    syncUrl: config.syncUrl,
    syncPeriod: config.syncInterval
  };
  const db2 = new import_libsql2.default(path3, options);
  executeStmt(db2, "SELECT 1 AS checkThatTheDatabaseCanBeOpened", config.intMode);
  return new Sqlite3Client(path3, options, db2, config.intMode);
}
function executeStmt(db2, stmt, intMode) {
  let sql3;
  let args2;
  if (typeof stmt === "string") {
    sql3 = stmt;
    args2 = [];
  } else {
    sql3 = stmt.sql;
    if (Array.isArray(stmt.args)) {
      args2 = stmt.args.map((value) => valueToSql(value, intMode));
    } else {
      args2 = {};
      for (const name3 in stmt.args) {
        const argName = name3[0] === "@" || name3[0] === "$" || name3[0] === ":" ? name3.substring(1) : name3;
        args2[argName] = valueToSql(stmt.args[name3], intMode);
      }
    }
  }
  try {
    const sqlStmt = db2.prepare(sql3);
    sqlStmt.safeIntegers(true);
    let returnsData = true;
    try {
      sqlStmt.raw(true);
    } catch {
      returnsData = false;
    }
    if (returnsData) {
      const columns = Array.from(sqlStmt.columns().map((col) => col.name));
      const columnTypes = Array.from(sqlStmt.columns().map((col) => col.type ?? ""));
      const rows = sqlStmt.all(args2).map((sqlRow) => {
        return rowFromSql(sqlRow, columns, intMode);
      });
      const rowsAffected = 0;
      const lastInsertRowid = void 0;
      return new ResultSetImpl(columns, columnTypes, rows, rowsAffected, lastInsertRowid);
    } else {
      const info3 = sqlStmt.run(args2);
      const rowsAffected = info3.changes;
      const lastInsertRowid = BigInt(info3.lastInsertRowid);
      return new ResultSetImpl([], [], [], rowsAffected, lastInsertRowid);
    }
  } catch (e6) {
    throw mapSqliteError(e6);
  }
}
function rowFromSql(sqlRow, columns, intMode) {
  const row = {};
  Object.defineProperty(row, "length", { value: sqlRow.length });
  for (let i8 = 0; i8 < sqlRow.length; ++i8) {
    const value = valueFromSql(sqlRow[i8], intMode);
    Object.defineProperty(row, i8, { value });
    const column6 = columns[i8];
    if (!Object.hasOwn(row, column6)) {
      Object.defineProperty(row, column6, {
        value,
        enumerable: true,
        configurable: true,
        writable: true
      });
    }
  }
  return row;
}
function valueFromSql(sqlValue, intMode) {
  if (typeof sqlValue === "bigint") {
    if (intMode === "number") {
      if (sqlValue < minSafeBigint || sqlValue > maxSafeBigint) {
        throw new RangeError("Received integer which cannot be safely represented as a JavaScript number");
      }
      return Number(sqlValue);
    } else if (intMode === "bigint") {
      return sqlValue;
    } else if (intMode === "string") {
      return "" + sqlValue;
    } else {
      throw new Error("Invalid value for IntMode");
    }
  } else if (sqlValue instanceof import_node_buffer3.Buffer) {
    return sqlValue.buffer;
  }
  return sqlValue;
}
function valueToSql(value, intMode) {
  if (typeof value === "number") {
    if (!Number.isFinite(value)) {
      throw new RangeError("Only finite numbers (not Infinity or NaN) can be passed as arguments");
    }
    return value;
  } else if (typeof value === "bigint") {
    if (value < minInteger || value > maxInteger) {
      throw new RangeError("bigint is too large to be represented as a 64-bit integer and passed as argument");
    }
    return value;
  } else if (typeof value === "boolean") {
    switch (intMode) {
      case "bigint":
        return value ? 1n : 0n;
      case "string":
        return value ? "1" : "0";
      default:
        return value ? 1 : 0;
    }
  } else if (value instanceof ArrayBuffer) {
    return import_node_buffer3.Buffer.from(value);
  } else if (value instanceof Date) {
    return value.valueOf();
  } else if (value === void 0) {
    throw new TypeError("undefined cannot be passed as argument to the database");
  } else {
    return value;
  }
}
function executeMultiple(db2, sql3) {
  try {
    db2.exec(sql3);
  } catch (e6) {
    throw mapSqliteError(e6);
  }
}
function mapSqliteError(e6) {
  if (e6 instanceof import_libsql2.default.SqliteError) {
    return new LibsqlError(e6.message, e6.code, e6.rawCode, e6);
  }
  return e6;
}
var import_libsql2, import_node_buffer3, _path3, _options, _db, _intMode, _Sqlite3Client_instances, checkNotClosed_fn, getDb_fn, Sqlite3Client, _database, _intMode2, _Sqlite3Transaction_instances, checkNotClosed_fn2, Sqlite3Transaction, minSafeBigint, maxSafeBigint, minInteger, maxInteger;
var init_sqlite3 = __esm({
  "../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/sqlite3.js"() {
    "use strict";
    import_libsql2 = __toESM(require_libsql(), 1);
    import_node_buffer3 = require("buffer");
    init_api();
    init_config5();
    init_util4();
    init_api();
    Sqlite3Client = class {
      /** @private */
      constructor(path3, options, db2, intMode) {
        __privateAdd(this, _Sqlite3Client_instances);
        __privateAdd(this, _path3);
        __privateAdd(this, _options);
        __privateAdd(this, _db);
        __privateAdd(this, _intMode);
        __publicField(this, "closed");
        __publicField(this, "protocol");
        __privateSet(this, _path3, path3);
        __privateSet(this, _options, options);
        __privateSet(this, _db, db2);
        __privateSet(this, _intMode, intMode);
        this.closed = false;
        this.protocol = "file";
      }
      async execute(stmtOrSql, args2) {
        let stmt;
        if (typeof stmtOrSql === "string") {
          stmt = {
            sql: stmtOrSql,
            args: args2 || []
          };
        } else {
          stmt = stmtOrSql;
        }
        __privateMethod(this, _Sqlite3Client_instances, checkNotClosed_fn).call(this);
        return executeStmt(__privateMethod(this, _Sqlite3Client_instances, getDb_fn).call(this), stmt, __privateGet(this, _intMode));
      }
      async batch(stmts, mode = "deferred") {
        __privateMethod(this, _Sqlite3Client_instances, checkNotClosed_fn).call(this);
        const db2 = __privateMethod(this, _Sqlite3Client_instances, getDb_fn).call(this);
        try {
          executeStmt(db2, transactionModeToBegin(mode), __privateGet(this, _intMode));
          const resultSets = stmts.map((stmt) => {
            if (!db2.inTransaction) {
              throw new LibsqlError("The transaction has been rolled back", "TRANSACTION_CLOSED");
            }
            return executeStmt(db2, stmt, __privateGet(this, _intMode));
          });
          executeStmt(db2, "COMMIT", __privateGet(this, _intMode));
          return resultSets;
        } finally {
          if (db2.inTransaction) {
            executeStmt(db2, "ROLLBACK", __privateGet(this, _intMode));
          }
        }
      }
      async migrate(stmts) {
        __privateMethod(this, _Sqlite3Client_instances, checkNotClosed_fn).call(this);
        const db2 = __privateMethod(this, _Sqlite3Client_instances, getDb_fn).call(this);
        try {
          executeStmt(db2, "PRAGMA foreign_keys=off", __privateGet(this, _intMode));
          executeStmt(db2, transactionModeToBegin("deferred"), __privateGet(this, _intMode));
          const resultSets = stmts.map((stmt) => {
            if (!db2.inTransaction) {
              throw new LibsqlError("The transaction has been rolled back", "TRANSACTION_CLOSED");
            }
            return executeStmt(db2, stmt, __privateGet(this, _intMode));
          });
          executeStmt(db2, "COMMIT", __privateGet(this, _intMode));
          return resultSets;
        } finally {
          if (db2.inTransaction) {
            executeStmt(db2, "ROLLBACK", __privateGet(this, _intMode));
          }
          executeStmt(db2, "PRAGMA foreign_keys=on", __privateGet(this, _intMode));
        }
      }
      async transaction(mode = "write") {
        const db2 = __privateMethod(this, _Sqlite3Client_instances, getDb_fn).call(this);
        executeStmt(db2, transactionModeToBegin(mode), __privateGet(this, _intMode));
        __privateSet(this, _db, null);
        return new Sqlite3Transaction(db2, __privateGet(this, _intMode));
      }
      async executeMultiple(sql3) {
        __privateMethod(this, _Sqlite3Client_instances, checkNotClosed_fn).call(this);
        const db2 = __privateMethod(this, _Sqlite3Client_instances, getDb_fn).call(this);
        try {
          return executeMultiple(db2, sql3);
        } finally {
          if (db2.inTransaction) {
            executeStmt(db2, "ROLLBACK", __privateGet(this, _intMode));
          }
        }
      }
      async sync() {
        __privateMethod(this, _Sqlite3Client_instances, checkNotClosed_fn).call(this);
        const rep = await __privateMethod(this, _Sqlite3Client_instances, getDb_fn).call(this).sync();
        return {
          frames_synced: rep.frames_synced,
          frame_no: rep.frame_no
        };
      }
      close() {
        this.closed = true;
        if (__privateGet(this, _db) !== null) {
          __privateGet(this, _db).close();
        }
      }
    };
    _path3 = new WeakMap();
    _options = new WeakMap();
    _db = new WeakMap();
    _intMode = new WeakMap();
    _Sqlite3Client_instances = new WeakSet();
    checkNotClosed_fn = function() {
      if (this.closed) {
        throw new LibsqlError("The client is closed", "CLIENT_CLOSED");
      }
    };
    // Lazily creates the database connection and returns it
    getDb_fn = function() {
      if (__privateGet(this, _db) === null) {
        __privateSet(this, _db, new import_libsql2.default(__privateGet(this, _path3), __privateGet(this, _options)));
      }
      return __privateGet(this, _db);
    };
    Sqlite3Transaction = class {
      /** @private */
      constructor(database, intMode) {
        __privateAdd(this, _Sqlite3Transaction_instances);
        __privateAdd(this, _database);
        __privateAdd(this, _intMode2);
        __privateSet(this, _database, database);
        __privateSet(this, _intMode2, intMode);
      }
      async execute(stmtOrSql, args2) {
        let stmt;
        if (typeof stmtOrSql === "string") {
          stmt = {
            sql: stmtOrSql,
            args: args2 || []
          };
        } else {
          stmt = stmtOrSql;
        }
        __privateMethod(this, _Sqlite3Transaction_instances, checkNotClosed_fn2).call(this);
        return executeStmt(__privateGet(this, _database), stmt, __privateGet(this, _intMode2));
      }
      async batch(stmts) {
        return stmts.map((stmt) => {
          __privateMethod(this, _Sqlite3Transaction_instances, checkNotClosed_fn2).call(this);
          return executeStmt(__privateGet(this, _database), stmt, __privateGet(this, _intMode2));
        });
      }
      async executeMultiple(sql3) {
        __privateMethod(this, _Sqlite3Transaction_instances, checkNotClosed_fn2).call(this);
        return executeMultiple(__privateGet(this, _database), sql3);
      }
      async rollback() {
        if (!__privateGet(this, _database).open) {
          return;
        }
        __privateMethod(this, _Sqlite3Transaction_instances, checkNotClosed_fn2).call(this);
        executeStmt(__privateGet(this, _database), "ROLLBACK", __privateGet(this, _intMode2));
      }
      async commit() {
        __privateMethod(this, _Sqlite3Transaction_instances, checkNotClosed_fn2).call(this);
        executeStmt(__privateGet(this, _database), "COMMIT", __privateGet(this, _intMode2));
      }
      close() {
        if (__privateGet(this, _database).inTransaction) {
          executeStmt(__privateGet(this, _database), "ROLLBACK", __privateGet(this, _intMode2));
        }
      }
      get closed() {
        return !__privateGet(this, _database).inTransaction;
      }
    };
    _database = new WeakMap();
    _intMode2 = new WeakMap();
    _Sqlite3Transaction_instances = new WeakSet();
    checkNotClosed_fn2 = function() {
      if (this.closed) {
        throw new LibsqlError("The transaction is closed", "TRANSACTION_CLOSED");
      }
    };
    minSafeBigint = -9007199254740991n;
    maxSafeBigint = 9007199254740991n;
    minInteger = -9223372036854775808n;
    maxInteger = 9223372036854775807n;
  }
});

// ../node_modules/.pnpm/@libsql+isomorphic-ws@0.1.5/node_modules/@libsql/isomorphic-ws/node.mjs
var init_node3 = __esm({
  "../node_modules/.pnpm/@libsql+isomorphic-ws@0.1.5/node_modules/@libsql/isomorphic-ws/node.mjs"() {
    "use strict";
    init_wrapper();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/client.js
var Client4;
var init_client4 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/client.js"() {
    "use strict";
    Client4 = class {
      /** @private */
      constructor() {
        /** Representation of integers returned from the database. See {@link IntMode}.
         *
         * This value is inherited by {@link Stream} objects created with {@link openStream}, but you can
         * override the integer mode for every stream by setting {@link Stream.intMode} on the stream.
         */
        __publicField(this, "intMode");
        this.intMode = "number";
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/errors.js
var ClientError, ProtoError, ResponseError, ClosedError, WebSocketUnsupportedError, WebSocketError, HttpServerError, ProtocolVersionError, InternalError, MisuseError;
var init_errors4 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/errors.js"() {
    "use strict";
    ClientError = class extends Error {
      /** @private */
      constructor(message) {
        super(message);
        this.name = "ClientError";
      }
    };
    ProtoError = class extends ClientError {
      /** @private */
      constructor(message) {
        super(message);
        this.name = "ProtoError";
      }
    };
    ResponseError = class extends ClientError {
      /** @private */
      constructor(message, protoError) {
        super(message);
        __publicField(this, "code");
        /** @internal */
        __publicField(this, "proto");
        this.name = "ResponseError";
        this.code = protoError.code;
        this.proto = protoError;
        this.stack = void 0;
      }
    };
    ClosedError = class extends ClientError {
      /** @private */
      constructor(message, cause) {
        if (cause !== void 0) {
          super(`${message}: ${cause}`);
          this.cause = cause;
        } else {
          super(message);
        }
        this.name = "ClosedError";
      }
    };
    WebSocketUnsupportedError = class extends ClientError {
      /** @private */
      constructor(message) {
        super(message);
        this.name = "WebSocketUnsupportedError";
      }
    };
    WebSocketError = class extends ClientError {
      /** @private */
      constructor(message) {
        super(message);
        this.name = "WebSocketError";
      }
    };
    HttpServerError = class extends ClientError {
      /** @private */
      constructor(message, status) {
        super(message);
        __publicField(this, "status");
        this.status = status;
        this.name = "HttpServerError";
      }
    };
    ProtocolVersionError = class extends ClientError {
      /** @private */
      constructor(message) {
        super(message);
        this.name = "ProtocolVersionError";
      }
    };
    InternalError = class extends ClientError {
      /** @private */
      constructor(message) {
        super(message);
        this.name = "InternalError";
      }
    };
    MisuseError = class extends ClientError {
      /** @private */
      constructor(message) {
        super(message);
        this.name = "MisuseError";
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/json/decode.js
function string(value) {
  if (typeof value === "string") {
    return value;
  }
  throw typeError(value, "string");
}
function stringOpt(value) {
  if (value === null || value === void 0) {
    return void 0;
  } else if (typeof value === "string") {
    return value;
  }
  throw typeError(value, "string or null");
}
function number(value) {
  if (typeof value === "number") {
    return value;
  }
  throw typeError(value, "number");
}
function boolean4(value) {
  if (typeof value === "boolean") {
    return value;
  }
  throw typeError(value, "boolean");
}
function array2(value) {
  if (Array.isArray(value)) {
    return value;
  }
  throw typeError(value, "array");
}
function object(value) {
  if (value !== null && typeof value === "object" && !Array.isArray(value)) {
    return value;
  }
  throw typeError(value, "object");
}
function arrayObjectsMap(value, fun) {
  return array2(value).map((elemValue) => fun(object(elemValue)));
}
function typeError(value, expected) {
  if (value === void 0) {
    return new ProtoError(`Expected ${expected}, but the property was missing`);
  }
  let received = typeof value;
  if (value === null) {
    received = "null";
  } else if (Array.isArray(value)) {
    received = "array";
  }
  return new ProtoError(`Expected ${expected}, received ${received}`);
}
function readJsonObject(value, fun) {
  return fun(object(value));
}
var init_decode = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/json/decode.js"() {
    "use strict";
    init_errors4();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/json/encode.js
function writeJsonObject(value, fun) {
  const output = [];
  const writer = new ObjectWriter(output);
  writer.begin();
  fun(writer, value);
  writer.end();
  return output.join("");
}
var _output, _isFirst, _ObjectWriter_instances, key_fn, ObjectWriter;
var init_encode2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/json/encode.js"() {
    "use strict";
    ObjectWriter = class {
      constructor(output) {
        __privateAdd(this, _ObjectWriter_instances);
        __privateAdd(this, _output);
        __privateAdd(this, _isFirst);
        __privateSet(this, _output, output);
        __privateSet(this, _isFirst, false);
      }
      begin() {
        __privateGet(this, _output).push("{");
        __privateSet(this, _isFirst, true);
      }
      end() {
        __privateGet(this, _output).push("}");
        __privateSet(this, _isFirst, false);
      }
      string(name3, value) {
        __privateMethod(this, _ObjectWriter_instances, key_fn).call(this, name3);
        __privateGet(this, _output).push(JSON.stringify(value));
      }
      stringRaw(name3, value) {
        __privateMethod(this, _ObjectWriter_instances, key_fn).call(this, name3);
        __privateGet(this, _output).push('"');
        __privateGet(this, _output).push(value);
        __privateGet(this, _output).push('"');
      }
      number(name3, value) {
        __privateMethod(this, _ObjectWriter_instances, key_fn).call(this, name3);
        __privateGet(this, _output).push("" + value);
      }
      boolean(name3, value) {
        __privateMethod(this, _ObjectWriter_instances, key_fn).call(this, name3);
        __privateGet(this, _output).push(value ? "true" : "false");
      }
      object(name3, value, valueFun) {
        __privateMethod(this, _ObjectWriter_instances, key_fn).call(this, name3);
        this.begin();
        valueFun(this, value);
        this.end();
      }
      arrayObjects(name3, values2, valueFun) {
        __privateMethod(this, _ObjectWriter_instances, key_fn).call(this, name3);
        __privateGet(this, _output).push("[");
        for (let i8 = 0; i8 < values2.length; ++i8) {
          if (i8 !== 0) {
            __privateGet(this, _output).push(",");
          }
          this.begin();
          valueFun(this, values2[i8]);
          this.end();
        }
        __privateGet(this, _output).push("]");
      }
    };
    _output = new WeakMap();
    _isFirst = new WeakMap();
    _ObjectWriter_instances = new WeakSet();
    key_fn = function(name3) {
      if (__privateGet(this, _isFirst)) {
        __privateGet(this, _output).push('"');
        __privateSet(this, _isFirst, false);
      } else {
        __privateGet(this, _output).push(',"');
      }
      __privateGet(this, _output).push(name3);
      __privateGet(this, _output).push('":');
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/util.js
var VARINT, FIXED_64, LENGTH_DELIMITED, FIXED_32;
var init_util5 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/util.js"() {
    "use strict";
    VARINT = 0;
    FIXED_64 = 1;
    LENGTH_DELIMITED = 2;
    FIXED_32 = 5;
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/decode.js
function readProtobufMessage(data, def) {
  const msgReader = new MessageReader(data);
  const fieldReader = new FieldReader(msgReader);
  let value = def.default();
  while (!msgReader.eof()) {
    const key = msgReader.varint();
    const tag = key >> 3;
    const wireType = key & 7;
    fieldReader.setup(wireType);
    const tagFun = def[tag];
    if (tagFun !== void 0) {
      const returnedValue = tagFun(fieldReader, value);
      if (returnedValue !== void 0) {
        value = returnedValue;
      }
    }
    fieldReader.maybeSkip();
  }
  return value;
}
var _array, _view, _pos, MessageReader, _reader, _wireType, _FieldReader_instances, expect_fn, FieldReader;
var init_decode2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/decode.js"() {
    "use strict";
    init_errors4();
    init_util5();
    MessageReader = class {
      constructor(array3) {
        __privateAdd(this, _array);
        __privateAdd(this, _view);
        __privateAdd(this, _pos);
        __privateSet(this, _array, array3);
        __privateSet(this, _view, new DataView(array3.buffer, array3.byteOffset, array3.byteLength));
        __privateSet(this, _pos, 0);
      }
      varint() {
        let value = 0;
        for (let shift = 0; ; shift += 7) {
          const byte = __privateGet(this, _array)[__privateWrapper(this, _pos)._++];
          value |= (byte & 127) << shift;
          if (!(byte & 128)) {
            break;
          }
        }
        return value;
      }
      varintBig() {
        let value = 0n;
        for (let shift = 0n; ; shift += 7n) {
          const byte = __privateGet(this, _array)[__privateWrapper(this, _pos)._++];
          value |= BigInt(byte & 127) << shift;
          if (!(byte & 128)) {
            break;
          }
        }
        return value;
      }
      bytes(length) {
        const array3 = new Uint8Array(__privateGet(this, _array).buffer, __privateGet(this, _array).byteOffset + __privateGet(this, _pos), length);
        __privateSet(this, _pos, __privateGet(this, _pos) + length);
        return array3;
      }
      double() {
        const value = __privateGet(this, _view).getFloat64(__privateGet(this, _pos), true);
        __privateSet(this, _pos, __privateGet(this, _pos) + 8);
        return value;
      }
      skipVarint() {
        for (; ; ) {
          const byte = __privateGet(this, _array)[__privateWrapper(this, _pos)._++];
          if (!(byte & 128)) {
            break;
          }
        }
      }
      skip(count2) {
        __privateSet(this, _pos, __privateGet(this, _pos) + count2);
      }
      eof() {
        return __privateGet(this, _pos) >= __privateGet(this, _array).byteLength;
      }
    };
    _array = new WeakMap();
    _view = new WeakMap();
    _pos = new WeakMap();
    FieldReader = class {
      constructor(reader) {
        __privateAdd(this, _FieldReader_instances);
        __privateAdd(this, _reader);
        __privateAdd(this, _wireType);
        __privateSet(this, _reader, reader);
        __privateSet(this, _wireType, -1);
      }
      setup(wireType) {
        __privateSet(this, _wireType, wireType);
      }
      bytes() {
        __privateMethod(this, _FieldReader_instances, expect_fn).call(this, LENGTH_DELIMITED);
        const length = __privateGet(this, _reader).varint();
        return __privateGet(this, _reader).bytes(length);
      }
      string() {
        return new TextDecoder().decode(this.bytes());
      }
      message(def) {
        return readProtobufMessage(this.bytes(), def);
      }
      int32() {
        __privateMethod(this, _FieldReader_instances, expect_fn).call(this, VARINT);
        return __privateGet(this, _reader).varint();
      }
      uint32() {
        return this.int32();
      }
      bool() {
        return this.int32() !== 0;
      }
      uint64() {
        __privateMethod(this, _FieldReader_instances, expect_fn).call(this, VARINT);
        return __privateGet(this, _reader).varintBig();
      }
      sint64() {
        const value = this.uint64();
        return value >> 1n ^ -(value & 1n);
      }
      double() {
        __privateMethod(this, _FieldReader_instances, expect_fn).call(this, FIXED_64);
        return __privateGet(this, _reader).double();
      }
      maybeSkip() {
        if (__privateGet(this, _wireType) < 0) {
          return;
        } else if (__privateGet(this, _wireType) === VARINT) {
          __privateGet(this, _reader).skipVarint();
        } else if (__privateGet(this, _wireType) === FIXED_64) {
          __privateGet(this, _reader).skip(8);
        } else if (__privateGet(this, _wireType) === LENGTH_DELIMITED) {
          const length = __privateGet(this, _reader).varint();
          __privateGet(this, _reader).skip(length);
        } else if (__privateGet(this, _wireType) === FIXED_32) {
          __privateGet(this, _reader).skip(4);
        } else {
          throw new ProtoError(`Unexpected wire type ${__privateGet(this, _wireType)}`);
        }
        __privateSet(this, _wireType, -1);
      }
    };
    _reader = new WeakMap();
    _wireType = new WeakMap();
    _FieldReader_instances = new WeakSet();
    expect_fn = function(expectedWireType) {
      if (__privateGet(this, _wireType) !== expectedWireType) {
        throw new ProtoError(`Expected wire type ${expectedWireType}, got ${__privateGet(this, _wireType)}`);
      }
      __privateSet(this, _wireType, -1);
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/encode.js
function writeProtobufMessage(value, fun) {
  const w10 = new MessageWriter();
  fun(w10, value);
  return w10.data();
}
var _buf, _array2, _view2, _pos2, _MessageWriter_instances, ensure_fn, varint_fn, varintBig_fn, tag_fn, _MessageWriter, MessageWriter;
var init_encode3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/protobuf/encode.js"() {
    "use strict";
    init_util5();
    _MessageWriter = class _MessageWriter {
      constructor() {
        __privateAdd(this, _MessageWriter_instances);
        __privateAdd(this, _buf);
        __privateAdd(this, _array2);
        __privateAdd(this, _view2);
        __privateAdd(this, _pos2);
        __privateSet(this, _buf, new ArrayBuffer(256));
        __privateSet(this, _array2, new Uint8Array(__privateGet(this, _buf)));
        __privateSet(this, _view2, new DataView(__privateGet(this, _buf)));
        __privateSet(this, _pos2, 0);
      }
      bytes(tag, value) {
        __privateMethod(this, _MessageWriter_instances, tag_fn).call(this, tag, LENGTH_DELIMITED);
        __privateMethod(this, _MessageWriter_instances, varint_fn).call(this, value.byteLength);
        __privateMethod(this, _MessageWriter_instances, ensure_fn).call(this, value.byteLength);
        __privateGet(this, _array2).set(value, __privateGet(this, _pos2));
        __privateSet(this, _pos2, __privateGet(this, _pos2) + value.byteLength);
      }
      string(tag, value) {
        this.bytes(tag, new TextEncoder().encode(value));
      }
      message(tag, value, fun) {
        const writer = new _MessageWriter();
        fun(writer, value);
        this.bytes(tag, writer.data());
      }
      int32(tag, value) {
        __privateMethod(this, _MessageWriter_instances, tag_fn).call(this, tag, VARINT);
        __privateMethod(this, _MessageWriter_instances, varint_fn).call(this, value);
      }
      uint32(tag, value) {
        this.int32(tag, value);
      }
      bool(tag, value) {
        this.int32(tag, value ? 1 : 0);
      }
      sint64(tag, value) {
        __privateMethod(this, _MessageWriter_instances, tag_fn).call(this, tag, VARINT);
        __privateMethod(this, _MessageWriter_instances, varintBig_fn).call(this, value << 1n ^ value >> 63n);
      }
      double(tag, value) {
        __privateMethod(this, _MessageWriter_instances, tag_fn).call(this, tag, FIXED_64);
        __privateMethod(this, _MessageWriter_instances, ensure_fn).call(this, 8);
        __privateGet(this, _view2).setFloat64(__privateGet(this, _pos2), value, true);
        __privateSet(this, _pos2, __privateGet(this, _pos2) + 8);
      }
      data() {
        return new Uint8Array(__privateGet(this, _buf), 0, __privateGet(this, _pos2));
      }
    };
    _buf = new WeakMap();
    _array2 = new WeakMap();
    _view2 = new WeakMap();
    _pos2 = new WeakMap();
    _MessageWriter_instances = new WeakSet();
    ensure_fn = function(extra) {
      if (__privateGet(this, _pos2) + extra <= __privateGet(this, _buf).byteLength) {
        return;
      }
      let newCap = __privateGet(this, _buf).byteLength;
      while (newCap < __privateGet(this, _pos2) + extra) {
        newCap *= 2;
      }
      const newBuf = new ArrayBuffer(newCap);
      const newArray = new Uint8Array(newBuf);
      const newView = new DataView(newBuf);
      newArray.set(new Uint8Array(__privateGet(this, _buf), 0, __privateGet(this, _pos2)));
      __privateSet(this, _buf, newBuf);
      __privateSet(this, _array2, newArray);
      __privateSet(this, _view2, newView);
    };
    varint_fn = function(value) {
      __privateMethod(this, _MessageWriter_instances, ensure_fn).call(this, 5);
      value = 0 | value;
      do {
        let byte = value & 127;
        value >>>= 7;
        byte |= value ? 128 : 0;
        __privateGet(this, _array2)[__privateWrapper(this, _pos2)._++] = byte;
      } while (value);
    };
    varintBig_fn = function(value) {
      __privateMethod(this, _MessageWriter_instances, ensure_fn).call(this, 10);
      value = value & 0xffffffffffffffffn;
      do {
        let byte = Number(value & 0x7fn);
        value >>= 7n;
        byte |= value ? 128 : 0;
        __privateGet(this, _array2)[__privateWrapper(this, _pos2)._++] = byte;
      } while (value);
    };
    tag_fn = function(tag, wireType) {
      __privateMethod(this, _MessageWriter_instances, varint_fn).call(this, tag << 3 | wireType);
    };
    MessageWriter = _MessageWriter;
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/index.js
var init_encoding = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/encoding/index.js"() {
    "use strict";
    init_decode();
    init_encode2();
    init_decode2();
    init_encode3();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/id_alloc.js
var _usedIds, _freeIds, IdAlloc;
var init_id_alloc = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/id_alloc.js"() {
    "use strict";
    init_errors4();
    IdAlloc = class {
      constructor() {
        // Set of all allocated ids
        __privateAdd(this, _usedIds);
        // Set of all free ids lower than `#usedIds.size`
        __privateAdd(this, _freeIds);
        __privateSet(this, _usedIds, /* @__PURE__ */ new Set());
        __privateSet(this, _freeIds, /* @__PURE__ */ new Set());
      }
      // Returns an id that was free, and marks it as used.
      alloc() {
        for (const freeId2 of __privateGet(this, _freeIds)) {
          __privateGet(this, _freeIds).delete(freeId2);
          __privateGet(this, _usedIds).add(freeId2);
          if (!__privateGet(this, _usedIds).has(__privateGet(this, _usedIds).size - 1)) {
            __privateGet(this, _freeIds).add(__privateGet(this, _usedIds).size - 1);
          }
          return freeId2;
        }
        const freeId = __privateGet(this, _usedIds).size;
        __privateGet(this, _usedIds).add(freeId);
        return freeId;
      }
      free(id) {
        if (!__privateGet(this, _usedIds).delete(id)) {
          throw new InternalError("Freeing an id that is not allocated");
        }
        __privateGet(this, _freeIds).delete(__privateGet(this, _usedIds).size);
        if (id < __privateGet(this, _usedIds).size) {
          __privateGet(this, _freeIds).add(id);
        }
      }
    };
    _usedIds = new WeakMap();
    _freeIds = new WeakMap();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/util.js
function impossible(value, message) {
  throw new InternalError(message);
}
var init_util6 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/util.js"() {
    "use strict";
    init_errors4();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/value.js
function valueToProto(value) {
  if (value === null) {
    return null;
  } else if (typeof value === "string") {
    return value;
  } else if (typeof value === "number") {
    if (!Number.isFinite(value)) {
      throw new RangeError("Only finite numbers (not Infinity or NaN) can be passed as arguments");
    }
    return value;
  } else if (typeof value === "bigint") {
    if (value < minInteger2 || value > maxInteger2) {
      throw new RangeError("This bigint value is too large to be represented as a 64-bit integer and passed as argument");
    }
    return value;
  } else if (typeof value === "boolean") {
    return value ? 1n : 0n;
  } else if (value instanceof ArrayBuffer) {
    return new Uint8Array(value);
  } else if (value instanceof Uint8Array) {
    return value;
  } else if (value instanceof Date) {
    return +value.valueOf();
  } else if (typeof value === "object") {
    return "" + value.toString();
  } else {
    throw new TypeError("Unsupported type of value");
  }
}
function valueFromProto(value, intMode) {
  if (value === null) {
    return null;
  } else if (typeof value === "number") {
    return value;
  } else if (typeof value === "string") {
    return value;
  } else if (typeof value === "bigint") {
    if (intMode === "number") {
      const num = Number(value);
      if (!Number.isSafeInteger(num)) {
        throw new RangeError("Received integer which is too large to be safely represented as a JavaScript number");
      }
      return num;
    } else if (intMode === "bigint") {
      return value;
    } else if (intMode === "string") {
      return "" + value;
    } else {
      throw new MisuseError("Invalid value for IntMode");
    }
  } else if (value instanceof Uint8Array) {
    return value.slice().buffer;
  } else if (value === void 0) {
    throw new ProtoError("Received unrecognized type of Value");
  } else {
    throw impossible(value, "Impossible type of Value");
  }
}
var minInteger2, maxInteger2;
var init_value = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/value.js"() {
    "use strict";
    init_errors4();
    init_util6();
    minInteger2 = -9223372036854775808n;
    maxInteger2 = 9223372036854775807n;
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/result.js
function stmtResultFromProto(result) {
  return {
    affectedRowCount: result.affectedRowCount,
    lastInsertRowid: result.lastInsertRowid,
    columnNames: result.cols.map((col) => col.name),
    columnDecltypes: result.cols.map((col) => col.decltype)
  };
}
function rowsResultFromProto(result, intMode) {
  const stmtResult = stmtResultFromProto(result);
  const rows = result.rows.map((row) => rowFromProto(stmtResult.columnNames, row, intMode));
  return { ...stmtResult, rows };
}
function rowResultFromProto(result, intMode) {
  const stmtResult = stmtResultFromProto(result);
  let row;
  if (result.rows.length > 0) {
    row = rowFromProto(stmtResult.columnNames, result.rows[0], intMode);
  }
  return { ...stmtResult, row };
}
function valueResultFromProto(result, intMode) {
  const stmtResult = stmtResultFromProto(result);
  let value;
  if (result.rows.length > 0 && stmtResult.columnNames.length > 0) {
    value = valueFromProto(result.rows[0][0], intMode);
  }
  return { ...stmtResult, value };
}
function rowFromProto(colNames, values2, intMode) {
  const row = {};
  Object.defineProperty(row, "length", { value: values2.length });
  for (let i8 = 0; i8 < values2.length; ++i8) {
    const value = valueFromProto(values2[i8], intMode);
    Object.defineProperty(row, i8, { value });
    const colName = colNames[i8];
    if (colName !== void 0 && !Object.hasOwn(row, colName)) {
      Object.defineProperty(row, colName, { value, enumerable: true, configurable: true, writable: true });
    }
  }
  return row;
}
function errorFromProto(error2) {
  return new ResponseError(error2.message, error2);
}
var init_result2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/result.js"() {
    "use strict";
    init_errors4();
    init_value();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/sql.js
function sqlToProto(owner, sql3) {
  if (sql3 instanceof Sql) {
    return { sqlId: sql3._getSqlId(owner) };
  } else {
    return { sql: "" + sql3 };
  }
}
var _owner, _sqlId, _closed, Sql;
var init_sql3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/sql.js"() {
    "use strict";
    init_errors4();
    Sql = class {
      /** @private */
      constructor(owner, sqlId) {
        __privateAdd(this, _owner);
        __privateAdd(this, _sqlId);
        __privateAdd(this, _closed);
        __privateSet(this, _owner, owner);
        __privateSet(this, _sqlId, sqlId);
        __privateSet(this, _closed, void 0);
      }
      /** @private */
      _getSqlId(owner) {
        if (__privateGet(this, _owner) !== owner) {
          throw new MisuseError("Attempted to use SQL text opened with other object");
        } else if (__privateGet(this, _closed) !== void 0) {
          throw new ClosedError("SQL text is closed", __privateGet(this, _closed));
        }
        return __privateGet(this, _sqlId);
      }
      /** Remove the SQL text from the server, releasing resouces. */
      close() {
        this._setClosed(new ClientError("SQL text was manually closed"));
      }
      /** @private */
      _setClosed(error2) {
        if (__privateGet(this, _closed) === void 0) {
          __privateSet(this, _closed, error2);
          __privateGet(this, _owner)._closeSql(__privateGet(this, _sqlId));
        }
      }
      /** True if the SQL text is closed (removed from the server). */
      get closed() {
        return __privateGet(this, _closed) !== void 0;
      }
    };
    _owner = new WeakMap();
    _sqlId = new WeakMap();
    _closed = new WeakMap();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/queue.js
var _pushStack, _shiftStack, Queue2;
var init_queue2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/queue.js"() {
    "use strict";
    Queue2 = class {
      constructor() {
        __privateAdd(this, _pushStack);
        __privateAdd(this, _shiftStack);
        __privateSet(this, _pushStack, []);
        __privateSet(this, _shiftStack, []);
      }
      get length() {
        return __privateGet(this, _pushStack).length + __privateGet(this, _shiftStack).length;
      }
      push(elem) {
        __privateGet(this, _pushStack).push(elem);
      }
      shift() {
        if (__privateGet(this, _shiftStack).length === 0 && __privateGet(this, _pushStack).length > 0) {
          __privateSet(this, _shiftStack, __privateGet(this, _pushStack).reverse());
          __privateSet(this, _pushStack, []);
        }
        return __privateGet(this, _shiftStack).pop();
      }
      first() {
        return __privateGet(this, _shiftStack).length !== 0 ? __privateGet(this, _shiftStack)[__privateGet(this, _shiftStack).length - 1] : __privateGet(this, _pushStack)[0];
      }
    };
    _pushStack = new WeakMap();
    _shiftStack = new WeakMap();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/stmt.js
function stmtToProto(sqlOwner, stmt, wantRows) {
  let inSql;
  let args2 = [];
  let namedArgs = [];
  if (stmt instanceof Stmt) {
    inSql = stmt.sql;
    args2 = stmt._args;
    for (const [name3, value] of stmt._namedArgs.entries()) {
      namedArgs.push({ name: name3, value });
    }
  } else if (Array.isArray(stmt)) {
    inSql = stmt[0];
    if (Array.isArray(stmt[1])) {
      args2 = stmt[1].map((arg) => valueToProto(arg));
    } else {
      namedArgs = Object.entries(stmt[1]).map(([name3, value]) => {
        return { name: name3, value: valueToProto(value) };
      });
    }
  } else {
    inSql = stmt;
  }
  const { sql: sql3, sqlId } = sqlToProto(sqlOwner, inSql);
  return { sql: sql3, sqlId, args: args2, namedArgs, wantRows };
}
var Stmt;
var init_stmt = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/stmt.js"() {
    "use strict";
    init_sql3();
    init_value();
    Stmt = class {
      /** Initialize the statement with given SQL text. */
      constructor(sql3) {
        /** The SQL statement text. */
        __publicField(this, "sql");
        /** @private */
        __publicField(this, "_args");
        /** @private */
        __publicField(this, "_namedArgs");
        this.sql = sql3;
        this._args = [];
        this._namedArgs = /* @__PURE__ */ new Map();
      }
      /** Binds positional parameters from the given `values`. All previous positional bindings are cleared. */
      bindIndexes(values2) {
        this._args.length = 0;
        for (const value of values2) {
          this._args.push(valueToProto(value));
        }
        return this;
      }
      /** Binds a parameter by a 1-based index. */
      bindIndex(index7, value) {
        if (index7 !== (index7 | 0) || index7 <= 0) {
          throw new RangeError("Index of a positional argument must be positive integer");
        }
        while (this._args.length < index7) {
          this._args.push(null);
        }
        this._args[index7 - 1] = valueToProto(value);
        return this;
      }
      /** Binds a parameter by name. */
      bindName(name3, value) {
        this._namedArgs.set(name3, valueToProto(value));
        return this;
      }
      /** Clears all bindings. */
      unbindAll() {
        this._args.length = 0;
        this._namedArgs.clear();
        return this;
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/batch.js
function executeRegular(stream, steps, batch) {
  return stream._batch(batch).then((result) => {
    for (let step = 0; step < steps.length; ++step) {
      const stepResult = result.stepResults.get(step);
      const stepError = result.stepErrors.get(step);
      steps[step].callback(stepResult, stepError);
    }
  });
}
async function executeCursor(stream, steps, batch) {
  const cursor = await stream._openCursor(batch);
  try {
    let nextStep = 0;
    let beginEntry = void 0;
    let rows = [];
    for (; ; ) {
      const entry = await cursor.next();
      if (entry === void 0) {
        break;
      }
      if (entry.type === "step_begin") {
        if (entry.step < nextStep || entry.step >= steps.length) {
          throw new ProtoError("Server produced StepBeginEntry for unexpected step");
        } else if (beginEntry !== void 0) {
          throw new ProtoError("Server produced StepBeginEntry before terminating previous step");
        }
        for (let step = nextStep; step < entry.step; ++step) {
          steps[step].callback(void 0, void 0);
        }
        nextStep = entry.step + 1;
        beginEntry = entry;
        rows = [];
      } else if (entry.type === "step_end") {
        if (beginEntry === void 0) {
          throw new ProtoError("Server produced StepEndEntry but no step is active");
        }
        const stmtResult = {
          cols: beginEntry.cols,
          rows,
          affectedRowCount: entry.affectedRowCount,
          lastInsertRowid: entry.lastInsertRowid
        };
        steps[beginEntry.step].callback(stmtResult, void 0);
        beginEntry = void 0;
        rows = [];
      } else if (entry.type === "step_error") {
        if (beginEntry === void 0) {
          if (entry.step >= steps.length) {
            throw new ProtoError("Server produced StepErrorEntry for unexpected step");
          }
          for (let step = nextStep; step < entry.step; ++step) {
            steps[step].callback(void 0, void 0);
          }
        } else {
          if (entry.step !== beginEntry.step) {
            throw new ProtoError("Server produced StepErrorEntry for unexpected step");
          }
          beginEntry = void 0;
          rows = [];
        }
        steps[entry.step].callback(void 0, entry.error);
        nextStep = entry.step + 1;
      } else if (entry.type === "row") {
        if (beginEntry === void 0) {
          throw new ProtoError("Server produced RowEntry but no step is active");
        }
        rows.push(entry.row);
      } else if (entry.type === "error") {
        throw errorFromProto(entry.error);
      } else if (entry.type === "none") {
        throw new ProtoError("Server produced unrecognized CursorEntry");
      } else {
        throw impossible(entry, "Impossible CursorEntry");
      }
    }
    if (beginEntry !== void 0) {
      throw new ProtoError("Server closed Cursor before terminating active step");
    }
    for (let step = nextStep; step < steps.length; ++step) {
      steps[step].callback(void 0, void 0);
    }
  } finally {
    cursor.close();
  }
}
function stepIndex(step) {
  if (step._index === void 0) {
    throw new MisuseError("Cannot add a condition referencing a step that has not been added to the batch");
  }
  return step._index;
}
function checkCondBatch(expectedBatch, cond) {
  if (cond._batch !== expectedBatch) {
    throw new MisuseError("Cannot mix BatchCond objects for different Batch objects");
  }
}
var _useCursor, _executed, Batch, _conds, _BatchStep_instances, add_fn, BatchStep, BatchCond;
var init_batch = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/batch.js"() {
    "use strict";
    init_errors4();
    init_result2();
    init_stmt();
    init_util6();
    Batch = class {
      /** @private */
      constructor(stream, useCursor) {
        /** @private */
        __publicField(this, "_stream");
        __privateAdd(this, _useCursor);
        /** @private */
        __publicField(this, "_steps");
        __privateAdd(this, _executed);
        this._stream = stream;
        __privateSet(this, _useCursor, useCursor);
        this._steps = [];
        __privateSet(this, _executed, false);
      }
      /** Return a builder for adding a step to the batch. */
      step() {
        return new BatchStep(this);
      }
      /** Execute the batch. */
      execute() {
        if (__privateGet(this, _executed)) {
          throw new MisuseError("This batch has already been executed");
        }
        __privateSet(this, _executed, true);
        const batch = {
          steps: this._steps.map((step) => step.proto)
        };
        if (__privateGet(this, _useCursor)) {
          return executeCursor(this._stream, this._steps, batch);
        } else {
          return executeRegular(this._stream, this._steps, batch);
        }
      }
    };
    _useCursor = new WeakMap();
    _executed = new WeakMap();
    BatchStep = class {
      /** @private */
      constructor(batch) {
        __privateAdd(this, _BatchStep_instances);
        /** @private */
        __publicField(this, "_batch");
        __privateAdd(this, _conds);
        /** @private */
        __publicField(this, "_index");
        this._batch = batch;
        __privateSet(this, _conds, []);
        this._index = void 0;
      }
      /** Add the condition that needs to be satisfied to execute the statement. If you use this method multiple
       * times, we join the conditions with a logical AND. */
      condition(cond) {
        __privateGet(this, _conds).push(cond._proto);
        return this;
      }
      /** Add a statement that returns rows. */
      query(stmt) {
        return __privateMethod(this, _BatchStep_instances, add_fn).call(this, stmt, true, rowsResultFromProto);
      }
      /** Add a statement that returns at most a single row. */
      queryRow(stmt) {
        return __privateMethod(this, _BatchStep_instances, add_fn).call(this, stmt, true, rowResultFromProto);
      }
      /** Add a statement that returns at most a single value. */
      queryValue(stmt) {
        return __privateMethod(this, _BatchStep_instances, add_fn).call(this, stmt, true, valueResultFromProto);
      }
      /** Add a statement without returning rows. */
      run(stmt) {
        return __privateMethod(this, _BatchStep_instances, add_fn).call(this, stmt, false, stmtResultFromProto);
      }
    };
    _conds = new WeakMap();
    _BatchStep_instances = new WeakSet();
    add_fn = function(inStmt, wantRows, fromProto) {
      if (this._index !== void 0) {
        throw new MisuseError("This BatchStep has already been added to the batch");
      }
      const stmt = stmtToProto(this._batch._stream._sqlOwner(), inStmt, wantRows);
      let condition;
      if (__privateGet(this, _conds).length === 0) {
        condition = void 0;
      } else if (__privateGet(this, _conds).length === 1) {
        condition = __privateGet(this, _conds)[0];
      } else {
        condition = { type: "and", conds: __privateGet(this, _conds).slice() };
      }
      const proto2 = { stmt, condition };
      return new Promise((outputCallback, errorCallback) => {
        const callback = (stepResult, stepError) => {
          if (stepResult !== void 0 && stepError !== void 0) {
            errorCallback(new ProtoError("Server returned both result and error"));
          } else if (stepError !== void 0) {
            errorCallback(errorFromProto(stepError));
          } else if (stepResult !== void 0) {
            outputCallback(fromProto(stepResult, this._batch._stream.intMode));
          } else {
            outputCallback(void 0);
          }
        };
        this._index = this._batch._steps.length;
        this._batch._steps.push({ proto: proto2, callback });
      });
    };
    BatchCond = class _BatchCond {
      /** @private */
      constructor(batch, proto2) {
        /** @private */
        __publicField(this, "_batch");
        /** @private */
        __publicField(this, "_proto");
        this._batch = batch;
        this._proto = proto2;
      }
      /** Create a condition that evaluates to true when the given step executes successfully.
       *
       * If the given step fails error or is skipped because its condition evaluated to false, this
       * condition evaluates to false.
       */
      static ok(step) {
        return new _BatchCond(step._batch, { type: "ok", step: stepIndex(step) });
      }
      /** Create a condition that evaluates to true when the given step fails.
       *
       * If the given step succeeds or is skipped because its condition evaluated to false, this condition
       * evaluates to false.
       */
      static error(step) {
        return new _BatchCond(step._batch, { type: "error", step: stepIndex(step) });
      }
      /** Create a condition that is a logical negation of another condition.
       */
      static not(cond) {
        return new _BatchCond(cond._batch, { type: "not", cond: cond._proto });
      }
      /** Create a condition that is a logical AND of other conditions.
       */
      static and(batch, conds) {
        for (const cond of conds) {
          checkCondBatch(batch, cond);
        }
        return new _BatchCond(batch, { type: "and", conds: conds.map((e6) => e6._proto) });
      }
      /** Create a condition that is a logical OR of other conditions.
       */
      static or(batch, conds) {
        for (const cond of conds) {
          checkCondBatch(batch, cond);
        }
        return new _BatchCond(batch, { type: "or", conds: conds.map((e6) => e6._proto) });
      }
      /** Create a condition that evaluates to true when the SQL connection is in autocommit mode (not inside an
       * explicit transaction). This requires protocol version 3 or higher.
       */
      static isAutocommit(batch) {
        batch._stream.client()._ensureVersion(3, "BatchCond.isAutocommit()");
        return new _BatchCond(batch, { type: "is_autocommit" });
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/describe.js
function describeResultFromProto(result) {
  return {
    paramNames: result.params.map((p11) => p11.name),
    columns: result.cols,
    isExplain: result.isExplain,
    isReadonly: result.isReadonly
  };
}
var init_describe = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/describe.js"() {
    "use strict";
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/stream.js
var _Stream_instances, execute_fn, Stream5;
var init_stream2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/stream.js"() {
    "use strict";
    init_batch();
    init_describe();
    init_result2();
    init_sql3();
    init_stmt();
    Stream5 = class {
      /** @private */
      constructor(intMode) {
        __privateAdd(this, _Stream_instances);
        /** Representation of integers returned from the database. See {@link IntMode}.
         *
         * This value affects the results of all operations on this stream.
         */
        __publicField(this, "intMode");
        this.intMode = intMode;
      }
      /** Execute a statement and return rows. */
      query(stmt) {
        return __privateMethod(this, _Stream_instances, execute_fn).call(this, stmt, true, rowsResultFromProto);
      }
      /** Execute a statement and return at most a single row. */
      queryRow(stmt) {
        return __privateMethod(this, _Stream_instances, execute_fn).call(this, stmt, true, rowResultFromProto);
      }
      /** Execute a statement and return at most a single value. */
      queryValue(stmt) {
        return __privateMethod(this, _Stream_instances, execute_fn).call(this, stmt, true, valueResultFromProto);
      }
      /** Execute a statement without returning rows. */
      run(stmt) {
        return __privateMethod(this, _Stream_instances, execute_fn).call(this, stmt, false, stmtResultFromProto);
      }
      /** Return a builder for creating and executing a batch.
       *
       * If `useCursor` is true, the batch will be executed using a Hrana cursor, which will stream results from
       * the server to the client, which consumes less memory on the server. This requires protocol version 3 or
       * higher.
       */
      batch(useCursor = false) {
        return new Batch(this, useCursor);
      }
      /** Parse and analyze a statement. This requires protocol version 2 or higher. */
      describe(inSql) {
        const protoSql = sqlToProto(this._sqlOwner(), inSql);
        return this._describe(protoSql).then(describeResultFromProto);
      }
      /** Execute a sequence of statements separated by semicolons. This requires protocol version 2 or higher.
       * */
      sequence(inSql) {
        const protoSql = sqlToProto(this._sqlOwner(), inSql);
        return this._sequence(protoSql);
      }
    };
    _Stream_instances = new WeakSet();
    execute_fn = function(inStmt, wantRows, fromProto) {
      const stmt = stmtToProto(this._sqlOwner(), inStmt, wantRows);
      return this._execute(stmt).then((r6) => fromProto(r6, this.intMode));
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/cursor.js
var Cursor;
var init_cursor = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/cursor.js"() {
    "use strict";
    Cursor = class {
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/cursor.js
var fetchChunkSize, fetchQueueSize, _client, _stream, _cursorId, _entryQueue, _fetchQueue, _closed2, _done, _WsCursor_instances, fetch_fn, WsCursor;
var init_cursor2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/cursor.js"() {
    "use strict";
    init_errors4();
    init_cursor();
    init_queue2();
    fetchChunkSize = 1e3;
    fetchQueueSize = 10;
    WsCursor = class extends Cursor {
      /** @private */
      constructor(client, stream, cursorId) {
        super();
        __privateAdd(this, _WsCursor_instances);
        __privateAdd(this, _client);
        __privateAdd(this, _stream);
        __privateAdd(this, _cursorId);
        __privateAdd(this, _entryQueue);
        __privateAdd(this, _fetchQueue);
        __privateAdd(this, _closed2);
        __privateAdd(this, _done);
        __privateSet(this, _client, client);
        __privateSet(this, _stream, stream);
        __privateSet(this, _cursorId, cursorId);
        __privateSet(this, _entryQueue, new Queue2());
        __privateSet(this, _fetchQueue, new Queue2());
        __privateSet(this, _closed2, void 0);
        __privateSet(this, _done, false);
      }
      /** Fetch the next entry from the cursor. */
      async next() {
        for (; ; ) {
          if (__privateGet(this, _closed2) !== void 0) {
            throw new ClosedError("Cursor is closed", __privateGet(this, _closed2));
          }
          while (!__privateGet(this, _done) && __privateGet(this, _fetchQueue).length < fetchQueueSize) {
            __privateGet(this, _fetchQueue).push(__privateMethod(this, _WsCursor_instances, fetch_fn).call(this));
          }
          const entry = __privateGet(this, _entryQueue).shift();
          if (__privateGet(this, _done) || entry !== void 0) {
            return entry;
          }
          await __privateGet(this, _fetchQueue).shift().then((response) => {
            if (response === void 0) {
              return;
            }
            for (const entry2 of response.entries) {
              __privateGet(this, _entryQueue).push(entry2);
            }
            __privateGet(this, _done) || __privateSet(this, _done, response.done);
          });
        }
      }
      /** @private */
      _setClosed(error2) {
        if (__privateGet(this, _closed2) !== void 0) {
          return;
        }
        __privateSet(this, _closed2, error2);
        __privateGet(this, _stream)._sendCursorRequest(this, {
          type: "close_cursor",
          cursorId: __privateGet(this, _cursorId)
        }).catch(() => void 0);
        __privateGet(this, _stream)._cursorClosed(this);
      }
      /** Close the cursor. */
      close() {
        this._setClosed(new ClientError("Cursor was manually closed"));
      }
      /** True if the cursor is closed. */
      get closed() {
        return __privateGet(this, _closed2) !== void 0;
      }
    };
    _client = new WeakMap();
    _stream = new WeakMap();
    _cursorId = new WeakMap();
    _entryQueue = new WeakMap();
    _fetchQueue = new WeakMap();
    _closed2 = new WeakMap();
    _done = new WeakMap();
    _WsCursor_instances = new WeakSet();
    fetch_fn = function() {
      return __privateGet(this, _stream)._sendCursorRequest(this, {
        type: "fetch_cursor",
        cursorId: __privateGet(this, _cursorId),
        maxCount: fetchChunkSize
      }).then((resp) => resp, (error2) => {
        this._setClosed(error2);
        return void 0;
      });
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/stream.js
var _client2, _streamId, _queue, _cursor, _closing, _closed3, _WsStream_instances, sendStreamRequest_fn, pushToQueue_fn, flushQueue_fn, setClosed_fn, _WsStream, WsStream;
var init_stream3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/stream.js"() {
    "use strict";
    init_errors4();
    init_queue2();
    init_stream2();
    init_cursor2();
    _WsStream = class _WsStream extends Stream5 {
      /** @private */
      constructor(client, streamId) {
        super(client.intMode);
        __privateAdd(this, _WsStream_instances);
        __privateAdd(this, _client2);
        __privateAdd(this, _streamId);
        __privateAdd(this, _queue);
        __privateAdd(this, _cursor);
        __privateAdd(this, _closing);
        __privateAdd(this, _closed3);
        __privateSet(this, _client2, client);
        __privateSet(this, _streamId, streamId);
        __privateSet(this, _queue, new Queue2());
        __privateSet(this, _cursor, void 0);
        __privateSet(this, _closing, false);
        __privateSet(this, _closed3, void 0);
      }
      /** @private */
      static open(client) {
        const streamId = client._streamIdAlloc.alloc();
        const stream = new _WsStream(client, streamId);
        const responseCallback = () => void 0;
        const errorCallback = (e6) => {
          var _a506;
          return __privateMethod(_a506 = stream, _WsStream_instances, setClosed_fn).call(_a506, e6);
        };
        const request2 = { type: "open_stream", streamId };
        client._sendRequest(request2, { responseCallback, errorCallback });
        return stream;
      }
      /** Get the {@link WsClient} object that this stream belongs to. */
      client() {
        return __privateGet(this, _client2);
      }
      /** @private */
      _sqlOwner() {
        return __privateGet(this, _client2);
      }
      /** @private */
      _execute(stmt) {
        return __privateMethod(this, _WsStream_instances, sendStreamRequest_fn).call(this, {
          type: "execute",
          streamId: __privateGet(this, _streamId),
          stmt
        }).then((response) => {
          return response.result;
        });
      }
      /** @private */
      _batch(batch) {
        return __privateMethod(this, _WsStream_instances, sendStreamRequest_fn).call(this, {
          type: "batch",
          streamId: __privateGet(this, _streamId),
          batch
        }).then((response) => {
          return response.result;
        });
      }
      /** @private */
      _describe(protoSql) {
        __privateGet(this, _client2)._ensureVersion(2, "describe()");
        return __privateMethod(this, _WsStream_instances, sendStreamRequest_fn).call(this, {
          type: "describe",
          streamId: __privateGet(this, _streamId),
          sql: protoSql.sql,
          sqlId: protoSql.sqlId
        }).then((response) => {
          return response.result;
        });
      }
      /** @private */
      _sequence(protoSql) {
        __privateGet(this, _client2)._ensureVersion(2, "sequence()");
        return __privateMethod(this, _WsStream_instances, sendStreamRequest_fn).call(this, {
          type: "sequence",
          streamId: __privateGet(this, _streamId),
          sql: protoSql.sql,
          sqlId: protoSql.sqlId
        }).then((_response) => {
          return void 0;
        });
      }
      /** Check whether the SQL connection underlying this stream is in autocommit state (i.e., outside of an
       * explicit transaction). This requires protocol version 3 or higher.
       */
      getAutocommit() {
        __privateGet(this, _client2)._ensureVersion(3, "getAutocommit()");
        return __privateMethod(this, _WsStream_instances, sendStreamRequest_fn).call(this, {
          type: "get_autocommit",
          streamId: __privateGet(this, _streamId)
        }).then((response) => {
          return response.isAutocommit;
        });
      }
      /** @private */
      _openCursor(batch) {
        __privateGet(this, _client2)._ensureVersion(3, "cursor");
        return new Promise((cursorCallback, errorCallback) => {
          __privateMethod(this, _WsStream_instances, pushToQueue_fn).call(this, { type: "cursor", batch, cursorCallback, errorCallback });
        });
      }
      /** @private */
      _sendCursorRequest(cursor, request2) {
        if (cursor !== __privateGet(this, _cursor)) {
          throw new InternalError("Cursor not associated with the stream attempted to execute a request");
        }
        return new Promise((responseCallback, errorCallback) => {
          if (__privateGet(this, _closed3) !== void 0) {
            errorCallback(new ClosedError("Stream is closed", __privateGet(this, _closed3)));
          } else {
            __privateGet(this, _client2)._sendRequest(request2, { responseCallback, errorCallback });
          }
        });
      }
      /** @private */
      _cursorClosed(cursor) {
        if (cursor !== __privateGet(this, _cursor)) {
          throw new InternalError("Cursor was closed, but it was not associated with the stream");
        }
        __privateSet(this, _cursor, void 0);
        __privateMethod(this, _WsStream_instances, flushQueue_fn).call(this);
      }
      /** Immediately close the stream. */
      close() {
        __privateMethod(this, _WsStream_instances, setClosed_fn).call(this, new ClientError("Stream was manually closed"));
      }
      /** Gracefully close the stream. */
      closeGracefully() {
        __privateSet(this, _closing, true);
        __privateMethod(this, _WsStream_instances, flushQueue_fn).call(this);
      }
      /** True if the stream is closed or closing. */
      get closed() {
        return __privateGet(this, _closed3) !== void 0 || __privateGet(this, _closing);
      }
    };
    _client2 = new WeakMap();
    _streamId = new WeakMap();
    _queue = new WeakMap();
    _cursor = new WeakMap();
    _closing = new WeakMap();
    _closed3 = new WeakMap();
    _WsStream_instances = new WeakSet();
    sendStreamRequest_fn = function(request2) {
      return new Promise((responseCallback, errorCallback) => {
        __privateMethod(this, _WsStream_instances, pushToQueue_fn).call(this, { type: "request", request: request2, responseCallback, errorCallback });
      });
    };
    pushToQueue_fn = function(entry) {
      if (__privateGet(this, _closed3) !== void 0) {
        entry.errorCallback(new ClosedError("Stream is closed", __privateGet(this, _closed3)));
      } else if (__privateGet(this, _closing)) {
        entry.errorCallback(new ClosedError("Stream is closing", void 0));
      } else {
        __privateGet(this, _queue).push(entry);
        __privateMethod(this, _WsStream_instances, flushQueue_fn).call(this);
      }
    };
    flushQueue_fn = function() {
      for (; ; ) {
        const entry = __privateGet(this, _queue).first();
        if (entry === void 0 && __privateGet(this, _cursor) === void 0 && __privateGet(this, _closing)) {
          __privateMethod(this, _WsStream_instances, setClosed_fn).call(this, new ClientError("Stream was gracefully closed"));
          break;
        } else if (entry?.type === "request" && __privateGet(this, _cursor) === void 0) {
          const { request: request2, responseCallback, errorCallback } = entry;
          __privateGet(this, _queue).shift();
          __privateGet(this, _client2)._sendRequest(request2, { responseCallback, errorCallback });
        } else if (entry?.type === "cursor" && __privateGet(this, _cursor) === void 0) {
          const { batch, cursorCallback } = entry;
          __privateGet(this, _queue).shift();
          const cursorId = __privateGet(this, _client2)._cursorIdAlloc.alloc();
          const cursor = new WsCursor(__privateGet(this, _client2), this, cursorId);
          const request2 = {
            type: "open_cursor",
            streamId: __privateGet(this, _streamId),
            cursorId,
            batch
          };
          const responseCallback = () => void 0;
          const errorCallback = (e6) => cursor._setClosed(e6);
          __privateGet(this, _client2)._sendRequest(request2, { responseCallback, errorCallback });
          __privateSet(this, _cursor, cursor);
          cursorCallback(cursor);
        } else {
          break;
        }
      }
    };
    setClosed_fn = function(error2) {
      if (__privateGet(this, _closed3) !== void 0) {
        return;
      }
      __privateSet(this, _closed3, error2);
      if (__privateGet(this, _cursor) !== void 0) {
        __privateGet(this, _cursor)._setClosed(error2);
      }
      for (; ; ) {
        const entry = __privateGet(this, _queue).shift();
        if (entry !== void 0) {
          entry.errorCallback(error2);
        } else {
          break;
        }
      }
      const request2 = { type: "close_stream", streamId: __privateGet(this, _streamId) };
      const responseCallback = () => __privateGet(this, _client2)._streamIdAlloc.free(__privateGet(this, _streamId));
      const errorCallback = () => void 0;
      __privateGet(this, _client2)._sendRequest(request2, { responseCallback, errorCallback });
    };
    WsStream = _WsStream;
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/json_encode.js
function Stmt2(w10, msg) {
  if (msg.sql !== void 0) {
    w10.string("sql", msg.sql);
  }
  if (msg.sqlId !== void 0) {
    w10.number("sql_id", msg.sqlId);
  }
  w10.arrayObjects("args", msg.args, Value2);
  w10.arrayObjects("named_args", msg.namedArgs, NamedArg);
  w10.boolean("want_rows", msg.wantRows);
}
function NamedArg(w10, msg) {
  w10.string("name", msg.name);
  w10.object("value", msg.value, Value2);
}
function Batch2(w10, msg) {
  w10.arrayObjects("steps", msg.steps, BatchStep2);
}
function BatchStep2(w10, msg) {
  if (msg.condition !== void 0) {
    w10.object("condition", msg.condition, BatchCond2);
  }
  w10.object("stmt", msg.stmt, Stmt2);
}
function BatchCond2(w10, msg) {
  w10.stringRaw("type", msg.type);
  if (msg.type === "ok" || msg.type === "error") {
    w10.number("step", msg.step);
  } else if (msg.type === "not") {
    w10.object("cond", msg.cond, BatchCond2);
  } else if (msg.type === "and" || msg.type === "or") {
    w10.arrayObjects("conds", msg.conds, BatchCond2);
  } else if (msg.type === "is_autocommit") {
  } else {
    throw impossible(msg, "Impossible type of BatchCond");
  }
}
function Value2(w10, msg) {
  if (msg === null) {
    w10.stringRaw("type", "null");
  } else if (typeof msg === "bigint") {
    w10.stringRaw("type", "integer");
    w10.stringRaw("value", "" + msg);
  } else if (typeof msg === "number") {
    w10.stringRaw("type", "float");
    w10.number("value", msg);
  } else if (typeof msg === "string") {
    w10.stringRaw("type", "text");
    w10.string("value", msg);
  } else if (msg instanceof Uint8Array) {
    w10.stringRaw("type", "blob");
    w10.stringRaw("base64", gBase64.fromUint8Array(msg));
  } else if (msg === void 0) {
  } else {
    throw impossible(msg, "Impossible type of Value");
  }
}
var init_json_encode = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/json_encode.js"() {
    "use strict";
    init_base64();
    init_util6();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/json_encode.js
function ClientMsg(w10, msg) {
  w10.stringRaw("type", msg.type);
  if (msg.type === "hello") {
    if (msg.jwt !== void 0) {
      w10.string("jwt", msg.jwt);
    }
  } else if (msg.type === "request") {
    w10.number("request_id", msg.requestId);
    w10.object("request", msg.request, Request4);
  } else {
    throw impossible(msg, "Impossible type of ClientMsg");
  }
}
function Request4(w10, msg) {
  w10.stringRaw("type", msg.type);
  if (msg.type === "open_stream") {
    w10.number("stream_id", msg.streamId);
  } else if (msg.type === "close_stream") {
    w10.number("stream_id", msg.streamId);
  } else if (msg.type === "execute") {
    w10.number("stream_id", msg.streamId);
    w10.object("stmt", msg.stmt, Stmt2);
  } else if (msg.type === "batch") {
    w10.number("stream_id", msg.streamId);
    w10.object("batch", msg.batch, Batch2);
  } else if (msg.type === "open_cursor") {
    w10.number("stream_id", msg.streamId);
    w10.number("cursor_id", msg.cursorId);
    w10.object("batch", msg.batch, Batch2);
  } else if (msg.type === "close_cursor") {
    w10.number("cursor_id", msg.cursorId);
  } else if (msg.type === "fetch_cursor") {
    w10.number("cursor_id", msg.cursorId);
    w10.number("max_count", msg.maxCount);
  } else if (msg.type === "sequence") {
    w10.number("stream_id", msg.streamId);
    if (msg.sql !== void 0) {
      w10.string("sql", msg.sql);
    }
    if (msg.sqlId !== void 0) {
      w10.number("sql_id", msg.sqlId);
    }
  } else if (msg.type === "describe") {
    w10.number("stream_id", msg.streamId);
    if (msg.sql !== void 0) {
      w10.string("sql", msg.sql);
    }
    if (msg.sqlId !== void 0) {
      w10.number("sql_id", msg.sqlId);
    }
  } else if (msg.type === "store_sql") {
    w10.number("sql_id", msg.sqlId);
    w10.string("sql", msg.sql);
  } else if (msg.type === "close_sql") {
    w10.number("sql_id", msg.sqlId);
  } else if (msg.type === "get_autocommit") {
    w10.number("stream_id", msg.streamId);
  } else {
    throw impossible(msg, "Impossible type of Request");
  }
}
var init_json_encode2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/json_encode.js"() {
    "use strict";
    init_json_encode();
    init_util6();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/protobuf_encode.js
function Stmt3(w10, msg) {
  if (msg.sql !== void 0) {
    w10.string(1, msg.sql);
  }
  if (msg.sqlId !== void 0) {
    w10.int32(2, msg.sqlId);
  }
  for (const arg of msg.args) {
    w10.message(3, arg, Value3);
  }
  for (const arg of msg.namedArgs) {
    w10.message(4, arg, NamedArg2);
  }
  w10.bool(5, msg.wantRows);
}
function NamedArg2(w10, msg) {
  w10.string(1, msg.name);
  w10.message(2, msg.value, Value3);
}
function Batch3(w10, msg) {
  for (const step of msg.steps) {
    w10.message(1, step, BatchStep3);
  }
}
function BatchStep3(w10, msg) {
  if (msg.condition !== void 0) {
    w10.message(1, msg.condition, BatchCond3);
  }
  w10.message(2, msg.stmt, Stmt3);
}
function BatchCond3(w10, msg) {
  if (msg.type === "ok") {
    w10.uint32(1, msg.step);
  } else if (msg.type === "error") {
    w10.uint32(2, msg.step);
  } else if (msg.type === "not") {
    w10.message(3, msg.cond, BatchCond3);
  } else if (msg.type === "and") {
    w10.message(4, msg.conds, BatchCondList);
  } else if (msg.type === "or") {
    w10.message(5, msg.conds, BatchCondList);
  } else if (msg.type === "is_autocommit") {
    w10.message(6, void 0, Empty);
  } else {
    throw impossible(msg, "Impossible type of BatchCond");
  }
}
function BatchCondList(w10, msg) {
  for (const cond of msg) {
    w10.message(1, cond, BatchCond3);
  }
}
function Value3(w10, msg) {
  if (msg === null) {
    w10.message(1, void 0, Empty);
  } else if (typeof msg === "bigint") {
    w10.sint64(2, msg);
  } else if (typeof msg === "number") {
    w10.double(3, msg);
  } else if (typeof msg === "string") {
    w10.string(4, msg);
  } else if (msg instanceof Uint8Array) {
    w10.bytes(5, msg);
  } else if (msg === void 0) {
  } else {
    throw impossible(msg, "Impossible type of Value");
  }
}
function Empty(_w, _msg) {
}
var init_protobuf_encode = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/protobuf_encode.js"() {
    "use strict";
    init_util6();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/protobuf_encode.js
function ClientMsg2(w10, msg) {
  if (msg.type === "hello") {
    w10.message(1, msg, HelloMsg);
  } else if (msg.type === "request") {
    w10.message(2, msg, RequestMsg);
  } else {
    throw impossible(msg, "Impossible type of ClientMsg");
  }
}
function HelloMsg(w10, msg) {
  if (msg.jwt !== void 0) {
    w10.string(1, msg.jwt);
  }
}
function RequestMsg(w10, msg) {
  w10.int32(1, msg.requestId);
  const request2 = msg.request;
  if (request2.type === "open_stream") {
    w10.message(2, request2, OpenStreamReq);
  } else if (request2.type === "close_stream") {
    w10.message(3, request2, CloseStreamReq);
  } else if (request2.type === "execute") {
    w10.message(4, request2, ExecuteReq);
  } else if (request2.type === "batch") {
    w10.message(5, request2, BatchReq);
  } else if (request2.type === "open_cursor") {
    w10.message(6, request2, OpenCursorReq);
  } else if (request2.type === "close_cursor") {
    w10.message(7, request2, CloseCursorReq);
  } else if (request2.type === "fetch_cursor") {
    w10.message(8, request2, FetchCursorReq);
  } else if (request2.type === "sequence") {
    w10.message(9, request2, SequenceReq);
  } else if (request2.type === "describe") {
    w10.message(10, request2, DescribeReq);
  } else if (request2.type === "store_sql") {
    w10.message(11, request2, StoreSqlReq);
  } else if (request2.type === "close_sql") {
    w10.message(12, request2, CloseSqlReq);
  } else if (request2.type === "get_autocommit") {
    w10.message(13, request2, GetAutocommitReq);
  } else {
    throw impossible(request2, "Impossible type of Request");
  }
}
function OpenStreamReq(w10, msg) {
  w10.int32(1, msg.streamId);
}
function CloseStreamReq(w10, msg) {
  w10.int32(1, msg.streamId);
}
function ExecuteReq(w10, msg) {
  w10.int32(1, msg.streamId);
  w10.message(2, msg.stmt, Stmt3);
}
function BatchReq(w10, msg) {
  w10.int32(1, msg.streamId);
  w10.message(2, msg.batch, Batch3);
}
function OpenCursorReq(w10, msg) {
  w10.int32(1, msg.streamId);
  w10.int32(2, msg.cursorId);
  w10.message(3, msg.batch, Batch3);
}
function CloseCursorReq(w10, msg) {
  w10.int32(1, msg.cursorId);
}
function FetchCursorReq(w10, msg) {
  w10.int32(1, msg.cursorId);
  w10.uint32(2, msg.maxCount);
}
function SequenceReq(w10, msg) {
  w10.int32(1, msg.streamId);
  if (msg.sql !== void 0) {
    w10.string(2, msg.sql);
  }
  if (msg.sqlId !== void 0) {
    w10.int32(3, msg.sqlId);
  }
}
function DescribeReq(w10, msg) {
  w10.int32(1, msg.streamId);
  if (msg.sql !== void 0) {
    w10.string(2, msg.sql);
  }
  if (msg.sqlId !== void 0) {
    w10.int32(3, msg.sqlId);
  }
}
function StoreSqlReq(w10, msg) {
  w10.int32(1, msg.sqlId);
  w10.string(2, msg.sql);
}
function CloseSqlReq(w10, msg) {
  w10.int32(1, msg.sqlId);
}
function GetAutocommitReq(w10, msg) {
  w10.int32(1, msg.streamId);
}
var init_protobuf_encode2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/protobuf_encode.js"() {
    "use strict";
    init_protobuf_encode();
    init_util6();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/json_decode.js
function Error2(obj) {
  const message = string(obj["message"]);
  const code = stringOpt(obj["code"]);
  return { message, code };
}
function StmtResult(obj) {
  const cols = arrayObjectsMap(obj["cols"], Col);
  const rows = array2(obj["rows"]).map((rowObj) => arrayObjectsMap(rowObj, Value4));
  const affectedRowCount = number(obj["affected_row_count"]);
  const lastInsertRowidStr = stringOpt(obj["last_insert_rowid"]);
  const lastInsertRowid = lastInsertRowidStr !== void 0 ? BigInt(lastInsertRowidStr) : void 0;
  return { cols, rows, affectedRowCount, lastInsertRowid };
}
function Col(obj) {
  const name3 = stringOpt(obj["name"]);
  const decltype = stringOpt(obj["decltype"]);
  return { name: name3, decltype };
}
function BatchResult(obj) {
  const stepResults = /* @__PURE__ */ new Map();
  array2(obj["step_results"]).forEach((value, i8) => {
    if (value !== null) {
      stepResults.set(i8, StmtResult(object(value)));
    }
  });
  const stepErrors = /* @__PURE__ */ new Map();
  array2(obj["step_errors"]).forEach((value, i8) => {
    if (value !== null) {
      stepErrors.set(i8, Error2(object(value)));
    }
  });
  return { stepResults, stepErrors };
}
function CursorEntry(obj) {
  const type = string(obj["type"]);
  if (type === "step_begin") {
    const step = number(obj["step"]);
    const cols = arrayObjectsMap(obj["cols"], Col);
    return { type: "step_begin", step, cols };
  } else if (type === "step_end") {
    const affectedRowCount = number(obj["affected_row_count"]);
    const lastInsertRowidStr = stringOpt(obj["last_insert_rowid"]);
    const lastInsertRowid = lastInsertRowidStr !== void 0 ? BigInt(lastInsertRowidStr) : void 0;
    return { type: "step_end", affectedRowCount, lastInsertRowid };
  } else if (type === "step_error") {
    const step = number(obj["step"]);
    const error2 = Error2(object(obj["error"]));
    return { type: "step_error", step, error: error2 };
  } else if (type === "row") {
    const row = arrayObjectsMap(obj["row"], Value4);
    return { type: "row", row };
  } else if (type === "error") {
    const error2 = Error2(object(obj["error"]));
    return { type: "error", error: error2 };
  } else {
    throw new ProtoError("Unexpected type of CursorEntry");
  }
}
function DescribeResult(obj) {
  const params = arrayObjectsMap(obj["params"], DescribeParam);
  const cols = arrayObjectsMap(obj["cols"], DescribeCol);
  const isExplain = boolean4(obj["is_explain"]);
  const isReadonly = boolean4(obj["is_readonly"]);
  return { params, cols, isExplain, isReadonly };
}
function DescribeParam(obj) {
  const name3 = stringOpt(obj["name"]);
  return { name: name3 };
}
function DescribeCol(obj) {
  const name3 = string(obj["name"]);
  const decltype = stringOpt(obj["decltype"]);
  return { name: name3, decltype };
}
function Value4(obj) {
  const type = string(obj["type"]);
  if (type === "null") {
    return null;
  } else if (type === "integer") {
    const value = string(obj["value"]);
    return BigInt(value);
  } else if (type === "float") {
    return number(obj["value"]);
  } else if (type === "text") {
    return string(obj["value"]);
  } else if (type === "blob") {
    return gBase64.toUint8Array(string(obj["base64"]));
  } else {
    throw new ProtoError("Unexpected type of Value");
  }
}
var init_json_decode = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/json_decode.js"() {
    "use strict";
    init_base64();
    init_errors4();
    init_decode();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/json_decode.js
function ServerMsg(obj) {
  const type = string(obj["type"]);
  if (type === "hello_ok") {
    return { type: "hello_ok" };
  } else if (type === "hello_error") {
    const error2 = Error2(object(obj["error"]));
    return { type: "hello_error", error: error2 };
  } else if (type === "response_ok") {
    const requestId = number(obj["request_id"]);
    const response = Response4(object(obj["response"]));
    return { type: "response_ok", requestId, response };
  } else if (type === "response_error") {
    const requestId = number(obj["request_id"]);
    const error2 = Error2(object(obj["error"]));
    return { type: "response_error", requestId, error: error2 };
  } else {
    throw new ProtoError("Unexpected type of ServerMsg");
  }
}
function Response4(obj) {
  const type = string(obj["type"]);
  if (type === "open_stream") {
    return { type: "open_stream" };
  } else if (type === "close_stream") {
    return { type: "close_stream" };
  } else if (type === "execute") {
    const result = StmtResult(object(obj["result"]));
    return { type: "execute", result };
  } else if (type === "batch") {
    const result = BatchResult(object(obj["result"]));
    return { type: "batch", result };
  } else if (type === "open_cursor") {
    return { type: "open_cursor" };
  } else if (type === "close_cursor") {
    return { type: "close_cursor" };
  } else if (type === "fetch_cursor") {
    const entries = arrayObjectsMap(obj["entries"], CursorEntry);
    const done = boolean4(obj["done"]);
    return { type: "fetch_cursor", entries, done };
  } else if (type === "sequence") {
    return { type: "sequence" };
  } else if (type === "describe") {
    const result = DescribeResult(object(obj["result"]));
    return { type: "describe", result };
  } else if (type === "store_sql") {
    return { type: "store_sql" };
  } else if (type === "close_sql") {
    return { type: "close_sql" };
  } else if (type === "get_autocommit") {
    const isAutocommit = boolean4(obj["is_autocommit"]);
    return { type: "get_autocommit", isAutocommit };
  } else {
    throw new ProtoError("Unexpected type of Response");
  }
}
var init_json_decode2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/json_decode.js"() {
    "use strict";
    init_errors4();
    init_decode();
    init_json_decode();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/protobuf_decode.js
var Error3, StmtResult2, Col2, Row, BatchResult2, BatchResultStepResult, BatchResultStepError, CursorEntry2, StepBeginEntry, StepEndEntry, StepErrorEntry, DescribeResult2, DescribeParam2, DescribeCol2, Value5;
var init_protobuf_decode = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/shared/protobuf_decode.js"() {
    "use strict";
    Error3 = {
      default() {
        return { message: "", code: void 0 };
      },
      1(r6, msg) {
        msg.message = r6.string();
      },
      2(r6, msg) {
        msg.code = r6.string();
      }
    };
    StmtResult2 = {
      default() {
        return {
          cols: [],
          rows: [],
          affectedRowCount: 0,
          lastInsertRowid: void 0
        };
      },
      1(r6, msg) {
        msg.cols.push(r6.message(Col2));
      },
      2(r6, msg) {
        msg.rows.push(r6.message(Row));
      },
      3(r6, msg) {
        msg.affectedRowCount = Number(r6.uint64());
      },
      4(r6, msg) {
        msg.lastInsertRowid = r6.sint64();
      }
    };
    Col2 = {
      default() {
        return { name: void 0, decltype: void 0 };
      },
      1(r6, msg) {
        msg.name = r6.string();
      },
      2(r6, msg) {
        msg.decltype = r6.string();
      }
    };
    Row = {
      default() {
        return [];
      },
      1(r6, msg) {
        msg.push(r6.message(Value5));
      }
    };
    BatchResult2 = {
      default() {
        return { stepResults: /* @__PURE__ */ new Map(), stepErrors: /* @__PURE__ */ new Map() };
      },
      1(r6, msg) {
        const [key, value] = r6.message(BatchResultStepResult);
        msg.stepResults.set(key, value);
      },
      2(r6, msg) {
        const [key, value] = r6.message(BatchResultStepError);
        msg.stepErrors.set(key, value);
      }
    };
    BatchResultStepResult = {
      default() {
        return [0, StmtResult2.default()];
      },
      1(r6, msg) {
        msg[0] = r6.uint32();
      },
      2(r6, msg) {
        msg[1] = r6.message(StmtResult2);
      }
    };
    BatchResultStepError = {
      default() {
        return [0, Error3.default()];
      },
      1(r6, msg) {
        msg[0] = r6.uint32();
      },
      2(r6, msg) {
        msg[1] = r6.message(Error3);
      }
    };
    CursorEntry2 = {
      default() {
        return { type: "none" };
      },
      1(r6) {
        return r6.message(StepBeginEntry);
      },
      2(r6) {
        return r6.message(StepEndEntry);
      },
      3(r6) {
        return r6.message(StepErrorEntry);
      },
      4(r6) {
        return { type: "row", row: r6.message(Row) };
      },
      5(r6) {
        return { type: "error", error: r6.message(Error3) };
      }
    };
    StepBeginEntry = {
      default() {
        return { type: "step_begin", step: 0, cols: [] };
      },
      1(r6, msg) {
        msg.step = r6.uint32();
      },
      2(r6, msg) {
        msg.cols.push(r6.message(Col2));
      }
    };
    StepEndEntry = {
      default() {
        return {
          type: "step_end",
          affectedRowCount: 0,
          lastInsertRowid: void 0
        };
      },
      1(r6, msg) {
        msg.affectedRowCount = r6.uint32();
      },
      2(r6, msg) {
        msg.lastInsertRowid = r6.uint64();
      }
    };
    StepErrorEntry = {
      default() {
        return {
          type: "step_error",
          step: 0,
          error: Error3.default()
        };
      },
      1(r6, msg) {
        msg.step = r6.uint32();
      },
      2(r6, msg) {
        msg.error = r6.message(Error3);
      }
    };
    DescribeResult2 = {
      default() {
        return {
          params: [],
          cols: [],
          isExplain: false,
          isReadonly: false
        };
      },
      1(r6, msg) {
        msg.params.push(r6.message(DescribeParam2));
      },
      2(r6, msg) {
        msg.cols.push(r6.message(DescribeCol2));
      },
      3(r6, msg) {
        msg.isExplain = r6.bool();
      },
      4(r6, msg) {
        msg.isReadonly = r6.bool();
      }
    };
    DescribeParam2 = {
      default() {
        return { name: void 0 };
      },
      1(r6, msg) {
        msg.name = r6.string();
      }
    };
    DescribeCol2 = {
      default() {
        return { name: "", decltype: void 0 };
      },
      1(r6, msg) {
        msg.name = r6.string();
      },
      2(r6, msg) {
        msg.decltype = r6.string();
      }
    };
    Value5 = {
      default() {
        return void 0;
      },
      1(r6) {
        return null;
      },
      2(r6) {
        return r6.sint64();
      },
      3(r6) {
        return r6.double();
      },
      4(r6) {
        return r6.string();
      },
      5(r6) {
        return r6.bytes();
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/protobuf_decode.js
var ServerMsg2, HelloErrorMsg, ResponseErrorMsg, ResponseOkMsg, ExecuteResp, BatchResp, FetchCursorResp, DescribeResp, GetAutocommitResp;
var init_protobuf_decode2 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/protobuf_decode.js"() {
    "use strict";
    init_protobuf_decode();
    ServerMsg2 = {
      default() {
        return { type: "none" };
      },
      1(r6) {
        return { type: "hello_ok" };
      },
      2(r6) {
        return r6.message(HelloErrorMsg);
      },
      3(r6) {
        return r6.message(ResponseOkMsg);
      },
      4(r6) {
        return r6.message(ResponseErrorMsg);
      }
    };
    HelloErrorMsg = {
      default() {
        return { type: "hello_error", error: Error3.default() };
      },
      1(r6, msg) {
        msg.error = r6.message(Error3);
      }
    };
    ResponseErrorMsg = {
      default() {
        return { type: "response_error", requestId: 0, error: Error3.default() };
      },
      1(r6, msg) {
        msg.requestId = r6.int32();
      },
      2(r6, msg) {
        msg.error = r6.message(Error3);
      }
    };
    ResponseOkMsg = {
      default() {
        return {
          type: "response_ok",
          requestId: 0,
          response: { type: "none" }
        };
      },
      1(r6, msg) {
        msg.requestId = r6.int32();
      },
      2(r6, msg) {
        msg.response = { type: "open_stream" };
      },
      3(r6, msg) {
        msg.response = { type: "close_stream" };
      },
      4(r6, msg) {
        msg.response = r6.message(ExecuteResp);
      },
      5(r6, msg) {
        msg.response = r6.message(BatchResp);
      },
      6(r6, msg) {
        msg.response = { type: "open_cursor" };
      },
      7(r6, msg) {
        msg.response = { type: "close_cursor" };
      },
      8(r6, msg) {
        msg.response = r6.message(FetchCursorResp);
      },
      9(r6, msg) {
        msg.response = { type: "sequence" };
      },
      10(r6, msg) {
        msg.response = r6.message(DescribeResp);
      },
      11(r6, msg) {
        msg.response = { type: "store_sql" };
      },
      12(r6, msg) {
        msg.response = { type: "close_sql" };
      },
      13(r6, msg) {
        msg.response = r6.message(GetAutocommitResp);
      }
    };
    ExecuteResp = {
      default() {
        return { type: "execute", result: StmtResult2.default() };
      },
      1(r6, msg) {
        msg.result = r6.message(StmtResult2);
      }
    };
    BatchResp = {
      default() {
        return { type: "batch", result: BatchResult2.default() };
      },
      1(r6, msg) {
        msg.result = r6.message(BatchResult2);
      }
    };
    FetchCursorResp = {
      default() {
        return { type: "fetch_cursor", entries: [], done: false };
      },
      1(r6, msg) {
        msg.entries.push(r6.message(CursorEntry2));
      },
      2(r6, msg) {
        msg.done = r6.bool();
      }
    };
    DescribeResp = {
      default() {
        return { type: "describe", result: DescribeResult2.default() };
      },
      1(r6, msg) {
        msg.result = r6.message(DescribeResult2);
      }
    };
    GetAutocommitResp = {
      default() {
        return { type: "get_autocommit", isAutocommit: false };
      },
      1(r6, msg) {
        msg.isAutocommit = r6.bool();
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/client.js
var subprotocolsV2, subprotocolsV3, _socket2, _openCallbacks, _opened, _closed4, _recvdHello, _subprotocol, _getVersionCalled, _responseMap, _requestIdAlloc, _sqlIdAlloc, _WsClient_instances, send_fn, onSocketOpen_fn, sendToSocket_fn, onSocketError_fn, onSocketClose_fn, setClosed_fn2, onSocketMessage_fn, handleMsg_fn, WsClient;
var init_client5 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/ws/client.js"() {
    "use strict";
    init_client4();
    init_encoding();
    init_errors4();
    init_id_alloc();
    init_result2();
    init_sql3();
    init_util6();
    init_stream3();
    init_json_encode2();
    init_protobuf_encode2();
    init_json_decode2();
    init_protobuf_decode2();
    subprotocolsV2 = /* @__PURE__ */ new Map([
      ["hrana2", { version: 2, encoding: "json" }],
      ["hrana1", { version: 1, encoding: "json" }]
    ]);
    subprotocolsV3 = /* @__PURE__ */ new Map([
      ["hrana3-protobuf", { version: 3, encoding: "protobuf" }],
      ["hrana3", { version: 3, encoding: "json" }],
      ["hrana2", { version: 2, encoding: "json" }],
      ["hrana1", { version: 1, encoding: "json" }]
    ]);
    WsClient = class extends Client4 {
      /** @private */
      constructor(socket, jwt) {
        super();
        __privateAdd(this, _WsClient_instances);
        __privateAdd(this, _socket2);
        // List of callbacks that we queue until the socket transitions from the CONNECTING to the OPEN state.
        __privateAdd(this, _openCallbacks);
        // Have we already transitioned from CONNECTING to OPEN and fired the callbacks in #openCallbacks?
        __privateAdd(this, _opened);
        // Stores the error that caused us to close the client (and the socket). If we are not closed, this is
        // `undefined`.
        __privateAdd(this, _closed4);
        // Have we received a response to our "hello" from the server?
        __privateAdd(this, _recvdHello);
        // Subprotocol negotiated with the server. It is only available after the socket transitions to the OPEN
        // state.
        __privateAdd(this, _subprotocol);
        // Has the `getVersion()` function been called? This is only used to validate that the API is used
        // correctly.
        __privateAdd(this, _getVersionCalled);
        // A map from request id to the responses that we expect to receive from the server.
        __privateAdd(this, _responseMap);
        // An allocator of request ids.
        __privateAdd(this, _requestIdAlloc);
        // An allocator of stream ids.
        /** @private */
        __publicField(this, "_streamIdAlloc");
        // An allocator of cursor ids.
        /** @private */
        __publicField(this, "_cursorIdAlloc");
        // An allocator of SQL text ids.
        __privateAdd(this, _sqlIdAlloc);
        __privateSet(this, _socket2, socket);
        __privateSet(this, _openCallbacks, []);
        __privateSet(this, _opened, false);
        __privateSet(this, _closed4, void 0);
        __privateSet(this, _recvdHello, false);
        __privateSet(this, _subprotocol, void 0);
        __privateSet(this, _getVersionCalled, false);
        __privateSet(this, _responseMap, /* @__PURE__ */ new Map());
        __privateSet(this, _requestIdAlloc, new IdAlloc());
        this._streamIdAlloc = new IdAlloc();
        this._cursorIdAlloc = new IdAlloc();
        __privateSet(this, _sqlIdAlloc, new IdAlloc());
        __privateGet(this, _socket2).binaryType = "arraybuffer";
        __privateGet(this, _socket2).addEventListener("open", () => __privateMethod(this, _WsClient_instances, onSocketOpen_fn).call(this));
        __privateGet(this, _socket2).addEventListener("close", (event) => __privateMethod(this, _WsClient_instances, onSocketClose_fn).call(this, event));
        __privateGet(this, _socket2).addEventListener("error", (event) => __privateMethod(this, _WsClient_instances, onSocketError_fn).call(this, event));
        __privateGet(this, _socket2).addEventListener("message", (event) => __privateMethod(this, _WsClient_instances, onSocketMessage_fn).call(this, event));
        __privateMethod(this, _WsClient_instances, send_fn).call(this, { type: "hello", jwt });
      }
      /** Get the protocol version negotiated with the server, possibly waiting until the socket is open. */
      getVersion() {
        return new Promise((versionCallback, errorCallback) => {
          __privateSet(this, _getVersionCalled, true);
          if (__privateGet(this, _closed4) !== void 0) {
            errorCallback(__privateGet(this, _closed4));
          } else if (!__privateGet(this, _opened)) {
            const openCallback = () => versionCallback(__privateGet(this, _subprotocol).version);
            __privateGet(this, _openCallbacks).push({ openCallback, errorCallback });
          } else {
            versionCallback(__privateGet(this, _subprotocol).version);
          }
        });
      }
      // Make sure that the negotiated version is at least `minVersion`.
      /** @private */
      _ensureVersion(minVersion, feature) {
        if (__privateGet(this, _subprotocol) === void 0 || !__privateGet(this, _getVersionCalled)) {
          throw new ProtocolVersionError(`${feature} is supported only on protocol version ${minVersion} and higher, but the version supported by the WebSocket server is not yet known. Use Client.getVersion() to wait until the version is available.`);
        } else if (__privateGet(this, _subprotocol).version < minVersion) {
          throw new ProtocolVersionError(`${feature} is supported on protocol version ${minVersion} and higher, but the WebSocket server only supports version ${__privateGet(this, _subprotocol).version}`);
        }
      }
      // Send a request to the server and invoke a callback when we get the response.
      /** @private */
      _sendRequest(request2, callbacks) {
        if (__privateGet(this, _closed4) !== void 0) {
          callbacks.errorCallback(new ClosedError("Client is closed", __privateGet(this, _closed4)));
          return;
        }
        const requestId = __privateGet(this, _requestIdAlloc).alloc();
        __privateGet(this, _responseMap).set(requestId, { ...callbacks, type: request2.type });
        __privateMethod(this, _WsClient_instances, send_fn).call(this, { type: "request", requestId, request: request2 });
      }
      /** Open a {@link WsStream}, a stream for executing SQL statements. */
      openStream() {
        return WsStream.open(this);
      }
      /** Cache a SQL text on the server. This requires protocol version 2 or higher. */
      storeSql(sql3) {
        this._ensureVersion(2, "storeSql()");
        const sqlId = __privateGet(this, _sqlIdAlloc).alloc();
        const sqlObj = new Sql(this, sqlId);
        const responseCallback = () => void 0;
        const errorCallback = (e6) => sqlObj._setClosed(e6);
        const request2 = { type: "store_sql", sqlId, sql: sql3 };
        this._sendRequest(request2, { responseCallback, errorCallback });
        return sqlObj;
      }
      /** @private */
      _closeSql(sqlId) {
        if (__privateGet(this, _closed4) !== void 0) {
          return;
        }
        const responseCallback = () => __privateGet(this, _sqlIdAlloc).free(sqlId);
        const errorCallback = (e6) => __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, e6);
        const request2 = { type: "close_sql", sqlId };
        this._sendRequest(request2, { responseCallback, errorCallback });
      }
      /** Close the client and the WebSocket. */
      close() {
        __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, new ClientError("Client was manually closed"));
      }
      /** True if the client is closed. */
      get closed() {
        return __privateGet(this, _closed4) !== void 0;
      }
    };
    _socket2 = new WeakMap();
    _openCallbacks = new WeakMap();
    _opened = new WeakMap();
    _closed4 = new WeakMap();
    _recvdHello = new WeakMap();
    _subprotocol = new WeakMap();
    _getVersionCalled = new WeakMap();
    _responseMap = new WeakMap();
    _requestIdAlloc = new WeakMap();
    _sqlIdAlloc = new WeakMap();
    _WsClient_instances = new WeakSet();
    // Send (or enqueue to send) a message to the server.
    send_fn = function(msg) {
      if (__privateGet(this, _closed4) !== void 0) {
        throw new InternalError("Trying to send a message on a closed client");
      }
      if (__privateGet(this, _opened)) {
        __privateMethod(this, _WsClient_instances, sendToSocket_fn).call(this, msg);
      } else {
        const openCallback = () => __privateMethod(this, _WsClient_instances, sendToSocket_fn).call(this, msg);
        const errorCallback = () => void 0;
        __privateGet(this, _openCallbacks).push({ openCallback, errorCallback });
      }
    };
    // The socket transitioned from CONNECTING to OPEN
    onSocketOpen_fn = function() {
      const protocol2 = __privateGet(this, _socket2).protocol;
      if (protocol2 === void 0) {
        __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, new ClientError("The `WebSocket.protocol` property is undefined. This most likely means that the WebSocket implementation provided by the environment is broken. If you are using Miniflare 2, please update to Miniflare 3, which fixes this problem."));
        return;
      } else if (protocol2 === "") {
        __privateSet(this, _subprotocol, { version: 1, encoding: "json" });
      } else {
        __privateSet(this, _subprotocol, subprotocolsV3.get(protocol2));
        if (__privateGet(this, _subprotocol) === void 0) {
          __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, new ProtoError(`Unrecognized WebSocket subprotocol: ${JSON.stringify(protocol2)}`));
          return;
        }
      }
      for (const callbacks of __privateGet(this, _openCallbacks)) {
        callbacks.openCallback();
      }
      __privateGet(this, _openCallbacks).length = 0;
      __privateSet(this, _opened, true);
    };
    sendToSocket_fn = function(msg) {
      const encoding = __privateGet(this, _subprotocol).encoding;
      if (encoding === "json") {
        const jsonMsg = writeJsonObject(msg, ClientMsg);
        __privateGet(this, _socket2).send(jsonMsg);
      } else if (encoding === "protobuf") {
        const protobufMsg = writeProtobufMessage(msg, ClientMsg2);
        __privateGet(this, _socket2).send(protobufMsg);
      } else {
        throw impossible(encoding, "Impossible encoding");
      }
    };
    // The socket encountered an error.
    onSocketError_fn = function(event) {
      const eventMessage = event.message;
      const message = eventMessage ?? "WebSocket was closed due to an error";
      __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, new WebSocketError(message));
    };
    // The socket was closed.
    onSocketClose_fn = function(event) {
      let message = `WebSocket was closed with code ${event.code}`;
      if (event.reason) {
        message += `: ${event.reason}`;
      }
      __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, new WebSocketError(message));
    };
    // Close the client with the given error.
    setClosed_fn2 = function(error2) {
      if (__privateGet(this, _closed4) !== void 0) {
        return;
      }
      __privateSet(this, _closed4, error2);
      for (const callbacks of __privateGet(this, _openCallbacks)) {
        callbacks.errorCallback(error2);
      }
      __privateGet(this, _openCallbacks).length = 0;
      for (const [requestId, responseState] of __privateGet(this, _responseMap).entries()) {
        responseState.errorCallback(error2);
        __privateGet(this, _requestIdAlloc).free(requestId);
      }
      __privateGet(this, _responseMap).clear();
      __privateGet(this, _socket2).close();
    };
    // We received a message from the socket.
    onSocketMessage_fn = function(event) {
      if (__privateGet(this, _closed4) !== void 0) {
        return;
      }
      try {
        let msg;
        const encoding = __privateGet(this, _subprotocol).encoding;
        if (encoding === "json") {
          if (typeof event.data !== "string") {
            __privateGet(this, _socket2).close(3003, "Only text messages are accepted with JSON encoding");
            __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, new ProtoError("Received non-text message from server with JSON encoding"));
            return;
          }
          msg = readJsonObject(JSON.parse(event.data), ServerMsg);
        } else if (encoding === "protobuf") {
          if (!(event.data instanceof ArrayBuffer)) {
            __privateGet(this, _socket2).close(3003, "Only binary messages are accepted with Protobuf encoding");
            __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, new ProtoError("Received non-binary message from server with Protobuf encoding"));
            return;
          }
          msg = readProtobufMessage(new Uint8Array(event.data), ServerMsg2);
        } else {
          throw impossible(encoding, "Impossible encoding");
        }
        __privateMethod(this, _WsClient_instances, handleMsg_fn).call(this, msg);
      } catch (e6) {
        __privateGet(this, _socket2).close(3007, "Could not handle message");
        __privateMethod(this, _WsClient_instances, setClosed_fn2).call(this, e6);
      }
    };
    // Handle a message from the server.
    handleMsg_fn = function(msg) {
      if (msg.type === "none") {
        throw new ProtoError("Received an unrecognized ServerMsg");
      } else if (msg.type === "hello_ok" || msg.type === "hello_error") {
        if (__privateGet(this, _recvdHello)) {
          throw new ProtoError("Received a duplicated hello response");
        }
        __privateSet(this, _recvdHello, true);
        if (msg.type === "hello_error") {
          throw errorFromProto(msg.error);
        }
        return;
      } else if (!__privateGet(this, _recvdHello)) {
        throw new ProtoError("Received a non-hello message before a hello response");
      }
      if (msg.type === "response_ok") {
        const requestId = msg.requestId;
        const responseState = __privateGet(this, _responseMap).get(requestId);
        __privateGet(this, _responseMap).delete(requestId);
        if (responseState === void 0) {
          throw new ProtoError("Received unexpected OK response");
        }
        __privateGet(this, _requestIdAlloc).free(requestId);
        try {
          if (responseState.type !== msg.response.type) {
            console.dir({ responseState, msg });
            throw new ProtoError("Received unexpected type of response");
          }
          responseState.responseCallback(msg.response);
        } catch (e6) {
          responseState.errorCallback(e6);
          throw e6;
        }
      } else if (msg.type === "response_error") {
        const requestId = msg.requestId;
        const responseState = __privateGet(this, _responseMap).get(requestId);
        __privateGet(this, _responseMap).delete(requestId);
        if (responseState === void 0) {
          throw new ProtoError("Received unexpected error response");
        }
        __privateGet(this, _requestIdAlloc).free(requestId);
        responseState.errorCallback(errorFromProto(msg.error));
      } else {
        throw impossible(msg, "Impossible ServerMsg type");
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+isomorphic-fetch@0.2.5/node_modules/@libsql/isomorphic-fetch/node.js
function agentSelector(parsedUrl) {
  if (parsedUrl.protocol === "https:") {
    return httpsAgent;
  } else {
    return httpAgent;
  }
}
function fetchWithAgentSelection(resource, options = {}) {
  return fetch(resource, { agent: agentSelector, ...options });
}
var import_http5, import_https2, _Request, _Headers, httpAgent, httpsAgent;
var init_node4 = __esm({
  "../node_modules/.pnpm/@libsql+isomorphic-fetch@0.2.5/node_modules/@libsql/isomorphic-fetch/node.js"() {
    "use strict";
    import_http5 = __toESM(require("http"), 1);
    import_https2 = __toESM(require("https"), 1);
    _Request = Request;
    _Headers = Headers;
    httpAgent = new import_http5.default.Agent({ keepAlive: true });
    httpsAgent = new import_https2.default.Agent({ keepAlive: true });
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/queue_microtask.js
var _queueMicrotask;
var init_queue_microtask = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/queue_microtask.js"() {
    "use strict";
    if (typeof queueMicrotask !== "undefined") {
      _queueMicrotask = queueMicrotask;
    } else {
      const resolved = Promise.resolve();
      _queueMicrotask = (callback) => {
        resolved.then(callback);
      };
    }
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/byte_queue.js
var _array3, _shiftPos, _pushPos, _ByteQueue_instances, ensurePush_fn, ByteQueue;
var init_byte_queue = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/byte_queue.js"() {
    "use strict";
    ByteQueue = class {
      constructor(initialCap) {
        __privateAdd(this, _ByteQueue_instances);
        __privateAdd(this, _array3);
        __privateAdd(this, _shiftPos);
        __privateAdd(this, _pushPos);
        __privateSet(this, _array3, new Uint8Array(new ArrayBuffer(initialCap)));
        __privateSet(this, _shiftPos, 0);
        __privateSet(this, _pushPos, 0);
      }
      get length() {
        return __privateGet(this, _pushPos) - __privateGet(this, _shiftPos);
      }
      data() {
        return __privateGet(this, _array3).slice(__privateGet(this, _shiftPos), __privateGet(this, _pushPos));
      }
      push(chunk) {
        __privateMethod(this, _ByteQueue_instances, ensurePush_fn).call(this, chunk.byteLength);
        __privateGet(this, _array3).set(chunk, __privateGet(this, _pushPos));
        __privateSet(this, _pushPos, __privateGet(this, _pushPos) + chunk.byteLength);
      }
      shift(length) {
        __privateSet(this, _shiftPos, __privateGet(this, _shiftPos) + length);
      }
    };
    _array3 = new WeakMap();
    _shiftPos = new WeakMap();
    _pushPos = new WeakMap();
    _ByteQueue_instances = new WeakSet();
    ensurePush_fn = function(pushLength) {
      if (__privateGet(this, _pushPos) + pushLength <= __privateGet(this, _array3).byteLength) {
        return;
      }
      const filledLength = __privateGet(this, _pushPos) - __privateGet(this, _shiftPos);
      if (filledLength + pushLength <= __privateGet(this, _array3).byteLength && 2 * __privateGet(this, _pushPos) >= __privateGet(this, _array3).byteLength) {
        __privateGet(this, _array3).copyWithin(0, __privateGet(this, _shiftPos), __privateGet(this, _pushPos));
      } else {
        let newCap = __privateGet(this, _array3).byteLength;
        do {
          newCap *= 2;
        } while (filledLength + pushLength > newCap);
        const newArray = new Uint8Array(new ArrayBuffer(newCap));
        newArray.set(__privateGet(this, _array3).slice(__privateGet(this, _shiftPos), __privateGet(this, _pushPos)), 0);
        __privateSet(this, _array3, newArray);
      }
      __privateSet(this, _pushPos, filledLength);
      __privateSet(this, _shiftPos, 0);
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/json_decode.js
function PipelineRespBody(obj) {
  const baton = stringOpt(obj["baton"]);
  const baseUrl = stringOpt(obj["base_url"]);
  const results = arrayObjectsMap(obj["results"], StreamResult);
  return { baton, baseUrl, results };
}
function StreamResult(obj) {
  const type = string(obj["type"]);
  if (type === "ok") {
    const response = StreamResponse(object(obj["response"]));
    return { type: "ok", response };
  } else if (type === "error") {
    const error2 = Error2(object(obj["error"]));
    return { type: "error", error: error2 };
  } else {
    throw new ProtoError("Unexpected type of StreamResult");
  }
}
function StreamResponse(obj) {
  const type = string(obj["type"]);
  if (type === "close") {
    return { type: "close" };
  } else if (type === "execute") {
    const result = StmtResult(object(obj["result"]));
    return { type: "execute", result };
  } else if (type === "batch") {
    const result = BatchResult(object(obj["result"]));
    return { type: "batch", result };
  } else if (type === "sequence") {
    return { type: "sequence" };
  } else if (type === "describe") {
    const result = DescribeResult(object(obj["result"]));
    return { type: "describe", result };
  } else if (type === "store_sql") {
    return { type: "store_sql" };
  } else if (type === "close_sql") {
    return { type: "close_sql" };
  } else if (type === "get_autocommit") {
    const isAutocommit = boolean4(obj["is_autocommit"]);
    return { type: "get_autocommit", isAutocommit };
  } else {
    throw new ProtoError("Unexpected type of StreamResponse");
  }
}
function CursorRespBody(obj) {
  const baton = stringOpt(obj["baton"]);
  const baseUrl = stringOpt(obj["base_url"]);
  return { baton, baseUrl };
}
var init_json_decode3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/json_decode.js"() {
    "use strict";
    init_errors4();
    init_decode();
    init_json_decode();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/protobuf_decode.js
var PipelineRespBody2, StreamResult2, StreamResponse2, ExecuteStreamResp, BatchStreamResp, DescribeStreamResp, GetAutocommitStreamResp, CursorRespBody2;
var init_protobuf_decode3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/protobuf_decode.js"() {
    "use strict";
    init_protobuf_decode();
    PipelineRespBody2 = {
      default() {
        return { baton: void 0, baseUrl: void 0, results: [] };
      },
      1(r6, msg) {
        msg.baton = r6.string();
      },
      2(r6, msg) {
        msg.baseUrl = r6.string();
      },
      3(r6, msg) {
        msg.results.push(r6.message(StreamResult2));
      }
    };
    StreamResult2 = {
      default() {
        return { type: "none" };
      },
      1(r6) {
        return { type: "ok", response: r6.message(StreamResponse2) };
      },
      2(r6) {
        return { type: "error", error: r6.message(Error3) };
      }
    };
    StreamResponse2 = {
      default() {
        return { type: "none" };
      },
      1(r6) {
        return { type: "close" };
      },
      2(r6) {
        return r6.message(ExecuteStreamResp);
      },
      3(r6) {
        return r6.message(BatchStreamResp);
      },
      4(r6) {
        return { type: "sequence" };
      },
      5(r6) {
        return r6.message(DescribeStreamResp);
      },
      6(r6) {
        return { type: "store_sql" };
      },
      7(r6) {
        return { type: "close_sql" };
      },
      8(r6) {
        return r6.message(GetAutocommitStreamResp);
      }
    };
    ExecuteStreamResp = {
      default() {
        return { type: "execute", result: StmtResult2.default() };
      },
      1(r6, msg) {
        msg.result = r6.message(StmtResult2);
      }
    };
    BatchStreamResp = {
      default() {
        return { type: "batch", result: BatchResult2.default() };
      },
      1(r6, msg) {
        msg.result = r6.message(BatchResult2);
      }
    };
    DescribeStreamResp = {
      default() {
        return { type: "describe", result: DescribeResult2.default() };
      },
      1(r6, msg) {
        msg.result = r6.message(DescribeResult2);
      }
    };
    GetAutocommitStreamResp = {
      default() {
        return { type: "get_autocommit", isAutocommit: false };
      },
      1(r6, msg) {
        msg.isAutocommit = r6.bool();
      }
    };
    CursorRespBody2 = {
      default() {
        return { baton: void 0, baseUrl: void 0 };
      },
      1(r6, msg) {
        msg.baton = r6.string();
      },
      2(r6, msg) {
        msg.baseUrl = r6.string();
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/cursor.js
var _stream2, _encoding, _reader2, _queue2, _closed5, _done2, _HttpCursor_instances, nextItem_fn, parseItemJson_fn, parseItemProtobuf_fn, HttpCursor;
var init_cursor3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/cursor.js"() {
    "use strict";
    init_byte_queue();
    init_cursor();
    init_decode();
    init_decode2();
    init_errors4();
    init_util6();
    init_json_decode3();
    init_protobuf_decode3();
    init_json_decode();
    init_protobuf_decode();
    HttpCursor = class extends Cursor {
      /** @private */
      constructor(stream, encoding) {
        super();
        __privateAdd(this, _HttpCursor_instances);
        __privateAdd(this, _stream2);
        __privateAdd(this, _encoding);
        __privateAdd(this, _reader2);
        __privateAdd(this, _queue2);
        __privateAdd(this, _closed5);
        __privateAdd(this, _done2);
        __privateSet(this, _stream2, stream);
        __privateSet(this, _encoding, encoding);
        __privateSet(this, _reader2, void 0);
        __privateSet(this, _queue2, new ByteQueue(16 * 1024));
        __privateSet(this, _closed5, void 0);
        __privateSet(this, _done2, false);
      }
      async open(response) {
        if (response.body === null) {
          throw new ProtoError("No response body for cursor request");
        }
        __privateSet(this, _reader2, response.body.getReader());
        const respBody = await __privateMethod(this, _HttpCursor_instances, nextItem_fn).call(this, CursorRespBody, CursorRespBody2);
        if (respBody === void 0) {
          throw new ProtoError("Empty response to cursor request");
        }
        return respBody;
      }
      /** Fetch the next entry from the cursor. */
      next() {
        return __privateMethod(this, _HttpCursor_instances, nextItem_fn).call(this, CursorEntry, CursorEntry2);
      }
      /** Close the cursor. */
      close() {
        this._setClosed(new ClientError("Cursor was manually closed"));
      }
      /** @private */
      _setClosed(error2) {
        if (__privateGet(this, _closed5) !== void 0) {
          return;
        }
        __privateSet(this, _closed5, error2);
        __privateGet(this, _stream2)._cursorClosed(this);
        if (__privateGet(this, _reader2) !== void 0) {
          __privateGet(this, _reader2).cancel();
        }
      }
      /** True if the cursor is closed. */
      get closed() {
        return __privateGet(this, _closed5) !== void 0;
      }
    };
    _stream2 = new WeakMap();
    _encoding = new WeakMap();
    _reader2 = new WeakMap();
    _queue2 = new WeakMap();
    _closed5 = new WeakMap();
    _done2 = new WeakMap();
    _HttpCursor_instances = new WeakSet();
    nextItem_fn = async function(jsonFun, protobufDef) {
      for (; ; ) {
        if (__privateGet(this, _done2)) {
          return void 0;
        } else if (__privateGet(this, _closed5) !== void 0) {
          throw new ClosedError("Cursor is closed", __privateGet(this, _closed5));
        }
        if (__privateGet(this, _encoding) === "json") {
          const jsonData = __privateMethod(this, _HttpCursor_instances, parseItemJson_fn).call(this);
          if (jsonData !== void 0) {
            const jsonText = new TextDecoder().decode(jsonData);
            const jsonValue = JSON.parse(jsonText);
            return readJsonObject(jsonValue, jsonFun);
          }
        } else if (__privateGet(this, _encoding) === "protobuf") {
          const protobufData = __privateMethod(this, _HttpCursor_instances, parseItemProtobuf_fn).call(this);
          if (protobufData !== void 0) {
            return readProtobufMessage(protobufData, protobufDef);
          }
        } else {
          throw impossible(__privateGet(this, _encoding), "Impossible encoding");
        }
        if (__privateGet(this, _reader2) === void 0) {
          throw new InternalError("Attempted to read from HTTP cursor before it was opened");
        }
        const { value, done } = await __privateGet(this, _reader2).read();
        if (done && __privateGet(this, _queue2).length === 0) {
          __privateSet(this, _done2, true);
        } else if (done) {
          throw new ProtoError("Unexpected end of cursor stream");
        } else {
          __privateGet(this, _queue2).push(value);
        }
      }
    };
    parseItemJson_fn = function() {
      const data = __privateGet(this, _queue2).data();
      const newlineByte = 10;
      const newlinePos = data.indexOf(newlineByte);
      if (newlinePos < 0) {
        return void 0;
      }
      const jsonData = data.slice(0, newlinePos);
      __privateGet(this, _queue2).shift(newlinePos + 1);
      return jsonData;
    };
    parseItemProtobuf_fn = function() {
      const data = __privateGet(this, _queue2).data();
      let varintValue = 0;
      let varintLength = 0;
      for (; ; ) {
        if (varintLength >= data.byteLength) {
          return void 0;
        }
        const byte = data[varintLength];
        varintValue |= (byte & 127) << 7 * varintLength;
        varintLength += 1;
        if (!(byte & 128)) {
          break;
        }
      }
      if (data.byteLength < varintLength + varintValue) {
        return void 0;
      }
      const protobufData = data.slice(varintLength, varintLength + varintValue);
      __privateGet(this, _queue2).shift(varintLength + varintValue);
      return protobufData;
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/json_encode.js
function PipelineReqBody(w10, msg) {
  if (msg.baton !== void 0) {
    w10.string("baton", msg.baton);
  }
  w10.arrayObjects("requests", msg.requests, StreamRequest);
}
function StreamRequest(w10, msg) {
  w10.stringRaw("type", msg.type);
  if (msg.type === "close") {
  } else if (msg.type === "execute") {
    w10.object("stmt", msg.stmt, Stmt2);
  } else if (msg.type === "batch") {
    w10.object("batch", msg.batch, Batch2);
  } else if (msg.type === "sequence") {
    if (msg.sql !== void 0) {
      w10.string("sql", msg.sql);
    }
    if (msg.sqlId !== void 0) {
      w10.number("sql_id", msg.sqlId);
    }
  } else if (msg.type === "describe") {
    if (msg.sql !== void 0) {
      w10.string("sql", msg.sql);
    }
    if (msg.sqlId !== void 0) {
      w10.number("sql_id", msg.sqlId);
    }
  } else if (msg.type === "store_sql") {
    w10.number("sql_id", msg.sqlId);
    w10.string("sql", msg.sql);
  } else if (msg.type === "close_sql") {
    w10.number("sql_id", msg.sqlId);
  } else if (msg.type === "get_autocommit") {
  } else {
    throw impossible(msg, "Impossible type of StreamRequest");
  }
}
function CursorReqBody(w10, msg) {
  if (msg.baton !== void 0) {
    w10.string("baton", msg.baton);
  }
  w10.object("batch", msg.batch, Batch2);
}
var init_json_encode3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/json_encode.js"() {
    "use strict";
    init_json_encode();
    init_util6();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/protobuf_encode.js
function PipelineReqBody2(w10, msg) {
  if (msg.baton !== void 0) {
    w10.string(1, msg.baton);
  }
  for (const req of msg.requests) {
    w10.message(2, req, StreamRequest2);
  }
}
function StreamRequest2(w10, msg) {
  if (msg.type === "close") {
    w10.message(1, msg, CloseStreamReq2);
  } else if (msg.type === "execute") {
    w10.message(2, msg, ExecuteStreamReq);
  } else if (msg.type === "batch") {
    w10.message(3, msg, BatchStreamReq);
  } else if (msg.type === "sequence") {
    w10.message(4, msg, SequenceStreamReq);
  } else if (msg.type === "describe") {
    w10.message(5, msg, DescribeStreamReq);
  } else if (msg.type === "store_sql") {
    w10.message(6, msg, StoreSqlStreamReq);
  } else if (msg.type === "close_sql") {
    w10.message(7, msg, CloseSqlStreamReq);
  } else if (msg.type === "get_autocommit") {
    w10.message(8, msg, GetAutocommitStreamReq);
  } else {
    throw impossible(msg, "Impossible type of StreamRequest");
  }
}
function CloseStreamReq2(_w, _msg) {
}
function ExecuteStreamReq(w10, msg) {
  w10.message(1, msg.stmt, Stmt3);
}
function BatchStreamReq(w10, msg) {
  w10.message(1, msg.batch, Batch3);
}
function SequenceStreamReq(w10, msg) {
  if (msg.sql !== void 0) {
    w10.string(1, msg.sql);
  }
  if (msg.sqlId !== void 0) {
    w10.int32(2, msg.sqlId);
  }
}
function DescribeStreamReq(w10, msg) {
  if (msg.sql !== void 0) {
    w10.string(1, msg.sql);
  }
  if (msg.sqlId !== void 0) {
    w10.int32(2, msg.sqlId);
  }
}
function StoreSqlStreamReq(w10, msg) {
  w10.int32(1, msg.sqlId);
  w10.string(2, msg.sql);
}
function CloseSqlStreamReq(w10, msg) {
  w10.int32(1, msg.sqlId);
}
function GetAutocommitStreamReq(_w, _msg) {
}
function CursorReqBody2(w10, msg) {
  if (msg.baton !== void 0) {
    w10.string(1, msg.baton);
  }
  w10.message(2, msg.batch, Batch3);
}
var init_protobuf_encode3 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/protobuf_encode.js"() {
    "use strict";
    init_protobuf_encode();
    init_util6();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/stream.js
function handlePipelineResponse(pipeline2, respBody) {
  if (respBody.results.length !== pipeline2.length) {
    throw new ProtoError("Server returned unexpected number of pipeline results");
  }
  for (let i8 = 0; i8 < pipeline2.length; ++i8) {
    const result = respBody.results[i8];
    const entry = pipeline2[i8];
    if (result.type === "ok") {
      if (result.response.type !== entry.request.type) {
        throw new ProtoError("Received unexpected type of response");
      }
      entry.responseCallback(result.response);
    } else if (result.type === "error") {
      entry.errorCallback(errorFromProto(result.error));
    } else if (result.type === "none") {
      throw new ProtoError("Received unrecognized type of StreamResult");
    } else {
      throw impossible(result, "Received impossible type of StreamResult");
    }
  }
}
async function decodePipelineResponse(resp, encoding) {
  if (encoding === "json") {
    const respJson = await resp.json();
    return readJsonObject(respJson, PipelineRespBody);
  } else if (encoding === "protobuf") {
    const respData = await resp.arrayBuffer();
    return readProtobufMessage(new Uint8Array(respData), PipelineRespBody2);
  } else {
    throw impossible(encoding, "Impossible encoding");
  }
}
async function errorFromResponse(resp) {
  const respType = resp.headers.get("content-type") ?? "text/plain";
  if (respType === "application/json") {
    const respBody = await resp.json();
    if ("message" in respBody) {
      return errorFromProto(respBody);
    }
  }
  let message = `Server returned HTTP status ${resp.status}`;
  if (respType === "text/plain") {
    const respBody = (await resp.text()).trim();
    if (respBody !== "") {
      message += `: ${respBody}`;
    }
  }
  return new HttpServerError(message, resp.status);
}
var _client3, _baseUrl, _jwt, _fetch, _baton, _queue3, _flushing, _cursor2, _closing2, _closeQueued, _closed6, _sqlIdAlloc2, _HttpStream_instances, sendStreamRequest_fn2, pushToQueue_fn2, flushQueue_fn2, flushPipeline_fn, flushCursor_fn, flush_fn, createPipelineRequest_fn, createCursorRequest_fn, createRequest_fn, HttpStream;
var init_stream4 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/stream.js"() {
    "use strict";
    init_node4();
    init_errors4();
    init_encoding();
    init_id_alloc();
    init_queue2();
    init_queue_microtask();
    init_result2();
    init_sql3();
    init_stream2();
    init_util6();
    init_cursor3();
    init_json_encode3();
    init_protobuf_encode3();
    init_json_encode3();
    init_protobuf_encode3();
    init_json_decode3();
    init_protobuf_decode3();
    HttpStream = class extends Stream5 {
      /** @private */
      constructor(client, baseUrl, jwt, customFetch) {
        super(client.intMode);
        __privateAdd(this, _HttpStream_instances);
        __privateAdd(this, _client3);
        __privateAdd(this, _baseUrl);
        __privateAdd(this, _jwt);
        __privateAdd(this, _fetch);
        __privateAdd(this, _baton);
        __privateAdd(this, _queue3);
        __privateAdd(this, _flushing);
        __privateAdd(this, _cursor2);
        __privateAdd(this, _closing2);
        __privateAdd(this, _closeQueued);
        __privateAdd(this, _closed6);
        __privateAdd(this, _sqlIdAlloc2);
        __privateSet(this, _client3, client);
        __privateSet(this, _baseUrl, baseUrl.toString());
        __privateSet(this, _jwt, jwt);
        __privateSet(this, _fetch, customFetch);
        __privateSet(this, _baton, void 0);
        __privateSet(this, _queue3, new Queue2());
        __privateSet(this, _flushing, false);
        __privateSet(this, _closing2, false);
        __privateSet(this, _closeQueued, false);
        __privateSet(this, _closed6, void 0);
        __privateSet(this, _sqlIdAlloc2, new IdAlloc());
      }
      /** Get the {@link HttpClient} object that this stream belongs to. */
      client() {
        return __privateGet(this, _client3);
      }
      /** @private */
      _sqlOwner() {
        return this;
      }
      /** Cache a SQL text on the server. */
      storeSql(sql3) {
        const sqlId = __privateGet(this, _sqlIdAlloc2).alloc();
        __privateMethod(this, _HttpStream_instances, sendStreamRequest_fn2).call(this, { type: "store_sql", sqlId, sql: sql3 }).then(() => void 0, (error2) => this._setClosed(error2));
        return new Sql(this, sqlId);
      }
      /** @private */
      _closeSql(sqlId) {
        if (__privateGet(this, _closed6) !== void 0) {
          return;
        }
        __privateMethod(this, _HttpStream_instances, sendStreamRequest_fn2).call(this, { type: "close_sql", sqlId }).then(() => __privateGet(this, _sqlIdAlloc2).free(sqlId), (error2) => this._setClosed(error2));
      }
      /** @private */
      _execute(stmt) {
        return __privateMethod(this, _HttpStream_instances, sendStreamRequest_fn2).call(this, { type: "execute", stmt }).then((response) => {
          return response.result;
        });
      }
      /** @private */
      _batch(batch) {
        return __privateMethod(this, _HttpStream_instances, sendStreamRequest_fn2).call(this, { type: "batch", batch }).then((response) => {
          return response.result;
        });
      }
      /** @private */
      _describe(protoSql) {
        return __privateMethod(this, _HttpStream_instances, sendStreamRequest_fn2).call(this, {
          type: "describe",
          sql: protoSql.sql,
          sqlId: protoSql.sqlId
        }).then((response) => {
          return response.result;
        });
      }
      /** @private */
      _sequence(protoSql) {
        return __privateMethod(this, _HttpStream_instances, sendStreamRequest_fn2).call(this, {
          type: "sequence",
          sql: protoSql.sql,
          sqlId: protoSql.sqlId
        }).then((_response) => {
          return void 0;
        });
      }
      /** Check whether the SQL connection underlying this stream is in autocommit state (i.e., outside of an
       * explicit transaction). This requires protocol version 3 or higher.
       */
      getAutocommit() {
        __privateGet(this, _client3)._ensureVersion(3, "getAutocommit()");
        return __privateMethod(this, _HttpStream_instances, sendStreamRequest_fn2).call(this, {
          type: "get_autocommit"
        }).then((response) => {
          return response.isAutocommit;
        });
      }
      /** @private */
      _openCursor(batch) {
        return new Promise((cursorCallback, errorCallback) => {
          __privateMethod(this, _HttpStream_instances, pushToQueue_fn2).call(this, { type: "cursor", batch, cursorCallback, errorCallback });
        });
      }
      /** @private */
      _cursorClosed(cursor) {
        if (cursor !== __privateGet(this, _cursor2)) {
          throw new InternalError("Cursor was closed, but it was not associated with the stream");
        }
        __privateSet(this, _cursor2, void 0);
        _queueMicrotask(() => __privateMethod(this, _HttpStream_instances, flushQueue_fn2).call(this));
      }
      /** Immediately close the stream. */
      close() {
        this._setClosed(new ClientError("Stream was manually closed"));
      }
      /** Gracefully close the stream. */
      closeGracefully() {
        __privateSet(this, _closing2, true);
        _queueMicrotask(() => __privateMethod(this, _HttpStream_instances, flushQueue_fn2).call(this));
      }
      /** True if the stream is closed. */
      get closed() {
        return __privateGet(this, _closed6) !== void 0 || __privateGet(this, _closing2);
      }
      /** @private */
      _setClosed(error2) {
        if (__privateGet(this, _closed6) !== void 0) {
          return;
        }
        __privateSet(this, _closed6, error2);
        if (__privateGet(this, _cursor2) !== void 0) {
          __privateGet(this, _cursor2)._setClosed(error2);
        }
        __privateGet(this, _client3)._streamClosed(this);
        for (; ; ) {
          const entry = __privateGet(this, _queue3).shift();
          if (entry !== void 0) {
            entry.errorCallback(error2);
          } else {
            break;
          }
        }
        if ((__privateGet(this, _baton) !== void 0 || __privateGet(this, _flushing)) && !__privateGet(this, _closeQueued)) {
          __privateGet(this, _queue3).push({
            type: "pipeline",
            request: { type: "close" },
            responseCallback: () => void 0,
            errorCallback: () => void 0
          });
          __privateSet(this, _closeQueued, true);
          _queueMicrotask(() => __privateMethod(this, _HttpStream_instances, flushQueue_fn2).call(this));
        }
      }
    };
    _client3 = new WeakMap();
    _baseUrl = new WeakMap();
    _jwt = new WeakMap();
    _fetch = new WeakMap();
    _baton = new WeakMap();
    _queue3 = new WeakMap();
    _flushing = new WeakMap();
    _cursor2 = new WeakMap();
    _closing2 = new WeakMap();
    _closeQueued = new WeakMap();
    _closed6 = new WeakMap();
    _sqlIdAlloc2 = new WeakMap();
    _HttpStream_instances = new WeakSet();
    sendStreamRequest_fn2 = function(request2) {
      return new Promise((responseCallback, errorCallback) => {
        __privateMethod(this, _HttpStream_instances, pushToQueue_fn2).call(this, { type: "pipeline", request: request2, responseCallback, errorCallback });
      });
    };
    pushToQueue_fn2 = function(entry) {
      if (__privateGet(this, _closed6) !== void 0) {
        throw new ClosedError("Stream is closed", __privateGet(this, _closed6));
      } else if (__privateGet(this, _closing2)) {
        throw new ClosedError("Stream is closing", void 0);
      } else {
        __privateGet(this, _queue3).push(entry);
        _queueMicrotask(() => __privateMethod(this, _HttpStream_instances, flushQueue_fn2).call(this));
      }
    };
    flushQueue_fn2 = function() {
      if (__privateGet(this, _flushing) || __privateGet(this, _cursor2) !== void 0) {
        return;
      }
      if (__privateGet(this, _closing2) && __privateGet(this, _queue3).length === 0) {
        this._setClosed(new ClientError("Stream was gracefully closed"));
        return;
      }
      const endpoint = __privateGet(this, _client3)._endpoint;
      if (endpoint === void 0) {
        __privateGet(this, _client3)._endpointPromise.then(() => __privateMethod(this, _HttpStream_instances, flushQueue_fn2).call(this), (error2) => this._setClosed(error2));
        return;
      }
      const firstEntry = __privateGet(this, _queue3).shift();
      if (firstEntry === void 0) {
        return;
      } else if (firstEntry.type === "pipeline") {
        const pipeline2 = [firstEntry];
        for (; ; ) {
          const entry = __privateGet(this, _queue3).first();
          if (entry !== void 0 && entry.type === "pipeline") {
            pipeline2.push(entry);
            __privateGet(this, _queue3).shift();
          } else if (entry === void 0 && __privateGet(this, _closing2) && !__privateGet(this, _closeQueued)) {
            pipeline2.push({
              type: "pipeline",
              request: { type: "close" },
              responseCallback: () => void 0,
              errorCallback: () => void 0
            });
            __privateSet(this, _closeQueued, true);
            break;
          } else {
            break;
          }
        }
        __privateMethod(this, _HttpStream_instances, flushPipeline_fn).call(this, endpoint, pipeline2);
      } else if (firstEntry.type === "cursor") {
        __privateMethod(this, _HttpStream_instances, flushCursor_fn).call(this, endpoint, firstEntry);
      } else {
        throw impossible(firstEntry, "Impossible type of QueueEntry");
      }
    };
    flushPipeline_fn = function(endpoint, pipeline2) {
      __privateMethod(this, _HttpStream_instances, flush_fn).call(this, () => __privateMethod(this, _HttpStream_instances, createPipelineRequest_fn).call(this, pipeline2, endpoint), (resp) => decodePipelineResponse(resp, endpoint.encoding), (respBody) => respBody.baton, (respBody) => respBody.baseUrl, (respBody) => handlePipelineResponse(pipeline2, respBody), (error2) => pipeline2.forEach((entry) => entry.errorCallback(error2)));
    };
    flushCursor_fn = function(endpoint, entry) {
      const cursor = new HttpCursor(this, endpoint.encoding);
      __privateSet(this, _cursor2, cursor);
      __privateMethod(this, _HttpStream_instances, flush_fn).call(this, () => __privateMethod(this, _HttpStream_instances, createCursorRequest_fn).call(this, entry, endpoint), (resp) => cursor.open(resp), (respBody) => respBody.baton, (respBody) => respBody.baseUrl, (_respBody) => entry.cursorCallback(cursor), (error2) => entry.errorCallback(error2));
    };
    flush_fn = function(createRequest2, decodeResponse, getBaton, getBaseUrl, handleResponse, handleError) {
      let promise;
      try {
        const request2 = createRequest2();
        const fetch3 = __privateGet(this, _fetch);
        promise = fetch3(request2);
      } catch (error2) {
        promise = Promise.reject(error2);
      }
      __privateSet(this, _flushing, true);
      promise.then((resp) => {
        if (!resp.ok) {
          return errorFromResponse(resp).then((error2) => {
            throw error2;
          });
        }
        return decodeResponse(resp);
      }).then((r6) => {
        __privateSet(this, _baton, getBaton(r6));
        __privateSet(this, _baseUrl, getBaseUrl(r6) ?? __privateGet(this, _baseUrl));
        handleResponse(r6);
      }).catch((error2) => {
        this._setClosed(error2);
        handleError(error2);
      }).finally(() => {
        __privateSet(this, _flushing, false);
        __privateMethod(this, _HttpStream_instances, flushQueue_fn2).call(this);
      });
    };
    createPipelineRequest_fn = function(pipeline2, endpoint) {
      return __privateMethod(this, _HttpStream_instances, createRequest_fn).call(this, new URL(endpoint.pipelinePath, __privateGet(this, _baseUrl)), {
        baton: __privateGet(this, _baton),
        requests: pipeline2.map((entry) => entry.request)
      }, endpoint.encoding, PipelineReqBody, PipelineReqBody2);
    };
    createCursorRequest_fn = function(entry, endpoint) {
      if (endpoint.cursorPath === void 0) {
        throw new ProtocolVersionError(`Cursors are supported only on protocol version 3 and higher, but the HTTP server only supports version ${endpoint.version}.`);
      }
      return __privateMethod(this, _HttpStream_instances, createRequest_fn).call(this, new URL(endpoint.cursorPath, __privateGet(this, _baseUrl)), {
        baton: __privateGet(this, _baton),
        batch: entry.batch
      }, endpoint.encoding, CursorReqBody, CursorReqBody2);
    };
    createRequest_fn = function(url, reqBody, encoding, jsonFun, protobufFun) {
      let bodyData;
      let contentType;
      if (encoding === "json") {
        bodyData = writeJsonObject(reqBody, jsonFun);
        contentType = "application/json";
      } else if (encoding === "protobuf") {
        bodyData = writeProtobufMessage(reqBody, protobufFun);
        contentType = "application/x-protobuf";
      } else {
        throw impossible(encoding, "Impossible encoding");
      }
      const headers = new _Headers();
      headers.set("content-type", contentType);
      if (__privateGet(this, _jwt) !== void 0) {
        headers.set("authorization", `Bearer ${__privateGet(this, _jwt)}`);
      }
      return new _Request(url.toString(), { method: "POST", headers, body: bodyData });
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/client.js
async function findEndpoint(customFetch, clientUrl) {
  const fetch3 = customFetch;
  for (const endpoint of checkEndpoints) {
    const url = new URL(endpoint.versionPath, clientUrl);
    const request2 = new _Request(url.toString(), { method: "GET" });
    const response = await fetch3(request2);
    await response.arrayBuffer();
    if (response.ok) {
      return endpoint;
    }
  }
  return fallbackEndpoint;
}
var checkEndpoints, fallbackEndpoint, _url, _jwt2, _fetch2, _closed7, _streams, _HttpClient_instances, setClosed_fn3, HttpClient;
var init_client6 = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/http/client.js"() {
    "use strict";
    init_node4();
    init_client4();
    init_errors4();
    init_stream4();
    checkEndpoints = [
      {
        versionPath: "v3-protobuf",
        pipelinePath: "v3-protobuf/pipeline",
        cursorPath: "v3-protobuf/cursor",
        version: 3,
        encoding: "protobuf"
      }
      /*
      {
          versionPath: "v3",
          pipelinePath: "v3/pipeline",
          cursorPath: "v3/cursor",
          version: 3,
          encoding: "json",
      },
      */
    ];
    fallbackEndpoint = {
      versionPath: "v2",
      pipelinePath: "v2/pipeline",
      cursorPath: void 0,
      version: 2,
      encoding: "json"
    };
    HttpClient = class extends Client4 {
      /** @private */
      constructor(url, jwt, customFetch, protocolVersion = 2) {
        super();
        __privateAdd(this, _HttpClient_instances);
        __privateAdd(this, _url);
        __privateAdd(this, _jwt2);
        __privateAdd(this, _fetch2);
        __privateAdd(this, _closed7);
        __privateAdd(this, _streams);
        /** @private */
        __publicField(this, "_endpointPromise");
        /** @private */
        __publicField(this, "_endpoint");
        __privateSet(this, _url, url);
        __privateSet(this, _jwt2, jwt);
        __privateSet(this, _fetch2, customFetch ?? fetchWithAgentSelection);
        __privateSet(this, _closed7, void 0);
        __privateSet(this, _streams, /* @__PURE__ */ new Set());
        if (protocolVersion == 3) {
          this._endpointPromise = findEndpoint(__privateGet(this, _fetch2), __privateGet(this, _url));
          this._endpointPromise.then((endpoint) => this._endpoint = endpoint, (error2) => __privateMethod(this, _HttpClient_instances, setClosed_fn3).call(this, error2));
        } else {
          this._endpointPromise = Promise.resolve(fallbackEndpoint);
          this._endpointPromise.then((endpoint) => this._endpoint = endpoint, (error2) => __privateMethod(this, _HttpClient_instances, setClosed_fn3).call(this, error2));
        }
      }
      /** Get the protocol version supported by the server. */
      async getVersion() {
        if (this._endpoint !== void 0) {
          return this._endpoint.version;
        }
        return (await this._endpointPromise).version;
      }
      // Make sure that the negotiated version is at least `minVersion`.
      /** @private */
      _ensureVersion(minVersion, feature) {
        if (minVersion <= fallbackEndpoint.version) {
          return;
        } else if (this._endpoint === void 0) {
          throw new ProtocolVersionError(`${feature} is supported only on protocol version ${minVersion} and higher, but the version supported by the HTTP server is not yet known. Use Client.getVersion() to wait until the version is available.`);
        } else if (this._endpoint.version < minVersion) {
          throw new ProtocolVersionError(`${feature} is supported only on protocol version ${minVersion} and higher, but the HTTP server only supports version ${this._endpoint.version}.`);
        }
      }
      /** Open a {@link HttpStream}, a stream for executing SQL statements. */
      openStream() {
        if (__privateGet(this, _closed7) !== void 0) {
          throw new ClosedError("Client is closed", __privateGet(this, _closed7));
        }
        const stream = new HttpStream(this, __privateGet(this, _url), __privateGet(this, _jwt2), __privateGet(this, _fetch2));
        __privateGet(this, _streams).add(stream);
        return stream;
      }
      /** @private */
      _streamClosed(stream) {
        __privateGet(this, _streams).delete(stream);
      }
      /** Close the client and all its streams. */
      close() {
        __privateMethod(this, _HttpClient_instances, setClosed_fn3).call(this, new ClientError("Client was manually closed"));
      }
      /** True if the client is closed. */
      get closed() {
        return __privateGet(this, _closed7) !== void 0;
      }
    };
    _url = new WeakMap();
    _jwt2 = new WeakMap();
    _fetch2 = new WeakMap();
    _closed7 = new WeakMap();
    _streams = new WeakMap();
    _HttpClient_instances = new WeakSet();
    setClosed_fn3 = function(error2) {
      if (__privateGet(this, _closed7) !== void 0) {
        return;
      }
      __privateSet(this, _closed7, error2);
      for (const stream of Array.from(__privateGet(this, _streams))) {
        stream._setClosed(new ClosedError("Client was closed", error2));
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/libsql_url.js
var init_libsql_url = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/libsql_url.js"() {
    "use strict";
    init_errors4();
  }
});

// ../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/index.js
function openWs(url, jwt, protocolVersion = 2) {
  if (typeof import_websocket.default === "undefined") {
    throw new WebSocketUnsupportedError("WebSockets are not supported in this environment");
  }
  var subprotocols = void 0;
  if (protocolVersion == 3) {
    subprotocols = Array.from(subprotocolsV3.keys());
  } else {
    subprotocols = Array.from(subprotocolsV2.keys());
  }
  const socket = new import_websocket.default(url, subprotocols);
  return new WsClient(socket, jwt);
}
function openHttp(url, jwt, customFetch, protocolVersion = 2) {
  return new HttpClient(url instanceof URL ? url : new URL(url), jwt, customFetch, protocolVersion);
}
var init_lib_esm = __esm({
  "../node_modules/.pnpm/@libsql+hrana-client@0.6.2/node_modules/@libsql/hrana-client/lib-esm/index.js"() {
    "use strict";
    init_node3();
    init_client5();
    init_errors4();
    init_client6();
    init_client5();
    init_node3();
    init_node4();
    init_client4();
    init_errors4();
    init_batch();
    init_libsql_url();
    init_sql3();
    init_stmt();
    init_stream2();
    init_client6();
    init_stream4();
    init_client5();
    init_stream3();
  }
});

// ../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/hrana.js
async function executeHranaBatch(mode, version3, batch, hranaStmts, disableForeignKeys = false) {
  if (disableForeignKeys) {
    batch.step().run("PRAGMA foreign_keys=off");
  }
  const beginStep = batch.step();
  const beginPromise = beginStep.run(transactionModeToBegin(mode));
  let lastStep = beginStep;
  const stmtPromises = hranaStmts.map((hranaStmt) => {
    const stmtStep = batch.step().condition(BatchCond.ok(lastStep));
    if (version3 >= 3) {
      stmtStep.condition(BatchCond.not(BatchCond.isAutocommit(batch)));
    }
    const stmtPromise = stmtStep.query(hranaStmt);
    lastStep = stmtStep;
    return stmtPromise;
  });
  const commitStep = batch.step().condition(BatchCond.ok(lastStep));
  if (version3 >= 3) {
    commitStep.condition(BatchCond.not(BatchCond.isAutocommit(batch)));
  }
  const commitPromise = commitStep.run("COMMIT");
  const rollbackStep = batch.step().condition(BatchCond.not(BatchCond.ok(commitStep)));
  rollbackStep.run("ROLLBACK").catch((_7) => void 0);
  if (disableForeignKeys) {
    batch.step().run("PRAGMA foreign_keys=on");
  }
  await batch.execute();
  const resultSets = [];
  await beginPromise;
  for (const stmtPromise of stmtPromises) {
    const hranaRows = await stmtPromise;
    if (hranaRows === void 0) {
      throw new LibsqlError("Statement in a batch was not executed, probably because the transaction has been rolled back", "TRANSACTION_CLOSED");
    }
    resultSets.push(resultSetFromHrana(hranaRows));
  }
  await commitPromise;
  return resultSets;
}
function stmtToHrana(stmt) {
  if (typeof stmt === "string") {
    return new Stmt(stmt);
  }
  const hranaStmt = new Stmt(stmt.sql);
  if (Array.isArray(stmt.args)) {
    hranaStmt.bindIndexes(stmt.args);
  } else {
    for (const [key, value] of Object.entries(stmt.args)) {
      hranaStmt.bindName(key, value);
    }
  }
  return hranaStmt;
}
function resultSetFromHrana(hranaRows) {
  const columns = hranaRows.columnNames.map((c6) => c6 ?? "");
  const columnTypes = hranaRows.columnDecltypes.map((c6) => c6 ?? "");
  const rows = hranaRows.rows;
  const rowsAffected = hranaRows.affectedRowCount;
  const lastInsertRowid = hranaRows.lastInsertRowid !== void 0 ? hranaRows.lastInsertRowid : void 0;
  return new ResultSetImpl(columns, columnTypes, rows, rowsAffected, lastInsertRowid);
}
function mapHranaError(e6) {
  if (e6 instanceof ClientError) {
    const code = mapHranaErrorCode(e6);
    return new LibsqlError(e6.message, code, void 0, e6);
  }
  return e6;
}
function mapHranaErrorCode(e6) {
  if (e6 instanceof ResponseError && e6.code !== void 0) {
    return e6.code;
  } else if (e6 instanceof ProtoError) {
    return "HRANA_PROTO_ERROR";
  } else if (e6 instanceof ClosedError) {
    return e6.cause instanceof ClientError ? mapHranaErrorCode(e6.cause) : "HRANA_CLOSED_ERROR";
  } else if (e6 instanceof WebSocketError) {
    return "HRANA_WEBSOCKET_ERROR";
  } else if (e6 instanceof HttpServerError) {
    return "SERVER_ERROR";
  } else if (e6 instanceof ProtocolVersionError) {
    return "PROTOCOL_VERSION_ERROR";
  } else if (e6 instanceof InternalError) {
    return "INTERNAL_ERROR";
  } else {
    return "UNKNOWN";
  }
}
var _mode, _version, _started, HranaTransaction;
var init_hrana = __esm({
  "../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/hrana.js"() {
    "use strict";
    init_lib_esm();
    init_api();
    init_util4();
    HranaTransaction = class {
      /** @private */
      constructor(mode, version3) {
        __privateAdd(this, _mode);
        __privateAdd(this, _version);
        // Promise that is resolved when the BEGIN statement completes, or `undefined` if we haven't executed the
        // BEGIN statement yet.
        __privateAdd(this, _started);
        __privateSet(this, _mode, mode);
        __privateSet(this, _version, version3);
        __privateSet(this, _started, void 0);
      }
      execute(stmt) {
        return this.batch([stmt]).then((results) => results[0]);
      }
      async batch(stmts) {
        const stream = this._getStream();
        if (stream.closed) {
          throw new LibsqlError("Cannot execute statements because the transaction is closed", "TRANSACTION_CLOSED");
        }
        try {
          const hranaStmts = stmts.map(stmtToHrana);
          let rowsPromises;
          if (__privateGet(this, _started) === void 0) {
            this._getSqlCache().apply(hranaStmts);
            const batch = stream.batch(__privateGet(this, _version) >= 3);
            const beginStep = batch.step();
            const beginPromise = beginStep.run(transactionModeToBegin(__privateGet(this, _mode)));
            let lastStep = beginStep;
            rowsPromises = hranaStmts.map((hranaStmt) => {
              const stmtStep = batch.step().condition(BatchCond.ok(lastStep));
              if (__privateGet(this, _version) >= 3) {
                stmtStep.condition(BatchCond.not(BatchCond.isAutocommit(batch)));
              }
              const rowsPromise = stmtStep.query(hranaStmt);
              rowsPromise.catch(() => void 0);
              lastStep = stmtStep;
              return rowsPromise;
            });
            __privateSet(this, _started, batch.execute().then(() => beginPromise).then(() => void 0));
            try {
              await __privateGet(this, _started);
            } catch (e6) {
              this.close();
              throw e6;
            }
          } else {
            if (__privateGet(this, _version) < 3) {
              await __privateGet(this, _started);
            } else {
            }
            this._getSqlCache().apply(hranaStmts);
            const batch = stream.batch(__privateGet(this, _version) >= 3);
            let lastStep = void 0;
            rowsPromises = hranaStmts.map((hranaStmt) => {
              const stmtStep = batch.step();
              if (lastStep !== void 0) {
                stmtStep.condition(BatchCond.ok(lastStep));
              }
              if (__privateGet(this, _version) >= 3) {
                stmtStep.condition(BatchCond.not(BatchCond.isAutocommit(batch)));
              }
              const rowsPromise = stmtStep.query(hranaStmt);
              rowsPromise.catch(() => void 0);
              lastStep = stmtStep;
              return rowsPromise;
            });
            await batch.execute();
          }
          const resultSets = [];
          for (const rowsPromise of rowsPromises) {
            const rows = await rowsPromise;
            if (rows === void 0) {
              throw new LibsqlError("Statement in a transaction was not executed, probably because the transaction has been rolled back", "TRANSACTION_CLOSED");
            }
            resultSets.push(resultSetFromHrana(rows));
          }
          return resultSets;
        } catch (e6) {
          throw mapHranaError(e6);
        }
      }
      async executeMultiple(sql3) {
        const stream = this._getStream();
        if (stream.closed) {
          throw new LibsqlError("Cannot execute statements because the transaction is closed", "TRANSACTION_CLOSED");
        }
        try {
          if (__privateGet(this, _started) === void 0) {
            __privateSet(this, _started, stream.run(transactionModeToBegin(__privateGet(this, _mode))).then(() => void 0));
            try {
              await __privateGet(this, _started);
            } catch (e6) {
              this.close();
              throw e6;
            }
          } else {
            await __privateGet(this, _started);
          }
          await stream.sequence(sql3);
        } catch (e6) {
          throw mapHranaError(e6);
        }
      }
      async rollback() {
        try {
          const stream = this._getStream();
          if (stream.closed) {
            return;
          }
          if (__privateGet(this, _started) !== void 0) {
          } else {
            return;
          }
          const promise = stream.run("ROLLBACK").catch((e6) => {
            throw mapHranaError(e6);
          });
          stream.closeGracefully();
          await promise;
        } catch (e6) {
          throw mapHranaError(e6);
        } finally {
          this.close();
        }
      }
      async commit() {
        try {
          const stream = this._getStream();
          if (stream.closed) {
            throw new LibsqlError("Cannot commit the transaction because it is already closed", "TRANSACTION_CLOSED");
          }
          if (__privateGet(this, _started) !== void 0) {
            await __privateGet(this, _started);
          } else {
            return;
          }
          const promise = stream.run("COMMIT").catch((e6) => {
            throw mapHranaError(e6);
          });
          stream.closeGracefully();
          await promise;
        } catch (e6) {
          throw mapHranaError(e6);
        } finally {
          this.close();
        }
      }
    };
    _mode = new WeakMap();
    _version = new WeakMap();
    _started = new WeakMap();
  }
});

// ../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/sql_cache.js
var _owner2, _sqls, SqlCache, _cache, Lru;
var init_sql_cache = __esm({
  "../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/sql_cache.js"() {
    "use strict";
    SqlCache = class {
      constructor(owner, capacity) {
        __privateAdd(this, _owner2);
        __privateAdd(this, _sqls);
        __publicField(this, "capacity");
        __privateSet(this, _owner2, owner);
        __privateSet(this, _sqls, new Lru());
        this.capacity = capacity;
      }
      // Replaces SQL strings with cached `hrana.Sql` objects in the statements in `hranaStmts`. After this
      // function returns, we guarantee that all `hranaStmts` refer to valid (not closed) `hrana.Sql` objects,
      // but _we may invalidate any other `hrana.Sql` objects_ (by closing them, thus removing them from the
      // server).
      //
      // In practice, this means that after calling this function, you can use the statements only up to the
      // first `await`, because concurrent code may also use the cache and invalidate those statements.
      apply(hranaStmts) {
        if (this.capacity <= 0) {
          return;
        }
        const usedSqlObjs = /* @__PURE__ */ new Set();
        for (const hranaStmt of hranaStmts) {
          if (typeof hranaStmt.sql !== "string") {
            continue;
          }
          const sqlText = hranaStmt.sql;
          if (sqlText.length >= 5e3) {
            continue;
          }
          let sqlObj = __privateGet(this, _sqls).get(sqlText);
          if (sqlObj === void 0) {
            while (__privateGet(this, _sqls).size + 1 > this.capacity) {
              const [evictSqlText, evictSqlObj] = __privateGet(this, _sqls).peekLru();
              if (usedSqlObjs.has(evictSqlObj)) {
                break;
              }
              evictSqlObj.close();
              __privateGet(this, _sqls).delete(evictSqlText);
            }
            if (__privateGet(this, _sqls).size + 1 <= this.capacity) {
              sqlObj = __privateGet(this, _owner2).storeSql(sqlText);
              __privateGet(this, _sqls).set(sqlText, sqlObj);
            }
          }
          if (sqlObj !== void 0) {
            hranaStmt.sql = sqlObj;
            usedSqlObjs.add(sqlObj);
          }
        }
      }
    };
    _owner2 = new WeakMap();
    _sqls = new WeakMap();
    Lru = class {
      constructor() {
        // This maps keys to the cache values. The entries are ordered by their last use (entires that were used
        // most recently are at the end).
        __privateAdd(this, _cache);
        __privateSet(this, _cache, /* @__PURE__ */ new Map());
      }
      get(key) {
        const value = __privateGet(this, _cache).get(key);
        if (value !== void 0) {
          __privateGet(this, _cache).delete(key);
          __privateGet(this, _cache).set(key, value);
        }
        return value;
      }
      set(key, value) {
        __privateGet(this, _cache).set(key, value);
      }
      peekLru() {
        for (const entry of __privateGet(this, _cache).entries()) {
          return entry;
        }
        return void 0;
      }
      delete(key) {
        __privateGet(this, _cache).delete(key);
      }
      get size() {
        return __privateGet(this, _cache).size;
      }
    };
    _cache = new WeakMap();
  }
});

// ../node_modules/.pnpm/promise-limit@2.7.0/node_modules/promise-limit/index.js
var require_promise_limit = __commonJS({
  "../node_modules/.pnpm/promise-limit@2.7.0/node_modules/promise-limit/index.js"(exports2, module2) {
    "use strict";
    function limiter(count2) {
      var outstanding = 0;
      var jobs = [];
      function remove() {
        outstanding--;
        if (outstanding < count2) {
          dequeue();
        }
      }
      function dequeue() {
        var job = jobs.shift();
        semaphore.queue = jobs.length;
        if (job) {
          run2(job.fn).then(job.resolve).catch(job.reject);
        }
      }
      function queue(fn3) {
        return new Promise(function(resolve2, reject) {
          jobs.push({ fn: fn3, resolve: resolve2, reject });
          semaphore.queue = jobs.length;
        });
      }
      function run2(fn3) {
        outstanding++;
        try {
          return Promise.resolve(fn3()).then(function(result) {
            remove();
            return result;
          }, function(error2) {
            remove();
            throw error2;
          });
        } catch (err3) {
          remove();
          return Promise.reject(err3);
        }
      }
      var semaphore = function(fn3) {
        if (outstanding >= count2) {
          return queue(fn3);
        } else {
          return run2(fn3);
        }
      };
      return semaphore;
    }
    function map2(items, mapper) {
      var failed = false;
      var limit = this;
      return Promise.all(items.map(function() {
        var args2 = arguments;
        return limit(function() {
          if (!failed) {
            return mapper.apply(void 0, args2).catch(function(e6) {
              failed = true;
              throw e6;
            });
          }
        });
      }));
    }
    function addExtras(fn3) {
      fn3.queue = 0;
      fn3.map = map2;
      return fn3;
    }
    module2.exports = function(count2) {
      if (count2) {
        return addExtras(limiter(count2));
      } else {
        return addExtras(function(fn3) {
          return fn3();
        });
      }
    };
  }
});

// ../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/ws.js
function _createClient2(config) {
  if (config.scheme !== "wss" && config.scheme !== "ws") {
    throw new LibsqlError(`The WebSocket client supports only "libsql:", "wss:" and "ws:" URLs, got ${JSON.stringify(config.scheme + ":")}. For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
  }
  if (config.encryptionKey !== void 0) {
    throw new LibsqlError("Encryption key is not supported by the remote client.", "ENCRYPTION_KEY_NOT_SUPPORTED");
  }
  if (config.scheme === "ws" && config.tls) {
    throw new LibsqlError(`A "ws:" URL cannot opt into TLS by using ?tls=1`, "URL_INVALID");
  } else if (config.scheme === "wss" && !config.tls) {
    throw new LibsqlError(`A "wss:" URL cannot opt out of TLS by using ?tls=0`, "URL_INVALID");
  }
  const url = encodeBaseUrl(config.scheme, config.authority, config.path);
  let client;
  try {
    client = openWs(url, config.authToken);
  } catch (e6) {
    if (e6 instanceof WebSocketUnsupportedError) {
      const suggestedScheme = config.scheme === "wss" ? "https" : "http";
      const suggestedUrl = encodeBaseUrl(suggestedScheme, config.authority, config.path);
      throw new LibsqlError(`This environment does not support WebSockets, please switch to the HTTP client by using a "${suggestedScheme}:" URL (${JSON.stringify(suggestedUrl)}). For more information, please read ${supportedUrlLink}`, "WEBSOCKETS_NOT_SUPPORTED");
    }
    throw mapHranaError(e6);
  }
  return new WsClient2(client, url, config.authToken, config.intMode, config.concurrency);
}
var import_promise_limit, maxConnAgeMillis, sqlCacheCapacity, _url2, _authToken, _intMode3, _connState, _futureConnState, _isSchemaDatabase, _promiseLimitFunction, _WsClient_instances2, openStream_fn, openConn_fn, WsClient2, _client4, _streamState, WsTransaction;
var init_ws = __esm({
  "../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/ws.js"() {
    "use strict";
    init_lib_esm();
    init_api();
    init_config5();
    init_hrana();
    init_sql_cache();
    init_uri2();
    init_util4();
    import_promise_limit = __toESM(require_promise_limit(), 1);
    init_api();
    maxConnAgeMillis = 60 * 1e3;
    sqlCacheCapacity = 100;
    WsClient2 = class {
      /** @private */
      constructor(client, url, authToken, intMode, concurrency) {
        __privateAdd(this, _WsClient_instances2);
        __privateAdd(this, _url2);
        __privateAdd(this, _authToken);
        __privateAdd(this, _intMode3);
        // State of the current connection. The `hrana.WsClient` inside may be closed at any moment due to an
        // asynchronous error.
        __privateAdd(this, _connState);
        // If defined, this is a connection that will be used in the future, once it is ready.
        __privateAdd(this, _futureConnState);
        __publicField(this, "closed");
        __publicField(this, "protocol");
        __privateAdd(this, _isSchemaDatabase);
        __privateAdd(this, _promiseLimitFunction);
        __privateSet(this, _url2, url);
        __privateSet(this, _authToken, authToken);
        __privateSet(this, _intMode3, intMode);
        __privateSet(this, _connState, __privateMethod(this, _WsClient_instances2, openConn_fn).call(this, client));
        __privateSet(this, _futureConnState, void 0);
        this.closed = false;
        this.protocol = "ws";
        __privateSet(this, _promiseLimitFunction, (0, import_promise_limit.default)(concurrency));
      }
      async limit(fn3) {
        return __privateGet(this, _promiseLimitFunction).call(this, fn3);
      }
      async execute(stmtOrSql, args2) {
        let stmt;
        if (typeof stmtOrSql === "string") {
          stmt = {
            sql: stmtOrSql,
            args: args2 || []
          };
        } else {
          stmt = stmtOrSql;
        }
        return this.limit(async () => {
          const streamState = await __privateMethod(this, _WsClient_instances2, openStream_fn).call(this);
          try {
            const hranaStmt = stmtToHrana(stmt);
            streamState.conn.sqlCache.apply([hranaStmt]);
            const hranaRowsPromise = streamState.stream.query(hranaStmt);
            streamState.stream.closeGracefully();
            const hranaRowsResult = await hranaRowsPromise;
            return resultSetFromHrana(hranaRowsResult);
          } catch (e6) {
            throw mapHranaError(e6);
          } finally {
            this._closeStream(streamState);
          }
        });
      }
      async batch(stmts, mode = "deferred") {
        return this.limit(async () => {
          const streamState = await __privateMethod(this, _WsClient_instances2, openStream_fn).call(this);
          try {
            const hranaStmts = stmts.map(stmtToHrana);
            const version3 = await streamState.conn.client.getVersion();
            streamState.conn.sqlCache.apply(hranaStmts);
            const batch = streamState.stream.batch(version3 >= 3);
            const resultsPromise = executeHranaBatch(mode, version3, batch, hranaStmts);
            const results = await resultsPromise;
            return results;
          } catch (e6) {
            throw mapHranaError(e6);
          } finally {
            this._closeStream(streamState);
          }
        });
      }
      async migrate(stmts) {
        return this.limit(async () => {
          const streamState = await __privateMethod(this, _WsClient_instances2, openStream_fn).call(this);
          try {
            const hranaStmts = stmts.map(stmtToHrana);
            const version3 = await streamState.conn.client.getVersion();
            const batch = streamState.stream.batch(version3 >= 3);
            const resultsPromise = executeHranaBatch("deferred", version3, batch, hranaStmts, true);
            const results = await resultsPromise;
            return results;
          } catch (e6) {
            throw mapHranaError(e6);
          } finally {
            this._closeStream(streamState);
          }
        });
      }
      async transaction(mode = "write") {
        return this.limit(async () => {
          const streamState = await __privateMethod(this, _WsClient_instances2, openStream_fn).call(this);
          try {
            const version3 = await streamState.conn.client.getVersion();
            return new WsTransaction(this, streamState, mode, version3);
          } catch (e6) {
            this._closeStream(streamState);
            throw mapHranaError(e6);
          }
        });
      }
      async executeMultiple(sql3) {
        return this.limit(async () => {
          const streamState = await __privateMethod(this, _WsClient_instances2, openStream_fn).call(this);
          try {
            const promise = streamState.stream.sequence(sql3);
            streamState.stream.closeGracefully();
            await promise;
          } catch (e6) {
            throw mapHranaError(e6);
          } finally {
            this._closeStream(streamState);
          }
        });
      }
      sync() {
        throw new LibsqlError("sync not supported in ws mode", "SYNC_NOT_SUPPORTED");
      }
      _closeStream(streamState) {
        streamState.stream.close();
        const connState = streamState.conn;
        connState.streamStates.delete(streamState);
        if (connState.streamStates.size === 0 && connState !== __privateGet(this, _connState)) {
          connState.client.close();
        }
      }
      close() {
        __privateGet(this, _connState).client.close();
        this.closed = true;
      }
    };
    _url2 = new WeakMap();
    _authToken = new WeakMap();
    _intMode3 = new WeakMap();
    _connState = new WeakMap();
    _futureConnState = new WeakMap();
    _isSchemaDatabase = new WeakMap();
    _promiseLimitFunction = new WeakMap();
    _WsClient_instances2 = new WeakSet();
    openStream_fn = async function() {
      if (this.closed) {
        throw new LibsqlError("The client is closed", "CLIENT_CLOSED");
      }
      const now = /* @__PURE__ */ new Date();
      const ageMillis = now.valueOf() - __privateGet(this, _connState).openTime.valueOf();
      if (ageMillis > maxConnAgeMillis && __privateGet(this, _futureConnState) === void 0) {
        const futureConnState = __privateMethod(this, _WsClient_instances2, openConn_fn).call(this);
        __privateSet(this, _futureConnState, futureConnState);
        futureConnState.client.getVersion().then((_version2) => {
          if (__privateGet(this, _connState) !== futureConnState) {
            if (__privateGet(this, _connState).streamStates.size === 0) {
              __privateGet(this, _connState).client.close();
            } else {
            }
          }
          __privateSet(this, _connState, futureConnState);
          __privateSet(this, _futureConnState, void 0);
        }, (_e8) => {
          __privateSet(this, _futureConnState, void 0);
        });
      }
      if (__privateGet(this, _connState).client.closed) {
        try {
          if (__privateGet(this, _futureConnState) !== void 0) {
            __privateSet(this, _connState, __privateGet(this, _futureConnState));
          } else {
            __privateSet(this, _connState, __privateMethod(this, _WsClient_instances2, openConn_fn).call(this));
          }
        } catch (e6) {
          throw mapHranaError(e6);
        }
      }
      const connState = __privateGet(this, _connState);
      try {
        if (connState.useSqlCache === void 0) {
          connState.useSqlCache = await connState.client.getVersion() >= 2;
          if (connState.useSqlCache) {
            connState.sqlCache.capacity = sqlCacheCapacity;
          }
        }
        const stream = connState.client.openStream();
        stream.intMode = __privateGet(this, _intMode3);
        const streamState = { conn: connState, stream };
        connState.streamStates.add(streamState);
        return streamState;
      } catch (e6) {
        throw mapHranaError(e6);
      }
    };
    openConn_fn = function(client) {
      try {
        client ??= openWs(__privateGet(this, _url2), __privateGet(this, _authToken));
        return {
          client,
          useSqlCache: void 0,
          sqlCache: new SqlCache(client, 0),
          openTime: /* @__PURE__ */ new Date(),
          streamStates: /* @__PURE__ */ new Set()
        };
      } catch (e6) {
        throw mapHranaError(e6);
      }
    };
    WsTransaction = class extends HranaTransaction {
      /** @private */
      constructor(client, state2, mode, version3) {
        super(mode, version3);
        __privateAdd(this, _client4);
        __privateAdd(this, _streamState);
        __privateSet(this, _client4, client);
        __privateSet(this, _streamState, state2);
      }
      /** @private */
      _getStream() {
        return __privateGet(this, _streamState).stream;
      }
      /** @private */
      _getSqlCache() {
        return __privateGet(this, _streamState).conn.sqlCache;
      }
      close() {
        __privateGet(this, _client4)._closeStream(__privateGet(this, _streamState));
      }
      get closed() {
        return __privateGet(this, _streamState).stream.closed;
      }
    };
    _client4 = new WeakMap();
    _streamState = new WeakMap();
  }
});

// ../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/http.js
function _createClient3(config) {
  if (config.scheme !== "https" && config.scheme !== "http") {
    throw new LibsqlError(`The HTTP client supports only "libsql:", "https:" and "http:" URLs, got ${JSON.stringify(config.scheme + ":")}. For more information, please read ${supportedUrlLink}`, "URL_SCHEME_NOT_SUPPORTED");
  }
  if (config.encryptionKey !== void 0) {
    throw new LibsqlError("Encryption key is not supported by the remote client.", "ENCRYPTION_KEY_NOT_SUPPORTED");
  }
  if (config.scheme === "http" && config.tls) {
    throw new LibsqlError(`A "http:" URL cannot opt into TLS by using ?tls=1`, "URL_INVALID");
  } else if (config.scheme === "https" && !config.tls) {
    throw new LibsqlError(`A "https:" URL cannot opt out of TLS by using ?tls=0`, "URL_INVALID");
  }
  const url = encodeBaseUrl(config.scheme, config.authority, config.path);
  return new HttpClient2(url, config.authToken, config.intMode, config.fetch, config.concurrency);
}
var import_promise_limit2, sqlCacheCapacity2, _client5, _authToken2, _promiseLimitFunction2, HttpClient2, _stream3, _sqlCache, HttpTransaction;
var init_http2 = __esm({
  "../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/http.js"() {
    "use strict";
    init_lib_esm();
    init_api();
    init_config5();
    init_hrana();
    init_sql_cache();
    init_uri2();
    init_util4();
    import_promise_limit2 = __toESM(require_promise_limit(), 1);
    init_api();
    sqlCacheCapacity2 = 30;
    HttpClient2 = class {
      /** @private */
      constructor(url, authToken, intMode, customFetch, concurrency) {
        __privateAdd(this, _client5);
        __publicField(this, "protocol");
        __privateAdd(this, _authToken2);
        __privateAdd(this, _promiseLimitFunction2);
        __privateSet(this, _client5, openHttp(url, authToken, customFetch));
        __privateGet(this, _client5).intMode = intMode;
        this.protocol = "http";
        __privateSet(this, _authToken2, authToken);
        __privateSet(this, _promiseLimitFunction2, (0, import_promise_limit2.default)(concurrency));
      }
      async limit(fn3) {
        return __privateGet(this, _promiseLimitFunction2).call(this, fn3);
      }
      async execute(stmtOrSql, args2) {
        let stmt;
        if (typeof stmtOrSql === "string") {
          stmt = {
            sql: stmtOrSql,
            args: args2 || []
          };
        } else {
          stmt = stmtOrSql;
        }
        return this.limit(async () => {
          try {
            const hranaStmt = stmtToHrana(stmt);
            let rowsPromise;
            const stream = __privateGet(this, _client5).openStream();
            try {
              rowsPromise = stream.query(hranaStmt);
            } finally {
              stream.closeGracefully();
            }
            const rowsResult = await rowsPromise;
            return resultSetFromHrana(rowsResult);
          } catch (e6) {
            throw mapHranaError(e6);
          }
        });
      }
      async batch(stmts, mode = "deferred") {
        return this.limit(async () => {
          try {
            const hranaStmts = stmts.map(stmtToHrana);
            const version3 = await __privateGet(this, _client5).getVersion();
            let resultsPromise;
            const stream = __privateGet(this, _client5).openStream();
            try {
              const sqlCache = new SqlCache(stream, sqlCacheCapacity2);
              sqlCache.apply(hranaStmts);
              const batch = stream.batch(false);
              resultsPromise = executeHranaBatch(mode, version3, batch, hranaStmts);
            } finally {
              stream.closeGracefully();
            }
            const results = await resultsPromise;
            return results;
          } catch (e6) {
            throw mapHranaError(e6);
          }
        });
      }
      async migrate(stmts) {
        return this.limit(async () => {
          try {
            const hranaStmts = stmts.map(stmtToHrana);
            const version3 = await __privateGet(this, _client5).getVersion();
            let resultsPromise;
            const stream = __privateGet(this, _client5).openStream();
            try {
              const batch = stream.batch(false);
              resultsPromise = executeHranaBatch("deferred", version3, batch, hranaStmts, true);
            } finally {
              stream.closeGracefully();
            }
            const results = await resultsPromise;
            return results;
          } catch (e6) {
            throw mapHranaError(e6);
          }
        });
      }
      async transaction(mode = "write") {
        return this.limit(async () => {
          try {
            const version3 = await __privateGet(this, _client5).getVersion();
            return new HttpTransaction(__privateGet(this, _client5).openStream(), mode, version3);
          } catch (e6) {
            throw mapHranaError(e6);
          }
        });
      }
      async executeMultiple(sql3) {
        return this.limit(async () => {
          try {
            let promise;
            const stream = __privateGet(this, _client5).openStream();
            try {
              promise = stream.sequence(sql3);
            } finally {
              stream.closeGracefully();
            }
            await promise;
          } catch (e6) {
            throw mapHranaError(e6);
          }
        });
      }
      sync() {
        throw new LibsqlError("sync not supported in http mode", "SYNC_NOT_SUPPORTED");
      }
      close() {
        __privateGet(this, _client5).close();
      }
      get closed() {
        return __privateGet(this, _client5).closed;
      }
    };
    _client5 = new WeakMap();
    _authToken2 = new WeakMap();
    _promiseLimitFunction2 = new WeakMap();
    HttpTransaction = class extends HranaTransaction {
      /** @private */
      constructor(stream, mode, version3) {
        super(mode, version3);
        __privateAdd(this, _stream3);
        __privateAdd(this, _sqlCache);
        __privateSet(this, _stream3, stream);
        __privateSet(this, _sqlCache, new SqlCache(stream, sqlCacheCapacity2));
      }
      /** @private */
      _getStream() {
        return __privateGet(this, _stream3);
      }
      /** @private */
      _getSqlCache() {
        return __privateGet(this, _sqlCache);
      }
      close() {
        __privateGet(this, _stream3).close();
      }
      get closed() {
        return __privateGet(this, _stream3).closed;
      }
    };
    _stream3 = new WeakMap();
    _sqlCache = new WeakMap();
  }
});

// ../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/node.js
var node_exports = {};
__export(node_exports, {
  LibsqlError: () => LibsqlError,
  createClient: () => createClient2
});
function createClient2(config) {
  return _createClient4(expandConfig(config, true));
}
function _createClient4(config) {
  if (config.scheme === "wss" || config.scheme === "ws") {
    return _createClient2(config);
  } else if (config.scheme === "https" || config.scheme === "http") {
    return _createClient3(config);
  } else {
    return _createClient(config);
  }
}
var init_node5 = __esm({
  "../node_modules/.pnpm/@libsql+client@0.10.0/node_modules/@libsql/client/lib-esm/node.js"() {
    "use strict";
    init_config5();
    init_sqlite3();
    init_ws();
    init_http2();
    init_api();
  }
});

// ../drizzle-orm/dist/libsql/session.js
function normalizeRow(obj) {
  return Object.keys(obj).reduce((acc, key) => {
    if (Object.prototype.propertyIsEnumerable.call(obj, key)) {
      acc[key] = obj[key];
    }
    return acc;
  }, {});
}
function normalizeFieldValue(value) {
  if (typeof ArrayBuffer !== "undefined" && value instanceof ArrayBuffer) {
    if (typeof Buffer !== "undefined") {
      if (!(value instanceof Buffer)) {
        return Buffer.from(value);
      }
      return value;
    }
    if (typeof TextDecoder !== "undefined") {
      return new TextDecoder().decode(value);
    }
    throw new Error("TextDecoder is not available. Please provide either Buffer or TextDecoder polyfill.");
  }
  return value;
}
var _a498, _b367, _LibSQLSession, LibSQLSession, _a499, _b368, _LibSQLTransaction, LibSQLTransaction, _a500, _b369, LibSQLPreparedQuery;
var init_session15 = __esm({
  "../drizzle-orm/dist/libsql/session.js"() {
    "use strict";
    init_core();
    init_entity();
    init_logger();
    init_sql();
    init_sqlite_core();
    init_session4();
    init_utils();
    _LibSQLSession = class _LibSQLSession extends (_b367 = SQLiteSession, _a498 = entityKind, _b367) {
      constructor(client, dialect6, schema6, options, tx) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.options = options;
        this.tx = tx;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        return new LibSQLPreparedQuery(
          this.client,
          query,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          this.tx,
          executeMethod,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      async batch(queries) {
        const preparedQueries = [];
        const builtQueries = [];
        for (const query of queries) {
          const preparedQuery = query._prepare();
          const builtQuery = preparedQuery.getQuery();
          preparedQueries.push(preparedQuery);
          builtQueries.push({ sql: builtQuery.sql, args: builtQuery.params });
        }
        const batchResults = await this.client.batch(builtQueries);
        return batchResults.map((result, i8) => preparedQueries[i8].mapResult(result, true));
      }
      async migrate(queries) {
        const preparedQueries = [];
        const builtQueries = [];
        for (const query of queries) {
          const preparedQuery = query._prepare();
          const builtQuery = preparedQuery.getQuery();
          preparedQueries.push(preparedQuery);
          builtQueries.push({ sql: builtQuery.sql, args: builtQuery.params });
        }
        const batchResults = await this.client.migrate(builtQueries);
        return batchResults.map((result, i8) => preparedQueries[i8].mapResult(result, true));
      }
      async transaction(transaction, _config) {
        const libsqlTx = await this.client.transaction();
        const session = new _LibSQLSession(
          this.client,
          this.dialect,
          this.schema,
          this.options,
          libsqlTx
        );
        const tx = new LibSQLTransaction("async", this.dialect, session, this.schema);
        try {
          const result = await transaction(tx);
          await libsqlTx.commit();
          return result;
        } catch (err3) {
          await libsqlTx.rollback();
          throw err3;
        }
      }
      extractRawAllValueFromBatchResult(result) {
        return result.rows;
      }
      extractRawGetValueFromBatchResult(result) {
        return result.rows[0];
      }
      extractRawValuesValueFromBatchResult(result) {
        return result.rows;
      }
    };
    __publicField(_LibSQLSession, _a498, "LibSQLSession");
    LibSQLSession = _LibSQLSession;
    _LibSQLTransaction = class _LibSQLTransaction extends (_b368 = SQLiteTransaction, _a499 = entityKind, _b368) {
      async transaction(transaction) {
        const savepointName = `sp${this.nestedIndex}`;
        const tx = new _LibSQLTransaction("async", this.dialect, this.session, this.schema, this.nestedIndex + 1);
        await this.session.run(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = await transaction(tx);
          await this.session.run(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          await this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_LibSQLTransaction, _a499, "LibSQLTransaction");
    LibSQLTransaction = _LibSQLTransaction;
    LibSQLPreparedQuery = class extends (_b369 = SQLitePreparedQuery, _a500 = entityKind, _b369) {
      constructor(client, query, logger2, cache5, queryMetadata, cacheConfig, fields, tx, executeMethod, _isResponseInArrayMode, customResultMapper) {
        super("async", executeMethod, query, cache5, queryMetadata, cacheConfig);
        this.client = client;
        this.logger = logger2;
        this.fields = fields;
        this.tx = tx;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
        this.customResultMapper = customResultMapper;
        this.fields = fields;
      }
      async run(placeholderValues) {
        const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
        this.logger.logQuery(this.query.sql, params);
        return await this.queryWithCache(this.query.sql, params, async () => {
          const stmt = { sql: this.query.sql, args: params };
          return this.tx ? this.tx.execute(stmt) : this.client.execute(stmt);
        });
      }
      async all(placeholderValues) {
        const { fields, logger: logger2, query, tx, client, customResultMapper } = this;
        if (!fields && !customResultMapper) {
          const params = fillPlaceholders(query.params, placeholderValues ?? {});
          logger2.logQuery(query.sql, params);
          return await this.queryWithCache(query.sql, params, async () => {
            const stmt = { sql: query.sql, args: params };
            return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows: rows2 }) => this.mapAllResult(rows2));
          });
        }
        const rows = await this.values(placeholderValues);
        return this.mapAllResult(rows);
      }
      mapAllResult(rows, isFromBatch) {
        if (isFromBatch) {
          rows = rows.rows;
        }
        if (!this.fields && !this.customResultMapper) {
          return rows.map((row) => normalizeRow(row));
        }
        if (this.customResultMapper) {
          return this.customResultMapper(rows, normalizeFieldValue);
        }
        return rows.map((row) => {
          return mapResultRow(
            this.fields,
            Array.prototype.slice.call(row).map((v11) => normalizeFieldValue(v11)),
            this.joinsNotNullableMap
          );
        });
      }
      async get(placeholderValues) {
        const { fields, logger: logger2, query, tx, client, customResultMapper } = this;
        if (!fields && !customResultMapper) {
          const params = fillPlaceholders(query.params, placeholderValues ?? {});
          logger2.logQuery(query.sql, params);
          return await this.queryWithCache(query.sql, params, async () => {
            const stmt = { sql: query.sql, args: params };
            return (tx ? tx.execute(stmt) : client.execute(stmt)).then(({ rows: rows2 }) => this.mapGetResult(rows2));
          });
        }
        const rows = await this.values(placeholderValues);
        return this.mapGetResult(rows);
      }
      mapGetResult(rows, isFromBatch) {
        if (isFromBatch) {
          rows = rows.rows;
        }
        const row = rows[0];
        if (!this.fields && !this.customResultMapper) {
          return normalizeRow(row);
        }
        if (!row) {
          return void 0;
        }
        if (this.customResultMapper) {
          return this.customResultMapper(rows, normalizeFieldValue);
        }
        return mapResultRow(
          this.fields,
          Array.prototype.slice.call(row).map((v11) => normalizeFieldValue(v11)),
          this.joinsNotNullableMap
        );
      }
      async values(placeholderValues) {
        const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
        this.logger.logQuery(this.query.sql, params);
        return await this.queryWithCache(this.query.sql, params, async () => {
          const stmt = { sql: this.query.sql, args: params };
          return (this.tx ? this.tx.execute(stmt) : this.client.execute(stmt)).then(({ rows }) => rows);
        });
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(LibSQLPreparedQuery, _a500, "LibSQLPreparedQuery");
  }
});

// ../drizzle-orm/dist/libsql/driver-core.js
function construct10(client, config = {}) {
  const dialect6 = new SQLiteAsyncDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const session = new LibSQLSession(client, dialect6, schema6, { logger: logger2, cache: config.cache }, void 0);
  const db2 = new LibSQLDatabase("async", dialect6, session, schema6);
  db2.$client = client;
  db2.$cache = config.cache;
  if (db2.$cache) {
    db2.$cache["invalidate"] = config.cache?.onMutate;
  }
  return db2;
}
var _a501, _b370, LibSQLDatabase;
var init_driver_core = __esm({
  "../drizzle-orm/dist/libsql/driver-core.js"() {
    "use strict";
    init_entity();
    init_logger();
    init_relations();
    init_db4();
    init_dialect4();
    init_session15();
    LibSQLDatabase = class extends (_b370 = BaseSQLiteDatabase, _a501 = entityKind, _b370) {
      async batch(batch) {
        return this.session.batch(batch);
      }
    };
    __publicField(LibSQLDatabase, _a501, "LibSQLDatabase");
  }
});

// ../drizzle-orm/dist/libsql/driver.js
function drizzle11(...params) {
  if (typeof params[0] === "string") {
    const instance2 = createClient2({
      url: params[0]
    });
    return construct10(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct10(client, drizzleConfig);
    const instance2 = typeof connection2 === "string" ? createClient2({ url: connection2 }) : createClient2(connection2);
    return construct10(instance2, drizzleConfig);
  }
  return construct10(params[0], params[1]);
}
var init_driver11 = __esm({
  "../drizzle-orm/dist/libsql/driver.js"() {
    "use strict";
    init_node5();
    init_utils();
    init_driver_core();
    init_driver_core();
    ((drizzle22) => {
      function mock(config) {
        return construct10({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle11 || (drizzle11 = {}));
  }
});

// ../drizzle-orm/dist/libsql/index.js
var libsql_exports = {};
__export(libsql_exports, {
  LibSQLDatabase: () => LibSQLDatabase,
  LibSQLPreparedQuery: () => LibSQLPreparedQuery,
  LibSQLSession: () => LibSQLSession,
  LibSQLTransaction: () => LibSQLTransaction,
  drizzle: () => drizzle11
});
var init_libsql2 = __esm({
  "../drizzle-orm/dist/libsql/index.js"() {
    "use strict";
    init_driver11();
    init_session15();
  }
});

// ../drizzle-orm/dist/libsql/migrator.js
var migrator_exports11 = {};
__export(migrator_exports11, {
  migrate: () => migrate11
});
async function migrate11(db2, config) {
  const migrations = readMigrationFiles(config);
  const migrationsTable = config.migrationsTable ?? "__drizzle_migrations";
  const migrationTableCreate = sql`
		CREATE TABLE IF NOT EXISTS ${sql.identifier(migrationsTable)} (
			id SERIAL PRIMARY KEY,
			hash text NOT NULL,
			created_at numeric
		)
	`;
  await db2.session.run(migrationTableCreate);
  const dbMigrations = await db2.values(
    sql`SELECT id, hash, created_at FROM ${sql.identifier(migrationsTable)} ORDER BY created_at DESC LIMIT 1`
  );
  const lastDbMigration = dbMigrations[0] ?? void 0;
  const statementToBatch = [];
  for (const migration of migrations) {
    if (!lastDbMigration || Number(lastDbMigration[2]) < migration.folderMillis) {
      for (const stmt of migration.sql) {
        statementToBatch.push(db2.run(sql.raw(stmt)));
      }
      statementToBatch.push(
        db2.run(
          sql`INSERT INTO ${sql.identifier(migrationsTable)} ("hash", "created_at") VALUES(${migration.hash}, ${migration.folderMillis})`
        )
      );
    }
  }
  await db2.session.migrate(statementToBatch);
}
var init_migrator12 = __esm({
  "../drizzle-orm/dist/libsql/migrator.js"() {
    "use strict";
    init_migrator();
    init_sql();
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js
var require_util4 = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/util.js"(exports2) {
    "use strict";
    exports2.getBooleanOption = (options, key) => {
      let value = false;
      if (key in options && typeof (value = options[key]) !== "boolean") {
        throw new TypeError(`Expected the "${key}" option to be a boolean`);
      }
      return value;
    };
    exports2.cppdb = Symbol();
    exports2.inspect = Symbol.for("nodejs.util.inspect.custom");
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js
var require_sqlite_error2 = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/sqlite-error.js"(exports2, module2) {
    "use strict";
    var descriptor = { value: "SqliteError", writable: true, enumerable: false, configurable: true };
    function SqliteError(message, code) {
      if (new.target !== SqliteError) {
        return new SqliteError(message, code);
      }
      if (typeof code !== "string") {
        throw new TypeError("Expected second argument to be a string");
      }
      Error.call(this, message);
      descriptor.value = "" + message;
      Object.defineProperty(this, "message", descriptor);
      Error.captureStackTrace(this, SqliteError);
      this.code = code;
    }
    Object.setPrototypeOf(SqliteError, Error);
    Object.setPrototypeOf(SqliteError.prototype, Error.prototype);
    Object.defineProperty(SqliteError.prototype, "name", descriptor);
    module2.exports = SqliteError;
  }
});

// ../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js
var require_file_uri_to_path = __commonJS({
  "../node_modules/.pnpm/file-uri-to-path@1.0.0/node_modules/file-uri-to-path/index.js"(exports2, module2) {
    "use strict";
    var sep3 = require("path").sep || "/";
    module2.exports = fileUriToPath;
    function fileUriToPath(uri) {
      if ("string" != typeof uri || uri.length <= 7 || "file://" != uri.substring(0, 7)) {
        throw new TypeError("must pass in a file:// URI to convert to a file path");
      }
      var rest = decodeURI(uri.substring(7));
      var firstSlash = rest.indexOf("/");
      var host = rest.substring(0, firstSlash);
      var path3 = rest.substring(firstSlash + 1);
      if ("localhost" == host) host = "";
      if (host) {
        host = sep3 + sep3 + host;
      }
      path3 = path3.replace(/^(.+)\|/, "$1:");
      if (sep3 == "\\") {
        path3 = path3.replace(/\//g, "\\");
      }
      if (/^.+\:/.test(path3)) {
      } else {
        path3 = sep3 + path3;
      }
      return host + path3;
    }
  }
});

// ../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js
var require_bindings = __commonJS({
  "../node_modules/.pnpm/bindings@1.5.0/node_modules/bindings/bindings.js"(exports2, module2) {
    "use strict";
    var fs9 = require("fs");
    var path3 = require("path");
    var fileURLToPath = require_file_uri_to_path();
    var join7 = path3.join;
    var dirname = path3.dirname;
    var exists2 = fs9.accessSync && function(path4) {
      try {
        fs9.accessSync(path4);
      } catch (e6) {
        return false;
      }
      return true;
    } || fs9.existsSync || path3.existsSync;
    var defaults3 = {
      arrow: process.env.NODE_BINDINGS_ARROW || " \u2192 ",
      compiled: process.env.NODE_BINDINGS_COMPILED_DIR || "compiled",
      platform: process.platform,
      arch: process.arch,
      nodePreGyp: "node-v" + process.versions.modules + "-" + process.platform + "-" + process.arch,
      version: process.versions.node,
      bindings: "bindings.node",
      try: [
        // node-gyp's linked version in the "build" dir
        ["module_root", "build", "bindings"],
        // node-waf and gyp_addon (a.k.a node-gyp)
        ["module_root", "build", "Debug", "bindings"],
        ["module_root", "build", "Release", "bindings"],
        // Debug files, for development (legacy behavior, remove for node v0.9)
        ["module_root", "out", "Debug", "bindings"],
        ["module_root", "Debug", "bindings"],
        // Release files, but manually compiled (legacy behavior, remove for node v0.9)
        ["module_root", "out", "Release", "bindings"],
        ["module_root", "Release", "bindings"],
        // Legacy from node-waf, node <= 0.4.x
        ["module_root", "build", "default", "bindings"],
        // Production "Release" buildtype binary (meh...)
        ["module_root", "compiled", "version", "platform", "arch", "bindings"],
        // node-qbs builds
        ["module_root", "addon-build", "release", "install-root", "bindings"],
        ["module_root", "addon-build", "debug", "install-root", "bindings"],
        ["module_root", "addon-build", "default", "install-root", "bindings"],
        // node-pre-gyp path ./lib/binding/{node_abi}-{platform}-{arch}
        ["module_root", "lib", "binding", "nodePreGyp", "bindings"]
      ]
    };
    function bindings(opts) {
      if (typeof opts == "string") {
        opts = { bindings: opts };
      } else if (!opts) {
        opts = {};
      }
      Object.keys(defaults3).map(function(i9) {
        if (!(i9 in opts)) opts[i9] = defaults3[i9];
      });
      if (!opts.module_root) {
        opts.module_root = exports2.getRoot(exports2.getFileName());
      }
      if (path3.extname(opts.bindings) != ".node") {
        opts.bindings += ".node";
      }
      var requireFunc = typeof __webpack_require__ === "function" ? __non_webpack_require__ : require;
      var tries = [], i8 = 0, l7 = opts.try.length, n7, b9, err3;
      for (; i8 < l7; i8++) {
        n7 = join7.apply(
          null,
          opts.try[i8].map(function(p11) {
            return opts[p11] || p11;
          })
        );
        tries.push(n7);
        try {
          b9 = opts.path ? requireFunc.resolve(n7) : requireFunc(n7);
          if (!opts.path) {
            b9.path = n7;
          }
          return b9;
        } catch (e6) {
          if (e6.code !== "MODULE_NOT_FOUND" && e6.code !== "QUALIFIED_PATH_RESOLUTION_FAILED" && !/not find/i.test(e6.message)) {
            throw e6;
          }
        }
      }
      err3 = new Error(
        "Could not locate the bindings file. Tried:\n" + tries.map(function(a9) {
          return opts.arrow + a9;
        }).join("\n")
      );
      err3.tries = tries;
      throw err3;
    }
    module2.exports = exports2 = bindings;
    exports2.getFileName = function getFileName(calling_file) {
      var origPST = Error.prepareStackTrace, origSTL = Error.stackTraceLimit, dummy = {}, fileName;
      Error.stackTraceLimit = 10;
      Error.prepareStackTrace = function(e6, st2) {
        for (var i8 = 0, l7 = st2.length; i8 < l7; i8++) {
          fileName = st2[i8].getFileName();
          if (fileName !== __filename) {
            if (calling_file) {
              if (fileName !== calling_file) {
                return;
              }
            } else {
              return;
            }
          }
        }
      };
      Error.captureStackTrace(dummy);
      dummy.stack;
      Error.prepareStackTrace = origPST;
      Error.stackTraceLimit = origSTL;
      var fileSchema = "file://";
      if (fileName.indexOf(fileSchema) === 0) {
        fileName = fileURLToPath(fileName);
      }
      return fileName;
    };
    exports2.getRoot = function getRoot(file) {
      var dir = dirname(file), prev;
      while (true) {
        if (dir === ".") {
          dir = process.cwd();
        }
        if (exists2(join7(dir, "package.json")) || exists2(join7(dir, "node_modules"))) {
          return dir;
        }
        if (prev === dir) {
          throw new Error(
            'Could not find module root given file: "' + file + '". Do you have a `package.json` file? '
          );
        }
        prev = dir;
        dir = join7(dir, "..");
      }
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js
var require_wrappers = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/wrappers.js"(exports2) {
    "use strict";
    var { cppdb } = require_util4();
    exports2.prepare = function prepare(sql3) {
      return this[cppdb].prepare(sql3, this, false);
    };
    exports2.exec = function exec3(sql3) {
      this[cppdb].exec(sql3);
      return this;
    };
    exports2.close = function close() {
      this[cppdb].close();
      return this;
    };
    exports2.loadExtension = function loadExtension(...args2) {
      this[cppdb].loadExtension(...args2);
      return this;
    };
    exports2.defaultSafeIntegers = function defaultSafeIntegers(...args2) {
      this[cppdb].defaultSafeIntegers(...args2);
      return this;
    };
    exports2.unsafeMode = function unsafeMode(...args2) {
      this[cppdb].unsafeMode(...args2);
      return this;
    };
    exports2.getters = {
      name: {
        get: function name3() {
          return this[cppdb].name;
        },
        enumerable: true
      },
      open: {
        get: function open() {
          return this[cppdb].open;
        },
        enumerable: true
      },
      inTransaction: {
        get: function inTransaction() {
          return this[cppdb].inTransaction;
        },
        enumerable: true
      },
      readonly: {
        get: function readonly() {
          return this[cppdb].readonly;
        },
        enumerable: true
      },
      memory: {
        get: function memory() {
          return this[cppdb].memory;
        },
        enumerable: true
      }
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js
var require_transaction2 = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/transaction.js"(exports2, module2) {
    "use strict";
    var { cppdb } = require_util4();
    var controllers = /* @__PURE__ */ new WeakMap();
    module2.exports = function transaction(fn3) {
      if (typeof fn3 !== "function") throw new TypeError("Expected first argument to be a function");
      const db2 = this[cppdb];
      const controller = getController(db2, this);
      const { apply } = Function.prototype;
      const properties = {
        default: { value: wrapTransaction(apply, fn3, db2, controller.default) },
        deferred: { value: wrapTransaction(apply, fn3, db2, controller.deferred) },
        immediate: { value: wrapTransaction(apply, fn3, db2, controller.immediate) },
        exclusive: { value: wrapTransaction(apply, fn3, db2, controller.exclusive) },
        database: { value: this, enumerable: true }
      };
      Object.defineProperties(properties.default.value, properties);
      Object.defineProperties(properties.deferred.value, properties);
      Object.defineProperties(properties.immediate.value, properties);
      Object.defineProperties(properties.exclusive.value, properties);
      return properties.default.value;
    };
    var getController = (db2, self2) => {
      let controller = controllers.get(db2);
      if (!controller) {
        const shared = {
          commit: db2.prepare("COMMIT", self2, false),
          rollback: db2.prepare("ROLLBACK", self2, false),
          savepoint: db2.prepare("SAVEPOINT `	_bs3.	`", self2, false),
          release: db2.prepare("RELEASE `	_bs3.	`", self2, false),
          rollbackTo: db2.prepare("ROLLBACK TO `	_bs3.	`", self2, false)
        };
        controllers.set(db2, controller = {
          default: Object.assign({ begin: db2.prepare("BEGIN", self2, false) }, shared),
          deferred: Object.assign({ begin: db2.prepare("BEGIN DEFERRED", self2, false) }, shared),
          immediate: Object.assign({ begin: db2.prepare("BEGIN IMMEDIATE", self2, false) }, shared),
          exclusive: Object.assign({ begin: db2.prepare("BEGIN EXCLUSIVE", self2, false) }, shared)
        });
      }
      return controller;
    };
    var wrapTransaction = (apply, fn3, db2, { begin, commit, rollback, savepoint, release: release2, rollbackTo }) => function sqliteTransaction() {
      let before, after, undo;
      if (db2.inTransaction) {
        before = savepoint;
        after = release2;
        undo = rollbackTo;
      } else {
        before = begin;
        after = commit;
        undo = rollback;
      }
      before.run();
      try {
        const result = apply.call(fn3, this, arguments);
        if (result && typeof result.then === "function") {
          throw new TypeError("Transaction function cannot return a promise");
        }
        after.run();
        return result;
      } catch (ex) {
        if (db2.inTransaction) {
          undo.run();
          if (undo !== rollback) after.run();
        }
        throw ex;
      }
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js
var require_pragma = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/pragma.js"(exports2, module2) {
    "use strict";
    var { getBooleanOption, cppdb } = require_util4();
    module2.exports = function pragma(source, options) {
      if (options == null) options = {};
      if (typeof source !== "string") throw new TypeError("Expected first argument to be a string");
      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
      const simple = getBooleanOption(options, "simple");
      const stmt = this[cppdb].prepare(`PRAGMA ${source}`, this, true);
      return simple ? stmt.pluck().get() : stmt.all();
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js
var require_backup = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/backup.js"(exports2, module2) {
    "use strict";
    var fs9 = require("fs");
    var path3 = require("path");
    var { promisify: promisify3 } = require("util");
    var { cppdb } = require_util4();
    var fsAccess = promisify3(fs9.access);
    module2.exports = async function backup(filename, options) {
      if (options == null) options = {};
      if (typeof filename !== "string") throw new TypeError("Expected first argument to be a string");
      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
      filename = filename.trim();
      const attachedName = "attached" in options ? options.attached : "main";
      const handler = "progress" in options ? options.progress : null;
      if (!filename) throw new TypeError("Backup filename cannot be an empty string");
      if (filename === ":memory:") throw new TypeError('Invalid backup filename ":memory:"');
      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
      if (handler != null && typeof handler !== "function") throw new TypeError('Expected the "progress" option to be a function');
      await fsAccess(path3.dirname(filename)).catch(() => {
        throw new TypeError("Cannot save backup because the directory does not exist");
      });
      const isNewFile = await fsAccess(filename).then(() => false, () => true);
      return runBackup(this[cppdb].backup(this, attachedName, filename, isNewFile), handler || null);
    };
    var runBackup = (backup, handler) => {
      let rate = 0;
      let useDefault = true;
      return new Promise((resolve2, reject) => {
        setImmediate(function step() {
          try {
            const progress = backup.transfer(rate);
            if (!progress.remainingPages) {
              backup.close();
              resolve2(progress);
              return;
            }
            if (useDefault) {
              useDefault = false;
              rate = 100;
            }
            if (handler) {
              const ret = handler(progress);
              if (ret !== void 0) {
                if (typeof ret === "number" && ret === ret) rate = Math.max(0, Math.min(2147483647, Math.round(ret)));
                else throw new TypeError("Expected progress callback to return a number or undefined");
              }
            }
            setImmediate(step);
          } catch (err3) {
            backup.close();
            reject(err3);
          }
        });
      });
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js
var require_serialize = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/serialize.js"(exports2, module2) {
    "use strict";
    var { cppdb } = require_util4();
    module2.exports = function serialize2(options) {
      if (options == null) options = {};
      if (typeof options !== "object") throw new TypeError("Expected first argument to be an options object");
      const attachedName = "attached" in options ? options.attached : "main";
      if (typeof attachedName !== "string") throw new TypeError('Expected the "attached" option to be a string');
      if (!attachedName) throw new TypeError('The "attached" option cannot be an empty string');
      return this[cppdb].serialize(attachedName);
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js
var require_function = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/function.js"(exports2, module2) {
    "use strict";
    var { getBooleanOption, cppdb } = require_util4();
    module2.exports = function defineFunction(name3, options, fn3) {
      if (options == null) options = {};
      if (typeof options === "function") {
        fn3 = options;
        options = {};
      }
      if (typeof name3 !== "string") throw new TypeError("Expected first argument to be a string");
      if (typeof fn3 !== "function") throw new TypeError("Expected last argument to be a function");
      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
      if (!name3) throw new TypeError("User-defined function name cannot be an empty string");
      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
      const deterministic = getBooleanOption(options, "deterministic");
      const directOnly = getBooleanOption(options, "directOnly");
      const varargs = getBooleanOption(options, "varargs");
      let argCount = -1;
      if (!varargs) {
        argCount = fn3.length;
        if (!Number.isInteger(argCount) || argCount < 0) throw new TypeError("Expected function.length to be a positive integer");
        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
      }
      this[cppdb].function(fn3, name3, argCount, safeIntegers, deterministic, directOnly);
      return this;
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js
var require_aggregate = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/aggregate.js"(exports2, module2) {
    "use strict";
    var { getBooleanOption, cppdb } = require_util4();
    module2.exports = function defineAggregate(name3, options) {
      if (typeof name3 !== "string") throw new TypeError("Expected first argument to be a string");
      if (typeof options !== "object" || options === null) throw new TypeError("Expected second argument to be an options object");
      if (!name3) throw new TypeError("User-defined function name cannot be an empty string");
      const start2 = "start" in options ? options.start : null;
      const step = getFunctionOption(options, "step", true);
      const inverse = getFunctionOption(options, "inverse", false);
      const result = getFunctionOption(options, "result", false);
      const safeIntegers = "safeIntegers" in options ? +getBooleanOption(options, "safeIntegers") : 2;
      const deterministic = getBooleanOption(options, "deterministic");
      const directOnly = getBooleanOption(options, "directOnly");
      const varargs = getBooleanOption(options, "varargs");
      let argCount = -1;
      if (!varargs) {
        argCount = Math.max(getLength(step), inverse ? getLength(inverse) : 0);
        if (argCount > 0) argCount -= 1;
        if (argCount > 100) throw new RangeError("User-defined functions cannot have more than 100 arguments");
      }
      this[cppdb].aggregate(start2, step, inverse, result, name3, argCount, safeIntegers, deterministic, directOnly);
      return this;
    };
    var getFunctionOption = (options, key, required) => {
      const value = key in options ? options[key] : null;
      if (typeof value === "function") return value;
      if (value != null) throw new TypeError(`Expected the "${key}" option to be a function`);
      if (required) throw new TypeError(`Missing required option "${key}"`);
      return null;
    };
    var getLength = ({ length }) => {
      if (Number.isInteger(length) && length >= 0) return length;
      throw new TypeError("Expected function.length to be a positive integer");
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js
var require_table = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/table.js"(exports2, module2) {
    "use strict";
    var { cppdb } = require_util4();
    module2.exports = function defineTable(name3, factory) {
      if (typeof name3 !== "string") throw new TypeError("Expected first argument to be a string");
      if (!name3) throw new TypeError("Virtual table module name cannot be an empty string");
      let eponymous = false;
      if (typeof factory === "object" && factory !== null) {
        eponymous = true;
        factory = defer(parseTableDefinition(factory, "used", name3));
      } else {
        if (typeof factory !== "function") throw new TypeError("Expected second argument to be a function or a table definition object");
        factory = wrapFactory(factory);
      }
      this[cppdb].table(factory, name3, eponymous);
      return this;
    };
    function wrapFactory(factory) {
      return function virtualTableFactory(moduleName, databaseName, tableName, ...args2) {
        const thisObject = {
          module: moduleName,
          database: databaseName,
          table: tableName
        };
        const def = apply.call(factory, thisObject, args2);
        if (typeof def !== "object" || def === null) {
          throw new TypeError(`Virtual table module "${moduleName}" did not return a table definition object`);
        }
        return parseTableDefinition(def, "returned", moduleName);
      };
    }
    function parseTableDefinition(def, verb, moduleName) {
      if (!hasOwnProperty.call(def, "rows")) {
        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "rows" property`);
      }
      if (!hasOwnProperty.call(def, "columns")) {
        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition without a "columns" property`);
      }
      const rows = def.rows;
      if (typeof rows !== "function" || Object.getPrototypeOf(rows) !== GeneratorFunctionPrototype) {
        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "rows" property (should be a generator function)`);
      }
      let columns = def.columns;
      if (!Array.isArray(columns) || !(columns = [...columns]).every((x11) => typeof x11 === "string")) {
        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "columns" property (should be an array of strings)`);
      }
      if (columns.length !== new Set(columns).size) {
        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate column names`);
      }
      if (!columns.length) {
        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with zero columns`);
      }
      let parameters;
      if (hasOwnProperty.call(def, "parameters")) {
        parameters = def.parameters;
        if (!Array.isArray(parameters) || !(parameters = [...parameters]).every((x11) => typeof x11 === "string")) {
          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "parameters" property (should be an array of strings)`);
        }
      } else {
        parameters = inferParameters(rows);
      }
      if (parameters.length !== new Set(parameters).size) {
        throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with duplicate parameter names`);
      }
      if (parameters.length > 32) {
        throw new RangeError(`Virtual table module "${moduleName}" ${verb} a table definition with more than the maximum number of 32 parameters`);
      }
      for (const parameter of parameters) {
        if (columns.includes(parameter)) {
          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with column "${parameter}" which was ambiguously defined as both a column and parameter`);
        }
      }
      let safeIntegers = 2;
      if (hasOwnProperty.call(def, "safeIntegers")) {
        const bool = def.safeIntegers;
        if (typeof bool !== "boolean") {
          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "safeIntegers" property (should be a boolean)`);
        }
        safeIntegers = +bool;
      }
      let directOnly = false;
      if (hasOwnProperty.call(def, "directOnly")) {
        directOnly = def.directOnly;
        if (typeof directOnly !== "boolean") {
          throw new TypeError(`Virtual table module "${moduleName}" ${verb} a table definition with an invalid "directOnly" property (should be a boolean)`);
        }
      }
      const columnDefinitions = [
        ...parameters.map(identifier).map((str) => `${str} HIDDEN`),
        ...columns.map(identifier)
      ];
      return [
        `CREATE TABLE x(${columnDefinitions.join(", ")});`,
        wrapGenerator(rows, new Map(columns.map((x11, i8) => [x11, parameters.length + i8])), moduleName),
        parameters,
        safeIntegers,
        directOnly
      ];
    }
    function wrapGenerator(generator, columnMap, moduleName) {
      return function* virtualTable(...args2) {
        const output = args2.map((x11) => Buffer.isBuffer(x11) ? Buffer.from(x11) : x11);
        for (let i8 = 0; i8 < columnMap.size; ++i8) {
          output.push(null);
        }
        for (const row of generator(...args2)) {
          if (Array.isArray(row)) {
            extractRowArray(row, output, columnMap.size, moduleName);
            yield output;
          } else if (typeof row === "object" && row !== null) {
            extractRowObject(row, output, columnMap, moduleName);
            yield output;
          } else {
            throw new TypeError(`Virtual table module "${moduleName}" yielded something that isn't a valid row object`);
          }
        }
      };
    }
    function extractRowArray(row, output, columnCount, moduleName) {
      if (row.length !== columnCount) {
        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an incorrect number of columns`);
      }
      const offset = output.length - columnCount;
      for (let i8 = 0; i8 < columnCount; ++i8) {
        output[i8 + offset] = row[i8];
      }
    }
    function extractRowObject(row, output, columnMap, moduleName) {
      let count2 = 0;
      for (const key of Object.keys(row)) {
        const index7 = columnMap.get(key);
        if (index7 === void 0) {
          throw new TypeError(`Virtual table module "${moduleName}" yielded a row with an undeclared column "${key}"`);
        }
        output[index7] = row[key];
        count2 += 1;
      }
      if (count2 !== columnMap.size) {
        throw new TypeError(`Virtual table module "${moduleName}" yielded a row with missing columns`);
      }
    }
    function inferParameters({ length }) {
      if (!Number.isInteger(length) || length < 0) {
        throw new TypeError("Expected function.length to be a positive integer");
      }
      const params = [];
      for (let i8 = 0; i8 < length; ++i8) {
        params.push(`$${i8 + 1}`);
      }
      return params;
    }
    var { hasOwnProperty } = Object.prototype;
    var { apply } = Function.prototype;
    var GeneratorFunctionPrototype = Object.getPrototypeOf(function* () {
    });
    var identifier = (str) => `"${str.replace(/"/g, '""')}"`;
    var defer = (x11) => () => x11;
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js
var require_inspect = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/methods/inspect.js"(exports2, module2) {
    "use strict";
    var DatabaseInspection = function Database2() {
    };
    module2.exports = function inspect(depth, opts) {
      return Object.assign(new DatabaseInspection(), this);
    };
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js
var require_database = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/database.js"(exports2, module2) {
    "use strict";
    var fs9 = require("fs");
    var path3 = require("path");
    var util2 = require_util4();
    var SqliteError = require_sqlite_error2();
    var DEFAULT_ADDON;
    function Database2(filenameGiven, options) {
      if (new.target == null) {
        return new Database2(filenameGiven, options);
      }
      let buffer2;
      if (Buffer.isBuffer(filenameGiven)) {
        buffer2 = filenameGiven;
        filenameGiven = ":memory:";
      }
      if (filenameGiven == null) filenameGiven = "";
      if (options == null) options = {};
      if (typeof filenameGiven !== "string") throw new TypeError("Expected first argument to be a string");
      if (typeof options !== "object") throw new TypeError("Expected second argument to be an options object");
      if ("readOnly" in options) throw new TypeError('Misspelled option "readOnly" should be "readonly"');
      if ("memory" in options) throw new TypeError('Option "memory" was removed in v7.0.0 (use ":memory:" filename instead)');
      const filename = filenameGiven.trim();
      const anonymous = filename === "" || filename === ":memory:";
      const readonly = util2.getBooleanOption(options, "readonly");
      const fileMustExist = util2.getBooleanOption(options, "fileMustExist");
      const timeout = "timeout" in options ? options.timeout : 5e3;
      const verbose = "verbose" in options ? options.verbose : null;
      const nativeBinding = "nativeBinding" in options ? options.nativeBinding : null;
      if (readonly && anonymous && !buffer2) throw new TypeError("In-memory/temporary databases cannot be readonly");
      if (!Number.isInteger(timeout) || timeout < 0) throw new TypeError('Expected the "timeout" option to be a positive integer');
      if (timeout > 2147483647) throw new RangeError('Option "timeout" cannot be greater than 2147483647');
      if (verbose != null && typeof verbose !== "function") throw new TypeError('Expected the "verbose" option to be a function');
      if (nativeBinding != null && typeof nativeBinding !== "string" && typeof nativeBinding !== "object") throw new TypeError('Expected the "nativeBinding" option to be a string or addon object');
      let addon;
      if (nativeBinding == null) {
        addon = DEFAULT_ADDON || (DEFAULT_ADDON = require_bindings()("better_sqlite3.node"));
      } else if (typeof nativeBinding === "string") {
        const requireFunc = typeof __non_webpack_require__ === "function" ? __non_webpack_require__ : require;
        addon = requireFunc(path3.resolve(nativeBinding).replace(/(\.node)?$/, ".node"));
      } else {
        addon = nativeBinding;
      }
      if (!addon.isInitialized) {
        addon.setErrorConstructor(SqliteError);
        addon.isInitialized = true;
      }
      if (!anonymous && !fs9.existsSync(path3.dirname(filename))) {
        throw new TypeError("Cannot open database because the directory does not exist");
      }
      Object.defineProperties(this, {
        [util2.cppdb]: { value: new addon.Database(filename, filenameGiven, anonymous, readonly, fileMustExist, timeout, verbose || null, buffer2 || null) },
        ...wrappers.getters
      });
    }
    var wrappers = require_wrappers();
    Database2.prototype.prepare = wrappers.prepare;
    Database2.prototype.transaction = require_transaction2();
    Database2.prototype.pragma = require_pragma();
    Database2.prototype.backup = require_backup();
    Database2.prototype.serialize = require_serialize();
    Database2.prototype.function = require_function();
    Database2.prototype.aggregate = require_aggregate();
    Database2.prototype.table = require_table();
    Database2.prototype.loadExtension = wrappers.loadExtension;
    Database2.prototype.exec = wrappers.exec;
    Database2.prototype.close = wrappers.close;
    Database2.prototype.defaultSafeIntegers = wrappers.defaultSafeIntegers;
    Database2.prototype.unsafeMode = wrappers.unsafeMode;
    Database2.prototype[util2.inspect] = require_inspect();
    module2.exports = Database2;
  }
});

// ../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js
var require_lib8 = __commonJS({
  "../node_modules/.pnpm/better-sqlite3@11.10.0/node_modules/better-sqlite3/lib/index.js"(exports2, module2) {
    "use strict";
    module2.exports = require_database();
    module2.exports.SqliteError = require_sqlite_error2();
  }
});

// ../drizzle-orm/dist/better-sqlite3/session.js
var _a502, _b371, BetterSQLiteSession, _a503, _b372, _BetterSQLiteTransaction, BetterSQLiteTransaction, _a504, _b373, PreparedQuery;
var init_session16 = __esm({
  "../drizzle-orm/dist/better-sqlite3/session.js"() {
    "use strict";
    init_core();
    init_entity();
    init_logger();
    init_sql();
    init_sqlite_core();
    init_session4();
    init_utils();
    BetterSQLiteSession = class extends (_b371 = SQLiteSession, _a502 = entityKind, _b371) {
      constructor(client, dialect6, schema6, options = {}) {
        super(dialect6);
        __publicField(this, "logger");
        __publicField(this, "cache");
        this.client = client;
        this.schema = schema6;
        this.logger = options.logger ?? new NoopLogger();
        this.cache = options.cache ?? new NoopCache();
      }
      prepareQuery(query, fields, executeMethod, isResponseInArrayMode, customResultMapper, queryMetadata, cacheConfig) {
        const stmt = this.client.prepare(query.sql);
        return new PreparedQuery(
          stmt,
          query,
          this.logger,
          this.cache,
          queryMetadata,
          cacheConfig,
          fields,
          executeMethod,
          isResponseInArrayMode,
          customResultMapper
        );
      }
      transaction(transaction, config = {}) {
        const tx = new BetterSQLiteTransaction("sync", this.dialect, this, this.schema);
        const nativeTx = this.client.transaction(transaction);
        return nativeTx[config.behavior ?? "deferred"](tx);
      }
    };
    __publicField(BetterSQLiteSession, _a502, "BetterSQLiteSession");
    _BetterSQLiteTransaction = class _BetterSQLiteTransaction extends (_b372 = SQLiteTransaction, _a503 = entityKind, _b372) {
      transaction(transaction) {
        const savepointName = `sp${this.nestedIndex}`;
        const tx = new _BetterSQLiteTransaction("sync", this.dialect, this.session, this.schema, this.nestedIndex + 1);
        this.session.run(sql.raw(`savepoint ${savepointName}`));
        try {
          const result = transaction(tx);
          this.session.run(sql.raw(`release savepoint ${savepointName}`));
          return result;
        } catch (err3) {
          this.session.run(sql.raw(`rollback to savepoint ${savepointName}`));
          throw err3;
        }
      }
    };
    __publicField(_BetterSQLiteTransaction, _a503, "BetterSQLiteTransaction");
    BetterSQLiteTransaction = _BetterSQLiteTransaction;
    PreparedQuery = class extends (_b373 = SQLitePreparedQuery, _a504 = entityKind, _b373) {
      constructor(stmt, query, logger2, cache5, queryMetadata, cacheConfig, fields, executeMethod, _isResponseInArrayMode, customResultMapper) {
        super("sync", executeMethod, query, cache5, queryMetadata, cacheConfig);
        this.stmt = stmt;
        this.logger = logger2;
        this.fields = fields;
        this._isResponseInArrayMode = _isResponseInArrayMode;
        this.customResultMapper = customResultMapper;
      }
      run(placeholderValues) {
        const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
        this.logger.logQuery(this.query.sql, params);
        return this.stmt.run(...params);
      }
      all(placeholderValues) {
        const { fields, joinsNotNullableMap, query, logger: logger2, stmt, customResultMapper } = this;
        if (!fields && !customResultMapper) {
          const params = fillPlaceholders(query.params, placeholderValues ?? {});
          logger2.logQuery(query.sql, params);
          return stmt.all(...params);
        }
        const rows = this.values(placeholderValues);
        if (customResultMapper) {
          return customResultMapper(rows);
        }
        return rows.map((row) => mapResultRow(fields, row, joinsNotNullableMap));
      }
      get(placeholderValues) {
        const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
        this.logger.logQuery(this.query.sql, params);
        const { fields, stmt, joinsNotNullableMap, customResultMapper } = this;
        if (!fields && !customResultMapper) {
          return stmt.get(...params);
        }
        const row = stmt.raw().get(...params);
        if (!row) {
          return void 0;
        }
        if (customResultMapper) {
          return customResultMapper([row]);
        }
        return mapResultRow(fields, row, joinsNotNullableMap);
      }
      values(placeholderValues) {
        const params = fillPlaceholders(this.query.params, placeholderValues ?? {});
        this.logger.logQuery(this.query.sql, params);
        return this.stmt.raw().all(...params);
      }
      /** @internal */
      isResponseInArrayMode() {
        return this._isResponseInArrayMode;
      }
    };
    __publicField(PreparedQuery, _a504, "BetterSQLitePreparedQuery");
  }
});

// ../drizzle-orm/dist/better-sqlite3/driver.js
function construct11(client, config = {}) {
  const dialect6 = new SQLiteSyncDialect({ casing: config.casing });
  let logger2;
  if (config.logger === true) {
    logger2 = new DefaultLogger();
  } else if (config.logger !== false) {
    logger2 = config.logger;
  }
  let schema6;
  if (config.schema) {
    const tablesConfig = extractTablesRelationalConfig(
      config.schema,
      createTableRelationsHelpers
    );
    schema6 = {
      fullSchema: config.schema,
      schema: tablesConfig.tables,
      tableNamesMap: tablesConfig.tableNamesMap
    };
  }
  const session = new BetterSQLiteSession(client, dialect6, schema6, { logger: logger2 });
  const db2 = new BetterSQLite3Database("sync", dialect6, session, schema6);
  db2.$client = client;
  return db2;
}
function drizzle12(...params) {
  if (params[0] === void 0 || typeof params[0] === "string") {
    const instance2 = params[0] === void 0 ? new import_better_sqlite3.default() : new import_better_sqlite3.default(params[0]);
    return construct11(instance2, params[1]);
  }
  if (isConfig(params[0])) {
    const { connection: connection2, client, ...drizzleConfig } = params[0];
    if (client) return construct11(client, drizzleConfig);
    if (typeof connection2 === "object") {
      const { source, ...options } = connection2;
      const instance22 = new import_better_sqlite3.default(source, options);
      return construct11(instance22, drizzleConfig);
    }
    const instance2 = new import_better_sqlite3.default(connection2);
    return construct11(instance2, drizzleConfig);
  }
  return construct11(params[0], params[1]);
}
var import_better_sqlite3, _a505, _b374, BetterSQLite3Database;
var init_driver12 = __esm({
  "../drizzle-orm/dist/better-sqlite3/driver.js"() {
    "use strict";
    import_better_sqlite3 = __toESM(require_lib8(), 1);
    init_entity();
    init_logger();
    init_relations();
    init_db4();
    init_dialect4();
    init_utils();
    init_session16();
    BetterSQLite3Database = class extends (_b374 = BaseSQLiteDatabase, _a505 = entityKind, _b374) {
    };
    __publicField(BetterSQLite3Database, _a505, "BetterSQLite3Database");
    ((drizzle22) => {
      function mock(config) {
        return construct11({}, config);
      }
      drizzle22.mock = mock;
    })(drizzle12 || (drizzle12 = {}));
  }
});

// ../drizzle-orm/dist/better-sqlite3/index.js
var better_sqlite3_exports = {};
__export(better_sqlite3_exports, {
  BetterSQLite3Database: () => BetterSQLite3Database,
  BetterSQLiteSession: () => BetterSQLiteSession,
  BetterSQLiteTransaction: () => BetterSQLiteTransaction,
  PreparedQuery: () => PreparedQuery,
  drizzle: () => drizzle12
});
var init_better_sqlite3 = __esm({
  "../drizzle-orm/dist/better-sqlite3/index.js"() {
    "use strict";
    init_driver12();
    init_session16();
  }
});

// ../drizzle-orm/dist/better-sqlite3/migrator.js
var migrator_exports12 = {};
__export(migrator_exports12, {
  migrate: () => migrate12
});
function migrate12(db2, config) {
  const migrations = readMigrationFiles(config);
  db2.dialect.migrate(migrations, db2.session, config);
}
var init_migrator13 = __esm({
  "../drizzle-orm/dist/better-sqlite3/migrator.js"() {
    "use strict";
    init_migrator();
  }
});

// src/cli/connections.ts
var connections_exports = {};
__export(connections_exports, {
  connectToLibSQL: () => connectToLibSQL,
  connectToMySQL: () => connectToMySQL,
  connectToSQLite: () => connectToSQLite,
  connectToSingleStore: () => connectToSingleStore,
  prepareGelDB: () => prepareGelDB,
  preparePostgresDB: () => preparePostgresDB
});
var preparePostgresDB, prepareGelDB, parseSingleStoreCredentials, connectToSingleStore, parseMysqlCredentials, connectToMySQL, prepareSqliteParams, preparePGliteParams, connectToSQLite, connectToLibSQL;
var init_connections = __esm({
  "src/cli/connections.ts"() {
    "use strict";
    init_src();
    init_wrapper();
    init_global();
    init_utils8();
    init_utils11();
    init_outputs();
    preparePostgresDB = async (credentials2) => {
      if ("driver" in credentials2) {
        const { driver: driver2 } = credentials2;
        if (driver2 === "aws-data-api") {
          assertPackages("@aws-sdk/client-rds-data");
          const { RDSDataClient: RDSDataClient2, ExecuteStatementCommand: ExecuteStatementCommand2, TypeHint: TypeHint2 } = await Promise.resolve().then(() => (init_dist_es53(), dist_es_exports8));
          const { AwsDataApiSession: AwsDataApiSession2, drizzle: drizzle13 } = await Promise.resolve().then(() => (init_pg(), pg_exports));
          const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator2(), migrator_exports));
          const { PgDialect: PgDialect2 } = await Promise.resolve().then(() => (init_pg_core(), pg_core_exports));
          const config = {
            database: credentials2.database,
            resourceArn: credentials2.resourceArn,
            secretArn: credentials2.secretArn
          };
          const rdsClient = new RDSDataClient2();
          const session = new AwsDataApiSession2(
            rdsClient,
            new PgDialect2(),
            void 0,
            config,
            void 0
          );
          const db2 = drizzle13(rdsClient, config);
          const migrateFn = async (config2) => {
            return migrate13(db2, config2);
          };
          const query = async (sql3, params) => {
            const prepared = session.prepareQuery(
              { sql: sql3, params: params ?? [] },
              void 0,
              void 0,
              false
            );
            const result = await prepared.all();
            return result;
          };
          const proxy2 = async (params) => {
            const prepared = session.prepareQuery(
              {
                sql: params.sql,
                params: params.params ?? [],
                typings: params.typings
              },
              void 0,
              void 0,
              params.mode === "array"
            );
            if (params.mode === "array") {
              const result2 = await prepared.values();
              return result2.rows;
            }
            const result = await prepared.execute();
            return result.rows;
          };
          const transactionProxy = async (queries) => {
            throw new Error("Transaction not supported");
          };
          return {
            packageName: "@aws-sdk/client-rds-data",
            query,
            proxy: proxy2,
            transactionProxy,
            migrate: migrateFn
          };
        }
        if (driver2 === "pglite") {
          assertPackages("@electric-sql/pglite");
          const { PGlite, types: types6 } = await Promise.resolve().then(() => (init_dist5(), dist_exports2));
          const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_pglite(), pglite_exports));
          const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator3(), migrator_exports2));
          const pglite = "client" in credentials2 ? credentials2.client : new PGlite(normalisePGliteUrl(credentials2.url));
          await pglite.waitReady;
          const drzl = drizzle13(pglite);
          const migrateFn = async (config) => {
            return migrate13(drzl, config);
          };
          const parsers2 = {
            [types6.TIMESTAMP]: (value) => value,
            [types6.TIMESTAMPTZ]: (value) => value,
            [types6.INTERVAL]: (value) => value,
            [types6.DATE]: (value) => value
          };
          const query = async (sql3, params = []) => {
            const result = await pglite.query(sql3, params, {
              parsers: parsers2
            });
            return result.rows;
          };
          const proxy2 = async (params) => {
            const preparedParams = preparePGliteParams(params.params || []);
            const result = await pglite.query(params.sql, preparedParams, {
              rowMode: params.mode,
              parsers: parsers2
            });
            return result.rows;
          };
          const transactionProxy = async (queries) => {
            const results = [];
            try {
              await pglite.transaction(async (tx) => {
                for (const query2 of queries) {
                  const result = await tx.query(query2.sql, void 0, {
                    parsers: parsers2
                  });
                  results.push(result.rows);
                }
              });
            } catch (error2) {
              results.push(error2);
            }
            return results;
          };
          return { packageName: "pglite", query, proxy: proxy2, transactionProxy, migrate: migrateFn };
        }
        assertUnreachable(driver2);
      }
      if (await checkPackage("pg")) {
        console.log(withStyle.info(`Using 'pg' driver for database querying`));
        const { default: pg2 } = await Promise.resolve().then(() => (init_esm3(), esm_exports));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_node_postgres(), node_postgres_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator4(), migrator_exports3));
        const ssl = "ssl" in credentials2 ? credentials2.ssl === "prefer" || credentials2.ssl === "require" || credentials2.ssl === "allow" ? { rejectUnauthorized: false } : credentials2.ssl === "verify-full" ? {} : credentials2.ssl : {};
        const types6 = {
          // @ts-ignore
          getTypeParser: (typeId, format2) => {
            if (typeId === pg2.types.builtins.TIMESTAMPTZ) {
              return (val2) => val2;
            }
            if (typeId === pg2.types.builtins.TIMESTAMP) {
              return (val2) => val2;
            }
            if (typeId === pg2.types.builtins.DATE) {
              return (val2) => val2;
            }
            if (typeId === pg2.types.builtins.INTERVAL) {
              return (val2) => val2;
            }
            return pg2.types.getTypeParser(typeId, format2);
          }
        };
        const client = "url" in credentials2 ? new pg2.Pool({ connectionString: credentials2.url, max: 1 }) : new pg2.Pool({ ...credentials2, ssl, max: 1 });
        const db2 = drizzle13(client);
        const migrateFn = async (config) => {
          return migrate13(db2, config);
        };
        const query = async (sql3, params) => {
          const result = await client.query({
            text: sql3,
            values: params ?? [],
            types: types6
          });
          return result.rows;
        };
        const proxy2 = async (params) => {
          const result = await client.query({
            text: params.sql,
            values: params.params,
            ...params.mode === "array" && { rowMode: "array" },
            types: types6
          });
          return result.rows;
        };
        const transactionProxy = async (queries) => {
          const results = [];
          const tx = await client.connect();
          try {
            await tx.query("BEGIN");
            for (const query2 of queries) {
              const result = await tx.query({
                text: query2.sql,
                types: types6
              });
              results.push(result.rows);
            }
            await tx.query("COMMIT");
          } catch (error2) {
            await tx.query("ROLLBACK");
            results.push(error2);
          } finally {
            tx.release();
          }
          return results;
        };
        return { packageName: "pg", query, proxy: proxy2, transactionProxy, migrate: migrateFn };
      }
      if (await checkPackage("postgres")) {
        console.log(
          withStyle.info(`Using 'postgres' driver for database querying`)
        );
        const postgres2 = await Promise.resolve().then(() => (init_src2(), src_exports));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_postgres_js(), postgres_js_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator5(), migrator_exports4));
        const client = "url" in credentials2 ? postgres2.default(credentials2.url, { max: 1 }) : postgres2.default({ ...credentials2, max: 1 });
        const transparentParser = (val2) => val2;
        for (const type of ["1184", "1082", "1083", "1114"]) {
          client.options.parsers[type] = transparentParser;
          client.options.serializers[type] = transparentParser;
        }
        client.options.serializers["114"] = transparentParser;
        client.options.serializers["3802"] = transparentParser;
        const db2 = drizzle13(client);
        const migrateFn = async (config) => {
          return migrate13(db2, config);
        };
        const query = async (sql3, params) => {
          const result = await client.unsafe(sql3, params ?? []);
          return result;
        };
        const proxy2 = async (params) => {
          if (params.mode === "array") {
            return await client.unsafe(params.sql, params.params).values();
          }
          return await client.unsafe(params.sql, params.params);
        };
        const transactionProxy = async (queries) => {
          const results = [];
          try {
            await client.begin(async (sql3) => {
              for (const query2 of queries) {
                const result = await sql3.unsafe(query2.sql);
                results.push(result);
              }
            });
          } catch (error2) {
            results.push(error2);
          }
          return results;
        };
        return { packageName: "postgres", query, proxy: proxy2, transactionProxy, migrate: migrateFn };
      }
      if (await checkPackage("@vercel/postgres")) {
        console.log(
          withStyle.info(`Using '@vercel/postgres' driver for database querying`)
        );
        console.log(
          withStyle.fullWarning(
            "'@vercel/postgres' can only connect to remote Neon/Vercel Postgres/Supabase instances through a websocket"
          )
        );
        const { VercelPool: VercelPool2, types: pgTypes } = await Promise.resolve().then(() => (init_index_node(), index_node_exports));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_vercel_postgres(), vercel_postgres_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator6(), migrator_exports5));
        const ssl = "ssl" in credentials2 ? credentials2.ssl === "prefer" || credentials2.ssl === "require" || credentials2.ssl === "allow" ? { rejectUnauthorized: false } : credentials2.ssl === "verify-full" ? {} : credentials2.ssl : {};
        const types6 = {
          // @ts-ignore
          getTypeParser: (typeId, format2) => {
            if (typeId === pgTypes.builtins.TIMESTAMPTZ) {
              return (val2) => val2;
            }
            if (typeId === pgTypes.builtins.TIMESTAMP) {
              return (val2) => val2;
            }
            if (typeId === pgTypes.builtins.DATE) {
              return (val2) => val2;
            }
            if (typeId === pgTypes.builtins.INTERVAL) {
              return (val2) => val2;
            }
            return pgTypes.getTypeParser(typeId, format2);
          }
        };
        const client = "url" in credentials2 ? new VercelPool2({ connectionString: credentials2.url }) : new VercelPool2({ ...credentials2, ssl });
        await client.connect();
        const db2 = drizzle13(client);
        const migrateFn = async (config) => {
          return migrate13(db2, config);
        };
        const query = async (sql3, params) => {
          const result = await client.query({
            text: sql3,
            values: params ?? [],
            types: types6
          });
          return result.rows;
        };
        const proxy2 = async (params) => {
          const result = await client.query({
            text: params.sql,
            values: params.params,
            ...params.mode === "array" && { rowMode: "array" },
            types: types6
          });
          return result.rows;
        };
        const transactionProxy = async (queries) => {
          const results = [];
          const tx = await client.connect();
          try {
            await tx.query("BEGIN");
            for (const query2 of queries) {
              const result = await tx.query({
                text: query2.sql,
                types: types6
              });
              results.push(result.rows);
            }
            await tx.query("COMMIT");
          } catch (error2) {
            await tx.query("ROLLBACK");
            results.push(error2);
          } finally {
            tx.release();
          }
          return results;
        };
        return { packageName: "@vercel/postgres", query, proxy: proxy2, transactionProxy, migrate: migrateFn };
      }
      if (await checkPackage("@neondatabase/serverless")) {
        console.log(
          withStyle.info(
            `Using '@neondatabase/serverless' driver for database querying`
          )
        );
        console.log(
          withStyle.fullWarning(
            "'@neondatabase/serverless' can only connect to remote Neon/Vercel Postgres/Supabase instances through a websocket"
          )
        );
        const { Pool: Pool3, neonConfig, types: pgTypes } = await Promise.resolve().then(() => (init_serverless2(), serverless_exports));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_neon_serverless(), neon_serverless_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator7(), migrator_exports6));
        const ssl = "ssl" in credentials2 ? credentials2.ssl === "prefer" || credentials2.ssl === "require" || credentials2.ssl === "allow" ? { rejectUnauthorized: false } : credentials2.ssl === "verify-full" ? {} : credentials2.ssl : {};
        const types6 = {
          // @ts-ignore
          getTypeParser: (typeId, format2) => {
            if (typeId === pgTypes.builtins.TIMESTAMPTZ) {
              return (val2) => val2;
            }
            if (typeId === pgTypes.builtins.TIMESTAMP) {
              return (val2) => val2;
            }
            if (typeId === pgTypes.builtins.DATE) {
              return (val2) => val2;
            }
            if (typeId === pgTypes.builtins.INTERVAL) {
              return (val2) => val2;
            }
            return pgTypes.getTypeParser(typeId, format2);
          }
        };
        const client = "url" in credentials2 ? new Pool3({ connectionString: credentials2.url, max: 1 }) : new Pool3({ ...credentials2, max: 1, ssl });
        neonConfig.webSocketConstructor = wrapper_default;
        const db2 = drizzle13(client);
        const migrateFn = async (config) => {
          return migrate13(db2, config);
        };
        const query = async (sql3, params) => {
          const result = await client.query({
            text: sql3,
            values: params ?? [],
            types: types6
          });
          return result.rows;
        };
        const proxy2 = async (params) => {
          const result = await client.query({
            text: params.sql,
            values: params.params,
            ...params.mode === "array" && { rowMode: "array" },
            types: types6
          });
          return result.rows;
        };
        const transactionProxy = async (queries) => {
          const results = [];
          const tx = await client.connect();
          try {
            await tx.query("BEGIN");
            for (const query2 of queries) {
              const result = await tx.query({
                text: query2.sql,
                types: types6
              });
              results.push(result.rows);
            }
            await tx.query("COMMIT");
          } catch (error2) {
            await tx.query("ROLLBACK");
            results.push(error2);
          } finally {
            tx.release();
          }
          return results;
        };
        return { packageName: "@neondatabase/serverless", query, proxy: proxy2, transactionProxy, migrate: migrateFn };
      }
      console.error(
        "To connect to Postgres database - please install either of 'pg', 'postgres', '@neondatabase/serverless' or '@vercel/postgres' drivers"
      );
      process.exit(1);
    };
    prepareGelDB = async (credentials2) => {
      if (await checkPackage("gel")) {
        const gel = await Promise.resolve().then(() => __toESM(require_index_node()));
        let client;
        if (!credentials2) {
          client = gel.createClient();
          try {
            await client.querySQL(`select 1;`);
          } catch (error2) {
            if (error2 instanceof gel.ClientConnectionError) {
              console.error(
                `It looks like you forgot to link the Gel project or provide the database credentials.
To link your project, please refer https://docs.geldata.com/reference/cli/gel_instance/gel_instance_link, or add the dbCredentials to your configuration file.`
              );
              process.exit(1);
            }
            throw error2;
          }
        } else if ("url" in credentials2) {
          "tlsSecurity" in credentials2 ? client = gel.createClient({ dsn: credentials2.url, tlsSecurity: credentials2.tlsSecurity, concurrency: 1 }) : client = gel.createClient({ dsn: credentials2.url, concurrency: 1 });
        } else {
          gel.createClient({ ...credentials2, concurrency: 1 });
        }
        const query = async (sql3, params) => {
          const result = params?.length ? await client.querySQL(sql3, params) : await client.querySQL(sql3);
          return result;
        };
        const proxy2 = async (params) => {
          const { method, mode, params: sqlParams, sql: sql3, typings } = params;
          let result;
          switch (mode) {
            case "array":
              result = sqlParams?.length ? await client.withSQLRowMode("array").querySQL(sql3, sqlParams) : await client.withSQLRowMode("array").querySQL(sql3);
              break;
            case "object":
              result = sqlParams?.length ? await client.querySQL(sql3, sqlParams) : await client.querySQL(sql3);
              break;
          }
          return result;
        };
        const transactionProxy = async (queries) => {
          const result = [];
          try {
            await client.transaction(async (tx) => {
              for (const query2 of queries) {
                const res = await tx.querySQL(query2.sql);
                result.push(res);
              }
            });
          } catch (error2) {
            result.push(error2);
          }
          return result;
        };
        return { packageName: "gel", query, proxy: proxy2, transactionProxy };
      }
      console.error(
        "To connect to gel database - please install 'edgedb' driver"
      );
      process.exit(1);
    };
    parseSingleStoreCredentials = (credentials2) => {
      if ("url" in credentials2) {
        const url = credentials2.url;
        const connectionUrl = new URL(url);
        const pathname = connectionUrl.pathname;
        const database = pathname.split("/")[pathname.split("/").length - 1];
        if (!database) {
          console.error(
            "You should specify a database name in connection string (singlestore://USER:PASSWORD@HOST:PORT/DATABASE)"
          );
          process.exit(1);
        }
        return { database, url };
      } else {
        return {
          database: credentials2.database,
          credentials: credentials2
        };
      }
    };
    connectToSingleStore = async (it2) => {
      const result = parseSingleStoreCredentials(it2);
      if (await checkPackage("mysql2")) {
        const { createConnection } = await Promise.resolve().then(() => __toESM(require_promise()));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_singlestore2(), singlestore_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator8(), migrator_exports7));
        const connection2 = result.url ? await createConnection(result.url) : await createConnection(result.credentials);
        const db2 = drizzle13(connection2);
        const migrateFn = async (config) => {
          return migrate13(db2, config);
        };
        await connection2.connect();
        const query = async (sql3, params) => {
          const res = await connection2.execute(sql3, params);
          return res[0];
        };
        const proxy2 = async (params) => {
          const result2 = await connection2.query({
            sql: params.sql,
            values: params.params,
            rowsAsArray: params.mode === "array"
          });
          return result2[0];
        };
        const transactionProxy = async (queries) => {
          const results = [];
          try {
            await connection2.beginTransaction();
            for (const query2 of queries) {
              const res = await connection2.query(query2.sql);
              results.push(res[0]);
            }
            await connection2.commit();
          } catch (error2) {
            await connection2.rollback();
            results.push(error2);
          }
          return results;
        };
        return {
          db: { query },
          packageName: "mysql2",
          proxy: proxy2,
          transactionProxy,
          database: result.database,
          migrate: migrateFn
        };
      }
      console.error(
        "To connect to SingleStore database - please install 'mysql2' driver"
      );
      process.exit(1);
    };
    parseMysqlCredentials = (credentials2) => {
      if ("url" in credentials2) {
        const url = credentials2.url;
        const connectionUrl = new URL(url);
        const pathname = connectionUrl.pathname;
        const database = pathname.split("/")[pathname.split("/").length - 1];
        if (!database) {
          console.error(
            "You should specify a database name in connection string (mysql://USER:PASSWORD@HOST:PORT/DATABASE)"
          );
          process.exit(1);
        }
        return { database, url };
      } else {
        return {
          database: credentials2.database,
          credentials: credentials2
        };
      }
    };
    connectToMySQL = async (it2) => {
      const result = parseMysqlCredentials(it2);
      if (await checkPackage("mysql2")) {
        const { createConnection } = await Promise.resolve().then(() => __toESM(require_promise()));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_mysql2(), mysql2_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator9(), migrator_exports8));
        const connection2 = result.url ? await createConnection(result.url) : await createConnection(result.credentials);
        const db2 = drizzle13(connection2);
        const migrateFn = async (config) => {
          return migrate13(db2, config);
        };
        const typeCast = (field, next) => {
          if (field.type === "TIMESTAMP" || field.type === "DATETIME" || field.type === "DATE") {
            return field.string();
          }
          return next();
        };
        await connection2.connect();
        const query = async (sql3, params) => {
          const res = await connection2.execute({
            sql: sql3,
            values: params,
            typeCast
          });
          return res[0];
        };
        const proxy2 = async (params) => {
          const result2 = await connection2.query({
            sql: params.sql,
            values: params.params,
            rowsAsArray: params.mode === "array",
            typeCast
          });
          return result2[0];
        };
        const transactionProxy = async (queries) => {
          const results = [];
          try {
            await connection2.beginTransaction();
            for (const query2 of queries) {
              const res = await connection2.query(query2.sql);
              results.push(res[0]);
            }
            await connection2.commit();
          } catch (error2) {
            await connection2.rollback();
            results.push(error2);
          }
          return results;
        };
        return {
          db: { query },
          packageName: "mysql2",
          proxy: proxy2,
          transactionProxy,
          database: result.database,
          migrate: migrateFn
        };
      }
      if (await checkPackage("@planetscale/database")) {
        const { Client: Client6 } = await Promise.resolve().then(() => (init_dist6(), dist_exports3));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_planetscale_serverless(), planetscale_serverless_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator10(), migrator_exports9));
        const connection2 = new Client6(result);
        const db2 = drizzle13(connection2);
        const migrateFn = async (config) => {
          return migrate13(db2, config);
        };
        const query = async (sql3, params) => {
          const res = await connection2.execute(sql3, params);
          return res.rows;
        };
        const proxy2 = async (params) => {
          const result2 = await connection2.execute(
            params.sql,
            params.params,
            params.mode === "array" ? { as: "array" } : void 0
          );
          return result2.rows;
        };
        const transactionProxy = async (queries) => {
          const results = [];
          try {
            await connection2.transaction(async (tx) => {
              for (const query2 of queries) {
                const res = await tx.execute(query2.sql);
                results.push(res.rows);
              }
            });
          } catch (error2) {
            results.push(error2);
          }
          return results;
        };
        return {
          db: { query },
          packageName: "@planetscale/database",
          proxy: proxy2,
          transactionProxy,
          database: result.database,
          migrate: migrateFn
        };
      }
      console.error(
        "To connect to MySQL database - please install either of 'mysql2' or '@planetscale/database' drivers"
      );
      process.exit(1);
    };
    prepareSqliteParams = (params, driver2) => {
      return params.map((param2) => {
        if (param2 && typeof param2 === "object" && "type" in param2 && "value" in param2 && param2.type === "binary") {
          const value = typeof param2.value === "object" ? JSON.stringify(param2.value) : param2.value;
          if (driver2 === "d1-http") {
            return value;
          }
          return Buffer.from(value);
        }
        return param2;
      });
    };
    preparePGliteParams = (params) => {
      return params.map((param2) => {
        if (param2 && typeof param2 === "object" && "type" in param2 && "value" in param2 && param2.type === "binary") {
          const value = typeof param2.value === "object" ? JSON.stringify(param2.value) : param2.value;
          return value;
        }
        return param2;
      });
    };
    connectToSQLite = async (credentials2) => {
      if ("driver" in credentials2) {
        const { driver: driver2 } = credentials2;
        if (driver2 === "d1-http") {
          const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_sqlite_proxy(), sqlite_proxy_exports));
          const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator11(), migrator_exports10));
          const remoteCallback = async (sql3, params, method) => {
            const res = await fetch2(
              `https://api.cloudflare.com/client/v4/accounts/${credentials2.accountId}/d1/database/${credentials2.databaseId}/${method === "values" ? "raw" : "query"}`,
              {
                method: "POST",
                body: JSON.stringify({ sql: sql3, params }),
                headers: {
                  "Content-Type": "application/json",
                  Authorization: `Bearer ${credentials2.token}`
                }
              }
            );
            const data = await res.json();
            if (!data.success) {
              throw new Error(
                data.errors.map((it2) => `${it2.code}: ${it2.message}`).join("\n")
              );
            }
            const result = data.result[0].results;
            const rows = Array.isArray(result) ? result : result.rows;
            return {
              rows
            };
          };
          const remoteBatchCallback = async (queries) => {
            const sql3 = queries.map((q7) => q7.sql).join("; ");
            const res = await fetch2(
              `https://api.cloudflare.com/client/v4/accounts/${credentials2.accountId}/d1/database/${credentials2.databaseId}/query`,
              {
                method: "POST",
                body: JSON.stringify({ sql: sql3 }),
                headers: {
                  "Content-Type": "application/json",
                  Authorization: `Bearer ${credentials2.token}`
                }
              }
            );
            const data = await res.json();
            if (!data.success) {
              throw new Error(
                data.errors.map((it2) => `${it2.code}: ${it2.message}`).join("\n")
              );
            }
            const rows = data.result.map((result) => {
              const res2 = result.results;
              return Array.isArray(res2) ? res2 : res2.rows;
            });
            return {
              rows
            };
          };
          const drzl = drizzle13(remoteCallback);
          const migrateFn = async (config) => {
            return migrate13(
              drzl,
              async (queries) => {
                for (const query of queries) {
                  await remoteCallback(query, [], "run");
                }
              },
              config
            );
          };
          const db2 = {
            query: async (sql3, params) => {
              const res = await remoteCallback(sql3, params || [], "all");
              return res.rows;
            },
            run: async (query) => {
              await remoteCallback(query, [], "run");
            }
          };
          const proxy2 = async (params) => {
            const preparedParams = prepareSqliteParams(params.params || [], "d1-http");
            const result = await remoteCallback(
              params.sql,
              preparedParams,
              params.mode === "array" ? "values" : "all"
            );
            return result.rows;
          };
          const transactionProxy = async (queries) => {
            const result = await remoteBatchCallback(queries);
            return result.rows;
          };
          return { ...db2, packageName: "d1-http", proxy: proxy2, transactionProxy, migrate: migrateFn };
        } else {
          assertUnreachable(driver2);
        }
      }
      if (await checkPackage("@libsql/client")) {
        const { createClient: createClient3 } = await Promise.resolve().then(() => (init_node5(), node_exports));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_libsql2(), libsql_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator12(), migrator_exports11));
        const client = createClient3({
          url: normaliseSQLiteUrl(credentials2.url, "libsql")
        });
        const drzl = drizzle13(client);
        const migrateFn = async (config) => {
          return migrate13(drzl, config);
        };
        const db2 = {
          query: async (sql3, params) => {
            const res = await client.execute({ sql: sql3, args: params || [] });
            return res.rows;
          },
          run: async (query) => {
            await client.execute(query);
          }
        };
        const proxy2 = async (params) => {
          const preparedParams = prepareSqliteParams(params.params || []);
          const result = await client.execute({
            sql: params.sql,
            args: preparedParams
          });
          if (params.mode === "array") {
            return result.rows.map((row) => Object.values(row));
          } else {
            return result.rows;
          }
        };
        const transactionProxy = async (queries) => {
          const results = [];
          let transaction = null;
          try {
            transaction = await client.transaction();
            for (const query of queries) {
              const result = await transaction.execute(query.sql);
              results.push(result.rows);
            }
            await transaction.commit();
          } catch (error2) {
            results.push(error2);
            await transaction?.rollback();
          } finally {
            transaction?.close();
          }
          return results;
        };
        return { ...db2, packageName: "@libsql/client", proxy: proxy2, transactionProxy, migrate: migrateFn };
      }
      if (await checkPackage("better-sqlite3")) {
        const { default: Database2 } = await Promise.resolve().then(() => __toESM(require_lib8()));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_better_sqlite3(), better_sqlite3_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator13(), migrator_exports12));
        const sqlite = new Database2(
          normaliseSQLiteUrl(credentials2.url, "better-sqlite")
        );
        const drzl = drizzle13(sqlite);
        const migrateFn = async (config) => {
          return migrate13(drzl, config);
        };
        const db2 = {
          query: async (sql3, params = []) => {
            return sqlite.prepare(sql3).bind(params).all();
          },
          run: async (query) => {
            sqlite.prepare(query).run();
          }
        };
        const proxy2 = async (params) => {
          const preparedParams = prepareSqliteParams(params.params || []);
          if (params.method === "values" || params.method === "get" || params.method === "all") {
            return sqlite.prepare(params.sql).raw(params.mode === "array").all(preparedParams);
          }
          sqlite.prepare(params.sql).run(preparedParams);
          return [];
        };
        const transactionProxy = async (queries) => {
          const results = [];
          const tx = sqlite.transaction((queries2) => {
            for (const query of queries2) {
              let result = [];
              if (query.method === "values" || query.method === "get" || query.method === "all") {
                result = sqlite.prepare(query.sql).all();
              } else {
                sqlite.prepare(query.sql).run();
              }
              results.push(result);
            }
          });
          try {
            tx(queries);
          } catch (error2) {
            results.push(error2);
          }
          return results;
        };
        return { ...db2, packageName: "better-sqlite3", proxy: proxy2, transactionProxy, migrate: migrateFn };
      }
      console.log(
        "Please install either 'better-sqlite3' or '@libsql/client' for Drizzle Kit to connect to SQLite databases"
      );
      process.exit(1);
    };
    connectToLibSQL = async (credentials2) => {
      if (await checkPackage("@libsql/client")) {
        const { createClient: createClient3 } = await Promise.resolve().then(() => (init_node5(), node_exports));
        const { drizzle: drizzle13 } = await Promise.resolve().then(() => (init_libsql2(), libsql_exports));
        const { migrate: migrate13 } = await Promise.resolve().then(() => (init_migrator12(), migrator_exports11));
        const client = createClient3({
          url: normaliseSQLiteUrl(credentials2.url, "libsql"),
          authToken: credentials2.authToken
        });
        const drzl = drizzle13(client);
        const migrateFn = async (config) => {
          return migrate13(drzl, config);
        };
        const db2 = {
          query: async (sql3, params) => {
            const res = await client.execute({ sql: sql3, args: params || [] });
            return res.rows;
          },
          run: async (query) => {
            await client.execute(query);
          },
          batchWithPragma: async (queries) => {
            await client.migrate(queries);
          }
        };
        const proxy2 = async (params) => {
          const preparedParams = prepareSqliteParams(params.params || []);
          const result = await client.execute({
            sql: params.sql,
            args: preparedParams
          });
          if (params.mode === "array") {
            return result.rows.map((row) => Object.values(row));
          } else {
            return result.rows;
          }
        };
        const transactionProxy = async (queries) => {
          const results = [];
          let transaction = null;
          try {
            transaction = await client.transaction();
            for (const query of queries) {
              const result = await transaction.execute(query.sql);
              results.push(result.rows);
            }
            await transaction.commit();
          } catch (error2) {
            results.push(error2);
            await transaction?.rollback();
          } finally {
            transaction?.close();
          }
          return results;
        };
        return { ...db2, packageName: "@libsql/client", proxy: proxy2, transactionProxy, migrate: migrateFn };
      }
      console.log(
        "Please install '@libsql/client' for Drizzle Kit to connect to LibSQL databases"
      );
      process.exit(1);
    };
  }
});

// src/serializer/studio.ts
var studio_exports = {};
__export(studio_exports, {
  drizzleForLibSQL: () => drizzleForLibSQL,
  drizzleForMySQL: () => drizzleForMySQL,
  drizzleForPostgres: () => drizzleForPostgres,
  drizzleForSQLite: () => drizzleForSQLite,
  drizzleForSingleStore: () => drizzleForSingleStore,
  extractRelations: () => extractRelations,
  prepareMySqlSchema: () => prepareMySqlSchema,
  preparePgSchema: () => preparePgSchema,
  prepareSQLiteSchema: () => prepareSQLiteSchema,
  prepareServer: () => prepareServer,
  prepareSingleStoreSchema: () => prepareSingleStoreSchema
});
var import_crypto8, import_fs9, import_node_https2, preparePgSchema, prepareMySqlSchema, prepareSQLiteSchema, prepareSingleStoreSchema, getCustomDefaults, drizzleForPostgres, drizzleForMySQL, drizzleForSQLite, drizzleForLibSQL, drizzleForSingleStore, extractRelations, init2, proxySchema, transactionProxySchema, defaultsSchema, schema5, jsonStringify, prepareServer;
var init_studio2 = __esm({
  "src/serializer/studio.ts"() {
    "use strict";
    init_dist2();
    init_esm2();
    import_crypto8 = require("crypto");
    init_dist();
    init_mysql_core();
    init_pg_core();
    init_relations();
    init_singlestore_core();
    init_sqlite_core();
    import_fs9 = __toESM(require("fs"));
    init_dist3();
    init_compress2();
    init_cors();
    import_node_https2 = require("https");
    init_global();
    init_esm();
    init_utils10();
    init_serializer();
    init_utils9();
    preparePgSchema = async (path3) => {
      const imports = prepareFilenames(path3);
      const pgSchema3 = {};
      const relations2 = {};
      const files = imports.map((it2, index7) => ({
        // get the file name from the path
        name: it2.split("/").pop() || `schema${index7}.ts`,
        content: import_fs9.default.readFileSync(it2, "utf-8")
      }));
      const { unregister } = await safeRegister();
      for (let i8 = 0; i8 < imports.length; i8++) {
        const it2 = imports[i8];
        const i0 = require(`${it2}`);
        const i0values = Object.entries(i0);
        i0values.forEach(([k9, t6]) => {
          if (is(t6, PgTable)) {
            const schema6 = getTableConfig2(t6).schema || "public";
            pgSchema3[schema6] = pgSchema3[schema6] || {};
            pgSchema3[schema6][k9] = t6;
          }
          if (is(t6, Relations)) {
            relations2[k9] = t6;
          }
        });
      }
      unregister();
      return { schema: pgSchema3, relations: relations2, files };
    };
    prepareMySqlSchema = async (path3) => {
      const imports = prepareFilenames(path3);
      const mysqlSchema3 = {
        public: {}
      };
      const relations2 = {};
      const files = imports.map((it2, index7) => ({
        // get the file name from the path
        name: it2.split("/").pop() || `schema${index7}.ts`,
        content: import_fs9.default.readFileSync(it2, "utf-8")
      }));
      const { unregister } = await safeRegister();
      for (let i8 = 0; i8 < imports.length; i8++) {
        const it2 = imports[i8];
        const i0 = require(`${it2}`);
        const i0values = Object.entries(i0);
        i0values.forEach(([k9, t6]) => {
          if (is(t6, MySqlTable)) {
            const schema6 = getTableConfig(t6).schema || "public";
            mysqlSchema3[schema6][k9] = t6;
          }
          if (is(t6, Relations)) {
            relations2[k9] = t6;
          }
        });
      }
      unregister();
      return { schema: mysqlSchema3, relations: relations2, files };
    };
    prepareSQLiteSchema = async (path3) => {
      const imports = prepareFilenames(path3);
      const sqliteSchema2 = {
        public: {}
      };
      const relations2 = {};
      const files = imports.map((it2, index7) => ({
        // get the file name from the path
        name: it2.split("/").pop() || `schema${index7}.ts`,
        content: import_fs9.default.readFileSync(it2, "utf-8")
      }));
      const { unregister } = await safeRegister();
      for (let i8 = 0; i8 < imports.length; i8++) {
        const it2 = imports[i8];
        const i0 = require(`${it2}`);
        const i0values = Object.entries(i0);
        i0values.forEach(([k9, t6]) => {
          if (is(t6, SQLiteTable)) {
            const schema6 = "public";
            sqliteSchema2[schema6][k9] = t6;
          }
          if (is(t6, Relations)) {
            relations2[k9] = t6;
          }
        });
      }
      unregister();
      return { schema: sqliteSchema2, relations: relations2, files };
    };
    prepareSingleStoreSchema = async (path3) => {
      const imports = prepareFilenames(path3);
      const singlestoreSchema2 = {
        public: {}
      };
      const relations2 = {};
      const files = imports.map((it2, index7) => ({
        // get the file name from the path
        name: it2.split("/").pop() || `schema${index7}.ts`,
        content: import_fs9.default.readFileSync(it2, "utf-8")
      }));
      const { unregister } = await safeRegister();
      for (let i8 = 0; i8 < imports.length; i8++) {
        const it2 = imports[i8];
        const i0 = require(`${it2}`);
        const i0values = Object.entries(i0);
        i0values.forEach(([k9, t6]) => {
          if (is(t6, SingleStoreTable)) {
            const schema6 = getTableConfig3(t6).schema || "public";
            singlestoreSchema2[schema6][k9] = t6;
          }
          if (is(t6, Relations)) {
            relations2[k9] = t6;
          }
        });
      }
      unregister();
      return { schema: singlestoreSchema2, relations: relations2, files };
    };
    getCustomDefaults = (schema6, casing2) => {
      const customDefaults = [];
      Object.entries(schema6).map(([schema7, tables]) => {
        Object.entries(tables).map(([, table6]) => {
          let tableConfig;
          if (is(table6, PgTable)) {
            tableConfig = getTableConfig2(table6);
          } else if (is(table6, MySqlTable)) {
            tableConfig = getTableConfig(table6);
          } else if (is(table6, SQLiteTable)) {
            tableConfig = getTableConfig4(table6);
          } else {
            tableConfig = getTableConfig3(table6);
          }
          tableConfig.columns.map((column6) => {
            if (column6.defaultFn) {
              customDefaults.push({
                schema: schema7,
                table: tableConfig.name,
                column: getColumnCasing(column6, casing2),
                func: column6.defaultFn
              });
            }
          });
        });
      });
      return customDefaults;
    };
    drizzleForPostgres = async (credentials2, pgSchema3, relations2, schemaFiles, casing2) => {
      const { preparePostgresDB: preparePostgresDB2 } = await Promise.resolve().then(() => (init_connections(), connections_exports));
      const db2 = await preparePostgresDB2(credentials2);
      const customDefaults = getCustomDefaults(pgSchema3, casing2);
      let dbUrl;
      if ("driver" in credentials2) {
        const { driver: driver2 } = credentials2;
        if (driver2 === "aws-data-api") {
          dbUrl = `aws-data-api://${credentials2.database}/${credentials2.secretArn}/${credentials2.resourceArn}`;
        } else if (driver2 === "pglite") {
          dbUrl = "client" in credentials2 ? credentials2.client.dataDir || "pglite://custom-client" : credentials2.url;
        } else {
          assertUnreachable(driver2);
        }
      } else if ("url" in credentials2) {
        dbUrl = credentials2.url;
      } else {
        dbUrl = `postgresql://${credentials2.user}:${credentials2.password}@${credentials2.host}:${credentials2.port}/${credentials2.database}`;
      }
      const dbHash = (0, import_crypto8.createHash)("sha256").update(dbUrl).digest("hex");
      return {
        dbHash,
        dialect: "postgresql",
        driver: "driver" in credentials2 ? credentials2.driver : void 0,
        packageName: db2.packageName,
        proxy: db2.proxy,
        transactionProxy: db2.transactionProxy,
        customDefaults,
        schema: pgSchema3,
        relations: relations2,
        schemaFiles,
        casing: casing2
      };
    };
    drizzleForMySQL = async (credentials2, mysqlSchema3, relations2, schemaFiles, casing2) => {
      const { connectToMySQL: connectToMySQL2 } = await Promise.resolve().then(() => (init_connections(), connections_exports));
      const { proxy: proxy2, transactionProxy, database, packageName } = await connectToMySQL2(credentials2);
      const customDefaults = getCustomDefaults(mysqlSchema3, casing2);
      let dbUrl;
      if ("url" in credentials2) {
        dbUrl = credentials2.url;
      } else {
        dbUrl = `mysql://${credentials2.user}:${credentials2.password}@${credentials2.host}:${credentials2.port}/${credentials2.database}`;
      }
      const dbHash = (0, import_crypto8.createHash)("sha256").update(dbUrl).digest("hex");
      return {
        dbHash,
        dialect: "mysql",
        packageName,
        databaseName: database,
        proxy: proxy2,
        transactionProxy,
        customDefaults,
        schema: mysqlSchema3,
        relations: relations2,
        schemaFiles,
        casing: casing2
      };
    };
    drizzleForSQLite = async (credentials2, sqliteSchema2, relations2, schemaFiles, casing2) => {
      const { connectToSQLite: connectToSQLite2 } = await Promise.resolve().then(() => (init_connections(), connections_exports));
      const sqliteDB = await connectToSQLite2(credentials2);
      const customDefaults = getCustomDefaults(sqliteSchema2, casing2);
      let dbUrl;
      if ("driver" in credentials2) {
        const { driver: driver2 } = credentials2;
        if (driver2 === "d1-http") {
          dbUrl = `d1-http://${credentials2.accountId}/${credentials2.databaseId}/${credentials2.token}`;
        } else {
          assertUnreachable(driver2);
        }
      } else {
        dbUrl = credentials2.url;
      }
      const dbHash = (0, import_crypto8.createHash)("sha256").update(dbUrl).digest("hex");
      return {
        dbHash,
        dialect: "sqlite",
        driver: "driver" in credentials2 ? credentials2.driver : void 0,
        packageName: sqliteDB.packageName,
        proxy: sqliteDB.proxy,
        transactionProxy: sqliteDB.transactionProxy,
        customDefaults,
        schema: sqliteSchema2,
        relations: relations2,
        schemaFiles,
        casing: casing2
      };
    };
    drizzleForLibSQL = async (credentials2, sqliteSchema2, relations2, schemaFiles, casing2) => {
      const { connectToLibSQL: connectToLibSQL2 } = await Promise.resolve().then(() => (init_connections(), connections_exports));
      const sqliteDB = await connectToLibSQL2(credentials2);
      const customDefaults = getCustomDefaults(sqliteSchema2, casing2);
      let dbUrl = `turso://${credentials2.url}/${credentials2.authToken}`;
      const dbHash = (0, import_crypto8.createHash)("sha256").update(dbUrl).digest("hex");
      return {
        dbHash,
        dialect: "sqlite",
        driver: void 0,
        packageName: sqliteDB.packageName,
        proxy: sqliteDB.proxy,
        transactionProxy: sqliteDB.transactionProxy,
        customDefaults,
        schema: sqliteSchema2,
        relations: relations2,
        schemaFiles,
        casing: casing2
      };
    };
    drizzleForSingleStore = async (credentials2, singlestoreSchema2, relations2, schemaFiles, casing2) => {
      const { connectToSingleStore: connectToSingleStore2 } = await Promise.resolve().then(() => (init_connections(), connections_exports));
      const { proxy: proxy2, transactionProxy, database, packageName } = await connectToSingleStore2(credentials2);
      const customDefaults = getCustomDefaults(singlestoreSchema2, casing2);
      let dbUrl;
      if ("url" in credentials2) {
        dbUrl = credentials2.url;
      } else {
        dbUrl = `singlestore://${credentials2.user}:${credentials2.password}@${credentials2.host}:${credentials2.port}/${credentials2.database}`;
      }
      const dbHash = (0, import_crypto8.createHash)("sha256").update(dbUrl).digest("hex");
      return {
        dbHash,
        dialect: "singlestore",
        databaseName: database,
        packageName,
        proxy: proxy2,
        transactionProxy,
        customDefaults,
        schema: singlestoreSchema2,
        relations: relations2,
        schemaFiles,
        casing: casing2
      };
    };
    extractRelations = (tablesConfig, casing2) => {
      const relations2 = Object.values(tablesConfig.tables).map(
        (it2) => Object.entries(it2.relations).map(([name3, relation]) => {
          try {
            const normalized = normalizeRelation(
              tablesConfig.tables,
              tablesConfig.tableNamesMap,
              relation
            );
            const rel = relation;
            const refTableName = rel.referencedTableName;
            const refTable = rel.referencedTable;
            const fields = normalized.fields.map((it3) => getColumnCasing(it3, casing2)).flat();
            const refColumns = normalized.references.map((it3) => getColumnCasing(it3, casing2)).flat();
            let refSchema;
            if (is(refTable, PgTable)) {
              refSchema = getTableConfig2(refTable).schema;
            } else if (is(refTable, MySqlTable)) {
              refSchema = getTableConfig(refTable).schema;
            } else if (is(refTable, SQLiteTable)) {
              refSchema = void 0;
            } else if (is(refTable, SingleStoreTable)) {
              refSchema = getTableConfig3(refTable).schema;
            } else {
              throw new Error("unsupported dialect");
            }
            let type;
            if (is(rel, One)) {
              type = "one";
            } else if (is(rel, Many)) {
              type = "many";
            } else {
              throw new Error("unsupported relation type");
            }
            return {
              name: name3,
              type,
              table: it2.dbName,
              schema: it2.schema || "public",
              columns: fields,
              refTable: refTableName,
              refSchema: refSchema || "public",
              refColumns
            };
          } catch (error2) {
            throw new Error(
              `Invalid relation "${relation.fieldName}" for table "${it2.schema ? `${it2.schema}.${it2.dbName}` : it2.dbName}"`
            );
          }
        })
      ).flat();
      return relations2;
    };
    init2 = external_exports.object({
      type: external_exports.literal("init")
    });
    proxySchema = external_exports.object({
      type: external_exports.literal("proxy"),
      data: external_exports.object({
        sql: external_exports.string(),
        params: external_exports.array(external_exports.any()).optional(),
        typings: external_exports.string().array().optional(),
        mode: external_exports.enum(["array", "object"]).default("object"),
        method: external_exports.union([
          external_exports.literal("values"),
          external_exports.literal("get"),
          external_exports.literal("all"),
          external_exports.literal("run"),
          external_exports.literal("execute")
        ])
      })
    });
    transactionProxySchema = external_exports.object({
      type: external_exports.literal("tproxy"),
      data: external_exports.object({
        sql: external_exports.string(),
        method: external_exports.union([
          external_exports.literal("values"),
          external_exports.literal("get"),
          external_exports.literal("all"),
          external_exports.literal("run"),
          external_exports.literal("execute")
        ]).optional()
      }).array()
    });
    defaultsSchema = external_exports.object({
      type: external_exports.literal("defaults"),
      data: external_exports.array(
        external_exports.object({
          schema: external_exports.string(),
          table: external_exports.string(),
          column: external_exports.string()
        })
      ).min(1)
    });
    schema5 = external_exports.union([
      init2,
      proxySchema,
      transactionProxySchema,
      defaultsSchema
    ]);
    jsonStringify = (data) => {
      return JSON.stringify(data, (_key, value) => {
        if (value instanceof Error) {
          return {
            error: value.message
          };
        }
        if (typeof value === "bigint") {
          return value.toString();
        }
        if (value && typeof value === "object" && "type" in value && "data" in value && value.type === "Buffer" || value instanceof ArrayBuffer || value instanceof Buffer) {
          return Buffer.from(value).toString("base64");
        }
        return value;
      });
    };
    prepareServer = async ({
      dialect: dialect6,
      driver: driver2,
      packageName,
      databaseName,
      proxy: proxy2,
      transactionProxy,
      customDefaults,
      schema: drizzleSchema,
      relations: relations2,
      dbHash,
      casing: casing2,
      schemaFiles
    }, app) => {
      app = app !== void 0 ? app : new Hono2();
      app.use(compress());
      app.use(async (ctx, next) => {
        await next();
        ctx.header("Access-Control-Allow-Private-Network", "true");
      });
      app.use(cors());
      app.onError((err3, ctx) => {
        console.error(err3);
        return ctx.json({
          status: "error",
          error: err3.message
        });
      });
      const relationalSchema = {
        ...Object.fromEntries(
          Object.entries(drizzleSchema).map(([schemaName, schema6]) => {
            const mappedTableEntries = Object.entries(schema6).map(
              ([tableName, table6]) => {
                return [`__${schemaName}__.${tableName}`, table6];
              }
            );
            return mappedTableEntries;
          }).flat()
        ),
        ...relations2
      };
      const relationsConfig = extractTablesRelationalConfig(
        relationalSchema,
        createTableRelationsHelpers
      );
      app.post("/", zValidator("json", schema5), async (c6) => {
        const body2 = c6.req.valid("json");
        const { type } = body2;
        if (type === "init") {
          const preparedDefaults = customDefaults.map((d7) => ({
            schema: d7.schema,
            table: d7.table,
            column: d7.column
          }));
          let relations3 = [];
          try {
            relations3 = extractRelations(relationsConfig, casing2);
          } catch (error2) {
            console.warn(
              "Failed to extract relations. This is likely due to ambiguous or misconfigured relations."
            );
            console.warn(
              "Please check your schema and ensure that all relations are correctly defined."
            );
            console.warn(
              "See: https://orm.drizzle.team/docs/relations#disambiguating-relations"
            );
            console.warn("Error message:", error2.message);
          }
          return c6.json({
            version: "6.2",
            dialect: dialect6,
            driver: driver2,
            packageName,
            schemaFiles,
            customDefaults: preparedDefaults,
            relations: relations3,
            dbHash,
            databaseName
          });
        }
        if (type === "proxy") {
          const result = await proxy2({
            ...body2.data,
            params: body2.data.params || []
          });
          return c6.json(JSON.parse(jsonStringify(result)));
        }
        if (type === "tproxy") {
          const result = await transactionProxy(body2.data);
          return c6.json(JSON.parse(jsonStringify(result)));
        }
        if (type === "defaults") {
          const columns = body2.data;
          const result = columns.map((column6) => {
            const found = customDefaults.find((d7) => {
              return d7.schema === column6.schema && d7.table === column6.table && d7.column === column6.column;
            });
            if (!found) {
              throw new Error(
                `Custom default not found for ${column6.schema}.${column6.table}.${column6.column}`
              );
            }
            const value = found.func();
            return {
              ...column6,
              value
            };
          });
          return c6.json(JSON.parse(jsonStringify(result)));
        }
        throw new Error(`Unknown type: ${type}`);
      });
      return {
        start: (params) => {
          serve(
            {
              fetch: app.fetch,
              createServer: params.key ? import_node_https2.createServer : void 0,
              hostname: params.host,
              port: params.port,
              serverOptions: {
                key: params.key,
                cert: params.cert
              }
            },
            () => params.cb(null, `${params.host}:${params.port}`)
          );
        }
      };
    };
  }
});

// src/serializer/sqliteImports.ts
var sqliteImports_exports = {};
__export(sqliteImports_exports, {
  prepareFromExports: () => prepareFromExports2,
  prepareFromSqliteImports: () => prepareFromSqliteImports
});
var prepareFromExports2, prepareFromSqliteImports;
var init_sqliteImports = __esm({
  "src/serializer/sqliteImports.ts"() {
    "use strict";
    init_dist();
    init_sqlite_core();
    init_utils10();
    prepareFromExports2 = (exports2) => {
      const tables = [];
      const views = [];
      const i0values = Object.values(exports2);
      i0values.forEach((t6) => {
        if (is(t6, SQLiteTable)) {
          tables.push(t6);
        }
        if (is(t6, SQLiteView)) {
          views.push(t6);
        }
      });
      return { tables, views };
    };
    prepareFromSqliteImports = async (imports) => {
      const tables = [];
      const views = [];
      const { unregister } = await safeRegister();
      for (let i8 = 0; i8 < imports.length; i8++) {
        const it2 = imports[i8];
        const i0 = require(`${it2}`);
        const prepared = prepareFromExports2(i0);
        tables.push(...prepared.tables);
        views.push(...prepared.views);
      }
      unregister();
      return { tables: Array.from(new Set(tables)), views };
    };
  }
});

// src/serializer/mysqlImports.ts
var mysqlImports_exports = {};
__export(mysqlImports_exports, {
  prepareFromExports: () => prepareFromExports3,
  prepareFromMySqlImports: () => prepareFromMySqlImports
});
var prepareFromExports3, prepareFromMySqlImports;
var init_mysqlImports = __esm({
  "src/serializer/mysqlImports.ts"() {
    "use strict";
    init_dist();
    init_mysql_core();
    init_utils10();
    prepareFromExports3 = (exports2) => {
      const tables = [];
      const views = [];
      const i0values = Object.values(exports2);
      i0values.forEach((t6) => {
        if (is(t6, MySqlTable)) {
          tables.push(t6);
        }
        if (is(t6, MySqlView)) {
          views.push(t6);
        }
      });
      return { tables, views };
    };
    prepareFromMySqlImports = async (imports) => {
      const tables = [];
      const views = [];
      const { unregister } = await safeRegister();
      for (let i8 = 0; i8 < imports.length; i8++) {
        const it2 = imports[i8];
        const i0 = require(`${it2}`);
        const prepared = prepareFromExports3(i0);
        tables.push(...prepared.tables);
        views.push(...prepared.views);
      }
      unregister();
      return { tables: Array.from(new Set(tables)), views };
    };
  }
});

// src/cli/commands/mysqlPushUtils.ts
var mysqlPushUtils_exports = {};
__export(mysqlPushUtils_exports, {
  filterStatements: () => filterStatements,
  logSuggestionsAndReturn: () => logSuggestionsAndReturn2
});
var import_hanji8, filterStatements, logSuggestionsAndReturn2;
var init_mysqlPushUtils = __esm({
  "src/cli/commands/mysqlPushUtils.ts"() {
    "use strict";
    init_source();
    import_hanji8 = __toESM(require_hanji());
    init_mysqlSchema();
    init_selector_ui();
    init_outputs();
    filterStatements = (statements, currentSchema, prevSchema) => {
      return statements.filter((statement) => {
        if (statement.type === "alter_table_alter_column_set_type") {
          if (statement.oldDataType.startsWith("tinyint") && statement.newDataType.startsWith("boolean")) {
            return false;
          }
          if (statement.oldDataType.startsWith("bigint unsigned") && statement.newDataType.startsWith("serial")) {
            return false;
          }
          if (statement.oldDataType.startsWith("serial") && statement.newDataType.startsWith("bigint unsigned")) {
            return false;
          }
        } else if (statement.type === "alter_table_alter_column_set_default") {
          if (statement.newDefaultValue === false && statement.oldDefaultValue === 0 && statement.newDataType === "boolean") {
            return false;
          }
          if (statement.newDefaultValue === true && statement.oldDefaultValue === 1 && statement.newDataType === "boolean") {
            return false;
          }
        } else if (statement.type === "delete_unique_constraint") {
          const unsquashed = MySqlSquasher.unsquashUnique(statement.data);
          if (unsquashed.columns.length === 1 && currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]].type === "serial" && prevSchema.tables[statement.tableName].columns[unsquashed.columns[0]].type === "serial" && currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]].name === unsquashed.columns[0]) {
            return false;
          }
        } else if (statement.type === "alter_table_alter_column_drop_notnull") {
          const serialStatement = statements.find(
            (it2) => it2.type === "alter_table_alter_column_set_type"
          );
          if (serialStatement?.oldDataType.startsWith("bigint unsigned") && serialStatement?.newDataType.startsWith("serial") && serialStatement.columnName === statement.columnName && serialStatement.tableName === statement.tableName) {
            return false;
          }
          if (statement.newDataType === "serial" && !statement.columnNotNull) {
            return false;
          }
          if (statement.columnAutoIncrement) {
            return false;
          }
        }
        return true;
      });
    };
    logSuggestionsAndReturn2 = async (db2, statements, json22) => {
      let shouldAskForApprove = false;
      const statementsToExecute = [];
      const infoToPrint = [];
      const tablesToRemove = [];
      const columnsToRemove = [];
      const schemasToRemove = [];
      const tablesToTruncate = [];
      for (const statement of statements) {
        if (statement.type === "drop_table") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                statement.tableName
              )} table with ${count2} items`
            );
            tablesToRemove.push(statement.tableName);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "alter_table_drop_column") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                statement.columnName
              )} column in ${statement.tableName} table with ${count2} items`
            );
            columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "drop_schema") {
          const res = await db2.query(
            `select count(*) as count from information_schema.tables where table_schema = \`${statement.name}\`;`
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                statement.name
              )} schema with ${count2} tables`
            );
            schemasToRemove.push(statement.name);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "alter_table_alter_column_set_type") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to change ${source_default.underline(
                statement.columnName
              )} column type from ${source_default.underline(
                statement.oldDataType
              )} to ${source_default.underline(statement.newDataType)} with ${count2} items`
            );
            statementsToExecute.push(`truncate table ${statement.tableName};`);
            tablesToTruncate.push(statement.tableName);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "alter_table_alter_column_drop_default") {
          if (statement.columnNotNull) {
            const res = await db2.query(
              `select count(*) as count from \`${statement.tableName}\``
            );
            const count2 = Number(res[0].count);
            if (count2 > 0) {
              infoToPrint.push(
                `\xB7 You're about to remove default value from ${source_default.underline(
                  statement.columnName
                )} not-null column with ${count2} items`
              );
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        } else if (statement.type === "alter_table_alter_column_set_notnull") {
          if (typeof statement.columnDefault === "undefined") {
            const res = await db2.query(
              `select count(*) as count from \`${statement.tableName}\``
            );
            const count2 = Number(res[0].count);
            if (count2 > 0) {
              infoToPrint.push(
                `\xB7 You're about to set not-null constraint to ${source_default.underline(
                  statement.columnName
                )} column without default, which contains ${count2} items`
              );
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        } else if (statement.type === "alter_table_alter_column_drop_pk") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          if (Object.values(json22.tables[statement.tableName].columns).filter(
            (column6) => column6.autoincrement
          ).length > 0) {
            console.log(
              `${withStyle.errorWarning(
                `You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`
              )}`
            );
            process.exit(1);
          }
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to change ${source_default.underline(
                statement.tableName
              )} primary key. This statements may fail and you table may left without primary key`
            );
            tablesToTruncate.push(statement.tableName);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "delete_composite_pk") {
          if (Object.values(json22.tables[statement.tableName].columns).filter(
            (column6) => column6.autoincrement
          ).length > 0) {
            console.log(
              `${withStyle.errorWarning(
                `You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`
              )}`
            );
            process.exit(1);
          }
        } else if (statement.type === "alter_table_add_column") {
          if (statement.column.notNull && typeof statement.column.default === "undefined") {
            const res = await db2.query(
              `select count(*) as count from \`${statement.tableName}\``
            );
            const count2 = Number(res[0].count);
            if (count2 > 0) {
              infoToPrint.push(
                `\xB7 You're about to add not-null ${source_default.underline(
                  statement.column.name
                )} column without default value, which contains ${count2} items`
              );
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        } else if (statement.type === "create_unique_constraint") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            const unsquashedUnique = MySqlSquasher.unsquashUnique(statement.data);
            console.log(
              `\xB7 You're about to add ${source_default.underline(
                unsquashedUnique.name
              )} unique constraint to the table, which contains ${count2} items. If this statement fails, you will receive an error from the database. Do you want to truncate ${source_default.underline(
                statement.tableName
              )} table?
`
            );
            const { status, data } = await (0, import_hanji8.render)(
              new Select([
                "No, add the constraint without truncating the table",
                `Yes, truncate the table`
              ])
            );
            if (data?.index === 1) {
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        }
      }
      return {
        statementsToExecute,
        shouldAskForApprove,
        infoToPrint,
        columnsToRemove: [...new Set(columnsToRemove)],
        schemasToRemove: [...new Set(schemasToRemove)],
        tablesToTruncate: [...new Set(tablesToTruncate)],
        tablesToRemove: [...new Set(tablesToRemove)]
      };
    };
  }
});

// src/cli/commands/mysqlIntrospect.ts
var mysqlIntrospect_exports = {};
__export(mysqlIntrospect_exports, {
  mysqlPushIntrospect: () => mysqlPushIntrospect
});
var import_hanji9, mysqlPushIntrospect;
var init_mysqlIntrospect = __esm({
  "src/cli/commands/mysqlIntrospect.ts"() {
    "use strict";
    import_hanji9 = __toESM(require_hanji());
    init_mjs();
    init_global();
    init_mysqlSerializer();
    init_views();
    mysqlPushIntrospect = async (db2, databaseName, filters) => {
      const matchers = filters.map((it2) => {
        return new Minimatch(it2);
      });
      const filter2 = (tableName) => {
        if (matchers.length === 0) return true;
        let flags2 = [];
        for (let matcher of matchers) {
          if (matcher.negate) {
            if (!matcher.match(tableName)) {
              flags2.push(false);
            }
          }
          if (matcher.match(tableName)) {
            flags2.push(true);
          }
        }
        if (flags2.length > 0) {
          return flags2.every(Boolean);
        }
        return false;
      };
      const progress = new ProgressView(
        "Pulling schema from database...",
        "Pulling schema from database..."
      );
      const res = await (0, import_hanji9.renderWithTask)(
        progress,
        fromDatabase3(db2, databaseName, filter2)
      );
      const schema6 = { id: originUUID, prevId: "", ...res };
      const { internal, ...schemaWithoutInternals } = schema6;
      return { schema: schemaWithoutInternals };
    };
  }
});

// src/serializer/singlestoreImports.ts
var singlestoreImports_exports = {};
__export(singlestoreImports_exports, {
  prepareFromExports: () => prepareFromExports4,
  prepareFromSingleStoreImports: () => prepareFromSingleStoreImports
});
var prepareFromExports4, prepareFromSingleStoreImports;
var init_singlestoreImports = __esm({
  "src/serializer/singlestoreImports.ts"() {
    "use strict";
    init_dist();
    init_singlestore_core();
    init_utils10();
    prepareFromExports4 = (exports2) => {
      const tables = [];
      const i0values = Object.values(exports2);
      i0values.forEach((t6) => {
        if (is(t6, SingleStoreTable)) {
          tables.push(t6);
        }
      });
      return {
        tables
        /* views  */
      };
    };
    prepareFromSingleStoreImports = async (imports) => {
      const tables = [];
      const { unregister } = await safeRegister();
      for (let i8 = 0; i8 < imports.length; i8++) {
        const it2 = imports[i8];
        const i0 = require(`${it2}`);
        const prepared = prepareFromExports4(i0);
        tables.push(...prepared.tables);
      }
      unregister();
      return {
        tables: Array.from(new Set(tables))
        /* , views */
      };
    };
  }
});

// src/cli/commands/singlestorePushUtils.ts
var singlestorePushUtils_exports = {};
__export(singlestorePushUtils_exports, {
  filterStatements: () => filterStatements2,
  findColumnTypeAlternations: () => findColumnTypeAlternations,
  logSuggestionsAndReturn: () => logSuggestionsAndReturn3
});
function findColumnTypeAlternations(columns1, columns2) {
  const changes = [];
  for (const key in columns1) {
    if (columns1.hasOwnProperty(key) && columns2.hasOwnProperty(key)) {
      const col1 = columns1[key];
      const col2 = columns2[key];
      if (col1.type !== col2.type) {
        changes.push(col2.name);
      }
    }
  }
  return changes;
}
var import_hanji10, filterStatements2, logSuggestionsAndReturn3;
var init_singlestorePushUtils = __esm({
  "src/cli/commands/singlestorePushUtils.ts"() {
    "use strict";
    init_source();
    import_hanji10 = __toESM(require_hanji());
    init_sqlgenerator();
    init_singlestoreSchema();
    init_utils8();
    init_selector_ui();
    init_outputs();
    filterStatements2 = (statements, currentSchema, prevSchema) => {
      return statements.filter((statement) => {
        if (statement.type === "alter_table_alter_column_set_type") {
          if (statement.oldDataType.startsWith("tinyint") && statement.newDataType.startsWith("boolean")) {
            return false;
          }
          if (statement.oldDataType.startsWith("bigint unsigned") && statement.newDataType.startsWith("serial")) {
            return false;
          }
          if (statement.oldDataType.startsWith("serial") && statement.newDataType.startsWith("bigint unsigned")) {
            return false;
          }
        } else if (statement.type === "alter_table_alter_column_set_default") {
          if (statement.newDefaultValue === false && statement.oldDefaultValue === 0 && statement.newDataType === "boolean") {
            return false;
          }
          if (statement.newDefaultValue === true && statement.oldDefaultValue === 1 && statement.newDataType === "boolean") {
            return false;
          }
        } else if (statement.type === "delete_unique_constraint") {
          const unsquashed = SingleStoreSquasher.unsquashUnique(statement.data);
          if (unsquashed.columns.length === 1 && currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]].type === "serial" && prevSchema.tables[statement.tableName].columns[unsquashed.columns[0]].type === "serial" && currentSchema.tables[statement.tableName].columns[unsquashed.columns[0]].name === unsquashed.columns[0]) {
            return false;
          }
        } else if (statement.type === "alter_table_alter_column_drop_notnull") {
          const serialStatement = statements.find(
            (it2) => it2.type === "alter_table_alter_column_set_type"
          );
          if (serialStatement?.oldDataType.startsWith("bigint unsigned") && serialStatement?.newDataType.startsWith("serial") && serialStatement.columnName === statement.columnName && serialStatement.tableName === statement.tableName) {
            return false;
          }
          if (statement.newDataType === "serial" && !statement.columnNotNull) {
            return false;
          }
          if (statement.columnAutoIncrement) {
            return false;
          }
        }
        return true;
      });
    };
    logSuggestionsAndReturn3 = async (db2, statements, json22, json1) => {
      let shouldAskForApprove = false;
      const statementsToExecute = [];
      const infoToPrint = [];
      const tablesToRemove = [];
      const columnsToRemove = [];
      const schemasToRemove = [];
      const tablesToTruncate = [];
      for (const statement of statements) {
        if (statement.type === "drop_table") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                statement.tableName
              )} table with ${count2} items`
            );
            tablesToRemove.push(statement.tableName);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "alter_table_drop_column") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                statement.columnName
              )} column in ${statement.tableName} table with ${count2} items`
            );
            columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "drop_schema") {
          const res = await db2.query(
            `select count(*) as count from information_schema.tables where table_schema = \`${statement.name}\`;`
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to delete ${source_default.underline(
                statement.name
              )} schema with ${count2} tables`
            );
            schemasToRemove.push(statement.name);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "alter_table_alter_column_set_type") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to change ${source_default.underline(
                statement.columnName
              )} column type from ${source_default.underline(
                statement.oldDataType
              )} to ${source_default.underline(statement.newDataType)} with ${count2} items`
            );
            statementsToExecute.push(`truncate table ${statement.tableName};`);
            tablesToTruncate.push(statement.tableName);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "alter_table_alter_column_drop_default") {
          if (statement.columnNotNull) {
            const res = await db2.query(
              `select count(*) as count from \`${statement.tableName}\``
            );
            const count2 = Number(res[0].count);
            if (count2 > 0) {
              infoToPrint.push(
                `\xB7 You're about to remove default value from ${source_default.underline(
                  statement.columnName
                )} not-null column with ${count2} items`
              );
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        } else if (statement.type === "alter_table_alter_column_set_notnull") {
          if (typeof statement.columnDefault === "undefined") {
            const res = await db2.query(
              `select count(*) as count from \`${statement.tableName}\``
            );
            const count2 = Number(res[0].count);
            if (count2 > 0) {
              infoToPrint.push(
                `\xB7 You're about to set not-null constraint to ${source_default.underline(
                  statement.columnName
                )} column without default, which contains ${count2} items`
              );
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        } else if (statement.type === "alter_table_alter_column_drop_pk") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          if (Object.values(json22.tables[statement.tableName].columns).filter(
            (column6) => column6.autoincrement
          ).length > 0) {
            console.log(
              `${withStyle.errorWarning(
                `You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`
              )}`
            );
            process.exit(1);
          }
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            infoToPrint.push(
              `\xB7 You're about to change ${source_default.underline(
                statement.tableName
              )} primary key. This statements may fail and you table may left without primary key`
            );
            tablesToTruncate.push(statement.tableName);
            shouldAskForApprove = true;
          }
        } else if (statement.type === "delete_composite_pk") {
          if (Object.values(json22.tables[statement.tableName].columns).filter(
            (column6) => column6.autoincrement
          ).length > 0) {
            console.log(
              `${withStyle.errorWarning(
                `You have removed the primary key from a ${statement.tableName} table without removing the auto-increment property from this table. As the database error states: 'there can be only one auto column, and it must be defined as a key. Make sure to remove autoincrement from ${statement.tableName} table`
              )}`
            );
            process.exit(1);
          }
        } else if (statement.type === "alter_table_add_column") {
          if (statement.column.notNull && typeof statement.column.default === "undefined") {
            const res = await db2.query(
              `select count(*) as count from \`${statement.tableName}\``
            );
            const count2 = Number(res[0].count);
            if (count2 > 0) {
              infoToPrint.push(
                `\xB7 You're about to add not-null ${source_default.underline(
                  statement.column.name
                )} column without default value, which contains ${count2} items`
              );
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        } else if (statement.type === "create_unique_constraint") {
          const res = await db2.query(
            `select count(*) as count from \`${statement.tableName}\``
          );
          const count2 = Number(res[0].count);
          if (count2 > 0) {
            const unsquashedUnique = SingleStoreSquasher.unsquashUnique(statement.data);
            console.log(
              `\xB7 You're about to add ${source_default.underline(
                unsquashedUnique.name
              )} unique constraint to the table, which contains ${count2} items. If this statement fails, you will receive an error from the database. Do you want to truncate ${source_default.underline(
                statement.tableName
              )} table?
`
            );
            const { status, data } = await (0, import_hanji10.render)(
              new Select([
                "No, add the constraint without truncating the table",
                `Yes, truncate the table`
              ])
            );
            if (data?.index === 1) {
              tablesToTruncate.push(statement.tableName);
              statementsToExecute.push(`truncate table ${statement.tableName};`);
              shouldAskForApprove = true;
            }
          }
        } else if (statement.type === "singlestore_recreate_table") {
          const tableName = statement.tableName;
          const prevColumns = json1.tables[tableName].columns;
          const currentColumns = json22.tables[tableName].columns;
          const { removedColumns, addedColumns } = findAddedAndRemoved(
            Object.keys(prevColumns),
            Object.keys(currentColumns)
          );
          if (removedColumns.length) {
            for (const removedColumn of removedColumns) {
              const res = await db2.query(
                `select count(\`${tableName}\`.\`${removedColumn}\`) as count from \`${tableName}\``
              );
              const count2 = Number(res[0].count);
              if (count2 > 0) {
                infoToPrint.push(
                  `\xB7 You're about to delete ${source_default.underline(
                    removedColumn
                  )} column in ${tableName} table with ${count2} items`
                );
                columnsToRemove.push(removedColumn);
                shouldAskForApprove = true;
              }
            }
          }
          if (addedColumns.length) {
            for (const addedColumn of addedColumns) {
              const [res] = await db2.query(
                `select count(*) as count from \`${tableName}\``
              );
              const columnConf = json22.tables[tableName].columns[addedColumn];
              const count2 = Number(res.count);
              if (count2 > 0 && columnConf.notNull && !columnConf.default) {
                infoToPrint.push(
                  `\xB7 You're about to add not-null ${source_default.underline(
                    addedColumn
                  )} column without default value to table, which contains ${count2} items`
                );
                shouldAskForApprove = true;
                tablesToTruncate.push(tableName);
                statementsToExecute.push(`TRUNCATE TABLE \`${tableName}\`;`);
              }
            }
          }
          const columnWithChangedType = findColumnTypeAlternations(prevColumns, currentColumns);
          for (const column6 of columnWithChangedType) {
            const [res] = await db2.query(
              `select count(*) as count from \`${tableName}\` WHERE \`${tableName}\`.\`${column6}\` IS NOT NULL;`
            );
            const count2 = Number(res.count);
            if (count2 > 0) {
              infoToPrint.push(
                `\xB7 You're about recreate ${source_default.underline(tableName)} table with data type changing for ${source_default.underline(
                  column6
                )} column, which contains ${count2} items`
              );
              shouldAskForApprove = true;
              tablesToTruncate.push(tableName);
              statementsToExecute.push(`TRUNCATE TABLE \`${tableName}\`;`);
            }
          }
        }
        const stmnt = fromJson([statement], "singlestore", "push");
        if (typeof stmnt !== "undefined") {
          statementsToExecute.push(...stmnt);
        }
      }
      return {
        statementsToExecute,
        shouldAskForApprove,
        infoToPrint,
        columnsToRemove: [...new Set(columnsToRemove)],
        schemasToRemove: [...new Set(schemasToRemove)],
        tablesToTruncate: [...new Set(tablesToTruncate)],
        tablesToRemove: [...new Set(tablesToRemove)]
      };
    };
  }
});

// src/cli/commands/singlestoreIntrospect.ts
var singlestoreIntrospect_exports = {};
__export(singlestoreIntrospect_exports, {
  singlestorePushIntrospect: () => singlestorePushIntrospect
});
var import_hanji11, singlestorePushIntrospect;
var init_singlestoreIntrospect = __esm({
  "src/cli/commands/singlestoreIntrospect.ts"() {
    "use strict";
    import_hanji11 = __toESM(require_hanji());
    init_mjs();
    init_global();
    init_singlestoreSerializer();
    init_views();
    singlestorePushIntrospect = async (db2, databaseName, filters) => {
      const matchers = filters.map((it2) => {
        return new Minimatch(it2);
      });
      const filter2 = (tableName) => {
        if (matchers.length === 0) return true;
        let flags2 = [];
        for (let matcher of matchers) {
          if (matcher.negate) {
            if (!matcher.match(tableName)) {
              flags2.push(false);
            }
          }
          if (matcher.match(tableName)) {
            flags2.push(true);
          }
        }
        if (flags2.length > 0) {
          return flags2.every(Boolean);
        }
        return false;
      };
      const progress = new ProgressView(
        "Pulling schema from database...",
        "Pulling schema from database..."
      );
      const res = await (0, import_hanji11.renderWithTask)(
        progress,
        fromDatabase4(db2, databaseName, filter2)
      );
      const schema6 = { id: originUUID, prevId: "", ...res };
      const { internal, ...schemaWithoutInternals } = schema6;
      return { schema: schemaWithoutInternals };
    };
  }
});

// src/api.ts
var api_exports = {};
__export(api_exports, {
  generateDrizzleJson: () => generateDrizzleJson,
  generateMigration: () => generateMigration,
  generateMySQLDrizzleJson: () => generateMySQLDrizzleJson,
  generateMySQLMigration: () => generateMySQLMigration,
  generateSQLiteDrizzleJson: () => generateSQLiteDrizzleJson,
  generateSQLiteMigration: () => generateSQLiteMigration,
  generateSingleStoreDrizzleJson: () => generateSingleStoreDrizzleJson,
  generateSingleStoreMigration: () => generateSingleStoreMigration,
  pushMySQLSchema: () => pushMySQLSchema,
  pushSQLiteSchema: () => pushSQLiteSchema,
  pushSchema: () => pushSchema,
  pushSingleStoreSchema: () => pushSingleStoreSchema,
  startStudioMySQLServer: () => startStudioMySQLServer,
  startStudioPostgresServer: () => startStudioPostgresServer,
  startStudioSQLiteServer: () => startStudioSQLiteServer,
  startStudioSingleStoreServer: () => startStudioSingleStoreServer,
  upPgSnapshot: () => upPgSnapshot
});
module.exports = __toCommonJS(api_exports);
var import_crypto9 = require("crypto");
init_dist();
init_mysql_core();
init_pg_core();
init_relations();
init_singlestore_core();
init_sqlite_core();
init_migrate();

// src/cli/commands/pgIntrospect.ts
var import_hanji3 = __toESM(require_hanji());
init_mjs();
init_global();
init_pgSerializer();
init_views();
var pgPushIntrospect = async (db2, filters, schemaFilters, entities, tsSchema) => {
  const matchers = filters.map((it2) => {
    return new Minimatch(it2);
  });
  const filter2 = (tableName) => {
    if (matchers.length === 0) return true;
    let flags2 = [];
    for (let matcher of matchers) {
      if (matcher.negate) {
        if (!matcher.match(tableName)) {
          flags2.push(false);
        }
      }
      if (matcher.match(tableName)) {
        flags2.push(true);
      }
    }
    if (flags2.length > 0) {
      return flags2.every(Boolean);
    }
    return false;
  };
  const progress = new ProgressView(
    "Pulling schema from database...",
    "Pulling schema from database..."
  );
  const res = await (0, import_hanji3.renderWithTask)(
    progress,
    fromDatabase(db2, filter2, schemaFilters, entities, void 0, tsSchema)
  );
  const schema6 = { id: originUUID, prevId: "", ...res };
  const { internal, ...schemaWithoutInternals } = schema6;
  return { schema: schemaWithoutInternals };
};

// src/cli/commands/pgPushUtils.ts
init_source();
var import_hanji5 = __toESM(require_hanji());
init_pgSchema();
init_sqlgenerator();
init_selector_ui();
function concatSchemaAndTableName(schema6, table6) {
  return schema6 ? `"${schema6}"."${table6}"` : `"${table6}"`;
}
function tableNameWithSchemaFrom(schema6, tableName, renamedSchemas, renamedTables) {
  const newSchemaName = schema6 ? renamedSchemas[schema6] ? renamedSchemas[schema6] : schema6 : void 0;
  const newTableName = renamedTables[concatSchemaAndTableName(newSchemaName, tableName)] ? renamedTables[concatSchemaAndTableName(newSchemaName, tableName)] : tableName;
  return concatSchemaAndTableName(newSchemaName, newTableName);
}
var pgSuggestions = async (db2, statements) => {
  let shouldAskForApprove = false;
  const statementsToExecute = [];
  const infoToPrint = [];
  const tablesToRemove = [];
  const columnsToRemove = [];
  const schemasToRemove = [];
  const tablesToTruncate = [];
  const matViewsToRemove = [];
  let renamedSchemas = {};
  let renamedTables = {};
  for (const statement of statements) {
    if (statement.type === "rename_schema") {
      renamedSchemas[statement.to] = statement.from;
    } else if (statement.type === "rename_table") {
      renamedTables[concatSchemaAndTableName(statement.toSchema, statement.tableNameTo)] = statement.tableNameFrom;
    } else if (statement.type === "drop_table") {
      const res = await db2.query(
        `select count(*) as count from ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)}`
      );
      const count2 = Number(res[0].count);
      if (count2 > 0) {
        infoToPrint.push(`\xB7 You're about to delete ${source_default.underline(statement.tableName)} table with ${count2} items`);
        tablesToRemove.push(statement.tableName);
        shouldAskForApprove = true;
      }
    } else if (statement.type === "drop_view" && statement.materialized) {
      const res = await db2.query(`select count(*) as count from "${statement.schema ?? "public"}"."${statement.name}"`);
      const count2 = Number(res[0].count);
      if (count2 > 0) {
        infoToPrint.push(
          `\xB7 You're about to delete "${source_default.underline(statement.name)}" materialized view with ${count2} items`
        );
        matViewsToRemove.push(statement.name);
        shouldAskForApprove = true;
      }
    } else if (statement.type === "alter_table_drop_column") {
      const res = await db2.query(
        `select count(*) as count from ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)}`
      );
      const count2 = Number(res[0].count);
      if (count2 > 0) {
        infoToPrint.push(
          `\xB7 You're about to delete ${source_default.underline(statement.columnName)} column in ${statement.tableName} table with ${count2} items`
        );
        columnsToRemove.push(`${statement.tableName}_${statement.columnName}`);
        shouldAskForApprove = true;
      }
    } else if (statement.type === "drop_schema") {
      const res = await db2.query(
        `select count(*) as count from information_schema.tables where table_schema = '${statement.name}';`
      );
      const count2 = Number(res[0].count);
      if (count2 > 0) {
        infoToPrint.push(`\xB7 You're about to delete ${source_default.underline(statement.name)} schema with ${count2} tables`);
        schemasToRemove.push(statement.name);
        shouldAskForApprove = true;
      }
    } else if (statement.type === "alter_table_alter_column_set_type") {
      const res = await db2.query(
        `select count(*) as count from ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)}`
      );
      const count2 = Number(res[0].count);
      if (count2 > 0) {
        infoToPrint.push(
          `\xB7 You're about to change ${source_default.underline(statement.columnName)} column type from ${source_default.underline(statement.oldDataType)} to ${source_default.underline(
            statement.newDataType
          )} with ${count2} items`
        );
        statementsToExecute.push(
          `truncate table ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)} cascade;`
        );
        tablesToTruncate.push(statement.tableName);
        shouldAskForApprove = true;
      }
    } else if (statement.type === "alter_table_alter_column_drop_pk") {
      const res = await db2.query(
        `select count(*) as count from ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)}`
      );
      const count2 = Number(res[0].count);
      if (count2 > 0) {
        infoToPrint.push(
          `\xB7 You're about to change ${source_default.underline(statement.tableName)} primary key. This statements may fail and you table may left without primary key`
        );
        tablesToTruncate.push(statement.tableName);
        shouldAskForApprove = true;
      }
      const tableNameWithSchema = tableNameWithSchemaFrom(
        statement.schema,
        statement.tableName,
        renamedSchemas,
        renamedTables
      );
      const pkNameResponse = await db2.query(
        `SELECT constraint_name FROM information_schema.table_constraints
        WHERE table_schema = '${typeof statement.schema === "undefined" || statement.schema === "" ? "public" : statement.schema}'
            AND table_name = '${statement.tableName}'
            AND constraint_type = 'PRIMARY KEY';`
      );
      statementsToExecute.push(
        `ALTER TABLE ${tableNameWithSchema} DROP CONSTRAINT "${pkNameResponse[0].constraint_name}"`
      );
      continue;
    } else if (statement.type === "alter_table_add_column") {
      if (statement.column.notNull && typeof statement.column.default === "undefined") {
        const res = await db2.query(
          `select count(*) as count from ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)}`
        );
        const count2 = Number(res[0].count);
        if (count2 > 0) {
          infoToPrint.push(
            `\xB7 You're about to add not-null ${source_default.underline(statement.column.name)} column without default value, which contains ${count2} items`
          );
          tablesToTruncate.push(statement.tableName);
          statementsToExecute.push(
            `truncate table ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)} cascade;`
          );
          shouldAskForApprove = true;
        }
      }
    } else if (statement.type === "create_unique_constraint") {
      const res = await db2.query(
        `select count(*) as count from ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)}`
      );
      const count2 = Number(res[0].count);
      if (count2 > 0) {
        const unsquashedUnique = PgSquasher.unsquashUnique(statement.data);
        console.log(
          `\xB7 You're about to add ${source_default.underline(
            unsquashedUnique.name
          )} unique constraint to the table, which contains ${count2} items. If this statement fails, you will receive an error from the database. Do you want to truncate ${source_default.underline(
            statement.tableName
          )} table?
`
        );
        const { status, data } = await (0, import_hanji5.render)(
          new Select(["No, add the constraint without truncating the table", `Yes, truncate the table`])
        );
        if (data?.index === 1) {
          tablesToTruncate.push(statement.tableName);
          statementsToExecute.push(
            `truncate table ${tableNameWithSchemaFrom(statement.schema, statement.tableName, renamedSchemas, renamedTables)} cascade;`
          );
          shouldAskForApprove = true;
        }
      }
    }
    const stmnt = fromJson([statement], "postgresql", "push");
    if (typeof stmnt !== "undefined") {
      statementsToExecute.push(...stmnt);
    }
  }
  return {
    statementsToExecute: [...new Set(statementsToExecute)],
    shouldAskForApprove,
    infoToPrint,
    matViewsToRemove: [...new Set(matViewsToRemove)],
    columnsToRemove: [...new Set(columnsToRemove)],
    schemasToRemove: [...new Set(schemasToRemove)],
    tablesToTruncate: [...new Set(tablesToTruncate)],
    tablesToRemove: [...new Set(tablesToRemove)]
  };
};

// src/cli/commands/pgUp.ts
init_pgSchema();
init_utils8();
var updateUpToV6 = (json4) => {
  const schema6 = pgSchemaV5.parse(json4);
  const tables = Object.fromEntries(
    Object.entries(schema6.tables).map((it2) => {
      const table6 = it2[1];
      const schema7 = table6.schema || "public";
      return [`${schema7}.${table6.name}`, table6];
    })
  );
  const enums = Object.fromEntries(
    Object.entries(schema6.enums).map((it2) => {
      const en2 = it2[1];
      return [
        `public.${en2.name}`,
        {
          name: en2.name,
          schema: "public",
          values: Object.values(en2.values)
        }
      ];
    })
  );
  return {
    ...schema6,
    version: "6",
    dialect: "postgresql",
    tables,
    enums
  };
};
var updateUpToV7 = (json4) => {
  const schema6 = pgSchemaV6.parse(json4);
  const tables = Object.fromEntries(
    Object.entries(schema6.tables).map((it2) => {
      const table6 = it2[1];
      const mappedIndexes = Object.fromEntries(
        Object.entries(table6.indexes).map((idx) => {
          const { columns, ...rest } = idx[1];
          const mappedColumns = columns.map((it3) => {
            return {
              expression: it3,
              isExpression: false,
              asc: true,
              nulls: "last",
              opClass: void 0
            };
          });
          return [idx[0], { columns: mappedColumns, with: {}, ...rest }];
        })
      );
      return [it2[0], { ...table6, indexes: mappedIndexes, policies: {}, isRLSEnabled: false, checkConstraints: {} }];
    })
  );
  return {
    ...schema6,
    version: "7",
    dialect: "postgresql",
    sequences: {},
    tables,
    policies: {},
    views: {},
    roles: {}
  };
};

// src/cli/commands/sqliteIntrospect.ts
var import_hanji6 = __toESM(require_hanji());
init_mjs();
init_global();

// ../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 = (string2, toLowerCase, toUpperCase, preserveConsecutiveUppercase2) => {
  let isLastCharLower = false;
  let isLastCharUpper = false;
  let isLastLastCharUpper = false;
  let isLastLastCharPreserved = false;
  for (let index7 = 0; index7 < string2.length; index7++) {
    const character = string2[index7];
    isLastLastCharPreserved = index7 > 2 ? string2[index7 - 3] === "-" : true;
    if (isLastCharLower && UPPERCASE.test(character)) {
      string2 = string2.slice(0, index7) + "-" + string2.slice(index7);
      isLastCharLower = false;
      isLastLastCharUpper = isLastCharUpper;
      isLastCharUpper = true;
      index7++;
    } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase2)) {
      string2 = string2.slice(0, index7 - 1) + "-" + string2.slice(index7 - 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 string2;
};
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, (_7, identifier) => toUpperCase(identifier)).replace(NUMBERS_AND_IDENTIFIER, (m12) => toUpperCase(m12));
};
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((x11) => x11.trim()).filter((x11) => x11.length).join("-");
  } else {
    input = input.trim();
  }
  if (input.length === 0) {
    return "";
  }
  const toLowerCase = options.locale === false ? (string2) => string2.toLowerCase() : (string2) => string2.toLocaleLowerCase(options.locale);
  const toUpperCase = options.locale === false ? (string2) => string2.toUpperCase() : (string2) => string2.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(char4) {
  let start2 = 0;
  let end = this.length;
  while (start2 < end && this[start2] === char4) ++start2;
  while (end > start2 && this[end - 1] === char4) --end;
  return start2 > 0 || end < this.length ? this.substring(start2, end) : this.toString();
};
String.prototype.squashSpaces = function() {
  return this.replace(/  +/g, " ").trim();
};
String.prototype.camelCase = function() {
  return camelCase(String(this));
};
String.prototype.capitalise = function() {
  return this && this.length > 0 ? `${this[0].toUpperCase()}${this.slice(1)}` : String(this);
};
String.prototype.concatIf = function(it2, condition) {
  return condition ? `${this}${it2}` : String(this);
};
String.prototype.snake_case = function() {
  return this && this.length > 0 ? `${this.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`)}` : String(this);
};
Array.prototype.random = function() {
  return this[~~(Math.random() * this.length)];
};

// src/introspect-sqlite.ts
init_global();

// src/cli/commands/sqliteIntrospect.ts
init_sqliteSerializer();
init_views();
var sqlitePushIntrospect = async (db2, filters) => {
  const matchers = filters.map((it2) => {
    return new Minimatch(it2);
  });
  const filter2 = (tableName) => {
    if (matchers.length === 0) return true;
    let flags2 = [];
    for (let matcher of matchers) {
      if (matcher.negate) {
        if (!matcher.match(tableName)) {
          flags2.push(false);
        }
      }
      if (matcher.match(tableName)) {
        flags2.push(true);
      }
    }
    if (flags2.length > 0) {
      return flags2.every(Boolean);
    }
    return false;
  };
  const progress = new ProgressView(
    "Pulling schema from database...",
    "Pulling schema from database..."
  );
  const res = await (0, import_hanji6.renderWithTask)(progress, fromDatabase2(db2, filter2));
  const schema6 = { id: originUUID, prevId: "", ...res };
  return { schema: schema6 };
};

// src/api.ts
init_sqlitePushUtils();
init_getTablesFilterByExtensions();
init_global();
init_mysqlSchema();
init_mysqlSerializer();
init_pgImports();
init_pgSchema();
init_pgSerializer();
init_singlestoreSchema();
init_singlestoreSerializer();
init_sqliteSchema();
init_sqliteSerializer();

// ../node_modules/.pnpm/env-paths@3.0.0/node_modules/env-paths/index.js
var import_node_path = __toESM(require("path"), 1);
var import_node_os2 = __toESM(require("os"), 1);
var import_node_process2 = __toESM(require("process"), 1);
var homedir = import_node_os2.default.homedir();
var tmpdir = import_node_os2.default.tmpdir();
var { env: env2 } = import_node_process2.default;
var macos = (name3) => {
  const library = import_node_path.default.join(homedir, "Library");
  return {
    data: import_node_path.default.join(library, "Application Support", name3),
    config: import_node_path.default.join(library, "Preferences", name3),
    cache: import_node_path.default.join(library, "Caches", name3),
    log: import_node_path.default.join(library, "Logs", name3),
    temp: import_node_path.default.join(tmpdir, name3)
  };
};
var windows = (name3) => {
  const appData = env2.APPDATA || import_node_path.default.join(homedir, "AppData", "Roaming");
  const localAppData = env2.LOCALAPPDATA || import_node_path.default.join(homedir, "AppData", "Local");
  return {
    // Data/config/cache/log are invented by me as Windows isn't opinionated about this
    data: import_node_path.default.join(localAppData, name3, "Data"),
    config: import_node_path.default.join(appData, name3, "Config"),
    cache: import_node_path.default.join(localAppData, name3, "Cache"),
    log: import_node_path.default.join(localAppData, name3, "Log"),
    temp: import_node_path.default.join(tmpdir, name3)
  };
};
var linux = (name3) => {
  const username = import_node_path.default.basename(homedir);
  return {
    data: import_node_path.default.join(env2.XDG_DATA_HOME || import_node_path.default.join(homedir, ".local", "share"), name3),
    config: import_node_path.default.join(env2.XDG_CONFIG_HOME || import_node_path.default.join(homedir, ".config"), name3),
    cache: import_node_path.default.join(env2.XDG_CACHE_HOME || import_node_path.default.join(homedir, ".cache"), name3),
    // https://wiki.debian.org/XDGBaseDirectorySpecification#state
    log: import_node_path.default.join(env2.XDG_STATE_HOME || import_node_path.default.join(homedir, ".local", "state"), name3),
    temp: import_node_path.default.join(tmpdir, username, name3)
  };
};
function envPaths(name3, { suffix = "nodejs" } = {}) {
  if (typeof name3 !== "string") {
    throw new TypeError(`Expected a string, got ${typeof name3}`);
  }
  if (suffix) {
    name3 += `-${suffix}`;
  }
  if (import_node_process2.default.platform === "darwin") {
    return macos(name3);
  }
  if (import_node_process2.default.platform === "win32") {
    return windows(name3);
  }
  return linux(name3);
}

// src/utils/certs.ts
var import_fs2 = require("fs");
var import_promises = require("fs/promises");
var import_node_child_process = require("child_process");
var import_path2 = require("path");
function runCommand(command, options = {}) {
  return new Promise((resolve2) => {
    (0, import_node_child_process.exec)(command, options, (error2) => {
      return resolve2({ exitCode: error2?.code ?? 0 });
    });
  });
}
var certs = async () => {
  const res = await runCommand("mkcert --help");
  if (res.exitCode === 0) {
    const p11 = envPaths("drizzle-studio", {
      suffix: ""
    });
    (0, import_fs2.mkdirSync)(p11.data, { recursive: true });
    const keyPath = (0, import_path2.join)(p11.data, "localhost-key.pem");
    const certPath = (0, import_path2.join)(p11.data, "localhost.pem");
    try {
      await Promise.all([(0, import_promises.access)(keyPath), (0, import_promises.access)(certPath)]);
    } catch (e6) {
      await runCommand(`mkcert localhost`, { cwd: p11.data });
    }
    const [key, cert] = await Promise.all([
      (0, import_promises.readFile)(keyPath, { encoding: "utf-8" }),
      (0, import_promises.readFile)(certPath, { encoding: "utf-8" })
    ]);
    return key && cert ? { key, cert } : null;
  }
  return null;
};

// src/api.ts
var generateDrizzleJson = (imports, prevId, schemaFilters, casing2) => {
  const prepared = prepareFromExports(imports);
  const id = (0, import_crypto9.randomUUID)();
  const snapshot = generatePgSnapshot(
    prepared.tables,
    prepared.enums,
    prepared.schemas,
    prepared.sequences,
    prepared.roles,
    prepared.policies,
    prepared.views,
    prepared.matViews,
    casing2,
    schemaFilters
  );
  return {
    ...snapshot,
    id,
    prevId: prevId ?? originUUID
  };
};
var generateMigration = async (prev, cur) => {
  const { applyPgSnapshotsDiff: applyPgSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const validatedPrev = pgSchema2.parse(prev);
  const validatedCur = pgSchema2.parse(cur);
  const squashedPrev = squashPgScheme(validatedPrev);
  const squashedCur = squashPgScheme(validatedCur);
  const { sqlStatements, _meta } = await applyPgSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    schemasResolver,
    enumsResolver,
    sequencesResolver,
    policyResolver,
    indPolicyResolver,
    roleResolver,
    tablesResolver,
    columnsResolver,
    viewsResolver,
    validatedPrev,
    validatedCur
  );
  return sqlStatements;
};
var pushSchema = async (imports, drizzleInstance, schemaFilters, tablesFilter, extensionsFilters) => {
  const { applyPgSnapshotsDiff: applyPgSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const { sql: sql3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
  const filters = (tablesFilter ?? []).concat(
    getTablesFilterByExtensions({ extensionsFilters, dialect: "postgresql" })
  );
  const db2 = {
    query: async (query, params) => {
      const res = await drizzleInstance.execute(sql3.raw(query));
      return res.rows;
    }
  };
  const cur = generateDrizzleJson(imports);
  const { schema: prev } = await pgPushIntrospect(
    db2,
    filters,
    schemaFilters ?? ["public"],
    void 0
  );
  const validatedPrev = pgSchema2.parse(prev);
  const validatedCur = pgSchema2.parse(cur);
  const squashedPrev = squashPgScheme(validatedPrev, "push");
  const squashedCur = squashPgScheme(validatedCur, "push");
  const { statements } = await applyPgSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    schemasResolver,
    enumsResolver,
    sequencesResolver,
    policyResolver,
    indPolicyResolver,
    roleResolver,
    tablesResolver,
    columnsResolver,
    viewsResolver,
    validatedPrev,
    validatedCur,
    "push"
  );
  const { shouldAskForApprove, statementsToExecute, infoToPrint } = await pgSuggestions(db2, statements);
  return {
    hasDataLoss: shouldAskForApprove,
    warnings: infoToPrint,
    statementsToExecute,
    apply: async () => {
      for (const dStmnt of statementsToExecute) {
        await db2.query(dStmnt);
      }
    }
  };
};
var startStudioPostgresServer = async (imports, credentials2, options) => {
  const { drizzleForPostgres: drizzleForPostgres2 } = await Promise.resolve().then(() => (init_studio2(), studio_exports));
  const pgSchema3 = {};
  const relations2 = {};
  Object.entries(imports).forEach(([k9, t6]) => {
    if (is(t6, PgTable)) {
      const schema6 = getTableConfig2(t6).schema || "public";
      pgSchema3[schema6] = pgSchema3[schema6] || {};
      pgSchema3[schema6][k9] = t6;
    }
    if (is(t6, Relations)) {
      relations2[k9] = t6;
    }
  });
  const setup = await drizzleForPostgres2(credentials2, pgSchema3, relations2, [], options?.casing);
  await startServerFromSetup(setup, options);
};
var generateSQLiteDrizzleJson = async (imports, prevId, casing2) => {
  const { prepareFromExports: prepareFromExports5 } = await Promise.resolve().then(() => (init_sqliteImports(), sqliteImports_exports));
  const prepared = prepareFromExports5(imports);
  const id = (0, import_crypto9.randomUUID)();
  const snapshot = generateSqliteSnapshot(prepared.tables, prepared.views, casing2);
  return {
    ...snapshot,
    id,
    prevId: prevId ?? originUUID
  };
};
var generateSQLiteMigration = async (prev, cur) => {
  const { applySqliteSnapshotsDiff: applySqliteSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const validatedPrev = sqliteSchema.parse(prev);
  const validatedCur = sqliteSchema.parse(cur);
  const squashedPrev = squashSqliteScheme(validatedPrev);
  const squashedCur = squashSqliteScheme(validatedCur);
  const { sqlStatements } = await applySqliteSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    tablesResolver,
    columnsResolver,
    sqliteViewsResolver,
    validatedPrev,
    validatedCur
  );
  return sqlStatements;
};
var pushSQLiteSchema = async (imports, drizzleInstance) => {
  const { applySqliteSnapshotsDiff: applySqliteSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const { sql: sql3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
  const db2 = {
    query: async (query, params) => {
      const res = drizzleInstance.all(sql3.raw(query));
      return res;
    },
    run: async (query) => {
      return Promise.resolve(drizzleInstance.run(sql3.raw(query))).then(
        () => {
        }
      );
    }
  };
  const cur = await generateSQLiteDrizzleJson(imports);
  const { schema: prev } = await sqlitePushIntrospect(db2, []);
  const validatedPrev = sqliteSchema.parse(prev);
  const validatedCur = sqliteSchema.parse(cur);
  const squashedPrev = squashSqliteScheme(validatedPrev, "push");
  const squashedCur = squashSqliteScheme(validatedCur, "push");
  const { statements, _meta } = await applySqliteSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    tablesResolver,
    columnsResolver,
    sqliteViewsResolver,
    validatedPrev,
    validatedCur,
    "push"
  );
  const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn(
    db2,
    statements,
    squashedPrev,
    squashedCur,
    _meta
  );
  return {
    hasDataLoss: shouldAskForApprove,
    warnings: infoToPrint,
    statementsToExecute,
    apply: async () => {
      for (const dStmnt of statementsToExecute) {
        await db2.query(dStmnt);
      }
    }
  };
};
var startStudioSQLiteServer = async (imports, credentials2, options) => {
  const { drizzleForSQLite: drizzleForSQLite2 } = await Promise.resolve().then(() => (init_studio2(), studio_exports));
  const sqliteSchema2 = {};
  const relations2 = {};
  Object.entries(imports).forEach(([k9, t6]) => {
    if (is(t6, SQLiteTable)) {
      const schema6 = "public";
      sqliteSchema2[schema6] = sqliteSchema2[schema6] || {};
      sqliteSchema2[schema6][k9] = t6;
    }
    if (is(t6, Relations)) {
      relations2[k9] = t6;
    }
  });
  const setup = await drizzleForSQLite2(credentials2, sqliteSchema2, relations2, [], options?.casing);
  await startServerFromSetup(setup, options);
};
var generateMySQLDrizzleJson = async (imports, prevId, casing2) => {
  const { prepareFromExports: prepareFromExports5 } = await Promise.resolve().then(() => (init_mysqlImports(), mysqlImports_exports));
  const prepared = prepareFromExports5(imports);
  const id = (0, import_crypto9.randomUUID)();
  const snapshot = generateMySqlSnapshot(prepared.tables, prepared.views, casing2);
  return {
    ...snapshot,
    id,
    prevId: prevId ?? originUUID
  };
};
var generateMySQLMigration = async (prev, cur) => {
  const { applyMysqlSnapshotsDiff: applyMysqlSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const validatedPrev = mysqlSchema.parse(prev);
  const validatedCur = mysqlSchema.parse(cur);
  const squashedPrev = squashMysqlScheme(validatedPrev);
  const squashedCur = squashMysqlScheme(validatedCur);
  const { sqlStatements } = await applyMysqlSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    tablesResolver,
    columnsResolver,
    mySqlViewsResolver,
    validatedPrev,
    validatedCur
  );
  return sqlStatements;
};
var pushMySQLSchema = async (imports, drizzleInstance, databaseName) => {
  const { applyMysqlSnapshotsDiff: applyMysqlSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const { logSuggestionsAndReturn: logSuggestionsAndReturn4 } = await Promise.resolve().then(() => (init_mysqlPushUtils(), mysqlPushUtils_exports));
  const { mysqlPushIntrospect: mysqlPushIntrospect2 } = await Promise.resolve().then(() => (init_mysqlIntrospect(), mysqlIntrospect_exports));
  const { sql: sql3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
  const db2 = {
    query: async (query, params) => {
      const res = await drizzleInstance.execute(sql3.raw(query));
      return res[0];
    }
  };
  const cur = await generateMySQLDrizzleJson(imports);
  const { schema: prev } = await mysqlPushIntrospect2(db2, databaseName, []);
  const validatedPrev = mysqlSchema.parse(prev);
  const validatedCur = mysqlSchema.parse(cur);
  const squashedPrev = squashMysqlScheme(validatedPrev);
  const squashedCur = squashMysqlScheme(validatedCur);
  const { statements } = await applyMysqlSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    tablesResolver,
    columnsResolver,
    mySqlViewsResolver,
    validatedPrev,
    validatedCur,
    "push"
  );
  const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn4(
    db2,
    statements,
    validatedCur
  );
  return {
    hasDataLoss: shouldAskForApprove,
    warnings: infoToPrint,
    statementsToExecute,
    apply: async () => {
      for (const dStmnt of statementsToExecute) {
        await db2.query(dStmnt);
      }
    }
  };
};
var startStudioMySQLServer = async (imports, credentials2, options) => {
  const { drizzleForMySQL: drizzleForMySQL2 } = await Promise.resolve().then(() => (init_studio2(), studio_exports));
  const mysqlSchema3 = {};
  const relations2 = {};
  Object.entries(imports).forEach(([k9, t6]) => {
    if (is(t6, MySqlTable)) {
      const schema6 = getTableConfig(t6).schema || "public";
      mysqlSchema3[schema6] = mysqlSchema3[schema6] || {};
      mysqlSchema3[schema6][k9] = t6;
    }
    if (is(t6, Relations)) {
      relations2[k9] = t6;
    }
  });
  const setup = await drizzleForMySQL2(credentials2, mysqlSchema3, relations2, [], options?.casing);
  await startServerFromSetup(setup, options);
};
var generateSingleStoreDrizzleJson = async (imports, prevId, casing2) => {
  const { prepareFromExports: prepareFromExports5 } = await Promise.resolve().then(() => (init_singlestoreImports(), singlestoreImports_exports));
  const prepared = prepareFromExports5(imports);
  const id = (0, import_crypto9.randomUUID)();
  const snapshot = generateSingleStoreSnapshot(
    prepared.tables,
    /* prepared.views, */
    casing2
  );
  return {
    ...snapshot,
    id,
    prevId: prevId ?? originUUID
  };
};
var generateSingleStoreMigration = async (prev, cur) => {
  const { applySingleStoreSnapshotsDiff: applySingleStoreSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const validatedPrev = singlestoreSchema.parse(prev);
  const validatedCur = singlestoreSchema.parse(cur);
  const squashedPrev = squashSingleStoreScheme(validatedPrev);
  const squashedCur = squashSingleStoreScheme(validatedCur);
  const { sqlStatements } = await applySingleStoreSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    tablesResolver,
    columnsResolver,
    /* singleStoreViewsResolver, */
    validatedPrev,
    validatedCur,
    "push"
  );
  return sqlStatements;
};
var pushSingleStoreSchema = async (imports, drizzleInstance, databaseName) => {
  const { applySingleStoreSnapshotsDiff: applySingleStoreSnapshotsDiff2 } = await Promise.resolve().then(() => (init_snapshotsDiffer(), snapshotsDiffer_exports));
  const { logSuggestionsAndReturn: logSuggestionsAndReturn4 } = await Promise.resolve().then(() => (init_singlestorePushUtils(), singlestorePushUtils_exports));
  const { singlestorePushIntrospect: singlestorePushIntrospect2 } = await Promise.resolve().then(() => (init_singlestoreIntrospect(), singlestoreIntrospect_exports));
  const { sql: sql3 } = await Promise.resolve().then(() => (init_dist(), dist_exports));
  const db2 = {
    query: async (query) => {
      const res = await drizzleInstance.execute(sql3.raw(query));
      return res[0];
    }
  };
  const cur = await generateSingleStoreDrizzleJson(imports);
  const { schema: prev } = await singlestorePushIntrospect2(db2, databaseName, []);
  const validatedPrev = singlestoreSchema.parse(prev);
  const validatedCur = singlestoreSchema.parse(cur);
  const squashedPrev = squashSingleStoreScheme(validatedPrev);
  const squashedCur = squashSingleStoreScheme(validatedCur);
  const { statements } = await applySingleStoreSnapshotsDiff2(
    squashedPrev,
    squashedCur,
    tablesResolver,
    columnsResolver,
    /* singleStoreViewsResolver, */
    validatedPrev,
    validatedCur,
    "push"
  );
  const { shouldAskForApprove, statementsToExecute, infoToPrint } = await logSuggestionsAndReturn4(
    db2,
    statements,
    validatedCur,
    validatedPrev
  );
  return {
    hasDataLoss: shouldAskForApprove,
    warnings: infoToPrint,
    statementsToExecute,
    apply: async () => {
      for (const dStmnt of statementsToExecute) {
        await db2.query(dStmnt);
      }
    }
  };
};
var startStudioSingleStoreServer = async (imports, credentials2, options) => {
  const { drizzleForSingleStore: drizzleForSingleStore2 } = await Promise.resolve().then(() => (init_studio2(), studio_exports));
  const singleStoreSchema = {};
  const relations2 = {};
  Object.entries(imports).forEach(([k9, t6]) => {
    if (is(t6, SingleStoreTable)) {
      const schema6 = getTableConfig3(t6).schema || "public";
      singleStoreSchema[schema6] = singleStoreSchema[schema6] || {};
      singleStoreSchema[schema6][k9] = t6;
    }
    if (is(t6, Relations)) {
      relations2[k9] = t6;
    }
  });
  const setup = await drizzleForSingleStore2(credentials2, singleStoreSchema, relations2, [], options?.casing);
  await startServerFromSetup(setup, options);
};
var startServerFromSetup = async (setup, options) => {
  const { prepareServer: prepareServer2 } = await Promise.resolve().then(() => (init_studio2(), studio_exports));
  const server = await prepareServer2(setup);
  const host = options?.host || "127.0.0.1";
  const port = options?.port || 4983;
  const { key, cert } = await certs() || {};
  server.start({
    host,
    port,
    key,
    cert,
    cb: (err3) => {
      if (err3) {
        console.error(err3);
      } else {
        console.log(`Studio is running at ${key ? "https" : "http"}://${host}:${port}`);
      }
    }
  });
};
var upPgSnapshot = (snapshot) => {
  if (snapshot.version === "5") {
    return updateUpToV7(updateUpToV6(snapshot));
  }
  if (snapshot.version === "6") {
    return updateUpToV7(snapshot);
  }
  return snapshot;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  generateDrizzleJson,
  generateMigration,
  generateMySQLDrizzleJson,
  generateMySQLMigration,
  generateSQLiteDrizzleJson,
  generateSQLiteMigration,
  generateSingleStoreDrizzleJson,
  generateSingleStoreMigration,
  pushMySQLSchema,
  pushSQLiteSchema,
  pushSchema,
  pushSingleStoreSchema,
  startStudioMySQLServer,
  startStudioPostgresServer,
  startStudioSQLiteServer,
  startStudioSingleStoreServer,
  upPgSnapshot
});
/*! Bundled license information:

web-streams-polyfill/dist/ponyfill.es2018.js:
  (**
   * @license
   * web-streams-polyfill v3.3.3
   * Copyright 2024 Mattias Buelens, Diwank Singh Tomer and other contributors.
   * This code is released under the MIT license.
   * SPDX-License-Identifier: MIT
   *)

fetch-blob/index.js:
  (*! fetch-blob. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)

formdata-polyfill/esm.min.js:
  (*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)

node-domexception/index.js:
  (*! node-domexception. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> *)

@neondatabase/serverless/index.mjs:
@neondatabase/serverless/index.mjs:
@neondatabase/serverless/index.mjs:
  (*! Bundled license information:
  
  ieee754/index.js:
    (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
  
  buffer/index.js:
    (*!
     * The buffer module from node.js, for the browser.
     *
     * @author   Feross Aboukhadijeh <https://feross.org>
     * @license  MIT
     *)
  *)

gel/dist/primitives/chars.js:
gel/dist/primitives/buffer.js:
gel/dist/errors/index.js:
gel/dist/primitives/lru.js:
gel/dist/codecs/consts.js:
gel/dist/codecs/ifaces.js:
gel/dist/codecs/boolean.js:
gel/dist/codecs/numbers.js:
gel/dist/codecs/numerics.js:
gel/dist/codecs/text.js:
gel/dist/codecs/uuid.js:
gel/dist/codecs/bytes.js:
gel/dist/codecs/json.js:
gel/dist/datatypes/datetime.js:
gel/dist/codecs/datetime.js:
gel/dist/datatypes/memory.js:
gel/dist/codecs/memory.js:
gel/dist/codecs/pgvector.js:
gel/dist/codecs/codecs.js:
gel/dist/codecs/tuple.js:
gel/dist/datatypes/range.js:
gel/dist/codecs/range.js:
gel/dist/codecs/namedtuple.js:
gel/dist/codecs/array.js:
gel/dist/codecs/enum.js:
gel/dist/codecs/object.js:
gel/dist/codecs/set.js:
gel/dist/codecs/record.js:
gel/dist/codecs/sparseObject.js:
gel/dist/codecs/registry.js:
gel/dist/retry.js:
gel/dist/conUtils.js:
gel/dist/errors/map.js:
gel/dist/errors/resolve.js:
gel/dist/baseConn.js:
gel/dist/scram.js:
gel/dist/rawConn.js:
gel/dist/index.shared.js:
gel/dist/index.node.js:
  (*!
   * This source file is part of the Gel open source project.
   *
   * Copyright 2019-present MagicStack Inc. and the Gel authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)

gel/dist/datatypes/dateutil.js:
  (*!
   * Portions Copyright (c) 2019 MagicStack Inc. and the Gel authors.
   * Portions Copyright (c) 2001-2019 Python Software Foundation.
   * All rights reserved.
   * Licence: PSFL https://docs.python.org/3/license.html
   *)

gel/dist/utils.js:
gel/dist/ifaces.js:
gel/dist/primitives/queues.js:
gel/dist/baseClient.js:
gel/dist/reflection/strictMap.js:
gel/dist/reflection/index.js:
  (*!
   * This source file is part of the Gel open source project.
   *
   * Copyright 2020-present MagicStack Inc. and the Gel authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)

gel/dist/primitives/event.js:
  (*!
   * This source file is part of the Gel open source project.
   *
   * Copyright 2021-present MagicStack Inc. and the Gel authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)

gel/dist/fetchConn.js:
  (*!
   * This source file is part of the Gel open source project.
   *
   * Copyright 2022-present MagicStack Inc. and the Gel authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *)

long/umd/index.js:
  (**
   * @license
   * Copyright 2009 The Closure Library Authors
   * Copyright 2020 Daniel Wirtz / The long.js Authors.
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *     http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   *
   * SPDX-License-Identifier: Apache-2.0
   *)
*/